cfprotected 1.1.4 → 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

@@ -147,7 +147,7 @@ function share(inst, klass, members) {
     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$$".
@@ -183,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.4",
+  "version": "1.2.0",
   "description": "An implementation of protected fields on top of class fields.",
   "main": "index.js",
   "scripts": {