@lumjs/core 1.14.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/arrays.js

@@ -1,82 +1,314 @@
 /**
- * Array helper functions.
+ * Array (and other list objects) helper functions.
  * @module @lumjs/core/arrays
  */
+const {F,S} = require('./types/js');
+
+/**
+ * A wrapper class to abstract functionality of various kinds of lists.
+ *
+ * Supports `Array`, `Set`, and `Map` explicitly.
+ * Other classes may be supported. YMMV.
+ *
+ * @alias module:@lumjs/core/arrays.List
+ */
+class List
+{
+  /**
+   * A list of known closure properties.
+   *
+   * Corresponding `wrap_${closure}` methods will be used to generate
+   * the closure properties.
+   */
+  static get KNOWN_CLOSURES()
+  {
+    return (Object.getOwnPropertyNames(this.prototype)
+      .filter(name => name.startsWith('wrap_')));
+  }
+
+  /**
+   * Build a new List wrapper.
+   *
+   * @param {object} obj - The list object.
+   *
+   * Typically an `Array`, `Set`, `Map`, or something similar.
+   * Not all of types will support all features. YMMV.
+   *
+   * @param {object} [opts] Options for advanced use.
+   *
+   * @param {bool} [opts.allowRaw=false] Attempt to support raw objects?
+   *
+   * Treat regular Javascript objects as lists, as they are a kind of
+   * map after all. This may lead to unusual results. YMMV.
+   *
+   * @param {mixed} [opts.closures=true] Create closure methods?
+   *
+   * If `true` or `"*"` we will create all known closure properties.
+   *
+   * If an `Array` it's the list of closure names we want to create.
+   * Possible values can be found in `List.KNOWN_CLOSURES`.
+   *
+   * If it's a `string` it's treated as a whitespace separated list
+   * of closure names and split into an `Array`.
+   *
+   * If `false` we won't create any closure properties.
+   *
+   */
+  constructor(obj, opts={})
+  {
+    this.obj = obj;
+    this.opts = opts;
+    this.allowRaw = opts.allowRaw ?? false;
+    this.setupClosures(opts.closures ?? true);  
+  }
+
+  setupClosures(closures)
+  {
+    if (!closures)
+    { // Nothing to do.
+      return;
+    }
+
+    if (closures === true || closures === '*')
+    { // Setup all closures.
+      closures = this.constructor.KNOWN_CLOSURES;
+    }
+    else if (typeof closures === S)
+    {
+      closures = closures.trim().split(/\s+/);
+    }
+    
+    if (Array.isArray(closures))
+    {
+      for (const closure of closures)
+      {
+        const meth = 'wrap_'+closure;
+        if (typeof this[meth] === F)
+        { // Create the detail property.
+          this[closure] = this[meth]();
+        }
+        else
+        {
+          console.error({closure, closures, list: this});
+          throw new Error("Unsupported closure");
+        }
+      }
+    }
+    else
+    {
+      console.error({closures, list: this});
+      throw new TypeError("Invalid closures value");
+    }
+  }
+
+  unsupported(obj, forClosure, info, retVal=false)
+  {
+    console.error("Unsupported object", {obj, forClosure, info, list: this});
+    return () => retVal;
+  }
+
+  /**
+   * Return a closure that returns if an item is in a list object.
+   *
+   * @param {object} obj - The list object the closure will be for.
+   *
+   * May be an `Array`, `Set`, `Map`, or `TypedArray` or any object
+   * that has either an `includes()` or `has()` method.
+   *
+   * @returns {function}
+   * @throws {TypeError}
+   */
+  wrap_contains(obj=this.obj, allowRaw=this.allowRaw)
+  {
+    if (typeof obj.includes === F)
+    { // Array and TypedArray have includes()
+      return item => obj.includes(item);
+    }
+    else if (typeof obj.has === F)
+    { // Set and Map have has()
+      return item => obj.has(item);
+    }
+    else if (allowRaw)
+    { // A fallback to raw object search.
+      return item => (typeof obj[item] !== undefined);
+    }
+    else
+    { // Nope.
+      return this.unsupported(obj, 'contains', {allowRaw});
+    }
+  }
+
+  /**
+   * Return a closure that removes an item from a list.
+   *
+   * @param {object} obj - The list object the closure will be for.
+   *
+   * May be an `Array`, `Set`, `Map`, or anything with a `delete()` method.
+   *
+   * @returns {function}
+   * @throws {TypeError}
+   */
+  wrap_remove(obj=this.obj, allowRaw=this.allowRaw)
+  {
+    let closure;
+    if (Array.isArray(obj))
+    { // Arrays have no easy method to do this.
+      closure = function(item) 
+      {
+        let removed = 0;
+        let index = obj.indexOf(item);
+        while (index !== -1)
+        {
+          obj.splice(index, 1);
+          removed++;
+          index = obj.indexOf(item, index);
+        }
+        return removed;
+      }
+    }
+    else if (typeof obj.delete === F)
+    { // Use the delete() method.
+      closure = item => (obj.delete(item) ?  1 : 0);
+    }
+    else if (allowRaw)
+    { // Fallback to removing the property.
+      closure = function(item)
+      {
+        if (obj[item] === undefined)
+        {
+          return 0;
+        }
+        else
+        {
+          return (delete obj[item] ? 1 : 0);
+        }
+      }
+    }
+    else
+    { // Nada.
+      closure = this.unsupported(obj, 'remove', {allowRaw}, 0);
+    }
+    return closure;
+  }
+
+  /** 
+   * See if our list object contains *any* of the specified items.
+   *
+   * @param  {...any} items 
+   * @returns {boolean}
+   */
+  containsAny(...items)
+  {
+    for (const item of items)
+    {
+      if (this.contains(item))
+      { // Item found.
+        return true;
+      }
+    }
+ 
+    // No items found.
+    return false;
+  }
+
+  /**
+    * See if our list contains *all* of the specified items.
+    *
+    * @param  {...any} items 
+    * @returns {boolean}
+    */
+  containsAll(...items)
+  {
+    for (const item of items)
+    {
+      if (!this.contains(item))
+      { // An item was missing.
+        return false;
+      }
+    }
+    // All items found.
+    return true;
+  }
+
+  /**
+   * Remove items from our list object.
+   * 
+   * Passed any number of items, it will see if any of those items are
+   * found in the array, and if they are, will remove them from the array.
+   * 
+   * @param  {...any} items 
+   * @returns {number} Number of items actually removed.
+   */
+  removeAll(...items)
+  {
+    let removed = 0;
+    for (const item of items)
+    {
+      removed += this.remove(item);
+    }
+    return removed;
+  }
+
+  /**
+   * Return a List instance for the passed object.
+   *
+   * If the object is already a `List` it is returned as is.
+   *
+   * @param {object} obj - The list object.
+   * @param {object} [opts] - Passed to constructor.
+   */
+  static for(obj, opts)
+  {
+    return (obj instanceof this) ? obj : new this(obj, opts);
+  }
+}
+
+const CONTAINS_OPTS = {closures: ['contains']};
 
 /** 
- * See if an array contains *any* of the specified items.
- * @param {Array} array 
+ * See if an list object contains *any* of the specified items.
+ *
+ * @param {object} list - A `List` or object for `new List(list)`;
  * @param  {...any} items 
  * @returns {boolean}
  * @alias module:@lumjs/core/arrays.containsAny
  */
- function containsAny(array, ...items)
- {
-   for (const item of items)
-   {
-     if (array.includes(item))
-     { // Item found.
-       return true;
-     }
-   }
- 
-   // No items found.
-   return false;
- }
- 
- exports.containsAny = containsAny;
+function containsAny(list, ...items)
+{
+  return List.for(list, CONTAINS_OPTS).containsAny(...items);
+}
 
  /**
-  * See if an array contains *all* of the specified items.
-  * @param {Array} array
+  * See if a list contains *all* of the specified items.
+  *
+  * @param {object} list - A `List` or object for `new List(list)`;
   * @param  {...any} items 
   * @returns {boolean}
   * @alias module:@lumjs/core/arrays.containsAll
   */
- function containsAll(array, ...items)
- {
-   for (const item of items)
-   {
-     if (!array.includes(item))
-     { // An item was missing.
-       return false;
-     }
-   }
-   
-   // All items found.
-   return true;
- }
-
- exports.containsAll = containsAll;
- 
+function containsAll(list, ...items)
+{
+  return List.for(list, CONTAINS_OPTS).containsAll(...items);
+}
+
+const REMOVE_OPTS = {closures: ['remove']};
+
 /**
- * Remove items from an array.
+ * Remove items from a list object.
  * 
  * Passed any number of items, it will see if any of those items are
  * found in the array, and if they are, will remove them from the array.
  * 
- * @param {Array} array 
+ * @param {object} list - A `List` or object for `new List(list)`; 
  * @param  {...any} items 
  * @returns {number} Number of items actually removed.
  * @alias module:@lumjs/core/arrays.removeItems
  */
-function removeItems(array, ...items)
+function removeItems(list, ...items)
 {
-  let removed = 0;
-  for (const item of items)
-  {
-    const index = array.indexOf(item);
-    if (index !== -1)
-    {
-      array.splice(index, 1);
-      removed++;
-    }
-  }
-  return removed;
+  return List.for(list, REMOVE_OPTS).removeAll(...items);
 }
 
-exports.removeItems = removeItems;
-
 /**
  * Return a Powerset of values in the array.
  * @param {Array} array  The array to make the powerset from.
@@ -99,8 +331,6 @@ function powerset(array)
   return ps;
 }
 
-exports.powerset = powerset;
-
 /**
  * Get a random element from an array.
  * @param {Array} array  The array to get an item from.
@@ -112,4 +342,9 @@ function random(array)
   return array[Math.floor(Math.random()*array.length)];
 }
 
-exports.random = random;
+module.exports = exports =
+{
+  List, containsAny, containsAll,
+  removeItems, powerset, random,
+}
+

package/lib/index.js

@@ -33,47 +33,44 @@ const def = types.def;
  */
 const lazy = types.lazy;
 
-// A descriptor template for def/lazy.
-const E = def.e;
-
-def(exports, 'types', types, E);
-def(exports, 'def',   def,   E);
-def(exports, 'lazy',  lazy,  E);
+def(exports, 'types', types);
+def(exports, 'def',   def);
+def(exports, 'lazy',  lazy);
 
 /**
  * Array utility functions «Lazy»
  * @name module:@lumjs/core.arrays
  * @type {module:@lumjs/core/arrays}
  */
-lazy(exports, 'arrays', () => require('./arrays'), E);
+lazy(exports, 'arrays', () => require('./arrays'));
 
 /**
  * Information about the JS context we're running in
  * @name module:@lumjs/core.context
  * @type {module:@lumjs/core/context}
  */
-def(exports, 'context', require('./context'), E);
+def(exports, 'context', require('./context'));
 
 /**
  * Functions for working with strings and locales «Lazy»
  * @name module:@lumjs/core.strings
  * @type {module:@lumjs/core/strings}
  */
-lazy(exports, 'strings', () => require('./strings'), E);
+lazy(exports, 'strings', () => require('./strings'));
 
 /**
  * Functions for working with binary flags «Lazy»
  * @name module:@lumjs/core.flags
  * @type {module:@lumjs/core/flags}
  */
-lazy(exports, 'flags', () => require('./flags'), E);
+lazy(exports, 'flags', () => require('./flags'));
 
 /**
  * Functions for manipulating objects «Lazy»
  * @name module:@lumjs/core.obj
  * @type {module:@lumjs/core/obj}
  */
-lazy(exports, 'obj', () => require('./obj'), E);
+lazy(exports, 'obj', () => require('./obj'));
 
 /**
  * Functions for getting values and properties with fallback defaults «Lazy»
@@ -88,7 +85,7 @@ function from(submod, ...libs)
 {
   for (const lib of libs)
   {
-    def(exports, lib, submod[lib], E);
+    def(exports, lib, submod[lib]);
   }
 }
 
@@ -133,7 +130,7 @@ from(meta, 'stacktrace', 'AbstractClass', 'Functions', 'NYI');
  * @function
  * @see module:@lumjs/core/enum
  */
-lazy(exports, 'Enum', () => require('./enum'), E);
+lazy(exports, 'Enum', () => require('./enum'));
 
 /**
  * Make an object support the *Observable* API «Lazy»
@@ -141,4 +138,5 @@ lazy(exports, 'Enum', () => require('./enum'), E);
  * @function
  * @see module:@lumjs/core/observable
  */
-lazy(exports, 'observable', () => require('./observable'), E);
+lazy(exports, 'observable', () => require('./observable'));
+

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.14.0",
+  "version": "1.16.0",
   "main": "lib/index.js",
   "exports":
   {