devskill 2.0.2

package/skills/vueuse-functions/references/useArrayEvery.md

@@ -0,0 +1,59 @@
+---
+category: Array
+---
+
+# useArrayEvery
+
+Reactive `Array.every`
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArrayEvery } from '@vueuse/core'
+
+const item1 = ref(0)
+const item2 = ref(2)
+const item3 = ref(4)
+const item4 = ref(6)
+const item5 = ref(8)
+const list = [item1, item2, item3, item4, item5]
+const result = useArrayEvery(list, i => i % 2 === 0)
+// result.value: true
+item1.value = 1
+// result.value: false
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayEvery } from '@vueuse/core'
+
+const list = ref([0, 2, 4, 6, 8])
+const result = useArrayEvery(list, i => i % 2 === 0)
+// result.value: true
+list.value.push(9)
+// result.value: false
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayEveryReturn = ComputedRef<boolean>
+/**
+ * Reactive `Array.every`
+ *
+ * @see https://vueuse.org/useArrayEvery
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayEvery<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown,
+): UseArrayEveryReturn
+```

package/skills/vueuse-functions/references/useArrayFilter.md

@@ -0,0 +1,63 @@
+---
+category: Array
+---
+
+# useArrayFilter
+
+Reactive `Array.filter`
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArrayFilter } from '@vueuse/core'
+
+const item1 = ref(0)
+const item2 = ref(2)
+const item3 = ref(4)
+const item4 = ref(6)
+const item5 = ref(8)
+const list = [item1, item2, item3, item4, item5]
+const result = useArrayFilter(list, i => i % 2 === 0)
+// result.value: [0, 2, 4, 6, 8]
+item2.value = 1
+// result.value: [0, 4, 6, 8]
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayFilter } from '@vueuse/core'
+
+const list = ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+const result = useArrayFilter(list, i => i % 2 === 0)
+// result.value: [0, 2, 4, 6, 8]
+list.value.shift()
+// result.value: [2, 4, 6, 8]
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayFilterReturn<T = any> = ComputedRef<T[]>
+/**
+ * Reactive `Array.filter`
+ *
+ * @see https://vueuse.org/useArrayFilter
+ * @param list - the array was called upon.
+ * @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
+ *
+ * @returns a shallow copy of a portion of the given array, filtered down to just the elements from the given array that pass the test implemented by the provided function. If no elements pass the test, an empty array will be returned.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayFilter<T, S extends T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: T[]) => element is S,
+): UseArrayFilterReturn<S>
+export declare function useArrayFilter<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: T[]) => unknown,
+): UseArrayFilterReturn<T>
+```

package/skills/vueuse-functions/references/useArrayFind.md

@@ -0,0 +1,50 @@
+---
+category: Array
+---
+
+# useArrayFind
+
+Reactive `Array.find`.
+
+## Usage
+
+```ts
+import { useArrayFind } from '@vueuse/core'
+
+const list = [ref(1), ref(-1), ref(2)]
+const positive = useArrayFind(list, val => val > 0)
+// positive.value: 1
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayFind } from '@vueuse/core'
+
+const list = reactive([-1, -2])
+const positive = useArrayFind(list, val => val > 0)
+// positive.value: undefined
+list.push(1)
+// positive.value: 1
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>
+/**
+ * Reactive `Array.find`
+ *
+ * @see https://vueuse.org/useArrayFind
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns the first element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayFind<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean,
+): UseArrayFindReturn<T>
+```

package/skills/vueuse-functions/references/useArrayFindIndex.md

@@ -0,0 +1,59 @@
+---
+category: Array
+---
+
+# useArrayFindIndex
+
+Reactive `Array.findIndex`
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArrayFindIndex } from '@vueuse/core'
+
+const item1 = ref(0)
+const item2 = ref(2)
+const item3 = ref(4)
+const item4 = ref(6)
+const item5 = ref(8)
+const list = [item1, item2, item3, item4, item5]
+const result = useArrayFindIndex(list, i => i % 2 === 0)
+// result.value: 0
+item1.value = 1
+// result.value: 1
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayFindIndex } from '@vueuse/core'
+
+const list = ref([0, 2, 4, 6, 8])
+const result = useArrayFindIndex(list, i => i % 2 === 0)
+// result.value: 0
+list.value.unshift(-1)
+// result.value: 1
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayFindIndexReturn = ComputedRef<number>
+/**
+ * Reactive `Array.findIndex`
+ *
+ * @see https://vueuse.org/useArrayFindIndex
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns the index of the first element in the array that passes the test. Otherwise, "-1".
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayFindIndex<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown,
+): UseArrayFindIndexReturn
+```

package/skills/vueuse-functions/references/useArrayFindLast.md

@@ -0,0 +1,52 @@
+---
+category: Array
+---
+
+# useArrayFindLast
+
+Reactive `Array.findLast`.
+
+## Usage
+
+```ts
+import { useArrayFindLast } from '@vueuse/core'
+
+const list = [ref(1), ref(-1), ref(2)]
+const positive = useArrayFindLast(list, val => val > 0)
+// positive.value: 2
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayFindLast } from '@vueuse/core'
+
+const list = reactive([-1, -2])
+const positive = useArrayFindLast(list, val => val > 0)
+// positive.value: undefined
+list.push(10)
+// positive.value: 10
+list.push(5)
+// positive.value: 5
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>
+/**
+ * Reactive `Array.findLast`
+ *
+ * @see https://vueuse.org/useArrayFindLast
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns the last element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayFindLast<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean,
+): UseArrayFindLastReturn<T>
+```

package/skills/vueuse-functions/references/useArrayIncludes.md

@@ -0,0 +1,63 @@
+---
+category: Array
+---
+
+# useArrayIncludes
+
+Reactive `Array.includes`
+
+## Usage
+
+### Use with reactive array
+
+```ts
+import { useArrayIncludes } from '@vueuse/core'
+
+const list = ref([0, 2, 4, 6, 8])
+const result = useArrayIncludes(list, 10)
+// result.value: false
+list.value.push(10)
+// result.value: true
+list.value.pop()
+// result.value: false
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayIncludesComparatorFn<T, V> = (
+  element: T,
+  value: V,
+  index: number,
+  array: MaybeRefOrGetter<T>[],
+) => boolean
+export interface UseArrayIncludesOptions<T, V> {
+  fromIndex?: number
+  comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T
+}
+export type UseArrayIncludesReturn = ComputedRef<boolean>
+/**
+ * Reactive `Array.includes`
+ *
+ * @see https://vueuse.org/useArrayIncludes
+ *
+ * @returns true if the `value` is found in the array. Otherwise, false.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayIncludes<T, V = any>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  value: MaybeRefOrGetter<V>,
+  comparator?: UseArrayIncludesComparatorFn<T, V>,
+): UseArrayIncludesReturn
+export declare function useArrayIncludes<T, V = any>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  value: MaybeRefOrGetter<V>,
+  comparator?: keyof T,
+): UseArrayIncludesReturn
+export declare function useArrayIncludes<T, V = any>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  value: MaybeRefOrGetter<V>,
+  options?: UseArrayIncludesOptions<T, V>,
+): UseArrayIncludesReturn
+```

package/skills/vueuse-functions/references/useArrayJoin.md

@@ -0,0 +1,74 @@
+---
+category: Array
+---
+
+# useArrayJoin
+
+Reactive `Array.join`
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArrayJoin } from '@vueuse/core'
+
+const item1 = ref('foo')
+const item2 = ref(0)
+const item3 = ref({ prop: 'val' })
+const list = [item1, item2, item3]
+const result = useArrayJoin(list)
+// result.value: foo,0,[object Object]
+item1.value = 'bar'
+// result.value: bar,0,[object Object]
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayJoin } from '@vueuse/core'
+
+const list = ref(['string', 0, { prop: 'val' }, false, [1], [[2]], null, undefined, []])
+const result = useArrayJoin(list)
+// result.value: string,0,[object Object],false,1,2,,,
+list.value.push(true)
+// result.value: string,0,[object Object],false,1,2,,,,true
+list.value = [null, 'string', undefined]
+// result.value: ,string,
+```
+
+### Use with reactive separator
+
+```ts
+import { useArrayJoin } from '@vueuse/core'
+
+const list = ref(['string', 0, { prop: 'val' }])
+const separator = ref()
+const result = useArrayJoin(list, separator)
+// result.value: string,0,[object Object]
+separator.value = ''
+// result.value: string0[object Object]
+separator.value = '--'
+// result.value: string--0--[object Object]
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayJoinReturn = ComputedRef<string>
+/**
+ * Reactive `Array.join`
+ *
+ * @see https://vueuse.org/useArrayJoin
+ * @param list - the array was called upon.
+ * @param separator - a string to separate each pair of adjacent elements of the array. If omitted, the array elements are separated with a comma (",").
+ *
+ * @returns a string with all array elements joined. If arr.length is 0, the empty string is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayJoin(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>,
+  separator?: MaybeRefOrGetter<string>,
+): UseArrayJoinReturn
+```

package/skills/vueuse-functions/references/useArrayMap.md

@@ -0,0 +1,59 @@
+---
+category: Array
+---
+
+# useArrayMap
+
+Reactive `Array.map`
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArrayMap } from '@vueuse/core'
+
+const item1 = ref(0)
+const item2 = ref(2)
+const item3 = ref(4)
+const item4 = ref(6)
+const item5 = ref(8)
+const list = [item1, item2, item3, item4, item5]
+const result = useArrayMap(list, i => i * 2)
+// result.value: [0, 4, 8, 12, 16]
+item1.value = 1
+// result.value: [2, 4, 8, 12, 16]
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayMap } from '@vueuse/core'
+
+const list = ref([0, 1, 2, 3, 4])
+const result = useArrayMap(list, i => i * 2)
+// result.value: [0, 2, 4, 6, 8]
+list.value.pop()
+// result.value: [0, 2, 4, 6]
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayMapReturn<T = any> = ComputedRef<T[]>
+/**
+ * Reactive `Array.map`
+ *
+ * @see https://vueuse.org/useArrayMap
+ * @param list - the array was called upon.
+ * @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
+ *
+ * @returns a new array with each element being the result of the callback function.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayMap<T, U = T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: T[]) => U,
+): UseArrayMapReturn<U>
+```

package/skills/vueuse-functions/references/useArrayReduce.md

@@ -0,0 +1,81 @@
+---
+category: Array
+---
+
+# useArrayReduce
+
+Reactive `Array.reduce`.
+
+## Usage
+
+```ts
+import { useArrayReduce } from '@vueuse/core'
+
+const sum = useArrayReduce([ref(1), ref(2), ref(3)], (sum, val) => sum + val)
+// sum.value: 6
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayReduce } from '@vueuse/core'
+
+const list = reactive([1, 2])
+const sum = useArrayReduce(list, (sum, val) => sum + val)
+
+list.push(3)
+// sum.value: 6
+```
+
+### Use with initialValue
+
+```ts
+import { useArrayReduce } from '@vueuse/core'
+
+const list = reactive([{ num: 1 }, { num: 2 }])
+const sum = useArrayReduce(list, (sum, val) => sum + val.num, 0)
+// sum.value: 3
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayReducer<PV, CV, R> = (
+  previousValue: PV,
+  currentValue: CV,
+  currentIndex: number,
+) => R
+export type UseArrayReduceReturn<T = any> = ComputedRef<T>
+/**
+ * Reactive `Array.reduce`
+ *
+ * @see https://vueuse.org/useArrayReduce
+ * @param list - the array was called upon.
+ * @param reducer - a "reducer" function.
+ *
+ * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayReduce<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  reducer: UseArrayReducer<T, T, T>,
+): UseArrayReduceReturn<T>
+/**
+ * Reactive `Array.reduce`
+ *
+ * @see https://vueuse.org/useArrayReduce
+ * @param list - the array was called upon.
+ * @param reducer - a "reducer" function.
+ * @param initialValue - a value to be initialized the first time when the callback is called.
+ *
+ * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayReduce<T, U>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  reducer: UseArrayReducer<U, T, U>,
+  initialValue: MaybeRefOrGetter<U>,
+): UseArrayReduceReturn<U>
+```

package/skills/vueuse-functions/references/useArraySome.md

@@ -0,0 +1,59 @@
+---
+category: Array
+---
+
+# useArraySome
+
+Reactive `Array.some`
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArraySome } from '@vueuse/core'
+
+const item1 = ref(0)
+const item2 = ref(2)
+const item3 = ref(4)
+const item4 = ref(6)
+const item5 = ref(8)
+const list = [item1, item2, item3, item4, item5]
+const result = useArraySome(list, i => i > 10)
+// result.value: false
+item1.value = 11
+// result.value: true
+```
+
+### Use with reactive array
+
+```ts
+import { useArraySome } from '@vueuse/core'
+
+const list = ref([0, 2, 4, 6, 8])
+const result = useArraySome(list, i => i > 10)
+// result.value: false
+list.value.push(11)
+// result.value: true
+```
+
+## Type Declarations
+
+```ts
+export type UseArraySomeReturn = ComputedRef<boolean>
+/**
+ * Reactive `Array.some`
+ *
+ * @see https://vueuse.org/useArraySome
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArraySome<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown,
+): UseArraySomeReturn
+```

package/skills/vueuse-functions/references/useArrayUnique.md

@@ -0,0 +1,76 @@
+---
+category: Array
+---
+
+# useArrayUnique
+
+reactive unique array
+
+## Usage
+
+### Use with array of multiple refs
+
+```ts
+import { useArrayUnique } from '@vueuse/core'
+
+const item1 = ref(0)
+const item2 = ref(1)
+const item3 = ref(1)
+const item4 = ref(2)
+const item5 = ref(3)
+const list = [item1, item2, item3, item4, item5]
+const result = useArrayUnique(list)
+// result.value: [0, 1, 2, 3]
+item5.value = 1
+// result.value: [0, 1, 2]
+```
+
+### Use with reactive array
+
+```ts
+import { useArrayUnique } from '@vueuse/core'
+
+const list = reactive([1, 2, 2, 3])
+const result = useArrayUnique(list)
+// result.value: [1, 2, 3]
+
+list.push(1)
+// result.value: [1, 2, 3]
+```
+
+### Use with custom function
+
+```ts
+import { useArrayUnique } from '@vueuse/core'
+
+const list = reactive([
+  { id: 1, name: 'foo' },
+  { id: 2, name: 'bar' },
+  { id: 1, name: 'baz' },
+])
+
+const result = useArrayUnique(list, (a, b) => a.id === b.id)
+// result.value: [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }]
+
+list.push({ id: 1, name: 'qux' })
+// result.value: [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }]
+```
+
+## Type Declarations
+
+```ts
+export type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>
+/**
+ * reactive unique array
+ * @see https://vueuse.org/useArrayUnique
+ * @param list - the array was called upon.
+ * @param compareFn
+ * @returns A computed ref that returns a unique array of items.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useArrayUnique<T>(
+  list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
+  compareFn?: (a: T, b: T, array: T[]) => boolean,
+): UseArrayUniqueReturn<T>
+```