feat(vanilla): enable per-proxy granularity for unstable_enableOp

Author: s524797336

src/vanilla.ts

@@ -123,38 +123,41 @@ const createHandlerDefault = <T extends object>(
   addPropListener: (prop: string | symbol, propValue: unknown) => void,
   removePropListener: (prop: string | symbol) => void,
   notifyUpdate: (op: Op | undefined) => void,
-): ProxyHandler<T> => ({
-  deleteProperty(target: T, prop: string | symbol) {
-    const prevValue = Reflect.get(target, prop)
-    removePropListener(prop)
-    const deleted = Reflect.deleteProperty(target, prop)
-    if (deleted) {
-      notifyUpdate(createOp?.('delete', prop, prevValue))
-    }
-    return deleted
-  },
-  set(target: T, prop: string | symbol, value: any, receiver: object) {
-    const hasPrevValue = !isInitializing() && Reflect.has(target, prop)
-    const prevValue = Reflect.get(target, prop, receiver)
-    if (
-      hasPrevValue &&
-      (objectIs(prevValue, value) ||
-        (proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value))))
-    ) {
+): ProxyHandler<T> => {
+  const createOpHandle = createOp
+  return {
+    deleteProperty(target: T, prop: string | symbol) {
+      const prevValue = Reflect.get(target, prop)
+      removePropListener(prop)
+      const deleted = Reflect.deleteProperty(target, prop)
+      if (deleted) {
+        notifyUpdate(createOpHandle?.('delete', prop, prevValue))
+      }
+      return deleted
+    },
+    set(target: T, prop: string | symbol, value: any, receiver: object) {
+      const hasPrevValue = !isInitializing() && Reflect.has(target, prop)
+      const prevValue = Reflect.get(target, prop, receiver)
+      if (
+        hasPrevValue &&
+        (objectIs(prevValue, value) ||
+          (proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value))))
+      ) {
+        return true
+      }
+      removePropListener(prop)
+      if (isObject(value)) {
+        value = getUntracked(value) || value
+      }
+      const nextValue =
+        !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value
+      addPropListener(prop, nextValue)
+      Reflect.set(target, prop, nextValue, receiver)
+      notifyUpdate(createOpHandle?.('set', prop, value, prevValue))
       return true
-    }
-    removePropListener(prop)
-    if (isObject(value)) {
-      value = getUntracked(value) || value
-    }
-    const nextValue =
-      !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value
-    addPropListener(prop, nextValue)
-    Reflect.set(target, prop, nextValue, receiver)
-    notifyUpdate(createOp?.('set', prop, value, prevValue))
-    return true
-  },
-})
+    },
+  }
+}
 
 const createOpDefault = (
   type: 'set' | 'delete',

tests/subscribe.test.tsx

@@ -266,3 +266,48 @@ describe('subscribe with op', () => {
     expect(handler).lastCalledWith([['delete', ['nested', 'count'], 1]])
   })
 })
+
+describe('subscribe to a specific proxy that has op enabled', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('obj1 should notify ops and obj2 not', async () => {
+    unstable_enableOp(true)
+    const obj1 = proxy<{ count1: number; count2?: number }>({
+      count1: 0,
+      count2: 0,
+    })
+    unstable_enableOp(false)
+    const obj2 = proxy<{ count1: number; count2?: number }>({
+      count1: 0,
+      count2: 0,
+    })
+    const handler1 = vi.fn()
+
+    subscribe(obj1, handler1)
+
+    obj1.count1 += 1
+    obj1.count2 = 2
+
+    const handler2 = vi.fn()
+
+    subscribe(obj2, handler2)
+
+    obj2.count1 += 1
+    obj2.count2 = 2
+
+    await vi.advanceTimersByTimeAsync(0)
+    expect(handler1).toBeCalledTimes(1)
+    expect(handler1).lastCalledWith([
+      ['set', ['count1'], 1, 0],
+      ['set', ['count2'], 2, 0],
+    ])
+    expect(handler2).toBeCalledTimes(1)
+    expect(handler2).lastCalledWith([])
+  })
+})