@lumjs/core 1.37.1 → 1.37.2

package/lib/types/def.js

@@ -1,7 +1,7 @@
-// Thanks to CJS `require()` rules, recursive dependencies are possible.
-const unbound = require('./root').unbound;
-const {F, B} = require('./js');
-const {isObj, isNil, isProperty, doesDescriptor} = require('./basics');
+"use strict";
+
+const {F,B} = require('./js');
+const {isObj,isNil,isProperty,doesDescriptor} = require('./basics');
 const clone = (...args) => Object.assign({}, ...args);
 
 /**
@@ -95,9 +95,10 @@ const clone = (...args) => Object.assign({}, ...args);
  */
 function def(obj, name, value, opts)
 {
-  const isBound // Is this a 'bound' def function?
-    = !unbound(this, true, true) 
-    && typeof this.bound === F;
+  const isBound
+    = isObj(this)
+    && typeof this.bound === F
+    && this.bound.$this === this;
 
   if (isNil(name) || typeof name === B)
   { // Binding of Isaac?

package/lib/types/root.js

@@ -1,5 +1,5 @@
 const {U} = require('./js');
-const {isNil,isArray} = require('./basics');
+const {isNil,isObj,isArray} = require('./basics');
 
 // «private»
 function no_root()
@@ -11,40 +11,81 @@ function no_root()
  * The global root object. Usually `globalThis` these days.
  * @alias module:@lumjs/core/types.root
  */
-const root = typeof globalThis !== U ? globalThis
-  : typeof global !== U ? global 
-  : typeof self !== U ? self 
-  : typeof window !== U ? window 
+const root 
+  = typeof globalThis !== U ? globalThis
+  : typeof global     !== U ? global 
+  : typeof self       !== U ? self 
+  : typeof window     !== U ? window 
   : no_root(); // Unlike the old way, we'll die if the environment is undetermined.
 
 exports.root = root;
 
-// A list of objects to be considered unbound globally.
+// A Set of objects to be considered unbound globally.
 const unboundObjects = require('./unbound/objects');
 
+// Default options for unbound()
+const UBDO =
+{
+  nil:   true,
+  root:  true,
+}
+
 /**
  * Pass `this` here to see if it is bound to an object.
  * 
- * Always considers `null` and `undefined` as unbound.
+ * @param {*} whatIsThis - The `this` from any context
+ * 
+ * @param {(boolean|object)} [opts] Options for advanced behaviours.
+ * 
+ * If this is boolean then it'll be used as `opts.root`;
+ * If it is an `Array` or `Set` it will be used as `opts.list`;
+ * Use just a plain object literal for specifying named options.
+ * 
+ * TODO: as of v2.0 this will no longer accept a boolean value
+ * as a shortcut to `opts.root`. That must be explicitly set.
+ * 
+ * @param {boolean} [opts.root=true] The global root is unbound?
+ * @param {boolean} [opts.nil=true] `null` and `undefined` are unbound?
+ * @param {(Array|Set)} [opts.list] A list of additional values that
+ * for the purposes of this test will be considered unbound.
+ * 
+ * @param {(Array|Set|boolean)} [list] A positional version of `opts.list`;
+ * ONLY used when the `opts` argument is boolean.
+ * 
+ * TODO: remove this argument as of v2.0
  * 
- * @param {*} whatIsThis - The `this` from any context.
- * @param {boolean} [rootIsUnbound=true] The global root is unbound. 
- * @param {(boolean|Array)} [areUnbound=false] A list of unbound objects.
- *   If the is `true` we use an global list that can register special
- *   internal objects. Otherwise an `Array` of unbound objects may be used.
  * @returns {boolean}
  * @alias module:@lumjs/core/types.unbound
  */
-function unbound(whatIsThis, rootIsUnbound=true, areUnbound=false)
+function unbound(whatIsThis, opts=true, list)
 {
-  if (areUnbound === true)
-  { // If areUnbound is true, we use the unboundObjects 
-    areUnbound = unboundObjects;
+  if (isObj(opts))
+  { // Merge in defaults
+    if (opts instanceof Set || isArray(opts))
+    { // A shortcut to the `list` property
+      list = opts;
+      opts = Object.assign({}, UBDO);
+    }
+    else
+    { // Regular options were specified.
+      opts = Object.assign({}, UBDO, {list}, opts);
+      list = opts.list;
+    }
+  }
+  else
+  { // Assume old positional arguments are being used
+    opts = Object.assign({}, UBDO, {root: opts});
+  }
+
+  if (list === true)
+  { // Internal special unbound values
+    list = unboundObjects;
   }
 
-  if (isNil(whatIsThis)) return true;
-  if (rootIsUnbound && whatIsThis === root) return true;
-  if (isArray(areUnbound) && areUnbound.includes(whatIsThis)) return true;
+  if (opts.nil && isNil(whatIsThis)) return true;
+  if (opts.root && whatIsThis === root) return true;
+  if (list instanceof Set && list.has(whatIsThis)) return true;
+  if (isArray(list) && list.includes(whatIsThis)) return true;
 
   // Nothing considered unbound.
   return false;

package/lib/types/unbound/extend.js

@@ -2,45 +2,41 @@
 
 const def = require('../def');
 const {needObj} = require('../needs');
-const removeFromArray = require('../../arrays/list').removeItems;
 const unboundObjects = require('./objects');
 
-// Adds a couple magic methods to the `unbound` function.
+// Adds a couple proxy methods to the `unbound` function.
 module.exports = function(unbound)
 {
   /**
    * Add an item to the unbound global objects list.
    * 
-   * @function
-   * @param {(object|function)} obj - The object to be considered unbound.
-   * @returns {boolean} Will be `false` if `obj` is already unbound.
-   * @throws {TypeError} If `obj` was neither an `object` nor a `function`.
-   * @name module:@lumjs/core/types.unbound.add
+   * @deprecated the global list is going away in 2.0
+   * @function module:@lumjs/core/types.unbound.add
+   * @param {(object|function)} obj - Value to be added
+   * @returns {boolean} always true as of v1.37.2
+   * @throws {TypeError} If `obj` was not a valid value
    */
   def(unbound, 'add', function (obj)
   {
     needObj(obj, true);
-    if (unbound(obj, true, true))
-    { // Item is already unbound.
-      return false;
-    }
-    // Add to list and we're done.
-    unboundObjects.push(obj);
+    if (unboundObjects.has(obj)) return false;
+    unboundObjects.add(obj);
     return true;
   });
 
   /**
    * Remove an item from the unbound global objects list.
    * 
-   * @function
-   * @param {(object|function)} obj - The object to be removed.
-   * @returns {boolean} Will be `false` if the item was not in the list.
-   * @throws {TypeError} If `obj` was neither an `object` nor a `function`.
-   * @name module:@lumjs/core/types.unbound.remove
+   * @deprecated the global list is going away in 2.0
+   * @function module:@lumjs/core/types.unbound.remove
+   * @param {(object|function)} obj - value to be removed
+   * @returns {boolean} always true as of v1.37.2
+   * @throws {TypeError} If `obj` was not a valid value
    */
   def(unbound, 'remove', function(obj)
   {
     needObj(obj, true);
-    return (removeFromArray(unboundObjects, obj) > 0);
+    unboundObjects.delete(obj);
+    return true;
   });
 }

package/lib/types/unbound/objects.js

@@ -1,2 +1,3 @@
 // Private storage, not exported outside the package.
-module.exports = [];
+// TODO: remove this in 2.0
+module.exports = new Set();

package/package.json

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