Skip to content

IWaitableList

Defined in: packages/data/src/list/iwaitable-list.ts:11

The blocking sibling of IList: waits for capacity instead of throwing when the list is full. The inherited set/splice throws — this adds a way to wait, it does not change the way to fail.

T extends DefinedValue = DefinedValue

readonly capacity: number

Defined in: packages/data/src/collection/ibounded.ts:17

The maximum number of elements the collection can hold.

Note: Infinity is not a legal value here — an unbounded type omits this mixin.

IBounded.capacity

[iterator](): Iterator<T, any, any>

Defined in: node_modules/.store/typescript-npm-6.0.3-585eecd158/package/lib/lib.es2015.iterable.d.ts:47

Iterator<T, any, any>

IList.[iterator]


clear(): void

Defined in: packages/data/src/collection/icollection.ts:23

Removes all elements from the collection.

void

IList.clear


count(): number

Defined in: packages/data/src/collection/icollection.ts:20

The number of elements in the collection.

A method, not a getter: its async counterpart needs a round trip to the backing store, and a member must have the same shape in both.

number

IList.count


get(index): T | undefined

Defined in: packages/data/src/list/ilist.ts:49

Returns the item at the specified index.

If the index is negative, it counts from the end of the list. If the index is out of bounds, undefined is returned.

Not uniformly O(1). This member reads as positional access, but only a random-access backing answers it in constant time. On a linked backing, it walks from an end, so a loop calling get over every index is quadratic. Iterate the list, or take a cursor (ICursorSequence/IBidirectionalCursorSequence), whenever the access pattern is sequential. Each implementation states its own complexity.

number

The index of the item to retrieve.

T | undefined

The item at the specified index, or undefined if the index is out of bounds.

IList.get


remove(condition): IterableIterator<T>

Defined in: packages/data/src/collection/isearchable.ts:19

Removes every item matching the given predicate.

Predicate<[T]>

A predicate function to identify the items to remove.

IterableIterator<T>

An iterator of the removed items.

IList.remove


removeFirst(condition): boolean

Defined in: packages/data/src/collection/isearchable.ts:11

Removes the first occurrence of the item matching the given predicate.

Predicate<[T]>

A predicate function to identify the item to remove.

boolean

true if the item was found and removed, false otherwise.

IList.removeFirst


replace(condition, newItemFactory): IterableIterator<T>

Defined in: packages/data/src/collection/isearchable.ts:38

Replaces every item matching the given predicate.

Predicate<[T]>

A predicate function to identify the items to replace.

Callable<[T], T>

A function that takes the old item and returns the new item to insert.

IterableIterator<T>

An iterator of the replaced items.

IList.replace


replaceFirst(condition, newItem): boolean

Defined in: packages/data/src/collection/isearchable.ts:28

Replaces the first occurrence of the item matching the given predicate.

Predicate<[T]>

A predicate function to identify the item to replace.

T

The new item to insert.

boolean

true if the item was found and replaced, false otherwise.

IList.replaceFirst


set(index, item): void

Defined in: packages/data/src/list/ilist.ts:62

Sets the item at the specified index.

If the index is negative, it counts from the end of the list. If the index is equal to the length of the list, the item is appended to the end. If the index is out of bounds, a RangeError is thrown.

number

The index at which to set the item.

T

The item to set.

void

If the index is out of bounds.

IList.set


slice(start?, end?): IterableIterator<T>

Defined in: packages/data/src/list/ilist.ts:131

Slice the list to a new list from start to end.

This method does not mutate the original list.

The range is specified by the start and end parameters, which are inclusive and exclusive, respectively. If start is omitted, it defaults to 0. If end is omitted, it defaults to the length of the list.

If either start or end is negative, they refer to positions from the end of the list. For example, -1 refers to the last element, -2 refers to the second last element, and so on.

If start is greater than or equal to end, the result is an empty iterator.

If the start index is out of bounds, a RangeError is thrown. If end is out of bounds, it is clamped to the valid range.

number

Optional start index of the range (inclusive).

number

Optional end index of the range (exclusive).

IterableIterator<T>

An iterator for the elements in the specified range.

If the start index is out of bounds.

IList.slice


splice(start, deleteCount?, item?): IterableIterator<T>

Defined in: packages/data/src/list/ilist.ts:88

Change the content of the list by removing or replacing existing elements and/or adding new elements in place.

If the start index is negative, it counts from the end of the list. If the start index is equal to the length of the list, no elements are removed and the items are appended to the end of the list. If the start index is out of bounds, a RangeError is thrown.

If deleteCount is omitted, it defaults to Infinity, meaning all elements from the start index to the end of the list will be removed. If deleteCount is greater than the number of elements from start to the end of the list, it will remove all elements from start to the end of the list. If deleteCount is 0 or negative, no elements will be removed.

If items are provided, they will be inserted starting at the start index.

number

The index at which to start changing the list.

number

The number of elements to remove from the list. Defaults to Infinity

T

An optional element to add to the list at the start index.

IterableIterator<T>

An iterable of the removed items.

If the start index is out of bounds.

IList.splice


spliceAll(start, deleteCount?, items?): IterableIterator<T>

Defined in: packages/data/src/list/ilist.ts:101

Same as IList.splice, but inserts every element of items at the start index, keeping their relative order.

number

The index at which to start changing the list.

number

The number of elements to remove from the list. Defaults to Infinity

readonly T[]

The elements to add to the list, beginning at the start index.

IterableIterator<T>

An iterable of the removed items.

If the start index is out of bounds.

IList.spliceAll


waitSet(index, item, signal?): Promise<void>

Defined in: packages/data/src/list/iwaitable-list.ts:27

Same as set, but waits for capacity if the operation would exceed it.

When index equals the list’s length (an append), the append lands at whatever the list’s length turns out to be once capacity frees up — not necessarily the length at call time — since another caller may have mutated the list while this call was waiting. A non-appending index gives no such guarantee: if another caller changes the list’s shape while this call waits, the eventual write still targets the originally requested numeric position, which may no longer mean what it did at call time.

number

T

AbortSignal | null

Optional abort signal to cancel the operation.

Promise<void>

IList.set


waitSplice(start, deleteCount?, item?, signal?): Promise<IterableIterator<T, any, any>>

Defined in: packages/data/src/list/iwaitable-list.ts:41

The same as splice, but waits for capacity if the operation would exceed it.

Same concurrent-mutation caveat as waitSet: when start equals the list’s length at call time (an append via splice), the insert lands at whatever the list’s length turns out to be once capacity frees up. A start that does not equal the list’s length gives no such guarantee.

number

number

T

AbortSignal | null

Optional abort signal to cancel the operation.

Promise<IterableIterator<T, any, any>>

IList.splice


waitSpliceAll(start, deleteCount?, items?, signal?): Promise<IterableIterator<T, any, any>>

Defined in: packages/data/src/list/iwaitable-list.ts:55

The same as spliceAll, but waits for capacity if the operation would exceed it. Same concurrent-mutation caveat as waitSplice.

number

number

Iterable<T, any, any>

AbortSignal | null

Optional abort signal to cancel the operation.

Promise<IterableIterator<T, any, any>>

IList.spliceAll