Adjust how the proxy functions for useObject

No longer uses `revoke()`

Author: exoRift

package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-exo-hooks",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "module": "index.ts",
   "main": "dist/index.js",
   "description": "A collection of useful hooks for data structures and logic, designed for efficiency",

src/hooks/use-object.ts

@@ -15,84 +15,67 @@ function isPlainObject (value: unknown): value is object {
 
 /**
  * Proxy an object recursively
- * @param object    The object
- * @param setSignal The signal dispatch fn
- * @returns         The proxied object
+ * @param object The object
+ * @param update The function that updates the signal
+ * @returns      The proxied object
  */
-function proxyObject<T extends object> (object: T, setSignal: React.Dispatch<React.SetStateAction<number>>): [proxy: T, revoke: () => void] {
-  const revocables: Array<() => void> = []
-
+function proxyObject<T extends object> (object: T, update: () => void): T {
   for (const key in object) {
     const original = object[key as keyof typeof object]
+
     if (isPlainObject(original)) {
-      const [subproxy, subrevoke] = proxyObject(original, setSignal)
+      const subproxy = proxyObject(original, update)
+
       object[key as keyof typeof object] = subproxy as any
-      revocables.push(() => {
-        subrevoke()
-        object[key as keyof typeof object] = original
-      })
     }
   }
 
-  const proxy = Proxy.revocable(object, {
-    set (target, prop, newValue) {
-      if (prop !== 'valueOf' && target[prop as keyof typeof target] !== newValue) setSignal((prior) => prior + 1)
+  const proxy = new Proxy(object, {
+    set (target, prop, newValue, receiver) {
+      if (prop !== 'valueOf' && target[prop as keyof typeof target] !== newValue) update()
+
       const isPlain = isPlainObject(newValue)
       if (isPlain) {
-        const [subproxy, subrevoke] = proxyObject(newValue, setSignal)
-        revocables.push(() => {
-          subrevoke()
-          Reflect.set(target, prop, newValue)
-        })
-        return Reflect.set(target, prop, subproxy)
-      } else return Reflect.set(target, prop, newValue)
+        const subproxy = proxyObject(newValue, update)
+
+        return Reflect.set(target, prop, subproxy, receiver)
+      } else return Reflect.set(target, prop, newValue, receiver)
     },
 
     deleteProperty (target, prop) {
-      if (prop in target) setSignal((prior) => prior + 1)
+      if (prop in target) update()
+
       return Reflect.deleteProperty(target, prop)
     }
   })
 
-  function revoke (): void {
-    proxy.revoke()
-    for (const subrevoke of revocables) subrevoke()
-  }
-
-  return [proxy.proxy, revoke]
+  return proxy
 }
 
 /**
  * Create an object state value that auto updates on mutation \
  * This hook is recursive into simple object properties. Class instances will remain unaffected
  * @note Effects and memos that use this object should also listen for its signal: `+INSTANCE`
- * @warn You should revoke the proxy if you're done with render and don't want unforseen complications. Auto-revokes on and `setObject`
  * @param initial The initial object
- * @returns       [object, setObject, forceUpdate, revoke]
+ * @returns       [object, setObject, forceUpdate]
  */
-export function useObject<T extends object> (initial: T): [object: T, setObject: React.Dispatch<React.SetStateAction<T>>, forceUpdate: () => void, revoke: () => void] {
+export function useObject<T extends object> (initial: T): [object: T, setObject: React.Dispatch<React.SetStateAction<T>>, forceUpdate: () => void] {
   const revoked = useRef(false)
 
   const [signal, setSignal] = useState(0)
   const [object, setObject] = useState(initial)
 
-  const [proxy, _revoke] = useMemo(() => proxyObject(object, setSignal), [object])
+  const proxy = useMemo(() => proxyObject(object, () => setSignal((prior) => prior + 1)), [object, setSignal])
 
-  const forceUpdate = useCallback(() => {
+  const forceUpdate = useCallback(() =>
     setSignal((prior) => prior + 1)
-  }, [])
-
-  const revoke = useCallback(() => {
-    if (!import.meta.hot) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-      _revoke()
-      revoked.current = true
-    }
-  }, [_revoke])
+  , [])
 
   useEffect(() => {
-    return () => revoke()
-  }, [revoke])
+    revoked.current = false
+    return () => { revoked.current = true }
+  }, [])
 
   proxy.valueOf = () => signal
-  return [revoked.current ? object : proxy, setObject, forceUpdate, revoke]
+  return [revoked.current ? object : proxy, setObject, forceUpdate]
 }