Class CellArray<TItem>

constructor

• new CellArray<TItem>(initialItems: Iterable<TItem>): CellArray<TItem>

  Type Parameters

  • TItem

  Parameters

  • initialItems: Iterable<TItem>

    The initial items of the array.

  Returns CellArray<TItem>

Readonlylength

ReadonlyonInsert

ReadonlyonRemove

items

• get items(): MutCell<TItem>[]

  All items of the array as mutable cells.

  Returns MutCell<TItem>[]

clear

• clear(): void

  Returns void

find

• find(
      predicate: (item: TItem, index: number) => boolean,
  ): undefined | MutCell<TItem>

  Find an item matching the predicate.

  Parameters

  • predicate: (item: TItem, index: number) => boolean

    A function to apply to each item.

  Returns undefined | MutCell<TItem>

  The mutable cell of the first item matching the predicate or undefined if not found.

get

• get(index: number): undefined | TItem

  Get the current cell value at the given index.

  Parameters

  • index: number

    The index.

  Returns undefined | TItem

  The item or undefined if out of bounds.

insert

• insert(index: number, item: TItem): void

  Insert an item.

  Parameters

  • index: number

    The index to insert the item at. Existing items will be moved over.
  • item: TItem

    The item to insert.

  Returns void

observe

• observe(
      insert: (index: number, item: Cell<TItem>, key: void) => void,
      remove: (index: number) => void,
  ): () => void

  Observe this iterable. Upon attaching an observer insert is called for each item currently contained in the underlying collection.

  Parameters

  • insert: (index: number, item: Cell<TItem>, key: void) => void

    An observer that is called whenever an item is inserted.
  • remove: (index: number) => void

    An observer that is called whenever an item is removed.

  Returns () => void

  A function that should be called to detach the observer functions.

push

• push(item: TItem): void

  Add an item to the end of the array increasing its length by one.

  When inserting items the order of events is as follows:

  1. The item is inserted in the internal array of cells
  2. An insertion event is emitted to active iterators
  3. The length cell emits an update to observers

  Parameters

  • item: TItem

    The item to add to the end of the array

  Returns void

pushAll

• pushAll(items: TItem[]): void

  Parameters

  • items: TItem[]

  Returns void

remove

• remove(index: number): undefined | TItem

  Parameters

  • index: number

  Returns undefined | TItem

removeIf

• removeIf(predicate: (item: TItem, index: number) => boolean): void

  Parameters

  • predicate: (item: TItem, index: number) => boolean

  Returns void

replaceAll

• replaceAll(
      items: TItem[],
      predicate?: (existingItem: TItem, newItem: TItem) => boolean,
  ): void

  Parameters

  • items: TItem[]
  • Optionalpredicate: (existingItem: TItem, newItem: TItem) => boolean

  Returns void

set

• set(index: number, item: TItem): void

  Set the value of the cell at the given index.

  Parameters

  • index: number

    The index.
  • item: TItem

    The new cell value.

  Returns void

update

• update<T>(index: number, mutator: (value: TItem) => T): undefined | T

  Update the value of the cell at the given index.

  Type Parameters

  • T

  Parameters

  • index: number

    The index.
  • mutator: (value: TItem) => T

    A function that modifies the value of the cell.

  Returns undefined | T

  If the mutator function returns a value, that value is returned by update as well.