@lumjs/core 1.15.0 → 1.16.0

package/debug/2023-06-08T19_55_05_247Z-debug-0.log

@@ -0,0 +1,107 @@
+0 verbose cli /usr/bin/node /usr/bin/npm
+1 info using npm@9.7.1
+2 info using node@v18.16.0
+3 timing npm:load:whichnode Completed in 1ms
+4 timing config:load:defaults Completed in 1ms
+5 timing config:load:file:/usr/lib/node_modules/npm/npmrc Completed in 1ms
+6 timing config:load:builtin Completed in 1ms
+7 timing config:load:cli Completed in 1ms
+8 timing config:load:env Completed in 0ms
+9 timing config:load:file:/system/docs/dev/js/lumjs/core/.npmrc Completed in 0ms
+10 timing config:load:project Completed in 1ms
+11 timing config:load:file:/home/novus/.npmrc Completed in 1ms
+12 timing config:load:user Completed in 1ms
+13 timing config:load:file:/usr/etc/npmrc Completed in 0ms
+14 timing config:load:global Completed in 0ms
+15 timing config:load:setEnvs Completed in 1ms
+16 timing config:load Completed in 6ms
+17 timing npm:load:configload Completed in 6ms
+18 timing config:load:flatten Completed in 1ms
+19 timing npm:load:mkdirpcache Completed in 0ms
+20 timing npm:load:mkdirplogs Completed in 0ms
+21 verbose title npm publish
+22 verbose argv "publish"
+23 timing npm:load:setTitle Completed in 0ms
+24 timing npm:load:display Completed in 1ms
+25 verbose logfile logs-max:10 dir:/home/novus/.npm/_logs/2023-06-08T19_55_05_247Z-
+26 verbose logfile /home/novus/.npm/_logs/2023-06-08T19_55_05_247Z-debug-0.log
+27 timing npm:load:logFile Completed in 5ms
+28 timing npm:load:timers Completed in 0ms
+29 timing npm:load:configScope Completed in 0ms
+30 timing npm:load Completed in 22ms
+31 verbose publish [ '.' ]
+32 silly logfile start cleaning logs, removing 1 files
+33 silly logfile done cleaning log files
+34 timing arborist:ctor Completed in 0ms
+35 notice
+36 notice 📦  @lumjs/core@1.16.0
+37 notice === Tarball Contents ===
+38 notice 928B   README.md             
+38 notice 627B   TODO.md               
+38 notice 501B   jsdoc.json            
+38 notice 8.6kB  lib/arrays.js         
+38 notice 6.4kB  lib/context.js        
+38 notice 5.8kB  lib/enum.js           
+38 notice 1.3kB  lib/flags.js          
+38 notice 3.6kB  lib/index.js          
+38 notice 3.8kB  lib/meta.js           
+38 notice 3.6kB  lib/modules.js        
+38 notice 1.2kB  lib/obj/apply.js      
+38 notice 12.1kB lib/obj/clone.js      
+38 notice 1.2kB  lib/obj/copyall.js    
+38 notice 12.5kB lib/obj/copyprops.js  
+38 notice 3.2kB  lib/obj/getmethods.js 
+38 notice 1.2kB  lib/obj/getproperty.js
+38 notice 870B   lib/obj/index.js      
+38 notice 2.2kB  lib/obj/lock.js       
+38 notice 2.8kB  lib/obj/merge.js      
+38 notice 6.8kB  lib/obj/ns.js         
+38 notice 2.5kB  lib/objectid.js       
+38 notice 8.7kB  lib/observable.js     
+38 notice 2.2kB  lib/opt.js            
+38 notice 5.3kB  lib/strings.js        
+38 notice 6.0kB  lib/types/basics.js   
+38 notice 4.7kB  lib/types/console.js  
+38 notice 7.2kB  lib/types/def.js      
+38 notice 1.1kB  lib/types/dt.js       
+38 notice 1.8kB  lib/types/index.js    
+38 notice 4.9kB  lib/types/isa.js      
+38 notice 457B   lib/types/js.js       
+38 notice 7.2kB  lib/types/lazy.js     
+38 notice 3.4kB  lib/types/needs.js    
+38 notice 2.7kB  lib/types/root.js     
+38 notice 3.8kB  lib/types/stringify.js
+38 notice 5.5kB  lib/types/typelist.js 
+38 notice 826B   package.json          
+39 notice === Tarball Details ===
+40 notice name:          @lumjs/core                             
+40 notice version:       1.16.0                                  
+40 notice filename:      lumjs-core-1.16.0.tgz                   
+40 notice package size:  42.7 kB                                 
+40 notice unpacked size: 147.6 kB                                
+40 notice shasum:        424727206c94f94fbf8e18c5f62eab4aa64e52af
+40 notice integrity:     sha512-iPLVQTAe/Bf8P[...]TV8PNxn6/ji5A==
+40 notice total files:   37                                      
+41 notice
+42 notice Publishing to https://registry.npmjs.org/ with tag latest and default access
+43 http fetch PUT 401 https://registry.npmjs.org/@lumjs%2fcore 277ms
+44 timing command:publish Completed in 367ms
+45 verbose stack HttpErrorGeneral: 401 Unauthorized - PUT https://registry.npmjs.org/@lumjs%2fcore - unexpected status code from "get-packument" = 401
+45 verbose stack     at /usr/lib/node_modules/npm/node_modules/npm-registry-fetch/lib/check-response.js:95:15
+45 verbose stack     at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
+45 verbose stack     at async publish (/usr/lib/node_modules/npm/node_modules/libnpmpublish/lib/publish.js:54:17)
+45 verbose stack     at async otplease (/usr/lib/node_modules/npm/lib/utils/otplease.js:4:12)
+45 verbose stack     at async Publish.exec (/usr/lib/node_modules/npm/lib/commands/publish.js:123:7)
+45 verbose stack     at async module.exports (/usr/lib/node_modules/npm/lib/cli-entry.js:61:5)
+46 verbose statusCode 401
+47 verbose pkgid @lumjs/core@1.16.0
+48 verbose cwd /system/docs/dev/js/lumjs/core
+49 verbose Linux 5.10.0-22-amd64
+50 verbose node v18.16.0
+51 verbose npm  v9.7.1
+52 error code E401
+53 error 401 Unauthorized - PUT https://registry.npmjs.org/@lumjs%2fcore - unexpected status code from "get-packument" = 401
+54 verbose exit 1
+55 timing npm Completed in 495ms
+56 verbose code 1
+57 error A complete log of this run can be found in: /home/novus/.npm/_logs/2023-06-08T19_55_05_247Z-debug-0.log

package/lib/obj/apply.js

@@ -0,0 +1,52 @@
+const {F,isObj} = require('../types');
+const copyProps = require('./copyprops');
+
+/**
+ * Apply functions to an object
+ *  
+ * In addition to the parameters passed, we'll also define:
+ * 
+ * - `cp` will be a `CopyProps` instance via `copyProps.cache.into(obj)`;
+ * - `args` will be an array of `[obj, opts]`;
+ * - `opts` will be an object of `{obj, cp, args}`;
+ * 
+ * @param {(object|function)} obj - The target we're applying to.
+ * 
+ * @param  {...(function|object)} fns - Values we are applying.
+ * 
+ * For each value of `fns` as `fn`:
+ * 
+ * - If a `function` we'll call `fn.apply(obj, args)`; 
+ * - If an `object` we'll call `cp.from(fn)`.
+ * 
+ * @returns {object} `obj`
+ * @throws {TypeError} If a `fns` value is not valid.
+ * @alias module:@lumjs/core/obj.apply
+ */
+function apply(obj, ...fns)
+{
+  const cp = copyProps.cache.into(obj);
+  const opts = {obj, cp};
+  const args = [obj, opts];
+  opts.args = args;
+
+  for (const fn of fns)
+  {
+    if (typeof fn === F)
+    { 
+      fn.apply(obj, args);
+    }
+    else if (isObj(fn))
+    {
+      cp.from(fn);
+    }
+    else
+    {
+      throw new TypeError("invalid parameter value");
+    }
+  }
+
+  return obj;
+}
+
+module.exports = apply;

package/lib/obj/copyall.js

@@ -39,7 +39,7 @@ exports.duplicateOne = copyAll.clone = obj => copyAll({}, obj);
  * 
  * Use `copyProps.into({}).from(...sources)` for a more robust version.
  * 
- * Alias: `copyAll.clone`
+ * Alias: `copyAll.duplicate`
  * 
  * @alias module:@lumjs/core/obj.duplicateOne
  * @param {object} obj - The object to duplicate.

package/lib/obj/copyprops.js

@@ -1,7 +1,7 @@
 
 // Get some constants
-const {B,N,F,isObj,isArray,needObj,def,console} = require('../types');
-const {duplicateOne: clone} = require('./copyall');
+const {S,B,N,F,isObj,isArray,needObj,def,console} = require('../types');
+const {copyAll, duplicateOne: clone} = require('./copyall');
 
 const RECURSE_NONE =  0;
 const RECURSE_ALL  = -1;
@@ -233,22 +233,35 @@ def(copyProps, 'RECURSE_LIST', RECURSE_LIST);
  * // Get a copy of the `copyProps` function.
  * const cp = require('@lumjs/core').obj.copyProps;
  * 
- * // Starting with the target:
+ * // Starting with the target(s):
  * cp.into(targetObj).given({all: true}).from(source1, source2);
  * 
- * // Starting with the sources:
+ * // Starting with the source(s):
  * cp.from(sourceObj).given({exclude: ['dontCopy']}).into(target1, target2);
  * 
  * // Starting with the options:
  * cp.given({recursive: cp.RECURSE_ALL}).from(source1, source2).into(target1, target2);
  * 
+ * // Call `cp.into()` and cache the instance in a `Map`.
+ * // Future calls with the same `targetObj` will return the cached instance.
+ * // Unlike `cp.into()`, only supports a single `targetObj`.
+ * cp.cache.into(targetObj);
+ *
+ * // Call `cp.from()` and cache the instance in a `Map`.
+ * // Future calls with the same `sourceObj` will return the cached instance.
+ * // Unlike `cp.from()`, only supports a single `sourceObj`.
+ * cp.cache.from(sourceObj);
  * 
+ * // Clear the `Map` instances for `cp.cache.into` and `cp.cache.from`
+ * cp.cache.clear();
+ *
  * ```
  * 
  * @alias module:@lumjs/core/obj~CopyProps
  */
 class $CopyProps
 {
+  // Constructor is private so we won't document it.
   constructor(opts={})
   {
     this.opts = opts;
@@ -257,21 +270,42 @@ class $CopyProps
   }
 
   /**
-   * Set a single option.
-   * @param {string} name - The option name
-   * @param {*} value - The option value
+   * Set options.
+   * 
+   * @param {(string|object)} opt - Option(s) to set.
+   * 
+   * If this is a `string` it's the name of an option to set.
+   * If this is an `object`, it's map of options to set with `copyAll`.
+   * 
+   * @param {*} value - The option value.
+   * 
+   * Only used if `option` is a `string`.
+   * 
    * @returns {object} `this`
    */
-  set(name, value)
+  set(opt, value)
   {
-    this.opts[name] = value;
+    //console.debug("CopyProps.set(", opt, value, ')');
+    if (typeof opt === S)
+    { // Set a single option.
+      this.opts[opt] = value;
+    }
+    else if (isObj(opt))
+    { // Set a bunch of options.
+      copyAll(this.opts, opt);
+    }
+    else
+    { // That's not supported
+      console.error("invalid opt", {opt, value, cp: this});
+    }
+    //console.debug("CopyProps.set:after", this);
     return this;
   }
 
   /**
-   * Set all of the options.
+   * Set all options.
    * 
-   * This replaces the currently set options entirely.
+   * This replaces any existing options entirely.
    * 
    * @param {object} opts - The options to set.
    * @returns {object} `this`
@@ -372,4 +406,48 @@ copyProps.from = function(...sources)
   return ((new $CopyProps()).from(...sources));
 }
 
+const CPC = copyProps.cache =
+{
+  into(target)
+  {
+    if (this.intoCache === undefined)
+      this.intoCache = new Map();
+    const cache = this.intoCache;
+    if (cache.has(target))
+    {
+      return cache.get(target);
+    }
+    else
+    {
+      const cp = copyProps.into(target);
+      cache.set(target, cp);
+      return cp;
+    }
+  },
+  from(source)
+  {
+    if (this.fromCache === undefined)
+      this.fromCache = new Map();
+    const cache = this.fromCache;
+    if (cache.has(source))
+    {
+      return cache.get(source);
+    }
+    else
+    {
+      const cp = copyProps.from(source);
+      cache.set(source, cp);
+      return cp;
+    }
+  },
+  clear()
+  {
+    if (this.intoCache)
+      this.intoCache.clear();
+    if (this.fromCache)
+      this.fromCache.clear();
+    return this;
+  },
+};
+
 module.exports = copyProps;

package/lib/obj/index.js

@@ -3,6 +3,7 @@
  * @module @lumjs/core/obj
  */
 
+const apply = require('./apply');
 const {copyAll,duplicateOne,duplicateAll} = require('./copyall');
 const copyProps = require('./copyprops');
 const {CLONE,clone,addClone,cloneIfLocked} = require('./clone');
@@ -23,5 +24,5 @@ module.exports =
   mergeNested, syncNested, copyProps, copyAll, ns,
   getObjectPath, setObjectPath, getNamespace, setNamespace,
   getProperty, duplicateAll, duplicateOne, getMethods, signatureOf,
-  MethodFilter,
+  MethodFilter, apply,
 }

package/lib/observable.js

@@ -1,4 +1,4 @@
-
+// Defining these after observable.
 const {B,F,S,def,isObj,isComplex,TYPES,console} = require('./types');
 const {duplicateAll: clone} = require('./obj/copyall');
 const lock = Object.freeze;
@@ -150,7 +150,7 @@ function observable (el={}, opts={})
 
     let fobj;
 
-    if (wrapthis || wrapargs)
+    if (wrapped)
     { // Something is going to use our wrapper object.
       const isWild = (name === wildcard);
       const fname = isWild ? (addname ? args[0] : args.shift()) : name;

package/lib/types/console.js

@@ -2,7 +2,7 @@ const def = require('./def');
 const {F} = require('./js');
 
 /**
- * A super simple wrapper around the Javascript console.
+ * A super simple singleton wrapper around the Javascript console.
  * 
  * By default includes `info`, `log`, `warn`, and `error` methods.
  * It may be expanded further using the `addMethod` method.
@@ -14,25 +14,68 @@ const LC =
   /**
    * A custom handler.
    * 
-   * If a `function`, will be passed the console method name as the
-   * first parameter, and method arguments as subsequent parameters.
+   * If a `function`, it will be called to handle all method calls.
    * 
    * If an `Array`, it will have all log entries added as objects with
-   * `time`, `method`, and `arguments` properties.
+   * at least `time`, `method`, and `opts` properties.
+   * By default and `arguments` property will also be included.
+   * See `msgArguments` and `msgArgs` for further details.
    * 
    * If the boolean value `false`, all output will be thrown into the void.
    * 
-   * Any other value (including the default `null`), passes the method call
-   * through to the real console object.
+   * If it is an `object`, then each property name represents a method name,
+   * and the values will be treated as a handler for that method only.
+   * All handler types are supported (i.e. `function`, `Array`, or `false`.)
+   * A special method name of `DEFAULT` may be specified as a default handler
+   * for method names not explicitly specified in the object.
+   * If no `DEFAULT` is specified and there is no handler value for a method
+   * name, calls to it will be passed through to the real console object.
+   * 
+   * If no handler was set, all methods are passed to the real console object.
+   * 
+   * Default value: `null`
    */
-  handler: null, 
+  handler: null,
+
   /**
    * Return the message object?
    * 
    * Only applicable if `handler` is an `Array`.
-   * If true, return the message object. If false, returns void/undefined.
+   * 
+   * If `true`, return the message `object`. 
+   * If `false`, returns `undefined`.
+   * 
+   * Default value: `false`
+   */
+  returnMsg: false,
+
+  /**
+   * The name to include the `arguments` magic object in the log.
+   * 
+   * Only applicable if `handler` is an `Array`.
+   * 
+   * This used to be hard-coded as `"arguments"` but the `shortArgs`
+   * option has replaced it as the array is simpler for most purposes.
+   * 
+   * Default value: `null`
+   */
+  msgArguments: null,
+
+  /**
+   * The name to include the `args` array in the log.
+   * 
+   * Only applicable if `handler` is an `Array`.
+   * 
+   * Default value: `"arguments"`
    */
-  returnMsg: false
+  msgArgs: 'arguments',
+
+  /**
+   * Use the method name as the first argument in function calls.
+   * 
+   * Default value: `true`
+   */
+  methodArg: true,
 }
 
 /** 
@@ -45,6 +88,12 @@ def(LC, 'real', RC);
 // Only including a few common ones.
 const DEFAULT_METHODS = ['debug','info','log','warn','error'];
 
+// Options that can be changed via handler settings.
+const HANDLER_OPTIONS = 
+[
+  'returnMsg', 'methodArg', 'msgArguments', 'msgArgs'
+];
+
 /**
  * Add a wrapper method to the console wrapper object.
  * @param {string} method - The console method to wrap.
@@ -52,25 +101,75 @@ const DEFAULT_METHODS = ['debug','info','log','warn','error'];
  */
 function addMethod(method)
 {
-  def(LC, method, function()
+  def(LC, method, function(...args)
   {
-    if (typeof LC.handler === F)
-    { // A custom handler.
-      return LC.handler(method, ...arguments);
+    if (typeof LC.trigger === F)
+    { // Support for core.observable(core.types.console);
+      LC.trigger(method, ...args);
+    }
+
+    let handler = LC.handler;
+    const opts = {}
+
+    function checkHandlerOptions(src)
+    {
+      for (const opt of HANDLER_OPTIONS)
+      {
+        if (src[opt] !== undefined)
+        { 
+          opts[opt] = src[opt];
+        }
+      }
+    }
+
+    // Get the default options.
+    checkHandlerOptions(LC);
+
+    // Check for complex handler definitions as a plain object.
+    if (isObj(handler) && !Array.isArray(handler))
+    { // Look for options in the handler defs.
+      checkHandlerOptions(handler);
+
+      if (handler[method] !== undefined)
+      { // A handler for that method was found.
+        handler = handler[method];
+      }
+      else if (handler.DEFAULT !== undefined)
+      { // A default handler.
+        handler = handler.DEFAULT;
+      }
     }
-    else if (Array.isArray(LC.handler))
-    { // Add a message item.
+    
+    if (typeof handler === F)
+    { // A custom handler function.
+      checkHandlerOptions(handler);
+      if (opts.methodArg) 
+        args.unshift(method)
+      return handler(...args);
+    }
+    else if (Array.isArray(handler))
+    { // Add a message item to a log array.
+      checkHandlerOptions(handler);
+
       const time = new Date().toJSON();
-      const msg = {time, method, arguments};
-      LC.handler.push(msg);
-      if (LC.returnMsg) return msg;
+      const msg = {time, method, opts};
+
+      if (typeof opts.msgArguments === S)
+        msg[opts.msgArguments] = arguments;
+      if (typeof opts.msgArgs === S)
+        msg[opts.msgArgs] = args;
+
+      handler.push(msg);
+
+      if (opts.returnMsg) return msg;
     }
-    else if (LC.handler !== false) 
+    else if (handler !== false) 
     { // Pass through to the real console.
-      return RC[method](...arguments);
+      return RC[method](...args);
     }
   });
 }
+
 def(LC, 'addMethod', addMethod);
 
 for (const method of DEFAULT_METHODS)

package/lib/types/typelist.js

@@ -35,6 +35,7 @@ const
  * @property {string} NIL - Either `null` or `undefined`.
  * @property {string} NOTNIL - Anything other than `null` or `undefined`.
  * @property {string} MAP - A `Map` object.
+ * @property {string} SET - A `Set` object.
  * @property {object} tests - A map of tests for the above types.
  */
  const TYPES = {};
@@ -162,6 +163,7 @@ const
    NIL: isNil,
    NOTNIL: notNil,
    MAP: v => v instanceof Map,
+   SET: v => v instanceof Set,
  });
  
  module.exports = TYPES;

package/package.json

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