cfprotected 1.1.2 → 1.1.3

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)) {
@@ -63,58 +83,55 @@ function share(inst, klass, members) {
 
     //Get the protected data object.
     let ancestorKey = (inst === klass) ? ancestor : inst;
-    let memo = ancestorMemo.get(ancestorKey) || {data: {}, $uper: {}, inheritance: null};
-    let protData = memo.data;
+    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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cfprotected",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "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"!`);
+        });
     }
 }