@lumjs/core 1.36.0 → 1.37.1

package/lib/events/event.js

@@ -1,13 +1,16 @@
 "use strict";
 
-const {F,isObj} = require('../types');
+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} name - The event name that was triggered.
+ * @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
@@ -38,17 +41,18 @@ class LumEvent
    * @protected
    * @param {module:@lumjs/core/events.Listener} listener 
    * @param {object} target 
-   * @param {string} name 
-   * @param {Array}  args 
+   * @param {(string|Symbol)} type 
+   * @param {Array} args 
    * @param {object} status
    */
-  constructor(listener, target, name, args, status)
+  constructor(listener, target, type, args, status)
   {
     const reg = listener.registry;
     this.eventListener = listener;
     this.args = args;
     this.target = target;
-    this.name = name;
+    this.type = type;
+    this.name = (typeof type === SY) ? type.description : type;
     this.emitStatus = status;
     this.options = Object.assign({},
       reg.options,

package/lib/events/listener.js

@@ -3,7 +3,7 @@
 const {F,isObj} = require('../types');
 const Event = require('./event');
 
-const REMOVE_OPTS = ['listener','handler','eventNames'];
+const REMOVE_OPTS = ['listener','handler','eventNames','eventTypes'];
 
 function makeOpts(spec)
 {
@@ -41,7 +41,8 @@ function isListener(v)
  * @prop {module:@lumjs/core/events.Registry} registry 
  * The Registry instance this Listener belongs to.
  * @prop {(function|object)} handler - Event handler callback
- * @prop {Set} eventNames - A set of all event names handled by this
+ * @prop {Set} eventTypes - A set of all event types handled by this
+ * @prop {Set} eventNames - Alias to `eventTypes`
  * @prop {object} options - Options specific to this listener.
  * 
  * See {@link module:@lumjs/core/events.Registry#makeListener makeListener()}
@@ -76,7 +77,8 @@ class LumEventListener
     // Assign the rest here.
     this.registry = registry;
     this.options = makeOpts(spec);
-    this.eventNames = registry.getEventNames(spec.eventNames);
+    const events = spec.eventTypes ?? spec.eventNames;
+    this.eventTypes = this.eventNames = registry.getEventNames(events);
 
     const setup = this.options.setupListener ?? registry.options.setupListener;
     if (typeof setup === F)
@@ -86,12 +88,12 @@ class LumEventListener
   }
 
   /**
-   * See if there is at least one item in `this.eventNames`
+   * See if there is at least one item in `this.eventTypes`
    * @type {boolean}
    */
   get hasEvents()
   {
-    return this.eventNames.size > 0;
+    return this.eventTypes.size > 0;
   }
 
   /**
@@ -100,15 +102,15 @@ class LumEventListener
    * 
    * This is a *protected method* and should not be called directly.
    * @protected
-   * @param {string} eventName - A single event name that was triggered
+   * @param {string} type      - A single event type/name that was triggered
    * @param {object} target    - A single target object
    * @param {Array}  args      - Arguments passed to `emit()`
    * @param {module:@lumjs/core/events~Status} status - Emit status info
    * @returns {module:@lumjs/core/events.Event} The new Event that was emitted
    */
-  emitEvent(eventName, target, args, status)
+  emitEvent(type, target, args, status)
   {
-    const event = new Event(this, target, eventName, args, status);
+    const event = new Event(this, target, type, args, status);
 
     if (typeof this.handler === F)
     { // The simplest is the good old function
@@ -127,6 +129,10 @@ class LumEventListener
     return event;
   }
 
+  static get classProps()
+  {
+    return Object.getOwnPropertyNames(this.prototype);
+  }
 }
 
 LumEventListener.isListener = isListener;

package/lib/events/registry.js

@@ -1,8 +1,9 @@
 "use strict";
 
-const {S,F,isObj,def,isIterable} = require('../types');
+const {S,F,SY,isObj,def,isIterable} = require('../types');
 const Listener = require('./listener');
 const RegSym = Symbol('@lumjs/core/events:registry');
+const cp = Object.assign;
 
 const DEF_EXTENDS =
 {
@@ -13,6 +14,13 @@ const DEF_EXTENDS =
   once:     null,
 }
 
+const INT_EXTENDS =
+{
+  listeners: true,
+  results:   true,
+  onDemand:  false,
+}
+
 const DEF_OPTIONS =
 {
   delimiter: /\s+/,
@@ -20,6 +28,12 @@ const DEF_OPTIONS =
   wildcard: '*',
 }
 
+const RES_PROPS =
+[
+  'eventNames', 'eventTypes', 'targets', 'multiMatch', 'onceRemoved', 
+  'stopEmitting', 'emitted', 'targetListeners', 'registry',
+]
+
 /**
  * Has a target object been registered with an event registry?
  * @param {object} target 
@@ -33,7 +47,7 @@ const isRegistered = target => isObj(target[RegSym]);
  * @private
  * @param {object} target - Object to get metadata for
  * @param {boolean} [create=false] Create metadata if it's not found?
- * @returns {object} metadata (TODO: schema docs)
+ * @returns {(object|undefined)} metadata (TODO: schema docs)
  * @alias module:@lumjs/core/events.Registry.getMetadata
  */
 function getMetadata(target, create=false)
@@ -44,10 +58,16 @@ function getMetadata(target, create=false)
   }
   else if (create)
   { // Create new metadata
+    const exts = Object.keys(DEF_EXTENDS);
     const tpm = 
     {
       r: new Map(),
       p: {},
+      x: {},
+    }
+    for (const ext of exts)
+    {
+      tpm.x[ext] = [];
     }
     def(target, RegSym, tpm);
     return tpm;
@@ -98,29 +118,53 @@ class LumEventRegistry
    * If you want to use a `function` as an actual target, you'll need to
    * wrap it in an array or other iterable object.
    * 
-   * @param {object} [opts] Options (saved to `options` property).
+   * @param {object} [opts] Options
+   * 
+   * A _compiled_ version is saved to the `options` property.
+   * The compiled version includes a bunch of defaults, and various
+   * compose rules (mostly for the `.extend` nested options).
    * 
    * @param {(RegExp|string)} [opts.delimiter=/\s+/] Used to split event names
    * 
-   * @param {(object|boolean)} [opts.extend]
-   * This option determines the rules for adding wrapper methods and
-   * other extension properties to the target objects.
+   * @param {object} [opts.extend] Options for wrapper methods/properties
+   * 
+   * The `boolean` options determine if extension methods will be added to
+   * certain types of objects (and in some cases, when to do so).
    * 
-   * If this is `true` (default when `targets` is an `object`), then
-   * the target objects will be extended using the default property names.
+   * The `?string` options are each the names of properties/methods in the
+   * Registry class. If they are set to a `string` then that will be the
+   * name used for the wrapper property/method added to objects. If it
+   * is explicitly set to `null` it means skip adding a wrapper for that
+   * method/property. If it is omitted entirely the default will be used.
    * 
-   * If this is set to `false` (default when `targets` is a `function`), 
-   * it disables adding extension properties entirely.
+   * @param {boolean} [opts.extend.targets] Extend target objects?
    * 
-   * If it is an `object` then each nested property may be set to a string
-   * to override the default, or `null` to skip adding that property.
+   * The default will be `true` when `targets` is an `object`, or `false`
+   * when `targets` is a `function`.
+   * 
+   * @param {boolean} [opts.extend.listeners=true] Extend Listener instances?
+   * As returned by `makeListener()`, `listen()`, and `once()`
+   * @param {boolean} [opts.extend.results=true] Extend `emit()` results?
+   * @param {boolean} [opts.extend.onDemand=false] On-demand target setup
+   * 
+   * If `targets` was a `function` and this is set to `true`, then
+   * we'll perform the target setup on every emit() call. The setup process
+   * is skipped on any targets that have already been set up, so this
+   * is meant for dynamic targets that may change on every call.
+   * 
+   * @param {?string} [opts.extend.registry="events"] Registry property;
+   * only added to `targets`, never to listeners or results which have
+   * their own inherent `registry` property already.
    * 
-   * @param {?string} [opts.extend.registry="events"] Registry property
    * @param {?string} [opts.extend.emit="emit"] `emit()` proxy method
    * @param {?string} [opts.extend.listen="on"] `listen()` proxy method
    * @param {?string} [opts.extend.once=null]   `once()` proxy method
    * @param {?string} [opts.extend.remove=null] `remove()` proxy method
    * 
+   * The `remove` wrapper method added to Listener instances is slightly
+   * different than the one added to other objects, as if you call it
+   * with no arguments, it will pass the Listener itself as the argument.
+   * 
    * @param {boolean} [opts.multiMatch=false]
    * If a registered listener has multiple event names, and a call
    * to `emit()` also has multiple event names, the value of this
@@ -159,7 +203,7 @@ class LumEventRegistry
    */
   constructor(targets, opts={})
   {
-    let defExt; // Default opts.extend value
+    let defExt; // Default opts.extend.targets value
     if (typeof targets === F)
     { // A dynamic getter method
       this.funTargets = true;
@@ -181,47 +225,54 @@ class LumEventRegistry
       defExt = true;
     }
 
-    this.options = Object.assign({extend: defExt}, DEF_OPTIONS, opts);
+    // Build composite extend rules
+    const extend = cp(
+      {targets: defExt}, 
+      INT_EXTENDS, 
+      DEF_EXTENDS, 
+      opts.extend);
+
+    // Now compile the final options
+    this.options = cp({}, DEF_OPTIONS, opts, {extend});
 
     this.allListeners = new Set();
     this.listenersFor = new Map();
 
-    this.extend(targets);
+    this.setupTargets(targets);
   } // constructor()
 
   /**
-   * Add extension methods to target objects;
-   * used by `constructor` and `register()`,
-   * not meant to be called from outside code.
+   * Set up target objects
+   * 
+   * Always sets the necessary metadata on each target.
+   * May also extend the targets with wrapper properties and methods
+   * depending on the `options.extend` values set.
+   * 
+   * Not meant to be called from outside code.
    * @private
    * @param  {Iterable} targets - Targets to extend
    * @returns {module:@lumjs/core/events.Registry} `this`
    */
-  extend(targets)
+  setupTargets(targets)
   {
     const opts = this.options;
     const extOpts = opts.extend;
-
-    let intNames = null, extNames = null;
-
-    if (extOpts)
-    {
-      intNames = Object.keys(DEF_EXTENDS);
-      extNames = Object.assign({}, DEF_EXTENDS, extOpts);
-    }
+    const intNames = extOpts.targets ? Object.keys(DEF_EXTENDS) : null;
 
     for (const target of targets)
     {
       const tps = {}, tpm = getMetadata(target, true);
+      if (tpm.r.has(this)) continue; // Already set up with this registry.
       tpm.r.set(this, tps);
 
-      if (extOpts)
+      if (extOpts.targets)
       {
         for (const iname of intNames)
         {
-          if (typeof extNames[iname] === S && extNames[iname].trim() !== '')
+          if ((typeof extOpts[iname] === S && extOpts[iname].trim() !== '')
+            || typeof extOpts[iname] === SY)
           {
-            const ename = extNames[iname];
+            const ename = extOpts[iname];
             const value = iname === 'registry' 
               ? this // The registry instance itself
               : (...args) => this[iname](...args) // A proxy method
@@ -230,6 +281,7 @@ class LumEventRegistry
               def(target, ename, {value});
               tps[ename] = iname;
               tpm.p[ename] = this;
+              tpm.x[iname].push([this, ename]);
             }
             else
             {
@@ -240,34 +292,79 @@ class LumEventRegistry
         }
       }
     }
+
+    return this;
+  }
+
+  /**
+   * Add extension methods to internal objects;
+   * currently supports Listener instances and result/status objects.
+   * Not meant to be called from outside code.
+   * @private
+   * @param {object} obj - Internal object to extend
+   * @returns {module:@lumjs/core/events.Registry} `this`
+   */
+  extendInternal(obj)
+  {
+    const opts = this.options;
+    const extOpts = opts.extend;
+    const intNames = Object.keys(DEF_EXTENDS);
+    const isLs = (obj instanceof Listener);
+    const reserved = isLs ? Listener.classProps : RES_PROPS;
+
+    for (const iname of intNames)
+    {
+      if (iname === 'registry') continue; // skip the registry property
+      if ((typeof extOpts[iname] === S && extOpts[iname].trim() !== '')
+        || typeof extOpts[iname] === SY)
+      {
+        const ename = extOpts[iname];
+        if (reserved.includes(ename))
+        { // Skip reserved names
+          console.warn("reserved property", {ename, obj, registry: this});
+          continue;
+        }
+
+        const value = (isLs && iname === 'remove') 
+          ? (what=obj) => this.remove(what)   // special remove wrapper
+          : (...args) => this[iname](...args) // regular wrapper method
+        if (opts.overwrite || obj[ename] === undefined)
+        {
+          def(obj, ename, {value});
+        }
+      }  
+    }
+
     return this;
   }
 
   /**
    * Build a new Listener instance; used by `listen()` method.
    * 
-   * @param  {(string|object)} eventNames 
+   * @param  {(string|symbol|object)} eventTypes 
    * What this does depends on the type, and the number of arguments passed.
    * 
    * If this is an `object` **AND** is *the only argument* passed,
-   * it will be used as the `spec`, and the `spec.eventNames`
+   * it will be used as the `spec`, and the `spec.eventTypes`
    * and `spec.listener` properties will become mandatory.
    * 
-   * If it's a string *OR* there is more than one argument, this 
-   * will be used as the `spec.eventNames` property.
+   * If it's NOT an object *OR* there is more than one argument, this
+   * will be used as the `spec.eventTypes` property.
    * 
    * @param {module:@lumjs/core/events~Handler} [handler] 
    * Used as the `spec.handler` property if specified.
    * 
-   * This is mandatory if `eventNames` argument is a `string`!
+   * This is mandatory if `eventTypes` argument is a string or Symbol!
    * 
    * @param {object} [spec] The listener specification rules
    * 
-   * @param {(string|Iterable)} [spec.eventNames] Event names to listen for
+   * @param {(string|symbol|Iterable)} [spec.eventTypes] Event type(s)
    * 
    * See {@link module:@lumjs/core/events.Registry#getEventNames} for details.
    * 
-   * @param {module:@lumjs/core/events~Handler} [spec.handler] Event handler.
+   * @param {(string|symbol|Iterable)} [spec.eventNames] Alias of `eventTypes`
+   * 
+   * @param {module:@lumjs/core/events~Handler} [spec.handler] Event handler
    * 
    * @param {(function|object)} [spec.listener] An alias for `handler`
    * 
@@ -279,8 +376,8 @@ class LumEventRegistry
    * 
    * If `spec.options` is used, the properties in it take precedence over
    * those directly in the `spec` object. Note that you cannot use the
-   * names `listener`, `handler` or `eventNames` as option properties,
-   * and if found, they will be removed.
+   * names `listener`, `handler`, `eventTypes`, or `eventNames` as option 
+   * properties, and if found, they will be removed.
    * 
    * You may also override the `setupEvent` and `setupListener` registry
    * options here if needed.
@@ -305,16 +402,21 @@ class LumEventRegistry
     }
     else if (args.length === 1 && isObj(args[0]))
     { // listen(spec)
-      spec = Object.assign({}, args[0]);
+      spec = cp({}, args[0]);
     }
     else
-    { // listen(eventNames, listener, [spec])
-      spec = Object.assign({}, args[2]);
-      spec.eventNames = args[0];
+    { // listen(eventTypes, listener, [spec])
+      spec = cp({}, args[2]);
+      spec.eventTypes = args[0];
       spec.handler    = args[1];
     }
 
-    return new Listener(this, spec);
+    const lsnr = new Listener(this, spec);
+    if (this.options.extend.listeners)
+    {
+      this.extendInternal(lsnr);
+    }
+    return lsnr;
   }
 
   /**
@@ -373,7 +475,7 @@ class LumEventRegistry
 
     this.allListeners.add(listener);
 
-    for (const ename of listener.eventNames)
+    for (const ename of listener.eventTypes)
     {
       let lset;
       if (this.listenersFor.has(ename))
@@ -431,7 +533,7 @@ class LumEventRegistry
         const eventListeners = this.listenersFor.get(name);
         for (const lsnr of eventListeners)
         {
-          lsnr.eventNames.delete(name);
+          lsnr.eventTypes.delete(name);
           if (!lsnr.hasEvents)
           { // The last event name was removed.
             this.removeListeners(lsnr);
@@ -456,7 +558,7 @@ class LumEventRegistry
       { // First remove it from allListeners
         this.allListeners.delete(listener);
   
-        for (const ename of listener.eventNames)
+        for (const ename of listener.eventTypes)
         {
           if (this.listenersFor.has(ename))
           {
@@ -477,6 +579,7 @@ class LumEventRegistry
    * - If this is the `wildcard` string, then this will call `removeAll()`.
    * - If this is any other `string` it will be split using `splitNames()`,
    *   and the resulting strings passed as arguments to `removeEvents()`.
+   * - If this is a `Symbol` it will be passed to `removeEvents()`.
    * - If this is a `Listener` instance, its passed to `removeListeners()`.
    * 
    * @returns {module:@lumjs/core/events.Registry} `this`
@@ -493,6 +596,10 @@ class LumEventRegistry
       const events = this.splitNames(what);
       return this.removeEvents(...events);
     }
+    else if (typeof what === SY)
+    {
+      return this.removeEvents(what);
+    }
     else if (what instanceof Listener)
     {
       return this.removeListeners(what);
@@ -507,9 +614,8 @@ class LumEventRegistry
   /**
    * Emit (trigger) one or more events.
    * 
-   * @param {(string|string[])} eventNames - Events to emit.
-   * 
-   * If this is a single `string` it will be split via `splitNames()`.
+   * @param {(string|symbol|Array)} eventTypes - Events to emit;
+   * see {@link module:@lumjs/core/events#getEventTypes} for details.
    * 
    * @param  {object} [data] A data object (highly recommended);
    * will be assigned to `event.data` if specified.
@@ -522,20 +628,32 @@ class LumEventRegistry
    * 
    * @returns {module:@lumjs/core/events~Status}
    */
-  emit(eventNames, ...args)
+  emit(eventTypes, ...args)
   {
+    const extOpts = this.options.extend;
     const sti =
     {
-      eventNames: this.getEventNames(eventNames),
+      eventTypes: this.getEventTypes(eventTypes),
       multiMatch: this.options.multiMatch,
       onceRemoved: new Set(),
       stopEmitting: false,
       emitted: [],
+      registry: this,
+    }
+    sti.eventNames = sti.eventTypes;
+
+    if (extOpts.results)
+    {
+      this.extendInternal(sti);
     }
 
     { // Get the targets.
       const tgs = this.getTargets(sti);
       sti.targets = (tgs instanceof Set) ? tgs : new Set(tgs);
+      if (this.funTargets && extOpts.onDemand)
+      {
+        this.setupTargets(sti.targets);
+      }
     }
 
     const wilds = this.listenersFor.get(this.options.wildcard);
@@ -543,7 +661,7 @@ class LumEventRegistry
     emitting: for (const tg of sti.targets)
     {
       const called = sti.targetListeners = new Set();
-      for (const ename of sti.eventNames)
+      for (const ename of sti.eventTypes)
       {
         if (!this.listenersFor.has(ename)) continue;
 
@@ -579,8 +697,6 @@ class LumEventRegistry
     return sti;
   }
 
-
-
   /**
    * Register additional target objects
    * @param  {...object} addTargets - Target objects to register
@@ -617,7 +733,7 @@ class LumEventRegistry
       }
     }
 
-    this.extend(addTargets);
+    this.setupTargets(addTargets);
     return this;
   }
 
@@ -693,32 +809,37 @@ class LumEventRegistry
   }
 
   /**
-   * Get a Set of event names from various kinds of values
-   * @param {(string|Iterable)} names - Event names source
+   * Get a Set of event types/names from various kinds of values
+   * @param {(string|symbol|Iterable)} types - Event types source
    * 
    * If this is a string, it'll be passed to `splitNames()`.
-   * If it's any kind of `Iterable`, it'll be converted to a `Set`.
+   * If it's a Symbol, it'll be wrapped in a Set.
+   * If it's any kind of Iterable value, it'll be converted to a Set.
    * 
    * @returns {Set}
    * @throws {TypeError} If `names` is not a valid value
    */
-  getEventNames(names)
+  getEventTypes(types)
   {
-    if (typeof names === S)
+    if (typeof types === S)
+    {
+      return this.splitNames(types);
+    }
+    else if (typeof types === SY)
     {
-      return this.splitNames(names);
+      return new Set([types]);
     }
-    else if (names instanceof Set)
+    else if (types instanceof Set)
     {
-      return names;
+      return types;
     }
-    else if (isIterable(names))
+    else if (isIterable(types))
     {
-      return new Set(names);
+      return new Set(types);
     }
     else
     {
-      console.error({names, registry: this});
+      console.error({names: types, registry: this});
       throw new TypeError("Invalid event names");
     }
   }
@@ -735,9 +856,20 @@ class LumEventRegistry
 
 }
 
-Object.assign(LumEventRegistry, 
+const LERP = LumEventRegistry.prototype;
+def(LERP, 'getEventNames', LERP.getEventTypes);
+
+cp(LumEventRegistry, 
 { 
   isRegistered, getMetadata, targetsAre,
 });
 
 module.exports = LumEventRegistry;
+
+/**
+ * An alias to `getEventTypes`
+ * @function module:@lumjs/core/events.Registry#getEventNames
+ * @param {(string|symbol|Iterable)} names - Event names source
+ * @returns {Set}
+ * @see module:@lumjs/core/events.Registry#getEventTypes
+ */

package/lib/obj/clone.js

@@ -296,6 +296,9 @@ exports.addClone = addClone;
   *
   * If not, if the object has a `clone()` method it will be used.
   * Otherwise use our `clone()` function.
+  * 
+  * **NOTE**: A newer replacement for this function exists, see
+  * {@link module:@lumjs/core/obj.unlocked} for details.
   *
   * @param {object} obj - The object to clone if needed.
   * @param {object} [opts] - Options to pass to `clone()` method.

package/lib/obj/index.js

@@ -14,6 +14,7 @@ const {lock,addLock} = require('./lock');
 const {mergeNested,syncNested} = require('./merge');
 const ns = require('./ns');
 const cp = require('./cp');
+const unlocked = require('./unlocked');
 
 const 
 {
@@ -27,5 +28,5 @@ module.exports =
   mergeNested, syncNested, copyProps, copyAll, ns,
   getObjectPath, setObjectPath, getNamespace, setNamespace,
   getProperty, duplicateAll, duplicateOne, getMethods, signatureOf,
-  MethodFilter, apply, flip, flipKeyVal, flipMap,
+  MethodFilter, apply, flip, flipKeyVal, flipMap, unlocked,
 }

package/lib/obj/unlocked.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const {F,S,isObj,needObj} = require('../types');
+
+const CLONE = 'clone';
+const clone = obj => Object.assign({}, obj);
+
+/**
+ * Get an unlocked object
+ * 
+ * @param {object} obj - The target object;
+ * 
+ * If the object is extensible it will be returned _as is_.
+ * 
+ * If the object is frozen, sealed, or otherwise non-extensible,
+ * a cloning function will be used to make an unlocked copy.
+ * 
+ * @param {(object|function|string)} [opts] Options to customize the behaviour
+ * 
+ * - If this is a `function` it will be used as the `opts.fn` value.
+ * - If this is a `string` it will be used as the `opts.method` value.
+ *
+ * @param {string} [opts.method='clone'] Object method to use
+ * 
+ * Set to an empty string `""` to skip checking for an object method.
+ * 
+ * If the method exists on the target object, it will be called to
+ * perform the cloning procedure, otherwise `opts.fn` will be used.
+ * 
+ * @param {Array} [opts.args] Arguments for `opts.method` method
+ * 
+ * If not specified, the default value is: `[opts]`
+ * 
+ * @param {function} [opts.fn] A function to perform the clone operation
+ *
+ * Must take only a single parameter, which is the object to clone.
+ * Must return an extensible clone of the object.
+ * 
+ * If for whatever reason you need the `opts` in the function,
+ * then use a unbound function, and `opts` will be available
+ * as `this` in the function body. Arrow functions (closures) are 
+ * always considered bound and cannot have a `this` value assigned.
+ * 
+ * The default value is a closure: `obj => Object.assign({}, obj)`;
+ * 
+ * @return {object}
+ *
+ * @alias module:@lumjs/core/obj.unlocked
+ */
+function unlocked(obj, opts={})
+{
+  needObj(obj, true, "invalid obj value");
+  
+  if (Object.isExtensible(obj))
+  { // We're done here.
+    return obj;
+  }
+
+  if (typeof opts === F)
+  {
+    opts = {fn: opts}
+  }
+  else if (typeof opts === S)
+  {
+    opts = {method: opts}
+  }
+  else if (!isObj(opts))
+  {
+    console.error({obj, opts});
+    throw new TypeError("invalid opts value");
+  }
+
+  const fn   = (typeof opts.fn     === F) ? opts.fn            : clone;
+  const meth = (typeof opts.method === S) ? opts.method.trim() : CLONE;
+  const args = (Array.isArray(opts.args)) ? opts.args          : [opts];
+
+  if (meth && typeof obj[meth] === F)
+  { // Use a clone method
+    return obj[meth](...args);
+  }
+  else
+  { // Use a clone function
+    return fn.call(opts, obj);
+  }
+}
+
+module.exports = unlocked;

package/lib/types/isa.js

@@ -461,7 +461,7 @@ class OfTest
     }
     else if (isObj(rules))
     {
-      this.valid = valid(rules.valid);
+      this.valid = valid(rules.value);
     }
     else
     { // That's gonna be a no from me.

package/package.json

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