@lumjs/core 1.38.0 → 1.38.2

package/lib/obj/assignd.js

@@ -1,12 +1,14 @@
 "use strict";
 
-const def = require('../types/def');
+const {dfa} = require('./df');
+const {isObj,isNil} = require('../types');
 
 /**
  * Copy properties into a target object.
  * 
- * Like Object.assign(), but it uses getOwnPropertyDescriptors()
- * to get the properties to copy and type.def() to assign them.
+ * Like Object.assign(), but it uses getOwnPropertyDescriptors() to get
+ * the properties to copy, and [dfa()]{@link module:@lumjs/core/obj.dfa} 
+ * to assign them.
  * 
  * Basically a super simple, non-recursive replacement for my copyProps()
  * and cp() functions that were overly complex and tried to do way too much.
@@ -21,8 +23,15 @@ function assignd (target, ...sources)
 {
   for (const src of sources)
   {
-    const descs = Object.getOwnPropertyDescriptors(src);
-    def(target, descs);
+    if (isObj(src))
+    {
+      const descs = Object.getOwnPropertyDescriptors(src);
+      dfa(target, descs);
+    }
+    else if (!isNil(src))
+    {
+      console.error("Invalid assignd source", {src, sources, target});
+    }
   }
   return target;
 }

package/lib/obj/df.js

@@ -3,7 +3,6 @@
 const {doesDescriptor,needObj,needType,lazy,B,TYPES} = require('../types');
 
 const DEF_DESC = {configurable: true}
-const DEF_OPTS = {autoDesc: true}
 
 const cp = Object.assign;
 const clone = (...args) => cp({}, ...args);
@@ -66,29 +65,38 @@ function descriptor(desc, opts)
  * @param {(string|symbol)} name  - Property identifier
  * @param {*} value - Value to assign
  * 
- * If `opts.autoDesc` is `true` and this is an `object` that passes the
- * {@link module:@lumjs/core/types.doesDescriptor} test, it will be
- * used as the template descriptor to assign the property.
- * 
- * In any other case, this will be used as the `value` property of
- * a generated descriptor to be assigned.
+ * See `opts.useDesc` for how this value is handled in regards to
+ * whether it is treated as a property descriptor or a plain data value.
  * 
  * @param {object} [opts] Options
  * 
+ * See {@link module:@lumjs/core/obj~descriptor} for options that
+ * are used as descriptor defaults when assigning the property.
+ * 
+ * @param {?boolean} [opts.useDesc=null] Treat `value` is a descriptor?
+ * 
+ * If this is set to `true` then the `value` will be assumed to be a
+ * valid descriptor object; no tests will be done to confirm, so be sure!
+ * 
+ * If this is set to `false` then a descriptor of `{value}` will be created.
+ * Again, no tests will be done, so this is a way to assign properties that
+ * have `value`, `get`, or `set` properties in them.
+ * 
+ * If this is `null` (the default), then the `value` will be tested with
+ * [doesDescriptor()]{@link module:@lumjs/core/types.doesDescriptor}, 
+ * and that will determine if the value is treated as a descriptor or not.
+ * 
  * @returns {object} `obj`
  * @alias module:@lumjs/core/obj.df
  */
-function df(obj, name, value, opts)
+function df(obj, name, value, opts={})
 {
   const log = {obj,name,value,opts};
   needObj(obj, {log, fun: true});
   needType(TYPES.PROP, name, {log});
 
-  opts = clone(DEF_OPTS, opts);
-
-  const desc = descriptor(((opts.autoDesc && doesDescriptor(value)) 
-    ? value 
-    : {value}), opts);
+  const useDesc = opts.useDesc ?? doesDescriptor(value);
+  const desc = descriptor((useDesc ? value : {value}), opts);
   
   return Object.defineProperty(obj, name, desc);
 }
@@ -121,11 +129,35 @@ function dfa(obj, values, opts)
   return obj;
 }
 
+df(df, 'all', dfa);
+
+/**
+ * A wrapper around df() that defines an *accessor property* with 
+ * BOTH a getter and a setter specified explicitly.
+ * 
+ * @param {(object|function)} obj - Target to define property in
+ * @param {(string|symbol)} name - Property identifier
+ * @param {function} getter - Getter function
+ * @param {function} setter - Setter function
+ * @param {object} [opts] Options
+ * 
+ * The actual options passed to df() will be a clone, with the
+ * `useDesc` option explicitly forced to `true`.
+ * 
+ */
+function dfb(obj, name, getter, setter, opts)
+{
+  const log = {obj,name,getter,setter,opts};
+  opts = clone(opts, {useDesc: true});
+  return df(obj, name, {get: getter, set: setter}, opts);
+}
+
+df(df, 'both', dfb);
+
 /**
  * Build magic closures to define properties using a chained syntax.
  * 
- * This actually creates three closures, one around df(), another
- * that wraps dfa(), and one that wraps the lazy() function.
+ * This actually creates closures for df(), dfa(), dfb(), and lazy().
  * You can switch between them using magic properties.
  * 
  * The closures when called will pass their arguments to the function
@@ -136,13 +168,15 @@ function dfa(obj, values, opts)
  * 
  * - `one(name, value)` → A closure that wraps df()
  * - `all(values)`      → A closure that wraps dfa()
+ * - `both(name, g, s)` → A closure that wraps dfb()
+ * - `lazy(name, func)` → A closure that wraps lazy()
  * - `update(opts)`     → Update the options used by the closures.
  *   Uses Object.assign() to copy options from the specied object
  *   to the internal options object from the original dfc() call.
  *   This is a method call, NOT a closure function.
  * - `opts`             → The actual options object used by the closures.
  * - `obj`              → The target object used by the closures.
- * - `next(obj)`        → A wrapper method that will call dfc().
+ * - `for(obj)`         → A wrapper method that will call dfc().
  *   When using this method, a *new set of closures* will be created,
  *   with the current options, but a new target object.
  *   If you use this in a chained statement, any calls after this
@@ -170,6 +204,12 @@ function dfc(obj, opts={})
     return fnAll;
   }
 
+  const fnBoth = function (name, getter, setter)
+  {
+    dfb(obj, name, getter, setter, opts);
+    return fnBoth;
+  }
+
   const fnLazy = function (name, initfunc)
   {
     lazy(obj, name, initfunc, opts);
@@ -182,6 +222,8 @@ function dfc(obj, opts={})
     opts: {value: opts},
     one:  {value: fnOne},
     all:  {value: fnAll},
+    both: {value: fnBoth},
+    lazy: {value: fnLazy},
     update: 
     {
       value()
@@ -190,7 +232,7 @@ function dfc(obj, opts={})
         return this;
       },
     },
-    next:
+    for:
     {
       value(newobj)
       {
@@ -199,15 +241,20 @@ function dfc(obj, opts={})
     },
   }
 
-  dps(fnOne, ctx);
-  dps(fnAll, ctx);
+  // Quick alias
+  ctx.next = ctx.for;
+
+  dps(fnOne,  ctx);
+  dps(fnAll,  ctx);
+  dps(fnBoth, ctx);
+  dps(fnLazy, ctx);
 
   return fnOne;
 }
 
-
+df(df, 'for', dfc);
 
 module.exports = 
 {
-  df, dfa, dfc, lazy,
+  df, dfa, dfb, dfc, lazy,
 }

package/lib/obj/index.js

@@ -8,7 +8,7 @@ const assignd = require('./assignd');
 const {copyAll,duplicateOne,duplicateAll} = require('./copyall');
 const copyProps = require('./copyprops');
 const {CLONE,clone,addClone,cloneIfLocked} = require('./clone');
-const {df,dfa,dfc,lazy} = require('./df');
+const {df,dfa,dfb,dfc,lazy} = require('./df');
 const {flip, flipKeyVal, flipMap} = require('./flip');
 const {getMethods,signatureOf,MethodFilter} = require('./getmethods');
 const getProperty = require('./getproperty');
@@ -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, dfc, lazy,
-  mergeNested, syncNested, copyProps, copyAll, ns,
-  getObjectPath, setObjectPath, getNamespace, setNamespace,
+  df, dfa, dfb, dfc, lazy,
+  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/def.js

@@ -7,13 +7,13 @@ const clone = (...args) => Object.assign({}, ...args);
 /**
  * A wrapper around `Object.defineProperty()` with added flair!
  * 
- * FUTURE DEPRECATION: When I release @lumjs/core 2.0, this function
- * will be deprecated! It's gotten almost as convoluted as the old
- * prop() method it replaced from my original Nano.js libraries.
+ * **FUTURE DEPRECATION**: this function will be deprecated in v1.19.0!
+ * It's gotten almost as convoluted as the old prop() method it replaced 
+ * from my original Nano.js libraries.
+ * 
  * I have written new `obj.{df,dfa,dfc}` functions that will replace this
  * function going forward. The related `types.lazy()` function will also
- * be refactored to use the new functions, and moved to the `obj` module,
- * although for the `2.x` lifetime an alias will remain in the `type` module.
+ * be refactored to use the new functions, and moved to the `obj` module.
  * 
  * @param {(object|function)} obj - The object to add a property to.
  * 

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/lib/types/lazy.js

@@ -101,11 +101,11 @@ const {doesDescriptor} = require('./basics');
  * This is an extension of the [def()]{@link module:@lumjs/core/types.def} 
  * method, and indeed an alias called `def.lazy()` is also available.
  * 
- * IMPORTANT: In version 2.x, this will be refactored to use the new
+ * IMPORTANT: In a later v1.18.x release, this will be refactored to use the
  * [obj.df()]{@link module:@lumjs/core/obj.df} function that will replace
  * def(). There's already an alias called `df.lazy()` available now.
- * This will also be moved to the `obj` module, with an alias left
- * in the `types` module for the duration of the 2.x lifecycle.
+ * This will also be moved to the `obj` module, with a deprecated alias left
+ * in the `types` module for the duration of the 1.x lifecycle.
  *
  * @param {(object|function)} target - The object to add the property to.
  * 

package/package.json

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