@yiin/reactive-proxy-state 1.0.13 → 1.0.14

package/dist/index.js

@@ -539,12 +539,12 @@ function watchEffect(effectCallback, options = {}) {
 }
 
 // src/wrap-set.ts
-function wrapSet(set, emit, path = [], seen = globalSeen) {
+function wrapSet(set, emit, path = []) {
   const cachedProxy = wrapperCache.get(set);
   if (cachedProxy)
     return cachedProxy;
-  if (seen.has(set))
-    return seen.get(set);
+  if (globalSeen.has(set))
+    return globalSeen.get(set);
   const methodCache = {};
   const proxy = new Proxy(set, {
     get(target, prop, receiver) {
@@ -657,8 +657,8 @@ function wrapSet(set, emit, path = [], seen = globalSeen) {
             track(target, String(index));
             let wrappedValue = valueToWrap;
             if (valueToWrap && typeof valueToWrap === "object") {
-              if (seen.has(valueToWrap)) {
-                wrappedValue = seen.get(valueToWrap);
+              if (globalSeen.has(valueToWrap)) {
+                wrappedValue = globalSeen.get(valueToWrap);
               } else {
                 const cachedValueProxy = wrapperCache.get(valueToWrap);
                 if (cachedValueProxy) {
@@ -672,15 +672,15 @@ function wrapSet(set, emit, path = [], seen = globalSeen) {
                     setPathConcat(pathKey, newPath);
                   }
                   if (valueToWrap instanceof Map)
-                    wrappedValue = wrapMap(valueToWrap, emit, newPath, seen);
+                    wrappedValue = wrapMap(valueToWrap, emit, newPath);
                   else if (valueToWrap instanceof Set)
-                    wrappedValue = wrapSet(valueToWrap, emit, newPath, seen);
+                    wrappedValue = wrapSet(valueToWrap, emit, newPath);
                   else if (Array.isArray(valueToWrap))
-                    wrappedValue = wrapArray(valueToWrap, emit, newPath, seen);
+                    wrappedValue = wrapArray(valueToWrap, emit, newPath);
                   else if (valueToWrap instanceof Date)
                     wrappedValue = new Date(valueToWrap.getTime());
                   else
-                    wrappedValue = reactive(valueToWrap, emit, newPath, seen);
+                    wrappedValue = reactive(valueToWrap, emit, newPath);
                 }
               }
             }
@@ -705,18 +705,18 @@ function wrapSet(set, emit, path = [], seen = globalSeen) {
       return value;
     }
   });
-  seen.set(set, proxy);
+  globalSeen.set(set, proxy);
   wrapperCache.set(set, proxy);
   return proxy;
 }
 
 // src/wrap-map.ts
-function wrapMap(map, emit, path = [], seen = globalSeen) {
+function wrapMap(map, emit, path = []) {
   const cachedProxy = wrapperCache.get(map);
   if (cachedProxy)
     return cachedProxy;
-  if (seen.has(map))
-    return seen.get(map);
+  if (globalSeen.has(map))
+    return globalSeen.get(map);
   const methodCache = {};
   const proxy = new Proxy(map, {
     get(target, prop, receiver) {
@@ -823,8 +823,8 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
           const value2 = target.get(key);
           if (!value2 || typeof value2 !== "object")
             return value2;
-          if (seen.has(value2))
-            return seen.get(value2);
+          if (globalSeen.has(value2))
+            return globalSeen.get(value2);
           const cachedValueProxy = wrapperCache.get(value2);
           if (cachedValueProxy)
             return cachedValueProxy;
@@ -836,14 +836,14 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
             setPathConcat(pathKey, newPath);
           }
           if (value2 instanceof Map)
-            return wrapMap(value2, emit, newPath, seen);
+            return wrapMap(value2, emit, newPath);
           if (value2 instanceof Set)
-            return wrapSet(value2, emit, newPath, seen);
+            return wrapSet(value2, emit, newPath);
           if (Array.isArray(value2))
-            return wrapArray(value2, emit, newPath, seen);
+            return wrapArray(value2, emit, newPath);
           if (value2 instanceof Date)
             return new Date(value2.getTime());
-          return reactive(value2, emit, newPath, seen);
+          return reactive(value2, emit, newPath);
         };
         return methodCache[prop];
       }
@@ -880,8 +880,8 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
             }
             let wrappedKey = keyToWrap;
             if (isEntry && keyToWrap && typeof keyToWrap === "object") {
-              if (seen.has(keyToWrap)) {
-                wrappedKey = seen.get(keyToWrap);
+              if (globalSeen.has(keyToWrap)) {
+                wrappedKey = globalSeen.get(keyToWrap);
               } else {
                 const pathKey = path.length > 0 ? `${path.join(".")}.${String(keyToWrap)}` : String(keyToWrap);
                 let keyPath = getPathConcat(pathKey);
@@ -889,13 +889,13 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
                   keyPath = path.concat(String(keyToWrap));
                   setPathConcat(pathKey, keyPath);
                 }
-                wrappedKey = reactive(keyToWrap, emit, keyPath, seen);
+                wrappedKey = reactive(keyToWrap, emit, keyPath);
               }
             }
             let wrappedValue = valueToWrap;
             if (valueToWrap && typeof valueToWrap === "object") {
-              if (seen.has(valueToWrap)) {
-                wrappedValue = seen.get(valueToWrap);
+              if (globalSeen.has(valueToWrap)) {
+                wrappedValue = globalSeen.get(valueToWrap);
               } else {
                 const cachedValueProxy = wrapperCache.get(valueToWrap);
                 if (cachedValueProxy) {
@@ -909,15 +909,15 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
                     setPathConcat(pathKey, newPath);
                   }
                   if (valueToWrap instanceof Map)
-                    wrappedValue = wrapMap(valueToWrap, emit, newPath, seen);
+                    wrappedValue = wrapMap(valueToWrap, emit, newPath);
                   else if (valueToWrap instanceof Set)
-                    wrappedValue = wrapSet(valueToWrap, emit, newPath, seen);
+                    wrappedValue = wrapSet(valueToWrap, emit, newPath);
                   else if (Array.isArray(valueToWrap))
-                    wrappedValue = wrapArray(valueToWrap, emit, newPath, seen);
+                    wrappedValue = wrapArray(valueToWrap, emit, newPath);
                   else if (valueToWrap instanceof Date)
                     wrappedValue = new Date(valueToWrap.getTime());
                   else
-                    wrappedValue = reactive(valueToWrap, emit, newPath, seen);
+                    wrappedValue = reactive(valueToWrap, emit, newPath);
                 }
               }
             }
@@ -943,7 +943,7 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
       return value;
     }
   });
-  seen.set(map, proxy);
+  globalSeen.set(map, proxy);
   wrapperCache.set(map, proxy);
   return proxy;
 }
@@ -952,12 +952,12 @@ function wrapMap(map, emit, path = [], seen = globalSeen) {
 function isObject2(v) {
   return v && typeof v === "object";
 }
-function wrapArray(arr, emit, path = [], seen = globalSeen) {
+function wrapArray(arr, emit, path = []) {
   const cachedProxy = wrapperCache.get(arr);
   if (cachedProxy)
     return cachedProxy;
-  if (seen.has(arr))
-    return seen.get(arr);
+  if (globalSeen.has(arr))
+    return globalSeen.get(arr);
   const methodCache = {};
   const proxy = new Proxy(arr, {
     get(target, prop, receiver) {
@@ -1111,8 +1111,8 @@ function wrapArray(arr, emit, path = [], seen = globalSeen) {
         track(target, String(prop));
         if (!isObject2(value))
           return value;
-        if (seen.has(value))
-          return seen.get(value);
+        if (globalSeen.has(value))
+          return globalSeen.get(value);
         const cachedValueProxy = wrapperCache.get(value);
         if (cachedValueProxy)
           return cachedValueProxy;
@@ -1124,14 +1124,14 @@ function wrapArray(arr, emit, path = [], seen = globalSeen) {
           setPathConcat(pathKey, newPath);
         }
         if (Array.isArray(value))
-          return wrapArray(value, emit, newPath, seen);
+          return wrapArray(value, emit, newPath);
         if (value instanceof Map)
-          return wrapMap(value, emit, newPath, seen);
+          return wrapMap(value, emit, newPath);
         if (value instanceof Set)
-          return wrapSet(value, emit, newPath, seen);
+          return wrapSet(value, emit, newPath);
         if (value instanceof Date)
           return new Date(value.getTime());
-        return reactive(value, emit, newPath, seen);
+        return reactive(value, emit, newPath);
       }
       if (typeof value === "function") {
         return value.bind(target);
@@ -1167,7 +1167,7 @@ function wrapArray(arr, emit, path = [], seen = globalSeen) {
       return result;
     }
   });
-  seen.set(arr, proxy);
+  globalSeen.set(arr, proxy);
   wrapperCache.set(arr, proxy);
   return proxy;
 }
@@ -1191,9 +1191,9 @@ function toRaw(observed) {
   const raw = observed && observed["__v_raw" /* RAW */];
   return raw ? toRaw(raw) : observed;
 }
-function reactive(obj, emit, path = [], seen = globalSeen) {
-  if (seen.has(obj))
-    return seen.get(obj);
+function reactive(obj, emit, path = []) {
+  if (globalSeen.has(obj))
+    return globalSeen.get(obj);
   if (emit && path.length === 0) {
     try {
       const initialEvent = {
@@ -1207,28 +1207,28 @@ function reactive(obj, emit, path = [], seen = globalSeen) {
     }
   }
   if (Array.isArray(obj)) {
-    return wrapArray(obj, emit, path, seen);
+    return wrapArray(obj, emit, path);
   }
   if (obj instanceof Map) {
-    return wrapMap(obj, emit, path, seen);
+    return wrapMap(obj, emit, path);
   }
   if (obj instanceof Set) {
-    return wrapSet(obj, emit, path, seen);
+    return wrapSet(obj, emit, path);
   }
   function wrapValue(val, subPath) {
     if (!isObject3(val))
       return val;
-    if (seen.has(val))
-      return seen.get(val);
+    if (globalSeen.has(val))
+      return globalSeen.get(val);
     if (Array.isArray(val))
       return wrapArray(val, emit, subPath);
     if (val instanceof Map)
-      return wrapMap(val, emit, subPath, seen);
+      return wrapMap(val, emit, subPath);
     if (val instanceof Set)
-      return wrapSet(val, emit, subPath, seen);
+      return wrapSet(val, emit, subPath);
     if (val instanceof Date)
       return new Date(val.getTime());
-    return reactive(val, emit, subPath, seen);
+    return reactive(val, emit, subPath);
   }
   const proxy = new Proxy(obj, {
     get(target, prop, receiver) {
@@ -1301,7 +1301,7 @@ function reactive(obj, emit, path = [], seen = globalSeen) {
       return result;
     }
   });
-  seen.set(obj, proxy);
+  globalSeen.set(obj, proxy);
   return proxy;
 }
 // src/watch.ts

package/dist/reactive.d.ts

@@ -1,4 +1,4 @@
-import { EmitFunction, Path } from './types';
+import { EmitFunction, Path } from "./types";
 /**
  * Checks if an object is a reactive proxy
  */
@@ -11,4 +11,4 @@ export declare function toRaw<T>(observed: T): T;
 /**
  * Create a reactive proxy for an object
  */
-export declare function reactive<T extends object>(obj: T, emit?: EmitFunction, path?: Path, seen?: WeakMap<any, any>): T;
+export declare function reactive<T extends object>(obj: T, emit?: EmitFunction, path?: Path): T;

package/dist/wrap-array.d.ts

@@ -1,2 +1,2 @@
-import { EmitFunction, Path } from './types';
-export declare function wrapArray<T extends any[]>(arr: T, emit?: EmitFunction, path?: Path, seen?: WeakMap<any, any>): T;
+import { EmitFunction, Path } from "./types";
+export declare function wrapArray<T extends any[]>(arr: T, emit?: EmitFunction, path?: Path): T;

package/dist/wrap-map.d.ts

@@ -1,2 +1,2 @@
-import { EmitFunction, Path } from './types';
-export declare function wrapMap<K, V>(map: Map<K, V>, emit?: EmitFunction, path?: Path, seen?: WeakMap<any, any>): Map<K, V>;
+import { EmitFunction, Path } from "./types";
+export declare function wrapMap<K, V>(map: Map<K, V>, emit?: EmitFunction, path?: Path): Map<K, V>;

package/dist/wrap-set.d.ts

@@ -1,2 +1,2 @@
-import { EmitFunction, Path } from './types';
-export declare function wrapSet<T>(set: Set<T>, emit?: EmitFunction, path?: Path, seen?: WeakMap<any, any>): Set<T>;
+import { EmitFunction, Path } from "./types";
+export declare function wrapSet<T>(set: Set<T>, emit?: EmitFunction, path?: Path): Set<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yiin/reactive-proxy-state",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "author": "Yiin <stanislovas@yiin.lt>",
   "repository": {
     "type": "git",