@lumjs/core 1.38.1 → 1.38.2

package/lib/obj/index.js

@@ -20,16 +20,16 @@ const unlocked = require('./unlocked');
 
 const 
 {
-  getObjectPath,setObjectPath,
-  getNamespace,setNamespace,
+  getObjectPath,setObjectPath,delObjectPath,
+  getNamespace,setNamespace,nsFactory,
 } = ns;
 
 module.exports =
 {
   assignd, cp, CLONE, clone, addClone, cloneIfLocked, lock, addLock,
   df, dfa, dfb, dfc, lazy,
-  mergeNested, syncNested, copyProps, copyAll, ns,
-  getObjectPath, setObjectPath, getNamespace, setNamespace,
+  mergeNested, syncNested, copyProps, copyAll, ns, nsFactory,
+  getObjectPath, setObjectPath, delObjectPath, getNamespace, setNamespace,
   getProperty, duplicateAll, duplicateOne, getMethods, signatureOf,
   MethodFilter, apply, flip, flipKeyVal, flipMap, unlocked,
 }

package/lib/obj/ns.js

@@ -2,10 +2,13 @@
 const 
 {
   B, S,
-  root, isObj, needObj, def, nonEmptyArray, isNil, notNil,
+  root, isObj, needObj, def, nonEmptyArray, isNil,
   doesDescriptorTemplate,
 } = require('../types');
 
+const {df} = require('./df');
+const cp = Object.assign;
+
 /**
  * Need a String or Array
  * @alias module:@lumjs/core/obj.SOA
@@ -79,9 +82,13 @@ exports.nsArray = nsArray;
  *
  * @param {(object|function)} obj - Object we're looking in.
  * @param {(string|Array)} proppath - Property path we're looking for.
- *   Generally a string of dot (`.`) separated nested property names.
+ * 
+ * Generally a string of dot (`.`) separated nested property names.
+ * 
  * @param {(object|boolean)} [opts] Options changing the behaviours.
- *   If this is a `boolean` it's assumed to be the `opts.log` option.
+ * 
+ * If this is a `boolean` it's assumed to be the `opts.log` option.
+ * 
  * @param {boolean} [opts.log=false] Log errors for missing namespaces?
  * @param {boolean} [opts.allowFun=true] Allow `obj` to be a `function` ?
  * 
@@ -129,15 +136,33 @@ exports.getObjectPath = getObjectPath;
  * 
  * @param {(object|function)} obj - Object the property path is for.
  * @param {(string|Array)} proppath - Property path to create.
- * @param {object} [opts] Options changing the behaviours.
+ * @param {(object|boolean)} [opts] Options changing the behaviours.
+ * 
+ * If this is a `boolean` it's assumed to be the `opts.overwrite` option.
+ * 
  * @param {*} [opts.value] A value to assign to the last property path.
  * @param {boolean} [opts.overwrite=false] Allow overwriting property paths.
- *   Only applicable if `opts.value` was also specified.
+ * 
+ * Only applicable if `opts.value` was also specified.
+ * 
  * @param {object} [opts.desc] Descriptor rules for defining the properties.
- *   Must NOT contain `value`, `get`, or `set` properties.
- *   Only, `configurable`, `enumerable`, and `writable` are supported.
- *   Will be ignored if `opts.assign` is `true`.
+ * 
+ * Must NOT contain `value`, `get`, or `set` properties.
+ * Only, `configurable`, `enumerable`, and `writable` are supported.
+ * Will be ignored if `opts.assign` is `true`.
+ * 
+ * NOTE: This option will likely be removed in version 2.x, as you can
+ * use `opts.df` to set descriptor rules instead.
+ * 
  * @param {boolean} [opts.assign=false] Use direct assignment instead of `def()`.
+ * @param {(boolean|object)} [opts.df] Use `df()` instead of `def()`?
+ * 
+ * If this is an object, it will be used as options for the df() function.
+ * 
+ * NOTE: In version 2.x, the boolean use of this option will be removed, 
+ * as df() will replace def() entirely in that release.
+ * 
+ * @param {boolean} [opts.allowFun=true] See getObjectPath() for details.
  * @param {boolean} [opts.returnThis=false] Return `this` variable.
  * @param {boolean} [opts.returnObj=false] Return the `obj` parameter.
  * @return {*} Generally the last object in the nested property paths.
@@ -146,28 +171,35 @@ exports.getObjectPath = getObjectPath;
  */
 function setObjectPath(obj, proppath, opts={})
 {
-  needObj(obj, true, 'obj parameter must be an object or function');
-  needObj(opts, 'opts parameter must be an object');
+  if (typeof opts === B)
+    opts = {overwrite: opts};
+  else if (!isObj(opts))
+    opts = {};
+
+  needObj(obj, (opts.allowFun ?? true));
+
+  const setprop = opts.df ? df : def;
+  const propopts = cp({}, opts.def, opts.df);
 
   proppath = nsArray(proppath);
 
   let assign;
   if (opts.assign)
   { // Use direct property assignment.
-    assign = (o,p,v={}) => o[p] = v;
+    assign = (t,p,v) => t[p] = v;
   }
   else if (doesDescriptorTemplate(opts.desc))
   { // An explicit descriptor.
-    assign = (o,p,v={}) => 
+    assign = (t,p,v) => 
     {
-      const desc = Object.assign({}, opts.desc);
+      const desc = cp({}, opts.desc);
       desc.value = v;
-      def(o,p,desc);
+      setprop(t,p,desc,propopts);
     }
   }
   else
   { // Use def with default descriptor.
-    assign = (o,p,v={}) => def(o,p,v);
+    assign = (t,p,v) => setprop(t,p,v,propopts);
   }
 
   let cns = obj;
@@ -183,17 +215,17 @@ function setObjectPath(obj, proppath, opts={})
 
     if (cns[ns] === undefined)
     { // Nothing currently here. Let's fix that.
-      if (n == lastns && notNil(opts.value))
-      { // We're at the end and have a value to assign.
+      if (n == lastns && opts.value !== undefined)
+      { // It's the end of the world as we know it.
         assign(cns, ns, opts.value);
       }
       else 
       { // Create a new empty object.
-        assign(cns, ns);
+        assign(cns, ns, {});
       }
     }
-    else if (opts.overwrite && n == lastns && notNil(opts.value))
-    { // We have a value, and overwrite mode is on.
+    else if (opts.overwrite && n == lastns && opts.value !== undefined)
+    { // We have a defined value, and overwrite mode is on.
       assign(cns, ns, opts.value);
     }
 
@@ -251,11 +283,54 @@ function delObjectPath(obj, proppath, opts={})
 
 exports.delObjectPath = delObjectPath;
 
+/**
+ * Build a simple factory object for working with property paths.
+ * 
+ * @param {(object|function)} value - The target object
+ * @param {object} [opts] Default options for the *ObjectPath() functions
+ * @returns {object} A frozen factory object
+ * 
+ * Has `get(path,opts)`, `set(path,opts)`, and `del(path,opts)` methods, 
+ * which are wrappers for getObjectPath(), setObjectPath(), 
+ * and delObjectPath() respectively.
+ * 
+ * Also has `value` and `opts` properties for the arguments.
+ */
+function nsFactory(value, opts={})
+{
+  const getOpts = (po) => cp({}, opts, po);
+
+  const factory = 
+  {
+    value,
+    opts,
+    get(pp,po) 
+    { 
+      return getObjectPath(value, pp, getOpts(po));
+    },
+    set(pp,po)
+    { 
+      setObjectPath(value, pp, getOpts(po));
+      return this;
+    },
+    del(pp,po)
+    { 
+      delObjectPath(value, pp, getOpts(po));
+      return this;
+    },
+  }
+
+  return Object.freeze(factory);
+}
+
+exports.nsFactory = nsFactory;
+
 /**
  * Get a global namespace path if it exists.
  *
  * This literally just calls `getObjectPath()` on the `root` object.
  * 
+ * @deprecated
  * @param {(string|Array)} proppath - Property path we're looking for.
  *   Generally a string of dot (`.`) separated nested property names.
  * @param {object} [opts] See `getObjectPath()` for details.
@@ -275,6 +350,7 @@ exports.getNamespace = getNamespace;
  * 
  * This literally just calls `setObjectPath()` on the `root` object.
  * 
+ * @deprecated
  * @param {(string|Array)} proppath - Property path to create.
  * @param {object} [opts] See `setObjectPath()` for details.
  * @return {*} See `setObjectPath()` for details.

package/lib/objectid.js

@@ -116,7 +116,7 @@ class UniqueObjectIds
       id += this.$options.prefix; 
     }
 
-    let className = obj.constructor.name;
+    let className = (typeof obj === F ? obj : obj.constructor).name;
 
     if (typeof cno.setup === F)
     { // Perform a transformation before any other changes.

package/lib/types/isa.js

@@ -398,7 +398,7 @@ class OfTest
    * 
    * This will be used to set the value of the `this.valid` property.
    * 
-   * @param {object} rules - Object to set as the `this.rules` property.
+   * @param {object} rulesets - Object to set as the `this.rules` property.
    * 
    * If `valid(rules)` returns `true` then the `rules` will be 
    * changed to `{value: rules}`. This is a short-cut so that
@@ -409,7 +409,7 @@ class OfTest
    * 
    * See the class property description for the supported optional values.
    * 
-   * @param {object} rules.value - The container being tested.
+   * @param {object} rulesets.value - The container being tested.
    * 
    * @param {?Array} valueTypes - An array of type tests for the values.
    * 
@@ -839,7 +839,7 @@ const isntRules = v => (isObj(v) && !(v instanceof OfTestRules));
  * test function that will return an instance of the `OfTest.Rules` class,
  * passing all parameters along to the constructor.
  * 
- * @param {object} rules - Rules for this test function.
+ * @param {object} rulesets - Rules for this test function.
  * 
  * If this argument is anything other than a `OfTest.Rules` instance,
  * it is assumed to be the `rules.value` named option.
@@ -852,7 +852,7 @@ const isntRules = v => (isObj(v) && !(v instanceof OfTestRules));
  * const isValid = isObjOf(isObjOf.rules(value, opts), type1, type2, ...);
  * ```
  * 
- * @param {Iterable} rules.value - The actual list object for the tests.
+ * @param {Iterable} rulesets.value - The actual list object for the tests.
  * 
  * @param  {...any} types - See {@link module:@lumjs/core/types.isa}.
  * 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/core",
-  "version": "1.38.1",
+  "version": "1.38.2",
   "main": "lib/index.js",
   "exports": 
   {