cfprotected 1.1.1 → 1.1.2

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

@@ -62,7 +62,8 @@ 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.
@@ -169,9 +170,11 @@ function abstract(klass) {
     };
 
     if (memos.has(klass)) {
-        memos.set(retval, memos.get(klass));
+        let memo = memos.get(klass);
+        memos.set(retval, memo);
+        memo.set(retval, memo.get(klass));
     }
-
+    
     return retval;
 };
 
@@ -182,51 +185,52 @@ 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)) {
-        memos.set(retval, memos.get(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.1",
+  "version": "1.1.2",
   "description": "An implementation of protected fields on top of class fields.",
   "main": "index.js",
   "scripts": {

package/test/test.mjs

@@ -140,13 +140,18 @@ describe(`Testing that $uper works in all cases`, () => {
 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`, () => {
@@ -158,20 +163,27 @@ describe(`Testing that abstract classes function as expected`, () => {
     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];
-        }
+        run() { return this.#shared[key]; }
+        static run() { return this.pvt.#sshared[key]; }
     });
 
     test(`Should be able to instantiate an instance directly`, () => {
@@ -190,4 +202,7 @@ describe(`Testing that final classes function as expected`, () => {
     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);
+    });
 });