cfprotected 1.0.0 → 1.1.3

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

@@ -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.mjs

@@ -8,6 +8,28 @@ function getAllOwnKeys(o) {
         .concat(Object.getOwnPropertySymbols(o));
 }
 
+function useDescriptor(desc, fn) {
+    if ("value" in desc) {
+        if (typeof(desc.value) == "function") {
+            fn("value");
+        }
+    }
+    else {
+        if (typeof(desc.get) == "function") {
+            fn("get");
+        }
+        if (typeof(desc.set) == "function") {
+            fn("set");
+        }
+    }
+}
+
+function bindDescriptor(desc, context) {
+    useDescriptor(desc, (key) => {
+        desc[key] = desc[key].bind(context);
+    });
+}
+
 /**
  * Used to both store inherited property information as well as retrieve it.
  * @param {Object} inst The instance object that will own the shared members.
@@ -17,8 +39,6 @@ function getAllOwnKeys(o) {
  * @returns {Object} The fully constructed inheritance object.
  */
 function share(inst, klass, members) {
-    let retval = {};
-
     if ((typeof(inst) == "function") 
         && klass && (typeof(klass) == "object")
         && (members === void 0)) {
@@ -62,58 +82,56 @@ function share(inst, klass, members) {
     }
 
     //Get the protected data object.
-    let memo = ancestorMemo.get(inst) || {data: {}, $uper: {}, inheritance: null};
-    let protData = memo.data;
+    let ancestorKey = (inst === klass) ? ancestor : inst;
+    let memo = ancestorMemo.get(ancestorKey) || {
+        data: {}, 
+        $uper: {},
+    };
+    let retval = {};
     
     //Get the details of the protected properties.
     let mDesc = Object.getOwnPropertyDescriptors(members);
     let mKeys = getAllOwnKeys(members);
 
     //Change the prototype of protoData using the new members.
-    let prototype = Object.getPrototypeOf(protData);
+    let prototype = Object.getPrototypeOf(memo.data);
     let proto = Object.create(prototype,
         Object.fromEntries(mKeys
-            .filter(k => !mDesc[k].value?.hasOwnProperty(ACCESSOR))
-            .map(k => [k, mDesc[k]])));
-    Object.setPrototypeOf(protData, proto);
-
-    //Build the accessors for this class.
-    mKeys.forEach(m => {
-        let desc = (mDesc[m].value?.hasOwnProperty(ACCESSOR))
-            ? {
-                enumerable: true,
-                get: mDesc[m].value.get,
-                set: mDesc[m].value.set
-            }
-            : mDesc[m];
-        
-        Object.defineProperty(retval, m, desc);
-    });
-    
-    //Define the "super" accessors
-    Object.defineProperty(retval, "$uper", { value: {} });
-
+            .map(k => {
+                if (mDesc[k].value?.hasOwnProperty(ACCESSOR)) {
+                    Object.assign(mDesc[k], mDesc[k].value);
+                    mDesc[k].enumerable = true;
+                    delete mDesc[k][ACCESSOR];
+                    delete mDesc[k].value;
+                    delete mDesc[k].writable;
+                }
+                bindDescriptor(mDesc[k], inst);
+                return [k, mDesc[k]];
+            })));
+    Object.setPrototypeOf(retval, proto);
+
+    //Define the "$uper" accessors
+    let $uper = {};
+    Object.defineProperty(retval, "$uper", { value: $uper });
+
+    //Build up the "$uper" object
     for (let key of mKeys) {
         if (key in prototype) {
             let obj = prototype;
             while (!obj.hasOwnProperty(key)) {
                 obj = Object.getPrototypeOf(obj);
             }
-            Object.defineProperty(retval.$uper, key, Object.getOwnPropertyDescriptor(obj, key));
+            Object.defineProperty($uper, key, Object.getOwnPropertyDescriptor(obj, key));
         }
     }
 
     //Attach the super inheritance
-    Object.setPrototypeOf(retval.$uper, memo.$uper);
-
-    //Inherit the inheritance
-    Object.setPrototypeOf(retval, memo.inheritance);
+    Object.setPrototypeOf($uper, memo.$uper);
 
     //Save the inheritance & protected data
     memos.get(klass).set(inst, {
-        data: protData,
-        inheritance: retval,
-        $uper: retval.$uper
+        data: retval,
+        $uper: $uper
     });    
 
     return retval;
@@ -158,30 +176,79 @@ function accessor(desc) {
  * @param {Function} klass The constructor of the current class.
  */
 function abstract(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);
+    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.
  */
 function final(klass) {
-    return new Proxy(klass, {
-        construct(target, args, newTarget) {
-            if (newTarget.prototype !== klass.prototype)
-                throw new TypeError(`Cannot extend final class.`);
+    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,6 +1,6 @@
 {
   "name": "cfprotected",
-  "version": "1.0.0",
+  "version": "1.1.3",
   "description": "An implementation of protected fields on top of class fields.",
   "main": "index.js",
   "scripts": {

package/test/test.mjs

@@ -1,7 +1,11 @@
 import { TestWatcher } from "@jest/core";
-import { share, saveSelf, accessor } from "../index"; //require("cfprotected");
+import { share, saveSelf, accessor, abstract, final } from "../index"; //require("cfprotected");
 
 class Base {
+    static #greeting = "Hello!";
+    static #sprot = share(this, {
+        getGreeting() { return this.#greeting; }
+    });
     #prot = share(this, Base, {
         num: 42,
         name: "John Jacob Jingleheimerschmidt",
@@ -12,7 +16,6 @@ class Base {
             get: () => this.propTestVal
         }),
         superTest: () => {
-            console.log(`Called Base::superTest() ...`);
             return 1;
         }
     });
@@ -76,12 +79,16 @@ class Derived extends Base {
 class NonParticipant extends Base {}
 
 class GrandChild extends NonParticipant {
+    static #sprot = share(this, {
+        getGreeting() {
+            return `${this.#sprot.$uper.getGreeting()} My name is`;
+        }
+    });
     #prot = share(this, GrandChild, {
         otherMethod: () => {
             this.#prot.name = this.testName;
         },
         superTest: () => {
-            console.log(`Called GrandChild::superTest() ...`);
             return 1 + this.pvt.#prot.$uper.superTest();
         }
     });
@@ -103,9 +110,13 @@ class GrandChild extends NonParticipant {
 }
 
 class SuperTest extends GrandChild {
+    static #sprot = share(this, {
+        getGreeting() {
+            return `${this.#sprot.$uper.getGreeting()} "${this.name}"!`
+        }
+    });
     #prot = share(this, SuperTest, {
         superTest: () => {
-            console.log(`Called SuperTest::superTest() ...`);
             return 1 + this.pvt.#prot.$uper.superTest();
         }
     });
@@ -119,6 +130,9 @@ class SuperTest extends GrandChild {
         test(`Should be able to call super through the entire inheritance chain`, () => {
             expect(this.pvt.#prot.superTest()).toBe(3);
         });
+        test(`Should be able to call super through the entire static inheritance chain`, () => {
+            expect(SuperTest.#sprot.getGreeting()).toBe(`Hello! My name is "SuperTest"!`);
+        });
     }
 }
 
@@ -135,4 +149,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);
+    });
+});