@util.js/privates 0.41.5 → 0.41.7

package/package.json

@@ -2,9 +2,13 @@
   "author": "Chris Topher <c@creemama.com>",
   "dependencies": {
     "@babel/runtime-corejs3": "7.29.7",
-    "@util.js/errors": "0.41.5"
+    "@util.js/errors": "0.41.7"
   },
   "description": "JavaScript utility class for private member variables",
+  "files": [
+    "dist",
+    "index.js"
+  ],
   "keywords": [
     "field",
     "fields",
@@ -29,5 +33,5 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-privates"
   },
-  "version": "0.41.5"
+  "version": "0.41.7"
 }

package/lib/Privates.js

@@ -1,192 +0,0 @@
-"use strict";
-
-const RethrownError = require("@util.js/errors/RethrownError");
-
-/**
- * JavaScript utility class for private member variables.
- *
- * This class decreases some of the boilerplate of the
- * [WeakMap]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap}
- * pattern as described by
- * ["Private Variables in JavaScript with ES6 WeakMaps"]{@link https://modernweb.com/private-variables-in-javascript-with-es6-weakmaps/}
- * and
- * ["Privates In ES2015 Javascript Classes"]{@link https://ilikekillnerds.com/2015/09/privates-in-es2015-javascript-classes/}.
- * This utility handles shallow copying at construction.
- *
- * Private fields may become a part of the ECMA standard. The following is a
- * StackOverflow answer to the question
- * ["Private properties in JavaScript ES6 classes"]{@link https://stackoverflow.com/a/52237988}:
- * "Private fields are being implemented in the ECMA standard. You can start
- * using them today with babel 7 and stage 3 preset." Wouldn't private fields
- * make this class obsolete? Not necessarily. If each of your privates is a
- * function (e.g., you want to lazy load all member variables), this class has
- * convenience methods for that.
- *
- * @public
- * @class Privates
- */
-module.exports = class Privates {
-  constructor() {
-    this.privates = new WeakMap();
-  }
-
-  /**
-   * Calls `this.get(thiz, property)()`.
-   *
-   * @public
-   * @function Privates#call
-   */
-  call(thiz, property) {
-    try {
-      // this.get(thiz, property)() does not work all the time unless we
-      // call bind, which we do in the set method. See
-      // https://javascript.info/object-methods.
-      return this.get(thiz, property)();
-    } catch (e) {
-      const propertyStr = getPropertyErrorString(property);
-      throw new RethrownError(
-        e,
-        `privates.call(${thiz}, ${propertyStr}) failed. ${e.message}`,
-      );
-    }
-  }
-
-  get(thiz, property) {
-    try {
-      return this.getProps(thiz)[property];
-    } catch (e) {
-      const propertyStr = getPropertyErrorString(property);
-      throw new RethrownError(
-        e,
-        `privates.get(${thiz}, ${propertyStr}) failed. ${e.message}`,
-      );
-    }
-  }
-
-  getCallProxy(thiz) {
-    return new Proxy(this.getProps(thiz), { get: callProp });
-  }
-
-  getProps(thiz) {
-    try {
-      let properties = this.privates.get(thiz);
-      if (!properties) this.privates.set(thiz, (properties = {}));
-      return properties;
-    } catch (e) {
-      if (thiz == null)
-        throw new RethrownError(e, `thiz cannot be null or undefined.`);
-      throw e;
-    }
-  }
-
-  lambdaize(properties) {
-    try {
-      const lambdaProperties = {};
-      Object.entries(properties).forEach(
-        ([property, value]) => (lambdaProperties[property] = () => value),
-      );
-      return lambdaProperties;
-    } catch (e) {
-      if (properties == null)
-        throw new RethrownError(e, `properties cannot be null or undefined.`);
-    }
-  }
-
-  lazyLoad(thiz, property, lazyLoadFunction) {
-    if (typeof lazyLoadFunction !== "function")
-      throw new TypeError(
-        `lazyLoadFunction (${lazyLoadFunction}) must be a function.`,
-      );
-    let value;
-    let loaded = false;
-    this.set(thiz, property, () => {
-      if (!loaded) {
-        value = lazyLoadFunction();
-        loaded = true;
-      }
-      return value;
-    });
-  }
-
-  lazyLoadProps(thiz, ...lazilyLoadedProperties) {
-    const t = this;
-    lazilyLoadedProperties.forEach((currentProperties) => {
-      Object.entries(currentProperties).forEach(
-        ([property, lazyLoadFunction]) =>
-          t.lazyLoad(thiz, property, lazyLoadFunction),
-      );
-    });
-  }
-
-  set(thiz, property, newValue) {
-    try {
-      this.getProps(thiz)[property] = newValue;
-    } catch (e) {
-      const propertyStr = getPropertyErrorString(property);
-      throw new RethrownError(
-        e,
-        `privates.set(${thiz}, ${propertyStr}, ${newValue}) failed. ${e.message}`,
-      );
-    }
-  }
-
-  setProps(thiz, ...properties) {
-    const t = this;
-    properties.forEach((currentProperties) => {
-      Object.entries(currentProperties).forEach(([property, value]) =>
-        t.set(thiz, property, value),
-      );
-      getAllMethods(currentProperties).forEach((method) =>
-        t.set(thiz, method, currentProperties[method].bind(currentProperties)),
-      );
-    });
-  }
-
-  subset(thiz, ...properties) {
-    const object = {};
-    for (let i = 0; i < properties.length; i++)
-      object[properties[i]] = this.get(thiz, properties[i]);
-    return object;
-  }
-};
-
-function getPropertyErrorString(property) {
-  // https://stackoverflow.com/a/7772724
-  if (typeof property === "string" || property instanceof String)
-    return `"${property}"`;
-  return `${property}`;
-}
-
-function callProp(obj, property) {
-  try {
-    return obj[property]();
-  } catch (e) {
-    throw new RethrownError(e, `Calling "${property}" as a function failed.`);
-  }
-}
-
-// https://stackoverflow.com/questions/31054910/get-functions-methods-of-a-class
-function getAllMethods(obj) {
-  if (!Object.getPrototypeOf(obj)) return [];
-
-  let props = [];
-
-  do {
-    const l = Object.getOwnPropertyNames(obj)
-      .concat(Object.getOwnPropertySymbols(obj).map((s) => s.toString()))
-      .sort()
-      .filter(
-        (p, i, arr) =>
-          typeof obj[p] === "function" && // only the methods
-          p !== "constructor" && // not the constructor
-          (i === 0 || p !== arr[i - 1]) && // not overriding in this prototype
-          props.indexOf(p) === -1, // not overridden in a child
-      );
-    props = props.concat(l);
-  } while (
-    (obj = Object.getPrototypeOf(obj)) && // walk-up the prototype chain
-    Object.getPrototypeOf(obj) // not the the Object prototype methods (hasOwnProperty, etc...)
-  );
-
-  return props;
-}

package/test/PrivatesTest.js

@@ -1,202 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const Privates = require("..");
-const { RethrownError } = require("@util.js/errors");
-
-const ExampleUsingGet = (function () {
-  const privates = new Privates();
-
-  class ExampleUsingGet {
-    constructor(options) {
-      privates.setProps(this, options);
-    }
-
-    getProperty1() {
-      return property1(this);
-    }
-
-    getProperty2() {
-      return property2(this);
-    }
-  }
-
-  function get(thiz, privatePart) {
-    return privates.get(thiz, privatePart);
-  }
-  function property1(thiz) {
-    return get(thiz, "property1");
-  }
-  function property2(thiz) {
-    return get(thiz, "property2");
-  }
-
-  return ExampleUsingGet;
-})();
-
-const ExampleUsingCall = (function () {
-  const privates = new Privates();
-
-  class ExampleUsingCall {
-    constructor(options) {
-      privates.setProps(this, options);
-    }
-
-    getProperty1() {
-      return property1(this);
-    }
-
-    getProperty2() {
-      return property2(this);
-    }
-  }
-
-  function call(thiz, privatePart) {
-    return privates.call(thiz, privatePart);
-  }
-  function property1(thiz) {
-    return call(thiz, "property1");
-  }
-  function property2(thiz) {
-    return call(thiz, "property2");
-  }
-
-  return ExampleUsingCall;
-})();
-
-describe("Privates", () => {
-  it("should hide member variables using Privates#get", () => {
-    const example = new ExampleUsingGet({
-      property1: "a",
-      property2: 2,
-    });
-    expect(example.property1).to.be.undefined;
-    expect(example.property2).to.be.undefined;
-    expect(example.getProperty1()).to.eql("a");
-    expect(example.getProperty2()).to.eql(2);
-  });
-  it("should hide member variables using Privates#call", () => {
-    const example = new ExampleUsingCall({
-      property1: () => "a",
-      property2: () => 2,
-    });
-    expect(example.property1).to.be.undefined;
-    expect(example.property2).to.be.undefined;
-    expect(example.getProperty1()).to.eql("a");
-    expect(example.getProperty2()).to.eql(2);
-  });
-});
-
-describe("Privates#call", () => {
-  const privates = new Privates();
-  it("should correctly call privates that are functions", () => {
-    const thiz = {};
-
-    // Test a lambda function.
-    privates.set(thiz, "lambda", () => "lambdaObj");
-    expect(privates.call(thiz, "lambda")).to.eql("lambdaObj");
-
-    // Test a declared function.
-    function func() {
-      return "funcObj";
-    }
-    privates.set(thiz, "function", func);
-    expect(privates.call(thiz, "function")).to.eql("funcObj");
-
-    // Test a class function.
-    class CallClass {
-      delegate() {
-        return "classObj";
-      }
-
-      call() {
-        return this.delegate();
-      }
-    }
-    const c = new CallClass();
-    privates.set(thiz, "classBound", c.call.bind(c));
-
-    // Test an object as a property.
-    const key = { a: "a" };
-    privates.set(thiz, key, () => "objectAsProperty");
-    expect(privates.call(thiz, key)).to.eql("objectAsProperty");
-
-    // Test a symbol as a property.
-    const symbol = Symbol("symbol");
-    privates.set(thiz, symbol, () => "symbolAsProperty");
-    expect(privates.call(thiz, symbol)).to.eql("symbolAsProperty");
-
-    // Test a number as a property.
-    privates.set(thiz, -5, () => "numberAsProperty");
-    expect(privates.call(thiz, -5)).to.eql("numberAsProperty");
-
-    // Test a boolean as a property.
-    privates.set(thiz, false, () => "booleanAsProperty");
-    expect(privates.call(thiz, false)).to.eql("booleanAsProperty");
-
-    // Test undefined as a property.
-    privates.set(thiz, undefined, () => "undefinedAsProperty");
-    expect(privates.call(thiz, undefined)).to.eql("undefinedAsProperty");
-
-    // Test null as a property.
-    privates.set(thiz, null, () => "nullAsProperty");
-    expect(privates.call(thiz, null)).to.eql("nullAsProperty");
-  });
-  it("should fail with invalid arguments", () => {
-    const thiz = {};
-
-    expect(() => privates.call()).to.throw(RethrownError);
-    // eslint-disable-next-line no-useless-call
-    expect(() => privates.call(null, "nonexistent")).to.throw(RethrownError);
-    expect(() => privates.call(thiz)).to.throw(RethrownError);
-    expect(() => privates.call(thiz, "nonexistent")).to.throw(RethrownError);
-
-    // Test an unbound function failing.
-    class CallClass {
-      delegate() {
-        return "classObj";
-      }
-
-      call() {
-        return this.delegate();
-      }
-    }
-    const c = new CallClass();
-    privates.set(thiz, "classBound", c.call);
-    expect(() => privates.call(thiz, "classBound")).to.throw(RethrownError);
-
-    // Test a private that is not a function.
-    privates.set(thiz, "notafunction", "string");
-    expect(() => privates.call(thiz, "notafunction")).to.throw(RethrownError);
-  });
-});
-
-describe("Privates#lambdaize", () => {
-  const privates = new Privates();
-  it("should convert an object's properties to lambda properties", () => {
-    const obj = privates.lambdaize({
-      a: 0,
-      b: 1,
-    });
-    expect(obj.a()).to.eql(0);
-    expect(obj.b()).to.eql(1);
-
-    expect(privates.lambdaize(true)).to.eql({});
-    expect(privates.lambdaize(1)).to.eql({});
-    expect(Object.keys(privates.lambdaize("string"))).to.eql([
-      "0",
-      "1",
-      "2",
-      "3",
-      "4",
-      "5",
-    ]);
-    expect(privates.lambdaize(Symbol("string"))).to.eql({});
-    expect(privates.lambdaize({})).to.eql({});
-  });
-  it("should fail with invalid arguments", () => {
-    expect(() => privates.lambdaize()).to.throw(RethrownError);
-    expect(() => privates.lambdaize(null)).to.throw(RethrownError);
-    expect(() => privates.lambdaize(undefined)).to.throw(RethrownError);
-  });
-});