refactor(math): extract common utils

packages/math/useAverage/index.ts

@@ -1,7 +1,8 @@
 import type { ComputedRef } from 'vue-demi'
 import { computed } from 'vue-demi'
-import { resolveUnref } from '@vueuse/shared'
 import type { MaybeComputedRef } from '@vueuse/shared'
+import type { MaybeComputedRefArgs } from '../utils'
+import { resolveUnrefArgsFlat } from '../utils'
 
 export function useAverage(array: MaybeComputedRef<MaybeComputedRef<number>[]>): ComputedRef<number>
 export function useAverage(...args: MaybeComputedRef<number>[]): ComputedRef<number>
@@ -11,15 +12,9 @@ export function useAverage(...args: MaybeComputedRef<number>[]): ComputedRef<num
  *
  * @see https://vueuse.org/useAverage
  */
-export function useAverage(...args: any[]): ComputedRef<number> {
+export function useAverage(...args: MaybeComputedRefArgs<number>): ComputedRef<number> {
   return computed(() => {
-    const array = args
-      .flatMap<number>((i) => {
-        const v = resolveUnref(i)
-        if (Array.isArray(v))
-          return v.map(i => resolveUnref(i))
-        return [v]
-      })
-    return array.reduce<number>((sum, v) => sum += v, 0) / array.length
+    const array = resolveUnrefArgsFlat(args)
+    return array.reduce((sum, v) => sum += v, 0) / array.length
   })
 }

packages/math/useMax/index.md

@@ -11,11 +11,15 @@ Reactive `Math.max`.
 ```ts
 import { useMax } from '@vueuse/math'
 
-const max1 = ref(10)
-const max2 = ref(20)
-const result = useMax(max1, max2)
-// result.value is 20
+const array = ref([1, 2, 3, 4])
+const sum = useMax(array) // Ref<4>
+```
+
+```ts
+import { useMax } from '@vueuse/math'
+
+const a = ref(1)
+const b = ref(3)
 
-max1.value = 50
-// result.value is 50 now
+const sum = useMax(a, b, 2) // Ref<3>
 ```

packages/math/useMax/index.ts

@@ -1,15 +1,21 @@
+import type { ComputedRef } from 'vue-demi'
 import { computed } from 'vue-demi'
 import type { MaybeComputedRef } from '@vueuse/shared'
-import { resolveUnref } from '@vueuse/shared'
+import type { MaybeComputedRefArgs } from '../utils'
+import { resolveUnrefArgsFlat } from '../utils'
+
+export function useMax(array: MaybeComputedRef<MaybeComputedRef<number>[]>): ComputedRef<number>
+export function useMax(...args: MaybeComputedRef<number>[]): ComputedRef<number>
 
 /**
  * Reactively get maximum of values.
  *
  * @see https://vueuse.org/useMax
  * @param values
  */
-export function useMax(...values: MaybeComputedRef<number>[]) {
-  return computed<number>(() =>
-    Math.max(...values.map(value => resolveUnref(value))),
-  )
+export function useMax(...args: MaybeComputedRefArgs<number>) {
+  return computed<number>(() => {
+    const array = resolveUnrefArgsFlat(args)
+    return Math.max(...array)
+  })
 }

packages/math/useSum/index.ts

@@ -1,7 +1,8 @@
 import type { ComputedRef } from 'vue-demi'
 import { computed } from 'vue-demi'
 import type { MaybeComputedRef } from '@vueuse/shared'
-import { resolveUnref } from '@vueuse/shared'
+import type { MaybeComputedRefArgs } from '../utils'
+import { resolveUnrefArgsFlat } from '../utils'
 
 export function useSum(array: MaybeComputedRef<MaybeComputedRef<number>[]>): ComputedRef<number>
 export function useSum(...args: MaybeComputedRef<number>[]): ComputedRef<number>
@@ -11,14 +12,6 @@ export function useSum(...args: MaybeComputedRef<number>[]): ComputedRef<number>
  *
  * @see https://vueuse.org/useSum
  */
-export function useSum(...args: any[]): ComputedRef<number> {
-  return computed(() => args
-    .flatMap((i) => {
-      const v = resolveUnref(i)
-      if (Array.isArray(v))
-        return v.map(i => resolveUnref(i))
-      return [v]
-    })
-    .reduce<number>((sum, v) => sum += v, 0),
-  )
+export function useSum(...args: MaybeComputedRefArgs<number>): ComputedRef<number> {
+  return computed(() => resolveUnrefArgsFlat(args).reduce((sum, v) => sum += v, 0))
 }

packages/math/utils.ts

@@ -0,0 +1,14 @@
+import type { MaybeComputedRef } from '@vueuse/shared'
+import { resolveUnref } from '@vueuse/shared'
+
+export type MaybeComputedRefArgs<T> = MaybeComputedRef<T>[] | [MaybeComputedRef<MaybeComputedRef<T>[]>]
+
+export function resolveUnrefArgsFlat<T>(args: MaybeComputedRefArgs<T>): T[] {
+  return args
+    .flatMap((i: any) => {
+      const v = resolveUnref(i)
+      if (Array.isArray(v))
+        return v.map(i => resolveUnref(i))
+      return [v]
+    })
+}

packages/shared/index.ts

@@ -33,6 +33,7 @@ export * from './tryOnUnmounted'
 export * from './until'
 export * from './useArrayEvery'
 export * from './useArrayFilter'
+export * from './useArrayFind'
 export * from './useArrayJoin'
 export * from './useArrayMap'
 export * from './useArrayReduce'