@util.js/privates 0.41.6 → 0.41.8

package/dist/Privates.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+var _weakMap = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/weak-map"));
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+var _entries = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/entries"));
+var _bind = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/bind"));
+var _getPrototypeOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-prototype-of"));
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+var _sort = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/sort"));
+var _getOwnPropertyNames = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-names"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));
+var 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 = /*#__PURE__*/function () {
+  function Privates() {
+    (0, _classCallCheck2["default"])(this, Privates);
+    this.privates = new _weakMap["default"]();
+  }
+
+  /**
+   * Calls `this.get(thiz, property)()`.
+   *
+   * @public
+   * @function Privates#call
+   */
+  return (0, _createClass2["default"])(Privates, [{
+    key: "call",
+    value: function 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) {
+        var _context, _context2;
+        var propertyStr = getPropertyErrorString(property);
+        throw new RethrownError(e, (0, _concat["default"])(_context = (0, _concat["default"])(_context2 = "privates.call(".concat(thiz, ", ")).call(_context2, propertyStr, ") failed. ")).call(_context, e.message));
+      }
+    }
+  }, {
+    key: "get",
+    value: function get(thiz, property) {
+      try {
+        return this.getProps(thiz)[property];
+      } catch (e) {
+        var _context3, _context4;
+        var propertyStr = getPropertyErrorString(property);
+        throw new RethrownError(e, (0, _concat["default"])(_context3 = (0, _concat["default"])(_context4 = "privates.get(".concat(thiz, ", ")).call(_context4, propertyStr, ") failed. ")).call(_context3, e.message));
+      }
+    }
+  }, {
+    key: "getCallProxy",
+    value: function getCallProxy(thiz) {
+      return new Proxy(this.getProps(thiz), {
+        get: callProp
+      });
+    }
+  }, {
+    key: "getProps",
+    value: function getProps(thiz) {
+      try {
+        var 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;
+      }
+    }
+  }, {
+    key: "lambdaize",
+    value: function lambdaize(properties) {
+      try {
+        var _context5;
+        var lambdaProperties = {};
+        (0, _forEach["default"])(_context5 = (0, _entries["default"])(properties)).call(_context5, function (_ref) {
+          var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+            property = _ref2[0],
+            value = _ref2[1];
+          return lambdaProperties[property] = function () {
+            return value;
+          };
+        });
+        return lambdaProperties;
+      } catch (e) {
+        if (properties == null) throw new RethrownError(e, "properties cannot be null or undefined.");
+      }
+    }
+  }, {
+    key: "lazyLoad",
+    value: function lazyLoad(thiz, property, lazyLoadFunction) {
+      if (typeof lazyLoadFunction !== "function") throw new TypeError("lazyLoadFunction (".concat(lazyLoadFunction, ") must be a function."));
+      var value;
+      var loaded = false;
+      this.set(thiz, property, function () {
+        if (!loaded) {
+          value = lazyLoadFunction();
+          loaded = true;
+        }
+        return value;
+      });
+    }
+  }, {
+    key: "lazyLoadProps",
+    value: function lazyLoadProps(thiz) {
+      var t = this;
+      for (var _len = arguments.length, lazilyLoadedProperties = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        lazilyLoadedProperties[_key - 1] = arguments[_key];
+      }
+      (0, _forEach["default"])(lazilyLoadedProperties).call(lazilyLoadedProperties, function (currentProperties) {
+        var _context6;
+        (0, _forEach["default"])(_context6 = (0, _entries["default"])(currentProperties)).call(_context6, function (_ref3) {
+          var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+            property = _ref4[0],
+            lazyLoadFunction = _ref4[1];
+          return t.lazyLoad(thiz, property, lazyLoadFunction);
+        });
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(thiz, property, newValue) {
+      try {
+        this.getProps(thiz)[property] = newValue;
+      } catch (e) {
+        var _context7, _context8, _context9;
+        var propertyStr = getPropertyErrorString(property);
+        throw new RethrownError(e, (0, _concat["default"])(_context7 = (0, _concat["default"])(_context8 = (0, _concat["default"])(_context9 = "privates.set(".concat(thiz, ", ")).call(_context9, propertyStr, ", ")).call(_context8, newValue, ") failed. ")).call(_context7, e.message));
+      }
+    }
+  }, {
+    key: "setProps",
+    value: function setProps(thiz) {
+      var t = this;
+      for (var _len2 = arguments.length, properties = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        properties[_key2 - 1] = arguments[_key2];
+      }
+      (0, _forEach["default"])(properties).call(properties, function (currentProperties) {
+        var _context0, _context1;
+        (0, _forEach["default"])(_context0 = (0, _entries["default"])(currentProperties)).call(_context0, function (_ref5) {
+          var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
+            property = _ref6[0],
+            value = _ref6[1];
+          return t.set(thiz, property, value);
+        });
+        (0, _forEach["default"])(_context1 = getAllMethods(currentProperties)).call(_context1, function (method) {
+          var _context10;
+          return t.set(thiz, method, (0, _bind["default"])(_context10 = currentProperties[method]).call(_context10, currentProperties));
+        });
+      });
+    }
+  }, {
+    key: "subset",
+    value: function subset(thiz) {
+      var object = {};
+      for (var _len3 = arguments.length, properties = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        properties[_key3 - 1] = arguments[_key3];
+      }
+      for (var 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 "\"".concat(property, "\"");
+  return "".concat(property);
+}
+function callProp(obj, property) {
+  try {
+    return obj[property]();
+  } catch (e) {
+    throw new RethrownError(e, "Calling \"".concat(property, "\" as a function failed."));
+  }
+}
+
+// https://stackoverflow.com/questions/31054910/get-functions-methods-of-a-class
+function getAllMethods(obj) {
+  if (!(0, _getPrototypeOf["default"])(obj)) return [];
+  var props = [];
+  do {
+    var _context11, _context12, _context13, _context14;
+    var l = (0, _filter["default"])(_context11 = (0, _sort["default"])(_context12 = (0, _concat["default"])(_context13 = (0, _getOwnPropertyNames["default"])(obj)).call(_context13, (0, _map["default"])(_context14 = (0, _getOwnPropertySymbols["default"])(obj)).call(_context14, function (s) {
+      return s.toString();
+    }))).call(_context12)).call(_context11, function (p, i, arr) {
+      return typeof obj[p] === "function" &&
+      // only the methods
+      p !== "constructor" && (
+      // not the constructor
+      i === 0 || p !== arr[i - 1]) &&
+      // not overriding in this prototype
+      (0, _indexOf["default"])(props).call(props, p) === -1;
+    } // not overridden in a child
+    );
+    props = (0, _concat["default"])(props).call(props, l);
+  } while ((obj = (0, _getPrototypeOf["default"])(obj)) &&
+  // walk-up the prototype chain
+  (0, _getPrototypeOf["default"])(obj) // not the the Object prototype methods (hasOwnProperty, etc...)
+  );
+  return props;
+}

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.6"
+    "@util.js/errors": "0.41.8"
   },
   "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.6"
+  "version": "0.41.8"
 }

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);
-  });
-});