cfprotected 1.1.0 → 1.1.4

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

@@ -119,6 +119,9 @@ const Example = final(class {
 });
 ```
 
+### 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.
@@ -47,7 +69,7 @@ function share(inst, klass, members) {
     * }
     */
    
-    //Find the nearest known registered ancestor
+    //Find the nearest known registered ancestor class
     let ancestor = Object.getPrototypeOf(klass);
     while (ancestor && !memos.has(ancestor)) {
         ancestor = Object.getPrototypeOf(ancestor);
@@ -56,43 +78,49 @@ function share(inst, klass, members) {
     //Get the memo from that ancestor
     let ancestorMemo = memos.get(ancestor) || new WeakMap();
 
-    //Create a memo for the current class
+    //Create a memo map for the current class
     if (!memos.has(klass)) {
         memos.set(klass, new WeakMap());
     }
 
     //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.
     let mDesc = Object.getOwnPropertyDescriptors(members);
     let mKeys = getAllOwnKeys(members);
 
-    //Change the prototype of protoData using the new members.
+    //Add the new members to the prototype chain of protData.
     let prototype = Object.getPrototypeOf(protData);
     let proto = Object.create(prototype,
         Object.fromEntries(mKeys
-            .filter(k => !mDesc[k].value?.hasOwnProperty(ACCESSOR))
-            .map(k => [k, mDesc[k]])));
+            .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(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);
+        Object.defineProperty(retval, m, {
+            get() { return protData[m]; },
+            set(v) { protData[m] = v; }
+        });
     });
     
-    //Define the "super" accessors
+    //Define the "$uper" accessors
     Object.defineProperty(retval, "$uper", { value: {} });
 
+    //Build up the "$uper" object
     for (let key of mKeys) {
         if (key in prototype) {
             let obj = prototype;
@@ -167,6 +195,13 @@ function abstract(klass) {
             super(...args);
         }
     };
+
+    if (memos.has(klass)) {
+        let memo = memos.get(klass);
+        memos.set(retval, memo);
+        memo.set(retval, memo.get(klass));
+    }
+    
     return retval;
 };
 
@@ -177,46 +212,51 @@ function abstract(klass) {
  * @param {Function} klass The constructor of the current class.
  */
 function final(klass) {
-    let name = klass.name?klass.name : "";
-    let retval = eval(`(function ${name}(...args) {
-        if (!new.target) {
-            throw new TypeError("Class constructor ${name} cannot be invoked without 'new'");
-        }
-        if (new.target !== retval) {
-            throw new TypeError("Cannot create an instance of a descendant of a final class");
-        }
-        if (retval.prototype !== void 0) {
-            retval.prototype = void 0;
-        }
-        let inst = new klass(...args);
-        let proto = Object.create(klass.prototype, {
-            constructor: {
-                enumerable: true,
-                configurable: true,
-                writable: true,
-                value: retval
+    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");
             }
-        });
-        Object.setPrototypeOf(inst, proto);
-        return inst;
-    })`);
-    retval.prototype = void 0;
-
-    Object.defineProperties(retval, {
-        toString: {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value() { return klass.toString(); }
+            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;
         },
-        length: {
-            configurable: true,
-            value: klass.length
+        get(_, prop, receiver) {
+            return (prop == "prototype")
+                ? void 0
+                : Reflect.get(klass, prop, receiver);
         },
-        [Symbol.hasInstance]: {
-            value(inst) { return inst instanceof klass; }
-        }
-    });
+        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 retval;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cfprotected",
-  "version": "1.1.0",
+  "version": "1.1.4",
   "description": "An implementation of protected fields on top of class fields.",
   "main": "index.js",
   "scripts": {

package/test/test.mjs

@@ -2,6 +2,10 @@ import { TestWatcher } from "@jest/core";
 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"!`);
+        });
     }
 }
 
@@ -138,31 +152,71 @@ describe(`Testing that $uper works in all cases`, () => {
 });
 
 describe(`Testing that abstract classes function as expected`, () => {
-    const ATest = abstract(class {});
-    class DTest extends ATest {};
-
-    test(`Should not be able to instantiate an abstract class directly`, () => {
+    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 class derived from an abstract class`, () => {
+    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 FTest = final(class {});
+    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 of a final class directly`, () => {
+    test(`Should be able to instantiate an instance directly`, () => {
         expect(() => { new FTest; }).not.toThrow();
     });
-    test(`Should not be able to extend a final class directly`, () => {
+    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 class derived from a final class`, () => {
+    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);
+    });
 });