simplified known types + token handling

Author: WebReflection

esm/index.js

@@ -1,16 +1,15 @@
 import * as handlerTraps from 'proxy-target/traps';
-import * as handlerTypes from 'proxy-target/types';
+
+import { ARRAY, FUNCTION, NULL, OBJECT, UNDEFINED } from 'proxy-target/types';
 import { bound } from 'proxy-target';
 import { create, drop } from 'gc-hook';
 
-const { ARRAY, FUNCTION, NULL, OBJECT } = handlerTypes;
 const { Object, Proxy, Reflect } = globalThis;
 
 const { isArray } = Array;
 const { create: extend, entries, values } = Object;
 
 const traps = new Set([...values(handlerTraps)]);
-const types = new Set([...values(handlerTypes)]);
 const typesOf = new WeakMap;
 
 const extendHandler = (handler, type, value) => {
@@ -20,7 +19,18 @@ const extendHandler = (handler, type, value) => {
   return extend(handler, descriptors);
 };
 
-const proxy = ($, target, handler, token = false) => {
+const proxy = ($, target, handler, token = $) => {
+  if (token === $) {
+    switch (typeof $) {
+      case OBJECT:
+      case FUNCTION:
+      case UNDEFINED: break;
+      default: {
+        token = false;
+        if (target === $) target = Object($);
+      }
+    }
+  }
   const p = new Proxy(target, handler);
   const { destruct } = handler;
   return destruct ? create($, destruct, { token, return: p }) : p;
@@ -58,26 +68,12 @@ export const proxyOf = namespace => {
         break;
       }
       default: {
-        if (types.has(type)) {
-          const handler = extendHandler(traps, type, method => ({
-            value($, ..._) {
-              return method.call(this, $.valueOf(), ..._);
-            }
-          }));
-          proxies[type] = ($, ..._) => {
-            const p = proxy($, Object($), handler, ..._);
-            typesOf.set(p, type);
-            return p;
-          };
-        }
-        else {
-          const handler = extendHandler(traps, type, value => ({ value }));
-          proxies[type] = ($, token = $) => {
-            const p = proxy($, $, handler, token);
-            typesOf.set(p, type);
-            return p;
-          };
-        }
+        const handler = extendHandler(traps, type, value => ({ value }));
+        proxies[type] = ($, ..._) => {
+          const p = proxy($, $, handler, ..._);
+          typesOf.set(p, type);
+          return p;
+        };
         break;
       }
     }
@@ -86,12 +82,13 @@ export const proxyOf = namespace => {
 };
 
 export const typeOf = value => {
-  let type = typeof value;
-  if (type === OBJECT) {
-    type = value === null ?
-      NULL :
-      (isArray(value) ? ARRAY : (typesOf.get(value) || OBJECT))
-    ;
-  }
-  return type;
+  const type = typeof value;
+  return type === OBJECT ?
+    (value ?
+      (typesOf.get(value) || (
+        isArray(value) ? ARRAY : OBJECT
+      )) :
+      NULL
+    ) :
+    type;
 };

package.json

@@ -7,7 +7,7 @@
     "build": "npm run cjs && npm run test",
     "cjs": "ascjs esm cjs",
     "coveralls": "c8 report --reporter=text-lcov | coveralls",
-    "test": "c8 node test/index.js"
+    "test": "c8 node --expose-gc test/index.js"
   },
   "keywords": [],
   "author": "Andrea Giammarchi",

test/index.js

@@ -1,20 +1,24 @@
 import { typeOf, proxyOf } from '../esm/index.js';
 
+const assert = (current, expected, message = `expected ${expected} - got ${current}`) => {
+  if (!Object.is(current, expected))
+    throw new Error(message);
+};
+
 // 🦄 typeOf coverage related
 let proxied = proxyOf({
   // native cases
   array: {},
   function: {},
   object: {},
 
-  // extra primitives
+  // custom primitives
   bigint: {
-    get(target, key) {
-      const value = target[key];
-      return typeof value === 'function' ?
-              value.bind(target) : value;
+    get(target, key, ..._) {
+      return key === Symbol.toPrimitive ?
+              () => target.valueOf() :
+              Reflect.get(target, key, ..._);
     },
-    getPrototypeOf: () => BigInt.prototype,
   },
   boolean: {},
   null: {},
@@ -28,31 +32,84 @@ let proxied = proxyOf({
 });
 
 // typeOf native cases
-console.assert(typeOf([]) === 'array');
-console.assert(typeOf(proxied.array(0)) === 'array');
-console.assert(typeOf(()=>{}) === 'function');
-console.assert(typeOf(proxied.function(0)) === 'function');
-console.assert(typeOf({}) === 'object');
-console.assert(typeOf(proxied.object(0)) === 'object');
+assert(typeOf([]), 'array');
+assert(typeOf(proxied.array(0)), 'array');
+assert(typeOf(()=>{}), 'function');
+assert(typeOf(proxied.function(0)), 'function');
+assert(typeOf({}), 'object');
+assert(typeOf(proxied.object(0)), 'object');
 
 // typeOf extra primitives
-console.assert(typeOf(1n) === 'bigint');
-console.assert(typeOf(proxied.bigint(0)) === 'bigint');
-console.assert(typeOf(false) === 'boolean');
-console.assert(typeOf(proxied.boolean(0)) === 'boolean');
-console.assert(typeOf(null) === 'null');
-console.assert(typeOf(proxied.null(0)) === 'null');
-console.assert(typeOf(1) === 'number');
-console.assert(typeOf(proxied.number(0)) === 'number');
-console.assert(typeOf('') === 'string');
-console.assert(typeOf(proxied.string(0)) === 'string');
-console.assert(typeOf(Symbol()) === 'symbol');
-console.assert(typeOf(proxied.symbol(0)) === 'symbol');
-console.assert(typeOf() === 'undefined');
-console.assert(typeOf(proxied.undefined({})) === 'undefined');
+assert(typeOf(1n), 'bigint');
+assert(typeOf(proxied.bigint(0)), 'bigint');
+assert(typeOf(false), 'boolean');
+assert(typeOf(proxied.boolean(0)), 'boolean');
+assert(typeOf(null), 'null');
+assert(typeOf(proxied.null(0)), 'null');
+assert(typeOf(1), 'number');
+assert(typeOf(proxied.number(0)), 'number');
+assert(typeOf(''), 'string');
+assert(typeOf(proxied.string(0)), 'string');
+assert(typeOf(Symbol()), 'symbol');
+assert(typeOf(proxied.symbol(0)), 'symbol');
+assert(typeOf(), 'undefined');
+assert(typeOf(proxied.undefined(0)), 'undefined');
 
 // typeOf custom direct/defined
-console.assert(typeOf(proxied.direct({})) === 'direct');
+assert(typeOf(proxied.direct({})), 'direct');
+
+assert(proxied.bigint(2n) == 2n, true, 'bigint');
+assert(proxied.bigint(2n) instanceof BigInt, true, 'bigint instanceof');
+
+// 🦄 proxyOf coverage related
+assert(proxied.array([1, 2, 3]).length, 3);
+assert(proxied.direct([1, 2, 3]).length, 3);
+assert(proxied.object({a: 1}).a, 1);
+assert(proxied.direct({a: 1}).a, 1);
+assert(proxied.function(() => 1)(), 1);
+assert(proxied.direct(() => 1)(), 1);
+
+let i = 0;
+
+const gcdo = Object(1);
+const gcdd = {b: 2};
+
+proxied = proxyOf({
+  object: {
+    destruct(ref) {
+      assert(ref, gcdo.valueOf());
+      i++;
+    }
+  },
+  direct: {
+    destruct(ref) {
+      assert(ref, gcdd);
+      i++;
+    }
+  },
+});
+
+
+let pgcdo = proxied.object(gcdo.valueOf(), gcdo);
+let pgcdd = proxied.direct(gcdd);
 
-console.assert(proxied.bigint(2n) == 2n);
-console.assert(proxied.bigint(2n) instanceof BigInt);
+setTimeout(() => {
+  pgcdo = pgcdd = null;
+  gc();
+  setTimeout(() => {
+    gc();
+    assert(i, 2);
+    pgcdo = proxied.object(gcdo.valueOf(), gcdo);
+    pgcdd = proxied.direct(gcdd);
+    setTimeout(() => {
+      proxied.free(gcdo);
+      proxied.free(gcdd);
+      gc();
+      setTimeout(() => {
+        gc();
+        assert(i, 2);
+        console.log('OK');
+      }, 100);
+    }, 100);
+  });
+}, 100);