Class ObservableSet<T>

constructor

• new ObservableSet<T>(values?): ObservableSet<T>

• Type Parameters

  • T

  Parameters

  • Optionalvalues: T[]

  Returns ObservableSet<T>

Readonlyarray$

Readonlyempty$

ReadonlyitemAdded$

ReadonlyitemDelta$

ReadonlyitemRemoved$

ReadonlyitemUpdates$

Readonlysize$

Readonlyupdates$

Readonlyvalue$

array

• get array(): T[]

• The values of the set as an array

  Returns T[]

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(): ReadonlySet<T>

• The inner non-observable Set

  Returns ReadonlySet<T>

[iterator]

• [iterator](): IterableIterator<T>

• Returns IterableIterator<T>

  Inherit Doc

add

• add(value): boolean

• Add a value to the collection is not already present

  Parameters

  • value: T

    The value to add

  Returns boolean

  added - Returns true if the value was added

addRange

• addRange(values): boolean

• Add a list of values to the collection is not already present

  Parameters

  • values: T[]

    The values to add

  Returns boolean

  added - Returns true if any value was added

clear

• clear(): boolean

• Clear the collection

  Returns boolean

delete

• delete(value): boolean

• Remove a value from the collection

  Parameters

  • value: T

    The key to remove

  Returns boolean

  removed - True if the value existed

deleteRange

• deleteRange(values): boolean

• Remove values from the collection

  Parameters

  • values: T[]

    The values to remove

  Returns boolean

  removed - True if any values were removed

filter

• filter(whitelist): boolean

• Remove all keys not in the whitelist

  Parameters

  • whitelist: undefined | ReadonlySet<T> | T[]

    The keys to keep

  Returns boolean

has

• has(value): boolean

• Check if a key exists in the collection

  Parameters

  • value: T

  Returns boolean

has$

• has$(value): Observable<boolean>

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

  Parameters

  • value: T

  Returns Observable<boolean>

modify

• modify(modify): void

• Manually modify the inner collection

  Parameters

  • modify: ((set: Set<T>) => void)
    • • (set): void

      • Parameters

        • set: Set<T>

        Returns void

  Returns void

set

• set(values?): boolean

• Reset the values in the collection to the provided list

  Parameters

  • values: T[] = []

    The values to set

  Returns boolean

  changed - Returns true if the collection changed

subscribe

• subscribe(observer): Unsubscribable

• Parameters

  • observer: Partial<Observer<ReadonlySet<T>>>

  Returns Unsubscribable

  Inherit Doc

toggle

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

• Toggle a value in the set

  Parameters

  • value: T

    The value to toggle
  • 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)