cfprotected 1.0.0 → 1.1.0

package/README.md

@@ -111,20 +111,14 @@ const Example = abstract(class {
 });
 ```
 
-### Note:
-This method uses a proxy internally to keep things consistent. However, the Proxy is not a membrane. So it's best if any use of static private fields is accessed through the property created by using `saveSelf(...)`.
-
 ## **final(klass)**
-This method is a class wrapper that prevents instances of the class from being created using descendant classes.
+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.
 ```js
 const Example = final(class {
     ...
 });
 ```
 
-### Note:
-Just as with `abstract(...)`, this method uses a proxy internally to keep things consistent. However, the Proxy is not a membrane. So it's best if any use of static private fields is accessed through the property created by using `saveSelf(...)`. Unfortunately, there's also a limitation with final. Normally in compiled languages, it is a syntax error to even create a class that extends from a final class. However, without taking over the means of building the class (as can be done with Babel or my ClassicJS library) it's just not possible to restrict that event. As a result, the only thing left to check for is construction of instances of such an error.
-
 ## 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

@@ -158,30 +158,67 @@ function accessor(desc) {
  * @param {Function} klass The constructor of the current class.
  */
 function abstract(klass) {
-    return new Proxy(klass, {
-        construct(target, args, newTarget) {
-            if (newTarget.prototype === klass.prototype)
-                throw new TypeError(`Cannot construct instance of abstract class.`);
-
-            return Reflect.construct(target, args, newTarget);
+    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'`);
+            }
+            super(...args);
         }
-    });
+    };
+    return retval;
 };
 
 /**
  * A class wrapper that blocks construction of an instance if the class being
- * constructed is a descendant of the current class.
+ * constructed is a descendant of the current class. It also attempts to block
+ * extending the targeted class.
  * @param {Function} klass The constructor of the current class.
  */
 function final(klass) {
-    return new Proxy(klass, {
-        construct(target, args, newTarget) {
-            if (newTarget.prototype !== klass.prototype)
-                throw new TypeError(`Cannot extend final class.`);
-
-            return Reflect.construct(target, args, newTarget);
+    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
+            }
+        });
+        Object.setPrototypeOf(inst, proto);
+        return inst;
+    })`);
+    retval.prototype = void 0;
+
+    Object.defineProperties(retval, {
+        toString: {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value() { return klass.toString(); }
+        },
+        length: {
+            configurable: true,
+            value: klass.length
+        },
+        [Symbol.hasInstance]: {
+            value(inst) { return inst instanceof klass; }
         }
     });
+
+    return retval;
 };
 
 export { share, saveSelf, accessor, abstract, final };

package/package.json

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

package/test/test.mjs

@@ -1,5 +1,5 @@
 import { TestWatcher } from "@jest/core";
-import { share, saveSelf, accessor } from "../index"; //require("cfprotected");
+import { share, saveSelf, accessor, abstract, final } from "../index"; //require("cfprotected");
 
 class Base {
     #prot = share(this, Base, {
@@ -135,4 +135,34 @@ describe(`Testing shared elements inherited from a non-participant`, () => {
 
 describe(`Testing that $uper works in all cases`, () => {
     (new SuperTest).run();
-})
+});
+
+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`, () => {
+        expect(() => { new ATest; }).toThrow();
+    });
+    test(`Should be able to instantiate a class derived from an abstract class`, () => {
+        expect(() => { new DTest; }).not.toThrow();
+    });
+});
+
+describe(`Testing that final classes function as expected`, () => {
+    const FTest = final(class {});
+
+    test(`Should be able to instantiate an instance of a final class directly`, () => {
+        expect(() => { new FTest; }).not.toThrow();
+    });
+    test(`Should not be able to extend a final class 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`, () => {
+        expect(() => {
+            FTest.prototype = {};
+            class DTest extends FTest {}
+            new DTest;
+        }).toThrow();
+    })
+});