feat(reactiveOmit): add predicate parameter

packages/shared/reactiveOmit/index.md

@@ -8,7 +8,9 @@ Reactively omit fields from a reactive object.
 
 ## Usage
 
-```js
+### Basic Usage
+
+```ts
 import { reactiveOmit } from '@vueuse/core'
 
 const obj = reactive({
@@ -21,6 +23,22 @@ const obj = reactive({
 const picked = reactiveOmit(obj, 'x', 'elementX') // { y: number, elementY: number }
 ```
 
+### Predicate Usage
+
+```ts
+import { reactiveOmit } from '@vueuse/core'
+
+const obj = reactive({
+  bar: 'bar',
+  baz: 'should be omit',
+  foo: 'foo2',
+  qux: true,
+})
+
+const picked = reactiveOmit(obj, (key, value) => key === 'baz' || value === true)
+// { bar: string, foo: string }
+```
+
 ### Scenarios
 
 #### Selectively passing props to child

packages/shared/reactiveOmit/index.test.ts

@@ -56,4 +56,28 @@ describe('reactiveOmit', () => {
       }
     `)
   })
+
+  it('should work with predicate', () => {
+    const source = reactive<TargetObject>({
+      foo: 'foo',
+      bar: 'bar',
+      baz: 'baz',
+      qux: true,
+    })
+
+    const state = reactiveOmit(source, (value, key) =>
+      key === 'bar' || key === 'baz' || value === true,
+    )
+
+    expect(state).toEqual({
+      foo: 'foo',
+    })
+
+    source.qux = false
+
+    expect(state).toEqual({
+      foo: 'foo',
+      qux: false,
+    })
+  })
 })

packages/shared/reactiveOmit/index.ts

@@ -1,6 +1,17 @@
 import { toRefs } from 'vue-demi'
+import { resolveUnref } from '../resolveUnref'
 import { reactiveComputed } from '../reactiveComputed'
 
+export type ReactiveOmitPredicate<T> = (value: T[keyof T], key: keyof T) => boolean
+
+export function reactiveOmit<T extends object, K extends keyof T>(
+  obj: T,
+  ...keys: (K | K[])[]
+): Omit<T, K>
+export function reactiveOmit<T extends object>(
+  obj: T,
+  predicate: ReactiveOmitPredicate<T>,
+): Partial<T>
 /**
  * Reactively omit fields from a reactive object
  *
@@ -11,5 +22,10 @@ export function reactiveOmit<T extends object, K extends keyof T>(
   ...keys: (K | K[])[]
 ): Omit<T, K> {
   const flatKeys = keys.flat() as K[]
-  return reactiveComputed<any>(() => Object.fromEntries(Object.entries(toRefs(obj)).filter(e => !flatKeys.includes(e[0] as any))))
+  const predicate = flatKeys[0] as unknown as ReactiveOmitPredicate<T>
+  return reactiveComputed<any>(() =>
+    typeof predicate === 'function'
+      ? Object.fromEntries(Object.entries(toRefs(obj)).filter(([k, v]) => !predicate(resolveUnref(v) as T[K], k as K)))
+      : Object.fromEntries(Object.entries(toRefs(obj)).filter(e => !flatKeys.includes(e[0] as any))),
+  )
 }