first commit

Author: WebReflection

.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+.nyc_output
+v8.log
+coverage/
+node_modules/
+cjs/*
+!cjs/package.json

.npmignore

@@ -0,0 +1,10 @@
+.DS_Store
+.nyc_output
+.eslintrc.json
+.github/
+.travis.yml
+v8.log
+coverage/
+node_modules/
+rollup/
+test/

.npmrc

@@ -0,0 +1 @@
+package-lock=false

cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

esm/index.js

@@ -0,0 +1,97 @@
+import * as handlerTraps from 'proxy-target/traps';
+import * as handlerTypes 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) => {
+  const descriptors = { type: { value: type } };
+  for(const trap of traps)
+    descriptors[trap] = value(handler[trap] || Reflect[trap]);
+  return extend(handler, descriptors);
+};
+
+const proxy = ($, target, handler, token = false) => {
+  const p = new Proxy(target, handler);
+  const { destruct } = handler;
+  return destruct ? create($, destruct, { token, return: p }) : p;
+};
+
+export const proxyOf = namespace => {
+  const proxies = { free: token => drop(token) };
+  for (const [type, traps] of entries(namespace)) {
+    switch (type) {
+      case ARRAY: {
+        const handler = extendHandler(traps, type, method => ({
+          value([ $ ], ..._) {
+            return method.call(this, $, ..._);
+          }
+        }));
+        proxies[type] = ($, ..._) => proxy($, [ $ ], handler, ..._);
+        break;
+      }
+      case FUNCTION: {
+        const handler = extendHandler(traps, type, method => ({
+          value($, ..._) {
+            return method.call(this, $(), ..._);
+          }
+        }));
+        proxies[type] = ($, ..._) => proxy($, bound($), handler, ..._);
+        break;
+      }
+      case OBJECT: {
+        const handler = extendHandler(traps, type, method => ({
+          value({ $ }, ..._) {
+            return method.call(this, $, ..._);
+          }
+        }));
+        proxies[type] = ($, ..._) => proxy($, { $ }, handler, ..._);
+        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;
+          };
+        }
+        break;
+      }
+    }
+  }
+  return proxies;
+};
+
+export const typeOf = value => {
+  let type = typeof value;
+  if (type === OBJECT) {
+    type = value === null ?
+      NULL :
+      (isArray(value) ? ARRAY : (typesOf.get(value) || OBJECT))
+    ;
+  }
+  return type;
+};

package.json

@@ -0,0 +1,33 @@
+{
+  "name": "js-proxy",
+  "version": "0.1.0",
+  "description": "",
+  "main": "./cjs/index.js",
+  "scripts": {
+    "build": "npm run cjs && npm run test",
+    "cjs": "ascjs esm cjs",
+    "coveralls": "c8 report --reporter=text-lcov | coveralls",
+    "test": "c8 node test/index.js"
+  },
+  "keywords": [],
+  "author": "Andrea Giammarchi",
+  "license": "ISC",
+  "devDependencies": {
+    "ascjs": "^6.0.3",
+    "c8": "^9.1.0",
+    "coveralls": "^3.1.1"
+  },
+  "module": "./esm/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "default": "./cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "gc-hook": "^0.3.1",
+    "proxy-target": "^3.0.2"
+  }
+}

test/index.js

@@ -0,0 +1,58 @@
+import { typeOf, proxyOf } from '../esm/index.js';
+
+// 🦄 typeOf coverage related
+let proxied = proxyOf({
+  // native cases
+  array: {},
+  function: {},
+  object: {},
+
+  // extra primitives
+  bigint: {
+    get(target, key) {
+      const value = target[key];
+      return typeof value === 'function' ?
+              value.bind(target) : value;
+    },
+    getPrototypeOf: () => BigInt.prototype,
+  },
+  boolean: {},
+  null: {},
+  number: {},
+  string: {},
+  symbol: {},
+  undefined: {},
+
+  // custom direct/defined
+  direct: {},
+});
+
+// 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');
+
+// 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');
+
+// typeOf custom direct/defined
+console.assert(typeOf(proxied.direct({})) === 'direct');
+
+console.assert(proxied.bigint(2n) == 2n);
+console.assert(proxied.bigint(2n) instanceof BigInt);