@lumjs/core 1.38.5 → 1.38.7

package/lib/console.js

@@ -1,5 +1,5 @@
-const def = require('./types/def');
-const {F,isObj} = require('./types/basics');
+const { df } = require('./obj/df');
+const { isObj } = require('./types/basics');
 
 /**
  * A super simple singleton wrapper around the Javascript console.
@@ -54,7 +54,7 @@ const LC =
    * 
    * Only applicable if `handler` is an `Array`.
    * 
-   * This used to be hard-coded as `"arguments"` but the `shortArgs`
+   * This used to be hard-coded as `"arguments"` but the `msgArgs`
    * option has replaced it as the array is simpler for most purposes.
    * 
    * Default value: `null`
@@ -83,7 +83,7 @@ const LC =
  * @alias module:@lumjs/core/console.real
  */ 
 const RC = globalThis.console;
-def(LC, 'real', RC);
+df(LC, 'real', RC);
 
 // Only including a few common ones.
 const DEFAULT_METHODS = ['debug','info','log','warn','error'];
@@ -101,9 +101,9 @@ const HANDLER_OPTIONS =
  */
 function addMethod(method)
 {
-  def(LC, method, function(...args)
+  df(LC, method, function(...args)
   {
-    if (typeof LC.trigger === F)
+    if (typeof LC.trigger === 'function')
     { // Support for core.observable(core.console);
       LC.trigger(method, ...args);
     }
@@ -140,7 +140,7 @@ function addMethod(method)
       }
     }
     
-    if (typeof handler === F)
+    if (typeof handler === 'function')
     { // A custom handler function.
       checkHandlerOptions(handler);
       if (opts.methodArg) 
@@ -170,7 +170,7 @@ function addMethod(method)
   });
 }
 
-def(LC, 'addMethod', addMethod);
+df(LC, 'addMethod', addMethod);
 
 for (const method of DEFAULT_METHODS)
 {
@@ -189,7 +189,7 @@ for (const method of DEFAULT_METHODS)
  * 
  * @function module:@lumjs/core/console.export
  */
-def(LC, 'export', function(handler)
+df(LC, 'export', function(handler)
 {
   if (handler !== undefined)
   { // Save the existing handler as 'preHandler'
@@ -210,7 +210,7 @@ def(LC, 'export', function(handler)
  * 
  * @function module:@lumjs/core/console.restore
  */
-def(LC, 'restore', function()
+df(LC, 'restore', function()
 {
   if (LC.preHandler !== undefined)
   {
@@ -226,9 +226,34 @@ def(LC, 'restore', function()
  * A shortcut for `LC.export(false)`
  * @function module:@lumjs/core/console.mute
  */
-def(LC, 'mute', function()
+df(LC, 'mute', function()
 {
   return LC.export(false);
 });
 
+/**
+ * Call a closure function with the console muted.
+ *
+ * Literally just calls `LC.mute()`, runs the function,
+ * then calls `LC.restore()` when finished.
+ *
+ * @param {function} fn - The function to call.
+ * @param {mixed} [ctx] Used as `this` in the function.
+ * @param {...mixed} [args] Arguments to pass to the function.
+ * @returns {mixed} The return value from the function.
+ * @throws {TypeError} if `fn` is not a function.
+ */
+df(LC, 'muted', function(fn, ctx, ...args) {
+  if (typeof fn !== 'function') {
+    console.error('@lumjs/core/console.muted', {fn, ctx, args});
+    throw new TypeError('first argument must be a function');
+  }
+
+  let retVal;
+  LC.mute();
+  retVal = fn.apply(ctx, args);
+  LC.restore();
+  return retVal;
+});
+
 module.exports = LC;

package/lib/obj/ns/index.js

@@ -37,7 +37,7 @@ exports.SOA = SOA;
  * Get a namespace path array.
  * 
  * If it's already an array, return it as is.
- * If it's a string, split it into an array, with the `.` delimiter.
+ * If it's a string, split it into an array (using one of our formats).
  * 
  * @param {(string|string[])} ns - A dotted string, or array of paths.
  * @param {(object|string)} [opts] Options.
@@ -48,7 +48,7 @@ exports.SOA = SOA;
  * @param {(module:@lumjs/core/obj.NS~Format|Array)} [opts.format] Format.
  * 
  * You can specify a single format, or an array of formats, in which case
- * the canStringify() method will be called on each of them and the first one
+ * the canParse() method will be called on each of them and the first one
  * that returns true will be used. If none return true, the last one listed
  * will be used.
  * 

package/lib/traits/index.js

@@ -1,13 +1,7 @@
 /**
- * A very simplistic Trait system.
+ * A deprecated alias to the @lumjs/traits package.
+ * Will be removed in v2.x.
  * @module @lumjs/core/traits
  */
 
-"use strict";
-
-const funcs = require('./funcs');
-const Trait = require('./trait');
-const regfns = require('./registry');
-
-// Export all the things
-Object.assign(exports, funcs, regfns, {Trait});
+module.exports = require('@lumjs/traits');

package/lib/types/index.js

@@ -16,7 +16,6 @@ Object.assign(exports,
   require('./basics'), 
   require('./root'),
   require('./isa'),
-  require('./stringify'),
   require('./needs'),
   { // A few standalone exports.
     def,
@@ -50,3 +49,16 @@ wrapDepr(exports, 'lazy',
   rep: 'core.obj.lazy',
   get: () => require('../obj/df').lazy,
 });
+
+// And for the stringify library
+wrapDepr(exports, 'stringify', {
+  dep: 'core.types.stringify',
+  rep: '@lumjs/describe',
+  get: () => require('./stringify').stringify,
+});
+
+wrapDepr(exports, 'Stringify', {
+  dep: 'core.types.Stringify',
+  rep: '@lumjs/describe',
+  get: () => require('./stringify').Stringify,
+});

package/lib/types/stringify.js

@@ -1,28 +1,3 @@
-// Get the extended type list.
-const TYPES = require('./typelist');
-const {F, S, N, B, isObj, isArray, isTypedArray} = require('./basics');
-const def = require('./def');
-
-const TOSTRING_TYPES     = [TYPES.SY];
-const TOSTRING_INSTANCES = [RegExp];
-const CUSTOM = [];
-const DEF = 
-{
-  MAXD: 1,
-  NEWD: 0,
-}
-const ANY = '{...}';
-
-function _opts(opts) {
-  return (typeof opts === N 
-    ? { maxDepth: opts } 
-    : (isObj(opts) 
-      ? opts 
-      : {}
-    )
-  );
-}
-
 /**
  * Stringify a Javascript value.
  * 
@@ -45,26 +20,12 @@ function _opts(opts) {
  * 
  * @returns {string} The stringified value
  * 
- * @alias module:@lumjs/core/types.stringify
+ * @deprecated replaced by `@lumjs/describe` package
+ * @function module:@lumjs/core/types.stringify
  * @see module:@lumjs/core/types.Stringify
  * @see module:@lumjs/core/types.Stringify#stringify
  */
-function stringify (what, opts={}, addNew=null)
-{
-  opts = _opts(opts);
-
-  if (typeof addNew === N)
-  {
-    opts.newDepth = addNew;
-  }
-  else if (typeof addNew === B)
-  {
-    opts.newDepth = addNew ? 1 : 0;
-  }
-
-  const si = new Stringify(opts);
-  return si.stringify(what);
-}
+const {stringify, Describe: Stringify} = require('@lumjs/describe');
 
 /**
  * A class to stringify Javascript values for testing and debugging.
@@ -86,256 +47,8 @@ function stringify (what, opts={}, addNew=null)
  * Any other JS value types (`number`,`boolean`, `string`, etc.) will
  * be serialized using JSON.
  * 
- * @alias module:@lumjs/core/types.Stringify
+ * @class module:@lumjs/core/types.Stringify
+ * @deprecated replaced by `@lumjs/describe` package
  */
-class Stringify 
-{
-  /**
-   * Create a new Stringify instance
-   * @param {object} [opts] Options; saved to `this.options`
-   * @param {number} [opts.maxDepth=1] Max depth to recurse?
-   * @param {number} [opts.newDepth=0] Depth to prepend 'new' to strings?
-   * @param {boolean} [opts.fnString=false] Fully stringify functions?
-   * @param {(Array|function)} [opts.setCustom] Set custom stringifiers;
-   * used *INSTEAD* of the globally registered ones.
-   * @param {(Array|function)} [opts.addCustom] Add custom stringifiers;
-   * used *in addition* to the globally registered ones.
-   */
-  constructor(opts={})
-  {
-    opts = _opts(opts);
-
-    this.options = opts;
-    this.maxDepth = opts.maxDepth ?? DEF.MAXD;
-    this.newDepth = opts.newDepth ?? DEF.NEWD;
-    this.seenObjects = new Map(); // object => description
-    this.seenDescrip = new Map(); // description => count
-    this.strClass = TOSTRING_INSTANCES.slice();
-    this.strTypes = TOSTRING_TYPES.slice();
-
-    if (opts.fnString)
-    {
-      this.strTypes.push(F);
-    }
-
-    if (opts.errString)
-    {
-      this.strClass.push(Error);
-    }
-
-    if (Array.isArray(opts.setCustom))
-    {
-      this.customFn = opts.setCustom.slice();
-    }
-    else if (typeof opts.setCustom === F)
-    {
-      this.customFn = [];
-      opts.setCustom.call(this, this.customFn);
-    }
-    else
-    { // Start out with the global custom tests.
-      this.customFn = CUSTOM.slice();
-      if (Array.isArray(opts.addCustom))
-      {
-        this.customFn.push(...opts.addCustom);
-      }
-      else if (typeof opts.addCustom === F)
-      {
-        opts.addCustom.call(this, this.customFn);
-      }
-    }
-
-  }
-
-  /**
-   * Stringify a JS value
-   * @param {*} what - Value to stringify
-   * @returns {string} A friendly representation of `what`
-   */
-  stringify(what, curd=0)
-  {
-    if (this.seenObjects.has(what))
-    { // Cached string for this subject already found.
-      return this.seenObjects.get(what);
-    }
-
-    const recurse = curd < this.maxDepth;
-    const addNew  = curd < this.newDepth;
-    const whatType = typeof what;
-    const strFor = (str) => this._stringFor(what, str);
-    
-    for (const test of this.customFn)
-    { // If there are custom extensions, we check them first.
-      const ret = test.call(this, what, curd);
-      if (typeof ret === S)
-      { // The extension processed the item.
-        return strFor(ret);
-      }
-    }
-
-    // A few types we simply stringify right now.
-    if (this.strTypes.includes(whatType)) 
-    {
-      return strFor(what.toString());
-    }
-
-    if (!this.options.fnString && typeof what === F)
-    { // Simple format for functions
-      return strFor(what.name+'()');
-    }
-    
-    if (isObj(what))
-    { // We support a few kinds of objects.
-
-      // Any class instance that we can simply call `toString()` on, let's do that.
-      for (const aClass of this.strClass)
-      {
-        if (what instanceof aClass)
-        {
-          return strFor(what.toString());
-        }
-      }
-
-      // A few formatting helpers used below.
-      const nameFor = (name=what.constructor.name) => 
-        (addNew ? 'new ' : '') + strFor(name);
-      
-      const container = (content, ps='[', pe=']') =>
-      {
-        let cstr = nameFor();
-        if (recurse)
-        {
-          cstr += ps;
-          if (!Array.isArray(content))
-          {
-            content = Array.from(content);
-          }
-          cstr += (content
-            .map(item => this.stringify(item, curd+1))
-            .join(','));
-          cstr += pe;
-        }
-        return cstr;
-      }
-      
-      if (isTypedArray(what))
-      { // This one is pretty simple.
-        if (this.options.typedContent)
-        {
-          return container(what.toString());
-        }
-        return nameFor();
-      }
-
-      if (what instanceof Map)
-      {
-        return container(what.entries());
-      }
-      
-      if (what instanceof Set)
-      {
-        return container(what.values());
-      }
-
-      if (isArray(what))
-      {
-        return container(what);
-      }
-
-      if (!this.options.errString && what instanceof Error)
-      {
-        return nameFor(what.name)+'('+JSON.stringify(what.message)+')';
-      }
-
-      // If we reached here, it's another kind of object entirely.
-      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
-    
-    // If we reached here, there's no special methods, use JSON.
-    return JSON.stringify(what);
-  }
-
-  _stringFor(obj, str)
-  {
-    let count = 0;
-    if (this.seenDescrip.has(str))
-    {
-      count = this.seenDescrip.get(str);
-    }
-    this.seenDescrip.set(str, ++count);
-    str += '#' + count.toString(16).padStart(3, '0');
-    this.seenObjects.set(obj, str);
-    return str;
-  }
-
-  static addCustoms(...testFns)
-  {
-    for (let fn of testFns)
-    {
-      if (typeof fn === F)
-      {
-        CUSTOM.push(fn);
-      }
-      else
-      {
-        console.debug({fn, testFns});
-        throw new TypeError("Invalid custom stringify function");
-      }
-    }
-  }
-
-  static registerCustoms(registerFn)
-  {
-    if (typeof registerFn === F)
-    {
-      registerFn.call(this, this);
-    }
-    else
-    {
-      console.debug({registerFn});
-      throw new TypeError("Invalid custom registration function");
-    }
-  }
-
-} // Stringify
-
-// Add some static properties for registerCustoms to use
-def(Stringify) 
-  ('strClass', {value: TOSTRING_INSTANCES})
-  ('strTypes', {value: TOSTRING_TYPES})
-  ('customFn', {value: CUSTOM})
-  ('DEFAULTS', {value: DEF})
 
-// Export it.
 module.exports = {stringify, Stringify};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/core",
-  "version": "1.38.5",
+  "version": "1.38.7",
   "main": "lib/index.js",
   "exports": 
   {
@@ -35,14 +35,17 @@
   },
   "dependencies": 
   {
-    "@lumjs/opts": "^1.0.0",
+    "@lumjs/cp": "^1.0.0",
+    "@lumjs/describe": "^1.0.0",
     "@lumjs/events-observable": "^1.0.1",
+    "@lumjs/opts": "^1.0.0",
+    "@lumjs/traits": "^1.0.0",
     "semver": "^7.7.3"
   },
   "devDependencies": 
   {
     "@lumjs/build": "^1.1.0",
-    "@lumjs/tests": "^2.0.0"
+    "@lumjs/tests": "^2.2.0"
   },
   "scripts": 
   {

package/lib/obj/cycle.js

@@ -1,182 +0,0 @@
-/*
-    cycle.js
-    2021-05-31
-
-    Public Domain.
-
-    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
-
-    This code should be minified before deployment.
-    See https://www.crockford.com/jsmin.html
-
-    USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
-    NOT CONTROL.
-*/
-
-// The file uses the WeakMap feature of ES6.
-
-/*jslint eval */
-
-/*property
-    $ref, decycle, forEach, get, indexOf, isArray, keys, length, push,
-    retrocycle, set, stringify, test
-*/
-
-if (typeof JSON.decycle !== "function") {
-    JSON.decycle = function decycle(object, replacer) {
-        "use strict";
-
-// Make a deep copy of an object or array, assuring that there is at most
-// one instance of each object or array in the resulting structure. The
-// duplicate references (which might be forming cycles) are replaced with
-// an object of the form
-
-//      {"$ref": PATH}
-
-// where the PATH is a JSONPath string that locates the first occurance.
-
-// So,
-
-//      var a = [];
-//      a[0] = a;
-//      return JSON.stringify(JSON.decycle(a));
-
-// produces the string '[{"$ref":"$"}]'.
-
-// If a replacer function is provided, then it will be called for each value.
-// A replacer function receives a value and returns a replacement value.
-
-// JSONPath is used to locate the unique object. $ indicates the top level of
-// the object or array. [NUMBER] or [STRING] indicates a child element or
-// property.
-
-        var objects = new WeakMap();     // object to path mappings
-
-        return (function derez(value, path) {
-
-// The derez function recurses through the object, producing the deep copy.
-
-            var old_path;   // The path of an earlier occurance of value
-            var nu;         // The new object or array
-
-// If a replacer function was provided, then call it to get a replacement value.
-
-            if (replacer !== undefined) {
-                value = replacer(value);
-            }
-
-// typeof null === "object", so go on if this value is really an object but not
-// one of the weird builtin objects.
-
-            if (
-                typeof value === "object"
-                && value !== null
-                && !(value instanceof Boolean)
-                && !(value instanceof Date)
-                && !(value instanceof Number)
-                && !(value instanceof RegExp)
-                && !(value instanceof String)
-            ) {
-
-// If the value is an object or array, look to see if we have already
-// encountered it. If so, return a {"$ref":PATH} object. This uses an
-// ES6 WeakMap.
-
-                old_path = objects.get(value);
-                if (old_path !== undefined) {
-                    return {$ref: old_path};
-                }
-
-// Otherwise, accumulate the unique value and its path.
-
-                objects.set(value, path);
-
-// If it is an array, replicate the array.
-
-                if (Array.isArray(value)) {
-                    nu = [];
-                    value.forEach(function (element, i) {
-                        nu[i] = derez(element, path + "[" + i + "]");
-                    });
-                } else {
-
-// If it is an object, replicate the object.
-
-                    nu = {};
-                    Object.keys(value).forEach(function (name) {
-                        nu[name] = derez(
-                            value[name],
-                            path + "[" + JSON.stringify(name) + "]"
-                        );
-                    });
-                }
-                return nu;
-            }
-            return value;
-        }(object, "$"));
-    };
-}
-
-
-if (typeof JSON.retrocycle !== "function") {
-    JSON.retrocycle = function retrocycle($) {
-        "use strict";
-
-// Restore an object that was reduced by decycle. Members whose values are
-// objects of the form
-//      {$ref: PATH}
-// are replaced with references to the value found by the PATH. This will
-// restore cycles. The object will be mutated.
-
-// The eval function is used to locate the values described by a PATH. The
-// root object is kept in a $ variable. A regular expression is used to
-// assure that the PATH is extremely well formed. The regexp contains nested
-// * quantifiers. That has been known to have extremely bad performance
-// problems on some browsers for very long strings. A PATH is expected to be
-// reasonably short. A PATH is allowed to belong to a very restricted subset of
-// Goessner's JSONPath.
-
-// So,
-//      var s = '[{"$ref":"$"}]';
-//      return JSON.retrocycle(JSON.parse(s));
-// produces an array containing a single element which is the array itself.
-
-        var px = /^\$(?:\[(?:\d+|"(?:[^\\"\u0000-\u001f]|\\(?:[\\"\/bfnrt]|u[0-9a-zA-Z]{4}))*")\])*$/;
-
-        (function rez(value) {
-
-// The rez function walks recursively through the object looking for $ref
-// properties. When it finds one that has a value that is a path, then it
-// replaces the $ref object with a reference to the value that is found by
-// the path.
-
-            if (value && typeof value === "object") {
-                if (Array.isArray(value)) {
-                    value.forEach(function (element, i) {
-                        if (typeof element === "object" && element !== null) {
-                            var path = element.$ref;
-                            if (typeof path === "string" && px.test(path)) {
-                                value[i] = eval(path);
-                            } else {
-                                rez(element);
-                            }
-                        }
-                    });
-                } else {
-                    Object.keys(value).forEach(function (name) {
-                        var item = value[name];
-                        if (typeof item === "object" && item !== null) {
-                            var path = item.$ref;
-                            if (typeof path === "string" && px.test(path)) {
-                                value[name] = eval(path);
-                            } else {
-                                rez(item);
-                            }
-                        }
-                    });
-                }
-            }
-        }($));
-        return $;
-    };
-}