cfprotected 0.1.0 → 1.1.2

package/.vscode/launch.json

@@ -4,16 +4,20 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+
         {
             "type": "node",
             "request": "launch",
             "name": "Jest Tests",
-            "program": "${workspaceRoot}/node_modules/jest/bin/jest.js",
-            "internalConsoleOptions": "openOnSessionStart",
-            "outFiles": [
-                "${workspaceRoot}/dist/**/*"
+            "runtimeArgs": [
+                "--experimental-vm-modules",
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                "--runInBand"
             ],
-            "envFile": "${workspaceRoot}/.env"
+            "internalConsoleOptions": "neverOpen",
+            "console": "integratedTerminal",
+            "port": 9229
         }
     ]
 }

package/README.md

@@ -8,7 +8,7 @@ to work around some the issues inherent in using private fields.
 Let's just start with a simple example:
 
 ```js
-const { share, accessor } = require("cfprotected");
+import { share, accessor } from "cfprotected";
 
 class Example {
     //shared static private fields
@@ -111,19 +111,16 @@ const Example = abstract(class {
 });
 ```
 
-### Note:
-This method uses a proxy internally to keep things consistent. However, the Proxy is not a membrane. So it's best if any use of static private fields is accessed through the property created by using `saveSelf(...)`.
-
 ## **final(klass)**
-This method is a class wrapper that prevents instances of the class from being created using descendant classes.
+This method is a class wrapper that prevents instances of the class from being created using descendant classes. It also attempts to prevent creation of descendant classes.
 ```js
 const Example = final(class {
     ...
 });
 ```
 
-### Note:
-Just as with `abstract(...)`, this method uses a proxy internally to keep things consistent. However, the Proxy is not a membrane. So it's best if any use of static private fields is accessed through the property created by using `saveSelf(...)`. Unfortunately, there's also a limitation with final. Normally in compiled languages, it is a syntax error to even create a class that extends from a final class. However, without taking over the means of building the class (as can be done with Babel or my ClassicJS library) it's just not possible to restrict that event. As a result, the only thing left to check for is construction of instances of such an error.
+### Notes:
+In order to ensure the functionality of final would not interfere with the ability to access static members, final is implemented using a Proxy. It is therefore very important to use `saveSelf(...)` and the resulting property (or a similar approach) to ensure that access to static private properties is not interrupted.
 
 ## Other features
 There will be occasions when a shared function that shadows an ancestor function needs to call the ancestor's function. Unfortunately, `super` cannot give you access to these. There is a similar problem when accessing accessors and data properties. To satisfy this need, the class-specific accessor option is given an additional property: `$uper`. Using this property, it is possible to reach the ancestor version of any shared member.

package/{index.js → index.mjs}

@@ -1,3 +1,5 @@
+"use strict"
+
 const memos = new WeakMap();
 const ACCESSOR = Symbol();
 
@@ -14,7 +16,7 @@ function getAllOwnKeys(o) {
  * @param {Object} members The object containing the properties being shared.
  * @returns {Object} The fully constructed inheritance object.
  */
-module.exports.share = function share(inst, klass, members) {
+function share(inst, klass, members) {
     let retval = {};
 
     if ((typeof(inst) == "function") 
@@ -60,7 +62,8 @@ module.exports.share = function share(inst, klass, members) {
     }
 
     //Get the protected data object.
-    let memo = ancestorMemo.get(inst) || {data: {}, $uper: {}, inheritance: null};
+    let ancestorKey = (inst === klass) ? ancestor : inst;
+    let memo = ancestorMemo.get(ancestorKey) || {data: {}, $uper: {}, inheritance: null};
     let protData = memo.data;
     
     //Get the details of the protected properties.
@@ -124,7 +127,7 @@ module.exports.share = function share(inst, klass, members) {
  * @param {Object} self The current class instance as seen from the constructor.
  * @param {String} name The name of the field on which to bind the instance.
  */
- module.exports.saveSelf = function(self, name) {
+function saveSelf(self, name) {
     Object.defineProperty(self, name, {value: self});
     if (typeof(self) == "function") {
         Object.defineProperty(self.prototype, "cla$$", {value: self});
@@ -139,7 +142,7 @@ module.exports.share = function share(inst, klass, members) {
  * @returns {Object} A tagged object that will be used to create the access
  * bindings for the property.
  */
-module.exports.accessor = function(desc) {
+function accessor(desc) {
     if ((typeof(desc) == "object") &&
         (("get" in desc) || ("set" in desc))) {
         return {
@@ -155,29 +158,80 @@ module.exports.accessor = function(desc) {
  * instantiated is not a descendant of the current class.
  * @param {Function} klass The constructor of the current class.
  */
-module.exports.abstract = function(klass) {
-    return new Proxy(klass, {
-        construct(target, args, newTarget) {
-            if (newTarget.prototype === klass.prototype)
-                throw new TypeError(`Cannot construct instance of abstract class.`);
-
-            return Reflect.construct(target, args, newTarget);
+function abstract(klass) {
+    let name = klass.name?klass.name : "";
+    let retval = class extends klass {
+        constructor (...args) {
+            if (new.target === retval) {
+                throw new TypeError(`Class constructor ${name} is abstract and cannot be directly invoked with 'new'`);
+            }
+            super(...args);
         }
-    });
+    };
+
+    if (memos.has(klass)) {
+        let memo = memos.get(klass);
+        memos.set(retval, memo);
+        memo.set(retval, memo.get(klass));
+    }
+    
+    return retval;
 };
 
 /**
  * A class wrapper that blocks construction of an instance if the class being
- * constructed is a descendant of the current class.
+ * constructed is a descendant of the current class. It also attempts to block
+ * extending the targeted class.
  * @param {Function} klass The constructor of the current class.
  */
-module.exports.final = function(klass) {
-    return new Proxy(klass, {
-        construct(target, args, newTarget) {
-            if (newTarget.prototype !== klass.prototype)
-                throw new TypeError(`Cannot extend final class.`);
+function final(klass) {
+    let retval = new Proxy(function() {}, {
+        handleDefault(fname, args) {
+            args.shift();
+            args.unshift(klass);
+            return Reflect[fname](...args);
+        },
+        construct(_, args, newTarget) {
+            if (newTarget !== retval) {
+                throw new TypeError("Cannot create an instance of a descendant of a final class");
+            }
+            let inst = Reflect.construct(klass, args, newTarget);
+            let proto = Object.create(klass.prototype, {
+                constructor: {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: retval
+                }
+            });
+            Object.setPrototypeOf(inst, proto);
+            return inst;
+        },
+        get(_, prop, receiver) {
+            return (prop == "prototype")
+                ? void 0
+                : Reflect.get(klass, prop, receiver);
+        },
+        set(...args) { return this.handleDefault("set", args); },
+        apply(...args) { return this.handleDefault("apply", args); },
+        defineProperty(...args) { return this.handleDefault("defineProperty", args); },
+        deleteProperty(...args) { return this.handleDefault("deleteProperty", args); },
+        getOwnPropertyDescriptor(...args) { return this.handleDefault("getOwnPropertyDescriptor", args); },
+        getPrototypeOf(...args) { return this.handleDefault("getPrototypeOf", args); },
+        has(...args) { return this.handleDefault("has", args); },
+        isExtensible(...args) { return this.handleDefault("isExtensible", args); },
+        ownKeys(...args) { return this.handleDefault("ownKeys", args); },
+        preventExtensions(...args) { return this.handleDefault("preventExtensions", args); },
+        setPrototypeOf(...args) { return this.handleDefault("setPrototypeOf", args); }
+    });        
+
+    if (memos.has(klass)) {
+        let memo = memos.get(klass);
+        memos.set(retval, memo);
+        memo.set(retval, memo.get(klass));
+    }
 
-            return Reflect.construct(target, args, newTarget);
-        }
-    });
+    return retval;
 };
+
+export { share, saveSelf, accessor, abstract, final };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "cfprotected",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "description": "An implementation of protected fields on top of class fields.",
   "main": "index.js",
   "scripts": {
-    "test": "jest"
+    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest"
   },
   "keywords": [
     "class",
@@ -19,6 +19,21 @@
     "url": "https://github.com/rdking/CFProtected.git"
   },
   "devDependencies": {
-    "jest": "^27.4.3"
+    "jest": "^27.4.7",
+    "jest-esm-transformer": "^1.0.0"
+  },
+  "jest": {
+    "verbose": true,
+    "moduleFileExtensions": [
+      "js",
+      "mjs"
+    ],
+    "transform": {
+      "\\.m?[j|t]sx?$": "babel-jest"
+    },
+    "testMatch": [
+      "**/__tests__/**/*.?(m)[jt]s?(x)",
+      "**/?(*.)+(spec|test).?(m)[tj]s?(x)"
+    ]
   }
 }

package/test/{test.js → test.mjs}

@@ -1,5 +1,5 @@
-const { TestWatcher } = require("@jest/core");
-const { share, saveSelf, accessor } = require("../index"); //require("cfprotected");
+import { TestWatcher } from "@jest/core";
+import { share, saveSelf, accessor, abstract, final } from "../index"; //require("cfprotected");
 
 class Base {
     #prot = share(this, Base, {
@@ -135,4 +135,74 @@ describe(`Testing shared elements inherited from a non-participant`, () => {
 
 describe(`Testing that $uper works in all cases`, () => {
     (new SuperTest).run();
-})
+});
+
+describe(`Testing that abstract classes function as expected`, () => {
+    const key = Symbol();
+    const ATest = abstract(class ATest {
+        static #sshared = share(this, {
+            [key]: true
+        });
+        #shared = share(this, ATest, {
+            [key]: true
+        });
+    });
+    class DTest extends ATest {
+        static #sshared = share(this, {});
+        #shared = share(this, DTest, {});
+        run() { return this.#shared[key]; }
+        static run() { return this.#sshared[key]; }
+    };
+
+    test(`Should not be able to instantiate directly`, () => {
+        expect(() => { new ATest; }).toThrow();
+    });
+    test(`Should be able to instantiate a derived class`, () => {
+        expect(() => { new DTest; }).not.toThrow();
+    });
+    test(`Should see shared members from constructed instance`, () => {
+        expect((new DTest).run()).toBe(true);
+    });
+    test(`Should see static shared members from constructed instance`, () => {
+        expect(DTest.run()).toBe(true);
+    });
+});
+
+describe(`Testing that final classes function as expected`, () => {
+    const key = Symbol();
+    class TestBase {
+        static #sshared = share(this, {
+            [key]: true
+        });
+        #shared = share(this, TestBase, {
+            [key]: true
+        });
+    }
+    const FTest = final(class FTest extends TestBase {
+        static { saveSelf(this, "pvt"); }
+        static #sshared = share(this, {});
+        #shared = share(this, FTest, {});
+        run() { return this.#shared[key]; }
+        static run() { return this.pvt.#sshared[key]; }
+    });
+
+    test(`Should be able to instantiate an instance directly`, () => {
+        expect(() => { new FTest; }).not.toThrow();
+    });
+    test(`Should not be able to extend directly`, () => {
+        expect(() => { class DTest extends FTest {}; }).toThrow();
+    });
+    test(`Should not be able to cheat and create an instance of a derived class`, () => {
+        expect(() => {
+            FTest.prototype = {};
+            class DTest extends FTest {}
+            new DTest;
+        }).toThrow();
+    });
+    test(`Should see shared members from constructed instance`, () => {
+        expect((new FTest).run()).toBe(true);
+    });
+    test(`Should see static shared members from constructed instance`, () => {
+        expect(FTest.run()).toBe(true);
+    });
+});