cfprotected 1.1.3 → 1.2.0

package/README.md

@@ -104,12 +104,22 @@ class Example {
 As a bonus, when used on the constructor, it creates an additional property named "cla\$\$" on the prototype. This "cla\$\$" property gives instances a means to reference the class constructor even when the class itself is anonymous. This is a fill-in feature for one of the TC39 proposals offering syntax for the same.
 
 ## **abstract(klass)**
-This method is a class wrapper that prevents instances of the class from being constructed directly. To construct an instance of the class you must extend it. This should be nearly identical to the same functionality that exists in some compiled languages.
+This method has 2 different uses. The first is as a class wrapper that prevents instances of the class from being constructed directly. To construct an instance of the class, you must extend it. This should be nearly identical to the same functionality that exists in some compiled languages.
 ```js
 const Example = abstract(class {
     ...
 });
 ```
+The second use is to mark the function as not having a valid implementation. Such functions must be overridden by derived classes.
+```js
+class Example {
+    ...
+    #prot = share(this, Example, {
+        method = abstract("Example::method")
+    });
+    ...
+};
+```
 
 ## **final(klass)**
 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.

package/index.mjs

@@ -39,6 +39,8 @@ function bindDescriptor(desc, context) {
  * @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)) {
@@ -67,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);
@@ -76,25 +78,22 @@ 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 ancestorKey = (inst === klass) ? ancestor : inst;
-    let memo = ancestorMemo.get(ancestorKey) || {
-        data: {}, 
-        $uper: {},
-    };
-    let retval = {};
+    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.
-    let prototype = Object.getPrototypeOf(memo.data);
+    //Add the new members to the prototype chain of protData.
+    let prototype = Object.getPrototypeOf(protData);
     let proto = Object.create(prototype,
         Object.fromEntries(mKeys
             .map(k => {
@@ -108,11 +107,18 @@ function share(inst, klass, members) {
                 bindDescriptor(mDesc[k], inst);
                 return [k, mDesc[k]];
             })));
-    Object.setPrototypeOf(retval, proto);
+    Object.setPrototypeOf(protData, proto);
 
+    //Build the accessors for this class.
+    mKeys.forEach(m => {
+        Object.defineProperty(retval, m, {
+            get() { return protData[m]; },
+            set(v) { protData[m] = v; }
+        });
+    });
+    
     //Define the "$uper" accessors
-    let $uper = {};
-    Object.defineProperty(retval, "$uper", { value: $uper });
+    Object.defineProperty(retval, "$uper", { value: {} });
 
     //Build up the "$uper" object
     for (let key of mKeys) {
@@ -121,23 +127,27 @@ function share(inst, klass, members) {
             while (!obj.hasOwnProperty(key)) {
                 obj = Object.getPrototypeOf(obj);
             }
-            Object.defineProperty($uper, key, Object.getOwnPropertyDescriptor(obj, key));
+            Object.defineProperty(retval.$uper, key, Object.getOwnPropertyDescriptor(obj, key));
         }
     }
 
     //Attach the super inheritance
-    Object.setPrototypeOf($uper, memo.$uper);
+    Object.setPrototypeOf(retval.$uper, memo.$uper);
+
+    //Inherit the inheritance
+    Object.setPrototypeOf(retval, memo.inheritance);
 
     //Save the inheritance & protected data
     memos.get(klass).set(inst, {
-        data: retval,
-        $uper: $uper
+        data: protData,
+        inheritance: retval,
+        $uper: retval.$uper
     });    
 
     return retval;
 }
 
-/**
+ /**
  * Binds the class instance to itself to allow code to selectively avoid Proxy
  * issues, especially ones involving private fields. Also binds the class
  * constructor to the instance for static referencing as "cla$$".
@@ -173,23 +183,37 @@ function accessor(desc) {
 /**
  * A class wrapper that blocks construction of an instance if the class being
  * instantiated is not a descendant of the current class.
- * @param {Function} klass The constructor of the current class.
+ * @param {function|string} klass If a function, the constructor of the current
+ * class. If a string, the name of the function being abstracted.
+ * @returns {function} Either an extended class that denies direct construction
+ * or a function that immediately throws.
  */
 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'`);
+    let retval;
+    if (typeof(klass) == "function") {
+        let name = klass.name?klass.name : "";
+        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);
             }
-            super(...args);
-        }
-    };
+        };
 
-    if (memos.has(klass)) {
-        let memo = memos.get(klass);
-        memos.set(retval, memo);
-        memo.set(retval, memo.get(klass));
+        if (memos.has(klass)) {
+            let memo = memos.get(klass);
+            memos.set(retval, memo);
+            memo.set(retval, memo.get(klass));
+        }
+    }
+    else if (typeof(klass) == "string") {
+        retval = function() {
+            throw new TypeError(`${klass}() must be overridden`);
+        }
+    }
+    else {
+        throw new TypeError(`abstract parameter must be a function or string`)
     }
     
     return retval;

package/package.json

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