cfprotected 1.2.0 → 1.3.1

package/GEMINI.md

@@ -0,0 +1,25 @@
+# Project: JSAppLib
+
+## General Instructions
+
+- Re-read this file when it is updated.
+- Follow the existing coding style when generating new Javascript.
+- Add JSDoc comments for all new functions and classes. Add JSDoc comments to all public functions and classes not currently possessing them.
+- Make use of the cfprotected node module to add support for protected members when creating classes.
+- Always provide a static private member named "spvt" for the class-private member container.
+- Always provide a private member named "pvt" for the instance-private member container.
+- TypeScript is not allowed in this project.
+- Tests use the jest node module.
+- Don't try to guess about what I want you to do. If there is any uncertainty, ask me.
+- Don't run anything on the command line without my review and approval.
+- Don't assume. Question the user.
+
+## Coding Style
+
+- Functions can only have a single exit point. This doesn't include exceptions.
+- Each new HTML Custom Element classes must be contained in its own file.
+- The name of a class's file must be the class name prefixed by 'js' and have an extension of '.mjs'.
+- Indentation is always 4 spaces.
+- Never use public fields. If a public field is desired, use a public accessor to a private field.
+- When a class uses private members, make sure to use `saveSelf(this, '$');` in the constructor, and if needed, in the static initializer block of the class.
+- Except in the class constructor and in the static initializer block, private fields must be accessed via `this.$` to protect against proxy access.

package/README.md

@@ -132,6 +132,27 @@ 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.
 
+## **define(klass, defs)**
+Adds specified definitions to the class prototype. All supplied definitions will default to {enumerable: true, configurable: true, writable: true} unless otherwise specified. The {writable} attribute will not be defaulted if {value} is not specified. This is for providing public class members that are bound to the prototype instead of the instance objects. Use this function in the `static {}` block of the class.
+```js
+class Example {
+    ...
+    static {
+        ...
+        define(this, {
+            ex1: {
+                get: () => {}
+            },
+            ex2: {
+                value: 42
+            }
+        });
+        ...
+    }
+    ...
+}
+```
+
 ## 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.js

@@ -0,0 +1,361 @@
+"use strict"
+
+const memos = new WeakMap();
+const ACCESSOR = Symbol();
+
+/**
+ * General definition of a class constructor function.
+ * @typedef Constructor
+ * @type new (...args: any[]) => object
+ */
+
+
+/**
+ * Returns all public keys of the specified object.
+ * @param {object} o
+ * @returns {(string|symbol)[]}
+ */
+function getAllOwnKeys(o) {
+    /** @type {(string|symbol)[]} */
+    let retval = Object.getOwnPropertyNames(o);
+    return retval.concat(Object.getOwnPropertySymbols(o));
+}
+
+/**
+ * @typedef Descriptor
+ * @property {*} [value]
+ * @property {Function} [get]
+ * @property {Function} [set]
+ * 
+ * Calls the given function against each descriptor property that itself is
+ * also a function.
+ * @param {Descriptor} desc 
+ * @param {Function} fn 
+ */
+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");
+        }
+    }
+}
+
+/**
+ * Binds all functions of the descriptor to the given context object.
+ * @param {Descriptor} desc 
+ * @param {object} context 
+ */
+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.
+ * @overload { (inst, klass, members) => object }
+ * @overload { (inst, members) => object }
+ * @param {object} inst The instance object that will own the shared members.
+ * @param {Constructor|object} klass The constructor function of the class sharing
+ * members. Optional. If omitted, defaults to inst.
+ * @param {object=} members The object containing the properties being shared.
+ * @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)) {
+        members = klass;
+        klass = inst;
+    }
+
+    if (!inst || !["function", "object"].includes(typeof(inst))) {
+        throw new TypeError(`Expected inst to be a function or an object.`);
+    }
+    if (!klass || (typeof(klass) != "function")) {
+        throw new TypeError(`Expected klass to be a function.`);
+    }
+    if (!members || (typeof(members) != "object")) {
+        throw new TypeError(`Expected members to be an object.`);
+    }
+
+    
+    /*
+    * Each class' memo entry has the following structure:
+    * 
+    * inst: {
+    *   data: <Object> - the actual protected data object
+    *   inheritance: <Object> - the object of accessor properties to share
+    *                           with descendant classes.
+    * }
+    */
+   
+    //Find the nearest known registered ancestor class
+    let ancestor = Object.getPrototypeOf(klass);
+    while (ancestor && !memos.has(ancestor)) {
+        ancestor = Object.getPrototypeOf(ancestor);
+    }
+
+    //Get the memo from that ancestor
+    let ancestorMemo = memos.get(ancestor) || new WeakMap();
+
+    //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: {}, inheritance: null};
+    let protData = memo.data;
+    
+    //Get the details of the protected properties.
+    let mDesc = Object.getOwnPropertyDescriptors(members);
+    let mKeys = getAllOwnKeys(members);
+
+    //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 => {
+                // @ts-ignore
+                let desc = mDesc[k];
+                if (desc.value?.hasOwnProperty(ACCESSOR)) {
+                    Object.assign(desc, desc.value);
+                    desc.enumerable = true;
+                    delete desc[ACCESSOR];
+                    delete desc.value;
+                    delete desc.writable;
+                }
+                bindDescriptor(desc, inst);
+                return [k, desc];
+            })));
+    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
+    Object.defineProperty(retval, "$uper", { value: {} });
+
+    //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));
+        }
+    }
+
+    //Attach the super inheritance
+    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: 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$$".
+ * @param {object} self The current class instance as seen from the constructor.
+ * @param {string} name The name of the field on which to bind the instance.
+ */
+function saveSelf(self, name) {
+    Object.defineProperty(self, name, {value: self});
+    if (typeof(self) == "function") {
+        Object.defineProperty(self.prototype, "cla$$", {value: self});
+    }
+}
+
+/**
+ * Marks the property as a shared, overrideable accessor and defines the 
+ * getter and setter methods for it.
+ * @param {object} desc Object containing get and/or set definitions for the
+ * accessor.
+ * @returns {object} A tagged object that will be used to create the access
+ * bindings for the property.
+ */
+function accessor(desc) {
+    if ((typeof(desc) == "object") &&
+        (("get" in desc) || ("set" in desc))) {
+        return {
+            [ACCESSOR]: undefined,
+            get: desc.get,
+            set: desc.set
+        }
+    }
+}
+
+/**
+ * A class wrapper that blocks construction of an instance if the class being
+ * instantiated is not a descendant of the current class.
+ * @param {Constructor|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 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);
+            }
+        };
+
+        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;
+};
+
+/**
+ * A class wrapper that blocks construction of an instance if the class being
+ * constructed is a descendant of the current class. It also attempts to block
+ * extending the targeted class.
+ * @param {Constructor} klass The constructor of the current class.
+ */
+function final(klass) {
+    /**
+     * Replaces the first parameter in the args list with the given class (klass)
+     * and calls the original method to bypass 
+     * @param {string} fname Name of the ProxyHandler method being called.
+     * @param {any[]} args Arguments to the ProxyHandler method
+     * @returns {any}
+     */
+    function handleDefault(fname, args) {
+        args.shift();
+        args.unshift(klass);
+        return Reflect[fname](...args);
+    }
+
+    let retval = new Proxy(function() {}, {
+        construct(_, args, newTarget) {
+            if (newTarget !== retval) {
+                throw new TypeError("Cannot create an instance of a descendant of a final class");
+            }
+            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;
+        },
+        get(_, prop, receiver) {
+            return (prop == "prototype")
+                ? void 0
+                : Reflect.get(klass, prop, receiver);
+        },
+        
+        set(...args) { return handleDefault("set", args); },
+        apply(...args) { return handleDefault("apply", args); },
+        defineProperty(...args) { return handleDefault("defineProperty", args); },
+        deleteProperty(...args) { return handleDefault("deleteProperty", args); },
+        getOwnPropertyDescriptor(...args) { return handleDefault("getOwnPropertyDescriptor", args); },
+        getPrototypeOf(...args) { return handleDefault("getPrototypeOf", args); },
+        has(...args) { return handleDefault("has", args); },
+        isExtensible(...args) { return handleDefault("isExtensible", args); },
+        ownKeys(...args) { return handleDefault("ownKeys", args); },
+        preventExtensions(...args) { return handleDefault("preventExtensions", args); },
+        setPrototypeOf(...args) { return handleDefault("setPrototypeOf", args); }
+    });        
+
+    if (memos.has(klass)) {
+        let memo = memos.get(klass);
+        memos.set(retval, memo);
+        memo.set(retval, memo.get(klass));
+    }
+
+    return retval;
+};
+
+/**
+ * Adds specified definitions to the class prototype. All supplied definitions will
+ * default to {enumerable: true, configurable: true, writable: true} unless otherwise
+ * specified. The {writable} attribute will not be defaulted if {value} is not specified.
+ * This is for providing public class members that are bound to the prototype instead of
+ * the instance objects. Use this function in the `static {}` block of the class.
+ * @param {function} tgt The constructor function whose prototype will be modified.
+ * @param {object} defs The set of property definitions to be applied to the prototype.
+ */
+function define(tgt, defs) {
+    if (typeof(tgt) !== "function") {
+        throw new TypeError("Invalid target type in first parameter.");
+    }
+    if (!defs || (typeof(defs) !== "object")) {
+        throw new TypeError("Invalid definition type in second parameter.");
+    }
+    
+    for (let key in defs) {
+        let def = defs[key];
+        let isDef = Object.getOwnPropertyNames(def).reduce((rv, cv) => {
+            return rv && ["enumerable", "configurable", "writable", "value"].includes(cv);
+        }, true);
+
+        if (!def || (typeof(def) !== "object") || !isDef || !("value" in def)) {
+            continue;
+        }
+        if (!("enumerable" in def)) {
+            def.enumerable = true;
+        }
+        if (!("configurable" in def)) {
+            def.configurable = true;
+        }
+        if (!("writable" in def)) {
+            def.writable = true;
+        }
+    }
+    
+    Object.defineProperties(tgt.prototype, defs);
+}
+
+module.exports = { share, saveSelf, accessor, abstract, final, define };

package/index.mjs

@@ -3,11 +3,35 @@
 const memos = new WeakMap();
 const ACCESSOR = Symbol();
 
+/**
+ * General definition of a class constructor function.
+ * @typedef Constructor
+ * @type new (...args: any[]) => object
+ */
+
+
+/**
+ * Returns all public keys of the specified object.
+ * @param {object} o
+ * @returns {(string|symbol)[]}
+ */
 function getAllOwnKeys(o) {
-    return Object.getOwnPropertyNames(o)
-        .concat(Object.getOwnPropertySymbols(o));
+    /** @type {(string|symbol)[]} */
+    let retval = Object.getOwnPropertyNames(o);
+    return retval.concat(Object.getOwnPropertySymbols(o));
 }
 
+/**
+ * @typedef Descriptor
+ * @property {*} [value]
+ * @property {Function} [get]
+ * @property {Function} [set]
+ * 
+ * Calls the given function against each descriptor property that itself is
+ * also a function.
+ * @param {Descriptor} desc 
+ * @param {Function} fn 
+ */
 function useDescriptor(desc, fn) {
     if ("value" in desc) {
         if (typeof(desc.value) == "function") {
@@ -24,6 +48,11 @@ function useDescriptor(desc, fn) {
     }
 }
 
+/**
+ * Binds all functions of the descriptor to the given context object.
+ * @param {Descriptor} desc 
+ * @param {object} context 
+ */
 function bindDescriptor(desc, context) {
     useDescriptor(desc, (key) => {
         desc[key] = desc[key].bind(context);
@@ -32,11 +61,13 @@ function bindDescriptor(desc, 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.
- * @param {Function?} klass The constructor function of the class sharing
+ * @overload { (inst, klass, members) => object }
+ * @overload { (inst, members) => object }
+ * @param {object} inst The instance object that will own the shared members.
+ * @param {Constructor|object} klass The constructor function of the class sharing
  * members. Optional. If omitted, defaults to inst.
- * @param {Object} members The object containing the properties being shared.
- * @returns {Object} The fully constructed inheritance object.
+ * @param {object=} members The object containing the properties being shared.
+ * @returns {object} The fully constructed inheritance object.
  */
 function share(inst, klass, members) {
     let retval = {};
@@ -94,18 +125,21 @@ function share(inst, klass, members) {
 
     //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 => {
-                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;
+                // @ts-ignore
+                let desc = mDesc[k];
+                if (desc.value?.hasOwnProperty(ACCESSOR)) {
+                    Object.assign(desc, desc.value);
+                    desc.enumerable = true;
+                    delete desc[ACCESSOR];
+                    delete desc.value;
+                    delete desc.writable;
                 }
-                bindDescriptor(mDesc[k], inst);
-                return [k, mDesc[k]];
+                bindDescriptor(desc, inst);
+                return [k, desc];
             })));
     Object.setPrototypeOf(protData, proto);
 
@@ -147,12 +181,12 @@ 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$$".
- * @param {Object} self The current class instance as seen from the constructor.
- * @param {String} name The name of the field on which to bind the instance.
+ * @param {object} self The current class instance as seen from the constructor.
+ * @param {string} name The name of the field on which to bind the instance.
  */
 function saveSelf(self, name) {
     Object.defineProperty(self, name, {value: self});
@@ -164,9 +198,9 @@ function saveSelf(self, name) {
 /**
  * Marks the property as a shared, overrideable accessor and defines the 
  * getter and setter methods for it.
- * @param {Object} desc Object containing get and/or set definitions for the
+ * @param {object} desc Object containing get and/or set definitions for the
  * accessor.
- * @returns {Object} A tagged object that will be used to create the access
+ * @returns {object} A tagged object that will be used to create the access
  * bindings for the property.
  */
 function accessor(desc) {
@@ -183,15 +217,15 @@ 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|string} klass If a function, the constructor of the current
+ * @param {Constructor|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
+ * @returns {Function} Either an extended class that denies direct construction
  * or a function that immediately throws.
  */
 function abstract(klass) {
     let retval;
     if (typeof(klass) == "function") {
-        let name = klass.name?klass.name : "";
+        let name = klass.name ? klass.name : "";
         retval = class extends klass {
             constructor (...args) {
                 if (new.target === retval) {
@@ -223,15 +257,23 @@ function abstract(klass) {
  * A class wrapper that blocks construction of an instance if the class being
  * 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.
+ * @param {Constructor} klass The constructor of the current class.
  */
 function final(klass) {
+    /**
+     * Replaces the first parameter in the args list with the given class (klass)
+     * and calls the original method to bypass 
+     * @param {string} fname Name of the ProxyHandler method being called.
+     * @param {any[]} args Arguments to the ProxyHandler method
+     * @returns {any}
+     */
+    function handleDefault(fname, args) {
+        args.shift();
+        args.unshift(klass);
+        return Reflect[fname](...args);
+    }
+
     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");
@@ -253,17 +295,18 @@ function final(klass) {
                 ? void 0
                 : Reflect.get(klass, prop, receiver);
         },
-        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); }
+        
+        set(...args) { return handleDefault("set", args); },
+        apply(...args) { return handleDefault("apply", args); },
+        defineProperty(...args) { return handleDefault("defineProperty", args); },
+        deleteProperty(...args) { return handleDefault("deleteProperty", args); },
+        getOwnPropertyDescriptor(...args) { return handleDefault("getOwnPropertyDescriptor", args); },
+        getPrototypeOf(...args) { return handleDefault("getPrototypeOf", args); },
+        has(...args) { return handleDefault("has", args); },
+        isExtensible(...args) { return handleDefault("isExtensible", args); },
+        ownKeys(...args) { return handleDefault("ownKeys", args); },
+        preventExtensions(...args) { return handleDefault("preventExtensions", args); },
+        setPrototypeOf(...args) { return handleDefault("setPrototypeOf", args); }
     });        
 
     if (memos.has(klass)) {
@@ -275,4 +318,39 @@ function final(klass) {
     return retval;
 };
 
-export { share, saveSelf, accessor, abstract, final };
+/**
+ * Adds specified definitions to the class prototype. All supplied definitions will
+ * default to {enumerable: true, configurable: true, writable: true} unless otherwise
+ * specified. The {writable} attribute will not be defaulted if {value} is not specified.
+ * This is for providing public class members that are bound to the prototype instead of
+ * the instance objects. Use this function in the `static {}` block of the class.
+ * @param {function} tgt The constructor function whose prototype will be modified.
+ * @param {object} defs The set of property definitions to be applied to the prototype.
+ */
+function define(tgt, defs) {
+    if (typeof(tgt) !== "function") {
+        throw new TypeError("Invalid target type in first parameter.");
+    }
+    if (!defs || (typeof(defs) !== "object")) {
+        throw new TypeError("Invalid definition type in second parameter.");
+    }
+    
+    for (let key in defs) {
+        let def = defs[key];
+        if (typeof def !== 'object' || def === null) continue;
+
+        if (!("enumerable" in def)) {
+            def.enumerable = true;
+        }
+        if (!("configurable" in def)) {
+            def.configurable = true;
+        }
+        if (("value" in def) && !("writable" in def)) {
+            def.writable = true;
+        }
+    }
+    
+    Object.defineProperties(tgt.prototype, defs);
+}
+
+export { share, saveSelf, accessor, abstract, final, define };

package/jsconfig.json

@@ -0,0 +1,9 @@
+{
+    "exclude": ["**/node_modules"],
+    "compilerOptions": {
+        "module": "ES2015",
+        "target": "ES2022",
+        "checkJs": true,
+        "moduleResolution": "node"
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cfprotected",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "An implementation of protected fields on top of class fields.",
   "main": "index.js",
   "scripts": {
@@ -12,11 +12,15 @@
     "protected",
     "inheritance"
   ],
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./index.js"
+  },
   "author": "Ranando D. King",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/rdking/CFProtected.git"
+    "url": "git+https://github.com/rdking/CFProtected.git"
   },
   "devDependencies": {
     "jest": "^27.4.7",

package/test/test.mjs

@@ -1,222 +1,284 @@
-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",
-        method: () => {
-            return "It works.";
-        },
+import { share, saveSelf, accessor, abstract, final, define } from "../index.mjs";
+
+describe('CFProtected Library', () => {
+
+  describe('share()', () => {
+    const greeting = "Hello!";
+    const name = "John Jacob Jingleheimerschmidt";
+    const num = 42;
+    const methodResult = "It works.";
+    const propTestValue = "I can make this return anything!";
+    const superTestResult = 1;
+    const subTestResult = 2;
+    const symbolKey = Symbol('test');
+    const symbolValue = 'symbol value';
+
+    class Base {
+      static #greeting = greeting;
+      static #sprot = share(this, {
+        getGreeting: () => this.#greeting,
+        superTest: () => 0,
+      });
+
+      #propTestVal = propTestValue;
+      #prot = share(this, Base, {
+        num,
+        name,
+        method: () => methodResult,
         prop: accessor({
-            get: () => this.propTestVal
+          get: () => this.#propTestVal,
+          set: (v) => this.#propTestVal = v
         }),
-        superTest: () => {
-            return 1;
-        }
-    });
+        superTest: () => superTestResult,
+        [symbolKey]: symbolValue
+      });
 
-    constructor() {
-        saveSelf(this, "pvt");
+      constructor() {
+        saveSelf(this, 'pvt');
+      }
+
+      getProt() { return this.#prot; }
+      getPropTestVal() { return this.#propTestVal; }
+      static getSprot() { return this.#sprot; }
     }
 
-    testName = "John Jacob Jingleheimerschmidt";
-    propTestVal = "I can make this return anything!";
+    class Sub extends Base {
+      static #sprot = share(this, {
+          superTest: () => 1
+      });
+      static getSprot() { return this.#sprot; } // Add this
+      #prot = share(this, Sub, {
+        superTest: () => subTestResult,
+      });
 
-    checkProp(proxied) {
-        expect((proxied?this.pvt:this).#prot.prop).toBe(this.propTestVal);
-    }
+      constructor() {
+        super();
+      }
 
-    run() {
-        test(`Access to shared members should just work on the instance`, () => {
-            expect(this.#prot.num).toBe(42);
-            expect(this.#prot.name).toBe(this.testName);
-            expect(this.#prot.method()).toBe("It works.");
-            this.checkProp();
-        });
-        
-        test(`Access to shared members should work even through a Proxy`, () => {
-            let that = new Proxy(this, {});
-            expect(that.pvt.#prot.num).toBe(42);
-            expect(that.pvt.#prot.name).toBe(this.testName);
-            expect(that.pvt.#prot.method()).toBe("It works.");
-            this.checkProp(true);
-        });
+      getProt() { return this.#prot; }
     }
-}
 
-class Derived extends Base {
-    #prot = share(this, Derived, {
-        otherMethod: () => {
-            this.#prot.name = this.testName;
-        },
-        prop: accessor({
-            get: () => this.propTestVal2
-        })
-    });
+    let baseInst;
+    let subInst;
 
-    constructor() {
-        super();
-        saveSelf(this, "pvt");
-        this.propTestVal2 = this.propTestVal;
-    }
+    beforeEach(() => {
+      baseInst = new Base();
+      subInst = new Sub();
+    });
 
-    run() {
-        super.run();
+    test('should allow access to basic properties', () => {
+      expect(baseInst.getProt().num).toBe(num);
+      expect(baseInst.getProt().name).toBe(name);
+    });
 
-        test(`Should be able to change a shared property value`, () => {
-            this.testName = "A. Nony Mouse";
-            expect(() => { this.#prot.otherMethod(); }).not.toThrow();
-            this.checkProp();
-        });
-    }
-}
+    test('should allow calling methods', () => {
+      expect(baseInst.getProt().method()).toBe(methodResult);
+    });
 
-class NonParticipant extends Base {}
+    test('should handle accessor properties (get)', () => {
+      expect(baseInst.getProt().prop).toBe(propTestValue);
+    });
+    
+    test('should handle accessor properties (set)', () => {
+        const newValue = "new value";
+        baseInst.getProt().prop = newValue;
+        expect(baseInst.getPropTestVal()).toBe(newValue);
+    });
 
-class GrandChild extends NonParticipant {
-    static #sprot = share(this, {
-        getGreeting() {
-            return `${this.#sprot.$uper.getGreeting()} My name is`;
-        }
+    test('should handle symbol properties', () => {
+      expect(baseInst.getProt()[symbolKey]).toBe(symbolValue);
     });
-    #prot = share(this, GrandChild, {
-        otherMethod: () => {
-            this.#prot.name = this.testName;
-        },
-        superTest: () => {
-            return 1 + this.pvt.#prot.$uper.superTest();
-        }
+
+    test('should handle inheritance correctly', () => {
+      const subProt = subInst.getProt();
+      expect(subProt.num).toBe(num);
+      expect(subProt.name).toBe(name);
+      expect(subProt.method()).toBe(methodResult);
     });
 
-    constructor() {
-        super();
-        saveSelf(this, "pvt");
-    }
+    test('should handle overriding properties', () => {
+      expect(baseInst.getProt().superTest()).toBe(superTestResult);
+      expect(subInst.getProt().superTest()).toBe(subTestResult);
+    });
 
-    run() {
-        super.run();
+    test('should provide access to superclass implementations via $uper', () => {
+      const subProt = subInst.getProt();
+      expect(subProt.$uper.superTest()).toBe(superTestResult);
+    });
+    
+    test('should handle static property sharing', () => {
+        expect(Base.getSprot().getGreeting()).toBe(greeting);
+    });
+    
+    test('should handle static property inheritance and $uper', () => {
+        expect(Sub.getSprot().$uper.superTest()).toBe(0);
+        expect(Sub.getSprot().superTest()).toBe(1);
+    });
 
-        test(`Should be able to change a shared property value`, () => {
-            this.testName = "A. Nony Mouse 1";
-            expect(() => { this.#prot.otherMethod(); }).not.toThrow();
-            this.checkProp();
-        });
-    }
-}
+    test('should throw TypeError for invalid arguments', () => {
+      expect(() => share(null, Base, {})).toThrow(TypeError);
+      expect(() => share({}, null, {})).toThrow(TypeError);
+      expect(() => share({}, Base, null)).toThrow(TypeError);
+    });
+    
+    test('should work with share(klass, members) overload', () => {
+        class A {
+            static #shared = share(this, { val: 1 });
+            static getShared() { return this.#shared; }
+        }
+        expect(A.getShared().val).toBe(1);
+    });
+  });
 
-class SuperTest extends GrandChild {
-    static #sprot = share(this, {
-        getGreeting() {
-            return `${this.#sprot.$uper.getGreeting()} "${this.name}"!`
+  describe('saveSelf()', () => {
+    test('should bind the instance to a property', () => {
+      class Test {
+        constructor() {
+          saveSelf(this, 'myself');
         }
+      }
+      const inst = new Test();
+      expect(inst.myself).toBe(inst);
     });
-    #prot = share(this, SuperTest, {
-        superTest: () => {
-            return 1 + this.pvt.#prot.$uper.superTest();
+
+    test('should add "cla$$" property to prototype when saving constructor', () => {
+      class Test {
+        static {
+          saveSelf(this, 'pvt');
         }
+      }
+      const inst = new Test();
+      expect(Test.pvt).toBe(Test);
+      expect(inst.cla$$).toBe(Test);
     });
+  });
 
-    constructor() {
-        super();
-        saveSelf(this, "pvt");
-    }
+  describe('accessor()', () => {
+    test('should return a descriptor for a valid getter/setter object', () => {
+      const desc = { get: () => 'foo', set: () => {} };
+      const acc = accessor(desc);
+      expect(typeof acc).toBe('object');
+      expect('get' in acc).toBe(true);
+      expect('set' in acc).toBe(true);
+      expect(Object.getOwnPropertySymbols(acc).length).toBe(1); // The ACCESSOR symbol
+    });
 
-    run() {
-        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"!`);
-        });
-    }
-}
+    test('should return undefined for invalid input', () => {
+      expect(accessor({})).toBeUndefined();
+      expect(accessor({ foo: 'bar' })).toBeUndefined();
+      expect(accessor(123)).toBeUndefined();
+    });
+  });
 
-describe(`Testing shared elements in the base class`, () => {
-    (new Base).run();
-});
-describe(`Testing shared elements in a direct descendant`, () => {
-    (new Derived).run();
-});
+  describe('abstract()', () => {
+    const A = abstract(class A {});
+    class B extends A {}
 
-describe(`Testing shared elements inherited from a non-participant`, () => {
-    (new GrandChild).run();
-});
+    test('should throw when directly instantiating an abstract class', () => {
+      expect(() => new A()).toThrow(TypeError);
+      expect(() => new A()).toThrow("Class constructor A is abstract and cannot be directly invoked with 'new'");
+    });
 
-describe(`Testing that $uper works in all cases`, () => {
-    (new SuperTest).run();
-});
+    test('should not throw when instantiating a derived class', () => {
+      expect(() => new B()).not.toThrow();
+    });
 
-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
-        });
+    test('should create a function that throws when given a string', () => {
+        const abstractFn = abstract('myFunc');
+        expect(typeof abstractFn).toBe('function');
+        expect(() => abstractFn()).toThrow(TypeError);
+        expect(() => abstractFn()).toThrow('myFunc() must be overridden');
     });
-    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`, () => {
-        expect(() => { new ATest; }).toThrow();
+    test('should throw a TypeError for invalid input', () => {
+        expect(() => abstract(123)).toThrow(TypeError);
+        expect(() => abstract(123)).toThrow('abstract parameter must be a function or string');
     });
-    test(`Should be able to instantiate a derived class`, () => {
-        expect(() => { new DTest; }).not.toThrow();
+    
+    test('should handle classes without names', () => {
+        const NoName = abstract(class {});
+        expect(() => new NoName()).toThrow("Class constructor  is abstract and cannot be directly invoked with 'new'");
     });
-    test(`Should see shared members from constructed instance`, () => {
-        expect((new DTest).run()).toBe(true);
+  });
+
+  describe('final()', () => {
+    const F = final(class F {});
+    
+    test('should allow direct instantiation', () => {
+        expect(() => new F()).not.toThrow();
     });
-    test(`Should see static shared members from constructed instance`, () => {
-        expect(DTest.run()).toBe(true);
+
+    test('should throw when trying to extend a final class', () => {
+      // The error happens at class definition time
+      expect(() => {
+        class D extends F {}
+      }).toThrow(TypeError);
+    });
+    
+    test('should throw when trying to create an instance of a descendant', () => {
+        // This simulates a bypass of the extension block
+        function cheat() {
+            const D = function() {};
+            Object.setPrototypeOf(D, F);
+            Reflect.construct(F, [], D);
+        }
+        expect(cheat).toThrow("Cannot create an instance of a descendant of a final class");
     });
-});
 
-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]; }
-        static run() { return this.pvt.#sshared[key]; }
+    test('prototype property should be undefined', () => {
+        expect(F.prototype).toBeUndefined();
+    });
+  });
+  
+  describe('define()', () => {
+    class MyClass {}
+
+    define(MyClass, {
+      prop1: { value: 10 },
+      prop2: { 
+        get: function() { return 20; },
+        enumerable: false
+      },
+      prop3: {
+        value: () => 30,
+        writable: false,
+      }
     });
 
-    test(`Should be able to instantiate an instance directly`, () => {
-        expect(() => { new FTest; }).not.toThrow();
+    const inst = new MyClass();
+
+    test('should define properties on the class prototype', () => {
+      expect(MyClass.prototype.hasOwnProperty('prop1')).toBe(true);
+      expect(inst.prop1).toBe(10);
     });
-    test(`Should not be able to extend directly`, () => {
-        expect(() => { class DTest extends FTest {}; }).toThrow();
+
+    test('should set default attributes (enumerable, configurable, writable)', () => {
+      const desc1 = Object.getOwnPropertyDescriptor(MyClass.prototype, 'prop1');
+      expect(desc1.enumerable).toBe(true);
+      expect(desc1.configurable).toBe(true);
+      expect(desc1.writable).toBe(true);
     });
-    test(`Should not be able to cheat and create an instance of a derived class`, () => {
-        expect(() => {
-            FTest.prototype = {};
-            class DTest extends FTest {}
-            new DTest;
-        }).toThrow();
+
+    test('should respect specified attributes', () => {
+      const desc2 = Object.getOwnPropertyDescriptor(MyClass.prototype, 'prop2');
+      expect(desc2.enumerable).toBe(false); // Overridden
+      expect(desc2.configurable).toBe(true); // Defaulted
+      expect(desc2.writable).toBeUndefined(); // Not a value property
     });
-    test(`Should see shared members from constructed instance`, () => {
-        expect((new FTest).run()).toBe(true);
+    
+    test('should not default writable if value is not present', () => {
+        const desc = Object.getOwnPropertyDescriptor(MyClass.prototype, 'prop2');
+        expect('writable' in desc).toBe(false);
     });
-    test(`Should see static shared members from constructed instance`, () => {
-        expect(FTest.run()).toBe(true);
+    
+    test('should respect specified writable attribute', () => {
+      const desc3 = Object.getOwnPropertyDescriptor(MyClass.prototype, 'prop3');
+      expect(desc3.writable).toBe(false);
     });
-});
+
+    test('should throw TypeError for invalid arguments', () => {
+      expect(() => define(null, {})).toThrow(TypeError);
+      expect(() => define(MyClass, null)).toThrow(TypeError);
+    });
+  });
+});