use-array

Reactive Array.prototype.filter.

Usage

import { useArrayFilter, useArrayMap, useArrayFind, useArrayReduce, useArraySome, useArrayEvery, useArrayUnique } from "@vizejs/composable/use-array";

Runtime contract

API

useArrayFilter

Reactive Array.prototype.filter. A type-guard predicate narrows the element type.

function useArrayFilter<Item, Narrowed extends Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: (item: Item, index: number, array: readonly Item[]) => item is Narrowed, ): ComputedRef<Narrowed[]>

const active = useArrayFilter(users, (user) => user.active);

useArrayFilter

function useArrayFilter<Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: ArrayCallback<Item, boolean>, ): ComputedRef<Item[]>

useArrayFilter

function useArrayFilter<Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: ArrayCallback<Item, boolean>, ): ComputedRef<Item[]>

useArrayMap

Reactive Array.prototype.map.

function useArrayMap<Item, Mapped>( list: MaybeRefOrGetter<readonly Item[]>, mapper: ArrayCallback<Item, Mapped>, ): ComputedRef<Mapped[]>

const names = useArrayMap(users, (user) => user.name);

useArrayFind

Reactive Array.prototype.find. A type-guard predicate narrows the result.

function useArrayFind<Item, Narrowed extends Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: (item: Item, index: number, array: readonly Item[]) => item is Narrowed, ): ComputedRef<Narrowed | undefined>

const admin = useArrayFind(users, (user) => user.role === "admin");

useArrayFind

function useArrayFind<Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: ArrayCallback<Item, boolean>, ): ComputedRef<Item | undefined>

useArrayFind

function useArrayFind<Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: ArrayCallback<Item, boolean>, ): ComputedRef<Item | undefined>

useArrayReduce

Reactive Array.prototype.reduce. With an initial value the result has the accumulator type. Without one, the first item seeds the accumulator and an empty array yields undefined (instead of throwing like reduce).

function useArrayReduce<Item, Accumulator>( list: MaybeRefOrGetter<readonly Item[]>, reducer: ( accumulator: Accumulator, item: Item, index: number, array: readonly Item[], ) => Accumulator, initial: MaybeRefOrGetter<Accumulator>, ): ComputedRef<Accumulator>

const total = useArrayReduce(cart, (sum, line) => sum + line.price, 0);

useArrayReduce

function useArrayReduce<Item>( list: MaybeRefOrGetter<readonly Item[]>, reducer: (accumulator: Item, item: Item, index: number, array: readonly Item[]) => Item, ): ComputedRef<Item | undefined>

useArrayReduce

function useArrayReduce<Item>( list: MaybeRefOrGetter<readonly Item[]>, reducer: (accumulator: unknown, item: Item, index: number, array: readonly Item[]) => unknown, ...initial: readonly [] | readonly [MaybeRefOrGetter<unknown>] ): ComputedRef<unknown>

useArraySome

Reactive Array.prototype.some.

function useArraySome<Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: ArrayCallback<Item, boolean>, ): ComputedRef<boolean>

const hasErrors = useArraySome(fields, (field) => field.error !== null);

useArrayEvery

Reactive Array.prototype.every.

function useArrayEvery<Item>( list: MaybeRefOrGetter<readonly Item[]>, predicate: ArrayCallback<Item, boolean>, ): ComputedRef<boolean>

const allDone = useArrayEvery(tasks, (task) => task.done);

useArrayUnique

Reactive de-duplication that keeps the first occurrence of each item. Without isSame, items are compared with SameValueZero (like Set) in linear time; with it, pairwise in quadratic time.

function useArrayUnique<Item>( list: MaybeRefOrGetter<readonly Item[]>, isSame?: (left: Item, right: Item) => boolean, ): ComputedRef<Item[]>

const tags = useArrayUnique(allTags);
const people = useArrayUnique(rows, (left, right) => left.id === right.id);