Class ObservableMap<TKey, TVal>

constructor

• new ObservableMap<TKey, TVal>(values?): ObservableMap<TKey, TVal>

• Type Parameters

  • TKey
  • TVal

  Parameters

  • Optionalvalues: ReadonlyMap<TKey, TVal>

  Returns ObservableMap<TKey, TVal>

Readonlyempty$

ReadonlyitemAdded$

ReadonlyitemDelta$

ReadonlyitemRemoved$

ReadonlyitemUpdates$

Readonlysize$

Readonlyupdates$

Readonlyvalue$

empty

• get empty(): boolean

• True if the collection is empty

  Returns boolean

size

• get size(): number

• The number of items in the collection

  Returns number

value

• get value(): ReadonlyMap<TKey, TVal>

• The inner non-observable map

  Returns ReadonlyMap<TKey, TVal>

[iterator]

• [iterator](): IterableIterator<[TKey, TVal]>

• Returns IterableIterator<[TKey, TVal]>

add

• add(key, value): boolean

• Add a value to the collection if the key is not in use

  Parameters

  • key: TKey

    The key to use
  • value: TVal

    The value to add

  Returns boolean

  added - Returns true if the value was added

clear

• clear(): boolean

• Clear the collection

  Returns boolean

delete

• delete(key): boolean

• Remove a key from the collection

  Parameters

  • key: TKey

    The key to remove

  Returns boolean

  removed - True if an item was removed

deleteRange

• deleteRange(values): boolean

• Remove keys from the collection

  Parameters

  • values: TKey[]

    The keys to remove

  Returns boolean

  removed - True if items were removed

filter

• filter(whitelist): boolean

• Remove all keys not in the whitelist

  Parameters

  • whitelist: undefined | readonly TKey[] | ReadonlySet<TKey>

    The keys to keep

  Returns boolean

get

• get(key): undefined | TVal

• Try to read a value with a given key

  Parameters

  • key: TKey

  Returns undefined | TVal

get$

• get$(key): Observable<undefined | TVal>

• Create an observable emitting the value under a given key

  Parameters

  • key: TKey

  Returns Observable<undefined | TVal>

has

• has(key): boolean

• Check if a key exists in the collection

  Parameters

  • key: TKey

  Returns boolean

has$

• has$(key): Observable<boolean>

• Create am observable emitting true if a key exists in the collection

  Parameters

  • key: TKey

  Returns Observable<boolean>

modify

• modify(modify): void

• Manually modify the inner collection

  Parameters

  • modify: ((map: Map<TKey, TVal>) => void)
    • • (map): void

      • Parameters

        • map: Map<TKey, TVal>

        Returns void

  Returns void

set

• set(key, value): boolean

• Add a value to the collection

  Parameters

  • key: TKey

    The key to use
  • value: TVal

    The value to add

  Returns boolean

  added - Returns true if the value was added or changed

subscribe

• subscribe(observer): Unsubscribable

• Parameters

  • observer: Partial<Observer<ReadonlyMap<TKey, TVal>>>

  Returns Unsubscribable

  Inherit Doc

toggle

• toggle(key, value, state?): undefined | boolean

• Toggle a value in the map

  Parameters

  • key: TKey

    The key to toggle
  • value: TVal

    The value to insert if applicable
  • Optionalstate: boolean

    A forced state (true = always add, false = always delete)

  Returns undefined | boolean

  The applied change (true = item added, false = item removed, undefined = nothing changed)