fix: ajusta emulador para nao perder memoria

src/Emulator.ts

@@ -31,15 +31,15 @@ export default class Emulator implements Exotic.Emulator {
   }
 
   getId(value: Exotic.traceable): number {
-    return lib.methods.getId(this, value);
+    return lib.methods.getId(value);
   }
 
   target(value?: any): any {
-    return lib.methods.target(this, value);
+    return lib.methods.target(value);
   }
 
   parent(value?: Exotic.traceable): undefined | Exotic.Proxy {
-    return lib.methods.parent(this, value);
+    return lib.methods.parent(value);
   }
 
   values(value?: Exotic.traceable): Exotic.Proxy[] {
@@ -51,23 +51,19 @@ export default class Emulator implements Exotic.Emulator {
   }
 
   revoke(value: Exotic.traceable): boolean {
-    return lib.methods.revoke(this, value);
+    return lib.methods.revoke(value);
   }
 
   isRevoked(value: Exotic.traceable): boolean {
-    return lib.methods.isRevoked(this, value);
+    return lib.methods.isRevoked(value);
   }
 
-  entries(): IterableIterator<Exotic.Proxy> {
-    return lib.methods.entries(this);
-  }
-
-  entriesBefore(value: Exotic.traceable): IterableIterator<Exotic.Proxy> {
-    return lib.methods.entriesBefore(this, value);
+  [Symbol.iterator](): IterableIterator<Exotic.Proxy> {
+    return lib.methods.entries();
   }
 
-  entriesAfter(value: Exotic.traceable): IterableIterator<Exotic.Proxy> {
-    return lib.methods.entriesAfter(this, value);
+  entries(): IterableIterator<Exotic.Proxy> {
+    return lib.methods.entries();
   }
 
   encode(value: any): Exotic.payload {
@@ -77,4 +73,8 @@ export default class Emulator implements Exotic.Emulator {
   get(value?: any): Promise<any> {
     return lib.methods.get(this, value);
   }
+
+  kill(): void {
+    return lib.methods.kill(this);
+  }
 }

src/index.ts

@@ -27,5 +27,6 @@ for (let i = 0; i < 1000000; i++) {
   p();
   p();
   p();
+  $.kill();
 }
 console.log("the end");

src/lib/constructor.spec.ts

@@ -7,32 +7,14 @@ describe("(constructor)", () => {
     const config: Exotic.emulator.options = {};
     const emulator = new Emulator(config);
     const data: Record<string, any> = map.emulators.get(emulator) || {};
-
-    const dataProps = [
-      "options",
-      "refs",
-      "totalProxies",
-      "activeProxies",
-      "firstProxy",
-      "lastProxy",
-    ];
-
-    const {
-      options,
-      refs,
-      totalProxies,
-      activeProxies,
-      firstProxy,
-      lastProxy,
-    } = data;
+    const dataProps = ["options", "refs", "totalProxies", "activeProxies"];
+    const { options, refs, totalProxies, activeProxies } = data;
 
     expect(map.emulators.has(emulator)).toBe(true);
     expect(Object.keys(data)).toEqual(dataProps);
     expect(options).toBe(config);
     expect(Reflect.ownKeys(refs).length).toBe(0);
     expect(totalProxies).toBe(0);
     expect(activeProxies).toBe(0);
-    expect(firstProxy).toBeUndefined();
-    expect(lastProxy).toBeUndefined();
   });
 });

src/lib/constructor.ts

@@ -10,8 +10,6 @@ export default function constructor(
     refs: Object.create(null),
     totalProxies: 0, // total item count including revoked items, it only increases
     activeProxies: 0, // items that are not revoked
-    firstProxy: undefined,
-    lastProxy: undefined,
   };
 
   map.emulators.set(scope, data);

src/lib/methods/entries.ts

@@ -1,10 +1,6 @@
 import Exotic from "../../types/Exotic";
-import { proxyGenerator } from "../../utils";
+import { proxyIterator } from "../../utils";
 
-export default function* entries(
-  scope: Exotic.Emulator,
-): IterableIterator<Exotic.Proxy> {
-  for (const proxy of proxyGenerator(scope)) {
-    yield proxy;
-  }
+export default function entries(): IterableIterator<Exotic.Proxy> {
+  return proxyIterator();
 }

src/lib/methods/getId.ts

@@ -1,10 +1,7 @@
 import Exotic from "../../types/Exotic";
 import { findProxy, map } from "../../utils";
 
-export default function getId(
-  scope: Exotic.Emulator,
-  value: Exotic.traceable,
-): number {
+export default function getId(value: Exotic.traceable): number {
   const proxy = findProxy(value);
   if (!proxy) {
     return NaN;

src/lib/methods/index.ts

@@ -7,11 +7,10 @@ import ownKeys from "./ownKeys";
 import revoke from "./revoke";
 import isRevoked from "./isRevoked";
 import entries from "./entries";
-import entriesBefore from "./entriesBefore";
-import entriesAfter from "./entriesAfter";
 import getId from "./getId";
 import encode from "./encode";
 import get from "./get";
+import kill from "./kill";
 
 export default {
   useRef,
@@ -23,9 +22,8 @@ export default {
   revoke,
   isRevoked,
   entries,
-  entriesBefore,
-  entriesAfter,
   getId,
   encode,
   get,
+  kill,
 };

src/lib/methods/isRevoked.ts

@@ -1,10 +1,7 @@
 import Exotic from "../../types/Exotic";
 import { findProxy, map } from "../../utils";
 
-export default function isRevoked(
-  scope: Exotic.Emulator,
-  value: Exotic.traceable,
-): boolean {
+export default function isRevoked(value: Exotic.traceable): boolean {
   const proxy = findProxy(value);
   if (!proxy) return false;
   const { revoked } = map.proxies.get(proxy);

src/lib/methods/kill.ts

@@ -0,0 +1,11 @@
+import Exotic from "../../types/Exotic";
+import { proxyIterator, revokeProxy, map } from "../../utils";
+
+export default function kill(scope: Exotic.Emulator): void {
+  for (const proxy of proxyIterator()) {
+    const { scope: proxyScope } = map.proxies.get(proxy);
+    if (scope === proxyScope) {
+      revokeProxy(proxy);
+    }
+  }
+}

src/lib/methods/parent.ts

@@ -2,7 +2,6 @@ import Exotic from "../../types/Exotic";
 import { findProxy, map } from "../../utils";
 
 export default function parent(
-  scope: Exotic.Emulator,
   value?: Exotic.traceable,
 ): undefined | Exotic.Proxy {
   const proxy = findProxy(value);

src/lib/methods/revoke.ts

@@ -1,9 +1,6 @@
 import Exotic from "../../types/Exotic";
 import { revokeProxy } from "../../utils";
 
-export default function revoke(
-  scope: Exotic.Emulator,
-  value: Exotic.traceable,
-): boolean {
-  return revokeProxy(scope, value);
+export default function revoke(value: Exotic.traceable): boolean {
+  return revokeProxy(value);
 }

src/lib/methods/target.ts

@@ -1,7 +1,6 @@
-import Exotic from "../../types/Exotic";
 import { findProxy, map } from "../../utils";
 
-export default function target(scope: Exotic.Emulator, value?: any): any {
+export default function target(value?: any): any {
   const proxy = findProxy(value);
   if (!proxy) return value;
   const { target } = map.proxies.get(proxy);

src/types/Exotic.ts

@@ -19,14 +19,14 @@ declare namespace Exotic {
     revoke(value: traceable): boolean;
     isRevoked(value: traceable): boolean;
     entries(): IterableIterator<Proxy>;
-    entriesBefore(value: traceable): IterableIterator<Proxy>;
-    entriesAfter(value: traceable): IterableIterator<Proxy>;
     encode(value: any): payload;
     get(value?: any): Promise<any>;
+    kill(): void;
     refs: key[];
     active: number;
     revoked: number;
     length: number;
+    [Symbol.iterator](): IterableIterator<Proxy>;
   }
 
   namespace emulator {
@@ -39,8 +39,6 @@ declare namespace Exotic {
       refs: Record<key, Proxy>;
       totalProxies: number;
       activeProxies: number;
-      firstProxy?: Proxy;
-      lastProxy?: Proxy;
     }
   }
 
@@ -56,7 +54,7 @@ declare namespace Exotic {
   namespace proxy {
     interface origin {
       action: "get" | "set" | "construct" | "apply";
-      proxy: Proxy;
+      proxy?: Proxy;
       key?: key;
       value?: any;
       that?: any;
@@ -72,9 +70,7 @@ declare namespace Exotic {
       sandbox: Record<key, any>;
       target?: any;
       origin?: origin;
-      refKey?: key;
-      next?: Proxy;
-      prev?: Proxy;
+      key?: key;
     }
   }
 }