@lumjs/core 1.38.2 → 1.38.4

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};
@@ -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/lazy.js

@@ -1,225 +1,18 @@
-const def = require('./def');
-const {S,F} = require('./js');
-const {COMPLEX} = require('./typelist');
-const {needType,needObj} = require('./needs');
-const {doesDescriptor} = require('./basics');
-
-/**
- * Metadata for the property definition.
- * 
- * @typedef module:@lumjs/core/types~LazyDef
- * @property {string} name - The `name` passed to `lazy()`
- * @property {(object|function)} target - The `target` passed to `lazy()`
- * @property {object} opts - The `opts` passed to `lazy()`
- * @property {object} arguments - The full `arguments` passed to `lazy()`
- * 
- * @property {boolean} [assign] Override default assignment rules?
- * 
- * This property may be added by the `LazyGetter` or `LazySetter` 
- * functions to override the default assignment rules. 
- * 
- * If this is `true` the return value will be assigned, replacing the 
- * lazy accessor property, even if the value is `undefined`.
- * 
- * If this is `false`, the value will be returned, but will **not** be 
- * *assigned*, so the lazy accessor property will remain.
- * 
- * Leave it `undefined` to use the default assignment behaviour.
- * 
- * @property {*} [def] Special options for `def()`
- * 
- * The [def()]{@link module:@lumjs/core/types.def} function has an
- * optional fourth parameter called `opts` which is used for a few
- * specialized purposes. If this property is set, it will be used as
- * the value for `opts` when assigning the return value to the property.
- * 
- * Leave it `undefined` to use the default `def()` behaviour.
- * 
- */
-
-/**
- * A function to generate the property value.
- * 
- * @callback module:@lumjs/core/types~LazyGetter 
- * @param {module:@lumjs/core/types~LazyDef} info - A metadata object
- * @returns {*} The generated *value* of the property
- * 
- * By default if this is `undefined` the value will **not** be
- * assigned, and instead the accessor property will remain in
- * place to be used on subsequent calls until a value other than
- * `undefined` is returned.
- * 
- * This assignment behaviour can be overridden by the function
- * if it sets `this.assign` to an explicit boolean value.
- * 
- * As we are using [def()]{@link module:@lumjs/core/types.def} 
- * to assign the value, by default if the return value appears 
- * to be a valid *Descriptor* object, it will be used as the 
- * property descriptor. See `def()` for further details on how
- * it handles the various arguments.
- * 
- * Regardless of the value of `this.assign`, this value will
- * be *returned* as the property value.
- * 
- * @this {module:@lumjs/core/types~LazyDef} The `info` metadata object
- */
-
-/**
- * A function to handle attempts at assignment.
- * 
- * Very similar to [LazyGetter]{@link module:@lumjs/core/types~LazyGetter}
- * but called when property assignment is attempted on the
- * lazy accessor property.
- * 
- * If you explicitly want to forbid assignment, you can throw
- * an `Error` from this function.
- * 
- * @callback module:@lumjs/core/types~LazySetter
- * @param {*} value - The value attempting to be assigned.
- * @returns {*} The *actual* assignment value (if any.)
- * 
- * The same assignment rules apply as in the
- * [LazyGetter]{@link module:@lumjs/core/types~LazyGetter}
- * callback.
- * 
- * @this {module:@lumjs/core/types~LazyDef} A metadata object.
- */
+const {deprecated} = require('../meta');
+const {lazy} = require('../obj/df');
 
 /**
  * Build a lazy initializer property.
- * 
- * This builds an *accessor* property that will replace itself
- * with a initialized property, the value of which is obtained from
- * a supplied initialization function. Any subsequent use of the
- * property will obviously be using the initialized property directly.
- * 
- * The general purpose is if there is a property that requires
- * a fairly intensive load time, or requires a large library that
- * you may not always *need* for basic things, you can use this
- * to ensure that the property is only initialized when needed.
- * 
- * 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 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 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.
- * 
- * As with `def()` itself, this can be either an `object` or `function`,
- * as in Javascript the latter is an extension of the former.
- * 
- * @param {string} name - The name of the property to add.
- * 
- * @param {module:@lumjs/core/types~LazyGetter} initfunc 
- * The function to initialize the property.
- * 
- * This will normally only ever be called the first time the property
- * is accessed in a *read* operation. The return value from this
- * will be assigned to the property using `def()`, replacing the
- * lazy accessor property.
- * 
- * @param {object} [opts] Options to customize behavior.
- * 
- * @param {module:@lumjs/core/types~LazySetter} [opts.set]
- * A function to handle assignment attempts.
- * 
- * This obviously only applies to the *lazy accessor* property,
- * and will have no affect once the property has been replaced
- * by its initialized value.
- * 
- * @param {boolean} [opts.enumerable=false] Is the property enumerable?
- * 
- * This applies to the *lazy accessor* property only.
- * You can set custom descriptor rules in the `initfunc`
- * if you need them on the initialized property.
- * 
- * @param {?boolean} [opts.assign] The *default* value for the `assign` property
- * in the [LazyDef]{@link module:@lumjs/core/types~LazyDef} object.
- * 
- * @param {*} [opts.def] The *default* value for the `def` property in
- * the [LazyDef]{@link module:@lumjs/core/types~LazyDef} object.
- *
- * @returns {(object|function)} The `target` argument
- * 
- * @alias module:@lumjs/core/types.lazy
+ * @name module:@lumjs/core/types.lazy
+ * @deprecated Moved to `obj` module; this alias will be removed in v2.x
+ * @see {@link module:@lumjs/core/obj.lazy} for API docs.
  */
-function lazy(target, name, initfunc, opts={})
+module.exports = function (...args)
 {
-  needType(COMPLEX, target, 'obj must be an object');
-  needType(S, name, 'name must be a string');
-  needType(F, initfunc, 'initfunc must be a function');
-  needObj(opts, 'opts parameter was not an object');
-
-  // The `this` object for the functions.
-  const context = 
-  { 
-    name, 
-    target, 
-    opts, 
-    arguments,
-    assign: opts.assign,
-    def: opts.def,
-  }
-
-  // The descriptor for the lazy accessor.
-  const desc = 
-  {
-    configurable: true, 
-    enumerable: opts.enumerable ?? false,
-  };
-
-  // Replace the property if rules are correct.
-  const defval = function(value)
-  {
-    const assign = (context.assign ?? value !== undefined);
-    if (assign)
-    { // Replace the lazy accessor with the returned value.
-      def(target, name, value, context.def);
-      // Now return the newly assigned value.
-      return target[name];
-    }
-    else if (doesDescriptor(value))
-    { // A descriptor was returned, extract the real value.
-      if (typeof value.get === F)
-      {
-        return value.get();
-      }
-      else 
-      {
-        return value.value;
-      }
-    }
-    else 
-    { // Just return the original value.
-      return value;
-    }
-  }
-
-  desc.get = function()
-  { 
-    return defval(initfunc.call(context,context));
-  }
-
-  if (typeof opts.set === F)
-  { // We want to assign a lazy setter as well.
-    desc.set = function(value)
-    {
-      defval(opts.set.call(context, value));
-    }
-  }
-
-  // Assign the lazy accessor property.
-  return def(target, name, desc);
+  const retval = lazy(...args);
+  return deprecated(
+    'core.types.def.lazy',
+    'core.obj.lazy',
+    retval
+  );
 }
-
-// Gotta be one of the greatest lines...
-def(def, 'lazy', lazy);
-
-// And this is a close second...
-def(lazy, 'def', def);
-
-module.exports = lazy;

package/lib/types/stringify.js

@@ -11,6 +11,17 @@ const DEF =
   MAXD: 1,
   NEWD: 0,
 }
+const ANY = '{...}';
+
+function _opts(opts) {
+  return (typeof opts === N 
+    ? { maxDepth: opts } 
+    : (isObj(opts) 
+      ? opts 
+      : {}
+    )
+  );
+}
 
 /**
  * Stringify a Javascript value.
@@ -40,10 +51,7 @@ const DEF =
  */
 function stringify (what, opts={}, addNew=null)
 {
-  if (typeof opts === N)
-  {
-    opts = {maxDepth: opts}
-  }
+  opts = _opts(opts);
 
   if (typeof addNew === N)
   {
@@ -95,6 +103,8 @@ class Stringify
    */
   constructor(opts={})
   {
+    opts = _opts(opts);
+
     this.options = opts;
     this.maxDepth = opts.maxDepth ?? DEF.MAXD;
     this.newDepth = opts.newDepth ?? DEF.NEWD;
@@ -238,7 +248,37 @@ class Stringify
       }
 
       // If we reached here, it's another kind of object entirely.
-      return container(Object.keys(what), '{', '}');
+      if (recurse) 
+      {
+        let cstr = nameFor() + '{';
+        let keys = Object.keys(what);
+        for (let k=0; k < keys.length; k++) 
+        {
+          let key = keys[k], val = what[key];
+          if (k > 0) cstr += ', ';
+          cstr += key + ':' + this.stringify(val, curd+1)
+        }
+        cstr += '}';
+        return cstr;
+      }
+      else 
+      {
+        if (this.options.jsonObjects) 
+        {
+          let json; 
+          try {
+            json = JSON.stringify(what);
+          } catch (err) {
+            console.error(err);
+            json = ANY;
+          }
+          return nameFor() + json;
+        }
+        else
+        {
+          return nameFor() + ANY;
+        }
+      }
 
     } // if isObj
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/core",
-  "version": "1.38.2",
+  "version": "1.38.4",
   "main": "lib/index.js",
   "exports": 
   {
@@ -31,7 +31,8 @@
   },
   "dependencies": 
   {
-    "@lumjs/opts": "^1.0.0"
+    "@lumjs/opts": "^1.0.0",
+    "@lumjs/events-observable": "^1.0.1"
   },
   "devDependencies": 
   {

package/lib/events/event.js

@@ -1,89 +0,0 @@
-"use strict";
-
-const {SY,F,isObj} = require('../types');
-
-/**
- * An Event object to emit to handler callbacks.
- * 
- * @prop {module:@lumjs/core/events.Listener} eventListener
- * The event Listener instance this event was emitted from.
- * @prop {(string|Symbol)} type - The event type that was triggered.
- * @prop {string} name - The event name that was triggered;
- * if `type` is a string this will be the same value,
- * for a Symbol type this will be the `type.description` value.
- * @prop {object} target - Target object for this event.
- * @prop {Array} args - Arguments passed to `emit()`
- * @prop {object} options - Composes options from the
- * Registry and the Listener. Listener options take priority.
- * @prop {?object} data 
- * If `args[0]` is any kind of `object` other than another Event 
- * instance, it will be used as the `data` property. 
- * If `args[0]` is not an `object`, this property will be `null`.
- * @prop {module:@lumjs/core/events.Event} origEvent
- * Unless `this.prevEvent` is set, this should always be
- * a reference to `this` instance itself.
- * @prop {?module:@lumjs/core/events.Event} prevEvent
- * If `args[0]` is another Event instance this property
- * will be set with its value, as well as the following
- * changes to the default behavior:
- * 
- * - `this.data` will be set to `prevEvent.data`.
- * - `this.origEvent` will be set to `prevEvent.origEvent`
- * 
- * @prop {module:@lumjs/core/events~Status} emitStatus
- * 
- * @alias module:@lumjs/core/events.Event
- */
-class LumEvent 
-{
-  /**
-   * Create a new Event instance; should not be called directly.
-   * @protected
-   * @param {module:@lumjs/core/events.Listener} listener 
-   * @param {object} target 
-   * @param {(string|Symbol)} type 
-   * @param {Array} args 
-   * @param {object} status
-   */
-  constructor(listener, target, type, args, status)
-  {
-    const reg = listener.registry;
-    this.eventListener = listener;
-    this.args = args;
-    this.target = target;
-    this.type = type;
-    this.name = (typeof type === SY) ? type.description : type;
-    this.emitStatus = status;
-    this.options = Object.assign({},
-      reg.options,
-      listener.options,
-      status.options);
-
-    this.data = null;
-    this.prevEvent = null;
-    this.origEvent = this;
-
-    if (isObj(args[0]))
-    { // The first argument is an object.
-      const ao = args[0];
-      if (ao instanceof LumEvent)
-      { // A previous event.
-        this.prevEvent = ao;
-        this.origEvent = ao.origEvent;
-        this.data      = ao.data;
-      }
-      else
-      { // Use it as a data object.
-        this.data = ao;
-      }
-    }
-
-    if (typeof this.options.setupEvent === F)
-    {
-      this.options.setupEvent.call(listener, this);
-    }
-
-  }
-}
-
-module.exports = LumEvent;