import type { Ref } from '@stacksjs/stx' import { ref, watch } from '@stacksjs/stx' import type { MaybeRef } from './_shared' import { isRef, unref } from './_shared' function watchSource(source: MaybeRef, cb: () => void): void { if (isRef(source)) watch(source as Ref, cb) } function getArray(source: MaybeRef): T[] { return unref(source) as T[] } /** * Reactive array difference: items in list but not in other. */ export function useArrayDifference( list: MaybeRef, other: MaybeRef, compareFn?: (a: T, b: T) => boolean, ): Ref { const result = ref([]) as Ref function update(): void { const arr = getArray(list) const otherArr = getArray(other) if (compareFn) result.value = arr.filter(item => !otherArr.some(o => compareFn(item, o))) else result.value = arr.filter(item => !otherArr.includes(item)) } update() watchSource(list, update) watchSource(other, update) return result } /** * Reactive Array.every. */ export function useArrayEvery( list: MaybeRef, fn: (element: T, index: number, array: T[]) => boolean, ): Ref { const result = ref(false) function update(): void { result.value = getArray(list).every(fn) } update() watchSource(list, update) return result } /** * Reactive Array.filter. */ export function useArrayFilter( list: MaybeRef, fn: (element: T, index: number, array: T[]) => boolean, ): Ref { const result = ref([]) as Ref function update(): void { result.value = getArray(list).filter(fn) } update() watchSource(list, update) return result } /** * Reactive Array.find. */ export function useArrayFind( list: MaybeRef, fn: (element: T, index: number, array: T[]) => boolean, ): Ref { const result = ref(undefined) as Ref function update(): void { result.value = getArray(list).find(fn) } update() watchSource(list, update) return result } /** * Reactive Array.findIndex. */ export function useArrayFindIndex( list: MaybeRef, fn: (element: T, index: number, array: T[]) => boolean, ): Ref { const result = ref(-1) function update(): void { result.value = getArray(list).findIndex(fn) } update() watchSource(list, update) return result } /** * Reactive Array.includes. */ export function useArrayIncludes( list: MaybeRef, value: MaybeRef, compareFn?: (a: T, b: T) => boolean, ): Ref { const result = ref(false) function update(): void { const arr = getArray(list) const v = unref(value) as T if (compareFn) result.value = arr.some(item => compareFn(item, v)) else result.value = arr.includes(v) } update() watchSource(list, update) if (isRef(value)) watch(value as Ref, update) return result } /** * Reactive Array.map. */ export function useArrayMap( list: MaybeRef, fn: (element: T, index: number, array: T[]) => U, ): Ref { const result = ref([]) as Ref function update(): void { result.value = getArray(list).map(fn) } update() watchSource(list, update) return result } /** * Reactive Array.reduce. */ export function useArrayReduce( list: MaybeRef, fn: (accumulator: U, current: T, index: number, array: T[]) => U, initialValue: U, ): Ref { const result = ref(initialValue) as Ref function update(): void { result.value = getArray(list).reduce(fn, initialValue) } update() watchSource(list, update) return result } /** * Reactive Array.some. */ export function useArraySome( list: MaybeRef, fn: (element: T, index: number, array: T[]) => boolean, ): Ref { const result = ref(false) function update(): void { result.value = getArray(list).some(fn) } update() watchSource(list, update) return result } /** * Reactive unique array values. */ export function useArrayUnique( list: MaybeRef, compareFn?: (a: T, b: T) => boolean, ): Ref { const result = ref([]) as Ref function update(): void { const arr = getArray(list) if (compareFn) result.value = arr.filter((item, index) => arr.findIndex(other => compareFn(item, other)) === index) else result.value = [...new Set(arr)] } update() watchSource(list, update) return result }