@lumjs/core 1.38.1 → 1.38.3

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

@@ -1,5 +1,5 @@
 
-const {notNil,def,isNil,F,N,S,SY} = require('./types');
+const {notNil,def,isNil,isObj,F,N,S,SY} = require('./types');
 const argOpts = require('./opt/args');
 
 /**
@@ -7,12 +7,14 @@ const argOpts = require('./opt/args');
  * 
  * @param {(object|number)} [opts] Options
  * 
- * @param {number} [opts.seed] A base number to use.
+ * If this is a number, then it's the `opts.seed` value.
+ * 
+ * @param {number} [opts.seed=0] A base number to use.
  *
  * If this is omitted, or an invalid value (including `0`), 
- * the default is to use `Date.now()` as the `seed`.
+ * the default is to use `Date.now()` as `opts.seed`.
  * 
- * @param {number} [mode=1] Determine how to handle return value
+ * @param {number} [opts.mode=1] Determine how to handle return value
  * 
  * | Mode    | Description                                               |
  * | ------- | --------------------------------------------------------- |
@@ -21,12 +23,16 @@ const argOpts = require('./opt/args');
  * | `2`     | `Math.floor()`                                            |
  * | `3`     | `Math.ceil()`                                             |
  * 
+ * @param {number} [mode=1] Positional version of `opts.mode`.
+ * 
  * @returns {number}
  * @alias module:@lumjs/core.randomNumber
  */
 function randomNumber(seed=0, mode=1)
 {
-  if (typeof seed !== N || seed === 0) seed = Date.now();
+  const opts = argOpts({seed, mode}, 'seed', 0);
+  if (typeof opts.seed !== N || opts.seed === 0) 
+    opts.seed = Date.now();
 
   const rand = Math.random() * seed;
 
@@ -56,18 +62,42 @@ class UniqueObjectIds
   {
     def(this, '$options', {value: opts});
 
-    if (validBase(opts.random))
+    let radix = null;
+
+    if (isObj(opts.random))
+    { // Random ids with custom options.
+      def(this, '$randOpts', {value: opts.random});
+      if (validBase(opts.random.radix))
+      {
+        radix = opts.random.radix;
+      }
+    }
+    else if (validBase(opts.random))
     { // Use random ids.
-      def(this, '$randIds', {value: {}});
+      def(this, '$randOpts', {value: {}});
+      radix = opts.random;
     }
     else if (validBase(opts.timestamp))
     { // Use timestamp-based ids.
       def(this, '$timeIds', {value: {}});
+      radix = opts.timestamp;
     }
     else
     { // Use incremental ids.
       def(this, '$incIds',  {value: {}});
     }
+
+    if (!radix)
+    {
+      radix = validBase(opts.radix) ? opts.radix : 16;
+    }
+
+    def(this, '$radix', radix);
+
+    if (this.$randOpts)
+    {
+      def(this, '$randIds',  {value: {}});
+    }
     
     const propType = (typeof opts.idProperty);
     const hasProp  = (propType === S || propType === SY);
@@ -104,6 +134,8 @@ class UniqueObjectIds
       return obj[idProp];
     }
 
+    let radix = this.$radix;
+
     let cno = this.$options.className ?? {};
     if (typeof cno === F)  cno = {setup: cno};
     else if (cno === 'lc') cno = {lowercase: true};
@@ -116,7 +148,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.
@@ -139,7 +171,7 @@ class UniqueObjectIds
       const ids = this.$incIds;
       if (ids[className])
       { // An existing value was found.
-        idNum = (++ids[className]).toString();
+        idNum = (++ids[className]).toString(radix);
       }
       else
       { // No existing values yet.
@@ -153,16 +185,14 @@ class UniqueObjectIds
     }
     else
     { // Something other than auto-increment.
-      let ids, radix;
+      let ids;
       if (this.$randIds)
       { // Using a random id.
         ids = this.$randIds;
-        radix = this.$options.random;
       }
       else if (this.$timeIds)
       { // Using timestamp ids.
         ids = this.$timeIds;
-        radix = this.$options.timestamp;
       }
       else
       { // Something went horribly wrong.
@@ -170,7 +200,7 @@ class UniqueObjectIds
       }
 
       const getId = () => (this.$randIds 
-        ? randomNumber() 
+        ? randomNumber(this.$randOpts) 
         : Date.now())
         .toString(radix);
 

package/lib/observable.js

@@ -1,6 +1,7 @@
 /**
  * Observable API module
  * @module @lumjs/core/observable
+ * @deprecated move to @lumjs/events and/or @lumjs/events-observable
  */
 "use strict";
 

package/lib/types/basics.js

@@ -17,6 +17,13 @@
 const JS = require('./js');
 const {O, F, S, SY} = JS;
 
+/**
+ * The _abstract prototype_ of all typed arrays.
+ * This is part of every modern JS runtime, but is not directly accessible.
+ * @alias module:@lumjs/core/types/basics.TypedArray
+ */
+const TypedArray = Object.getPrototypeOf(Int8Array);
+
 /**
  * See if a value is a non-null `object`.
  * @param {*} v - The value we're testing.
@@ -78,7 +85,7 @@ const isArray = Array.isArray;
  */
 function isTypedArray(v)
 {
-  return (ArrayBuffer.isView(v) && !(v instanceof DataView));
+  return (v instanceof TypedArray);
 }
 
 /**
@@ -147,6 +154,10 @@ function isIterable(v)
  * For the purposes of this test, a class constructor is
  * any Function that has a `prototype` Object property.
  * 
+ * NOTE: almost every function has a prototype property,
+ * only Closures and some built-in methods don't.
+ * So this is not a foolproof method by any stretch.
+ * 
  * @param {*} v - Value to test
  * @returns {boolean}
  * @alias module:@lumjs/core/types/basics.isConstructor
@@ -185,6 +196,20 @@ function isClassObject(v)
   return (isObj(v) && typeof v.constructor === F && v.constructor !== Object);
 }
 
+/**
+ * Is a value an object with a null prototype?
+ * 
+ * An object with a null prototype won't have any of the usual
+ * meta-programming methods or properties from `Object.prototype`.
+ * 
+ * @param {*} v - Value to test
+ * @returns {boolean}
+ */
+function isDiscreteObject(v)
+{
+  return (isObj(v) && Object.getPrototypeOf(v) === null);
+}
+
 /**
  * See if an object can be used as a valid *descriptor*.
  * 
@@ -278,8 +303,9 @@ module.exports =
 {
   isObj, isComplex, isNil, notNil, isScalar, isArray, isTypedArray,
   isIterable, nonEmptyArray, isArguments, isProperty, isConstructor,
-  isPlainObject, isClassObject, doesDescriptor, doesDescriptorTemplate,
-  JS,
+  isPlainObject, isClassObject, isDiscreteObject,
+  doesDescriptor, doesDescriptorTemplate,
+  JS, TypedArray,
 }
 
 JS.addTo(module.exports);

package/lib/types/def.js

@@ -11,7 +11,7 @@ const clone = (...args) => Object.assign({}, ...args);
  * 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
+ * I have written new `obj.{df,dfa,dfor}` 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.
  * 
@@ -248,3 +248,6 @@ module.exports = def;
 const DT = require('./dt');
 DT.addInit(def);
 def.DT = DT;
+
+// And a reference to the old lazy
+def(def, 'lazy', {get: () => require('./lazy')});

package/lib/types/index.js

@@ -9,7 +9,7 @@
  * @module @lumjs/core/types
  */
 
-const def = require('./def'), lazy = require('./lazy');
+const def = require('./def');
 
 // Compose in sub-modules.
 Object.assign(exports,
@@ -19,7 +19,7 @@ Object.assign(exports,
   require('./stringify'),
   require('./needs'),
   { // A few standalone exports.
-    def, lazy,
+    def,
     TYPES: require('./typelist'),
     ownCount: require('./owncount'),
   },
@@ -42,3 +42,11 @@ def(exports.TYPES, '$module', module);
 
 // Extend `unbound` with add() and remove() methods.
 require('./unbound/extend')(exports.unbound);
+
+// Deprecated alias for `lazy` function.
+wrapDepr(exports, 'lazy', 
+{
+  dep: 'core.types.lazy',
+  rep: 'core.obj.lazy',
+  get: () => require('../obj/df').lazy,
+});

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}.
  *