feat(useMax): new function

packages/math/index.ts

@@ -6,5 +6,6 @@ export * from './logicOr'
 export * from './useCeil'
 export * from './useClamp'
 export * from './useFloor'
+export * from './useMax'
 export * from './useProjection'
 export * from './useRound'

packages/math/useMax/index.md

@@ -0,0 +1,21 @@
+---
+category: '@Math'
+---
+
+# useMax
+
+Reactive `Math.max`.
+
+## Usage
+
+```ts
+import { useMax } from '@vueuse/math'
+
+const max1 = ref(10)
+const max2 = ref(20)
+const result = useMax(max1, max2)
+// result.value is 20
+
+max1.value = 50
+// result.value is 50 now
+```

packages/math/useMax/index.test.ts

@@ -0,0 +1,53 @@
+import { ref } from 'vue-demi'
+import { useMax } from '.'
+
+describe('useMax', () => {
+  it('should be defined', () => {
+    expect(useMax).toBeDefined()
+  })
+
+  it('should accept numbers', () => {
+    const v = useMax(50, 100)
+    expect(v.value).toBe(100)
+  })
+
+  it('should accept refs', () => {
+    const value1 = ref(10)
+    const value2 = ref(100)
+    const value3 = ref(1000)
+
+    const v = useMax(value1, value2, value3)
+    expect(v.value).toBe(1000)
+
+    value1.value = 2000
+    expect(v.value).toBe(2000)
+
+    value2.value = 2001
+    expect(v.value).toBe(2001)
+
+    value3.value = 2002
+    expect(v.value).toBe(2002)
+  })
+
+  it('should accept numbers and refs', () => {
+    const value1 = 10
+    const value2 = ref(100)
+
+    const v = useMax(50, value1, value2)
+
+    expect(v.value).toBe(100)
+
+    value2.value = 200
+    expect(v.value).toBe(200)
+  })
+
+  it('should accept single arg', () => {
+    const v = useMax(50)
+    expect(v.value).toBe(50)
+  })
+
+  it('should accept zero arg', () => {
+    const v = useMax()
+    expect(v.value).toBe(-Infinity)
+  })
+})

packages/math/useMax/index.ts

@@ -0,0 +1,15 @@
+import { computed } from 'vue-demi'
+import type { MaybeComputedRef } from '@vueuse/shared'
+import { resolveUnref } from '@vueuse/shared'
+
+/**
+ * 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))),
+  )
+}