@lumjs/core 1.38.0 → 1.38.1

package/lib/obj/assignd.js

@@ -1,12 +1,14 @@
 "use strict";
 
-const def = require('../types/def');
+const {dfa} = require('./df');
+const {isObj,isNil} = require('../types');
 
 /**
  * Copy properties into a target object.
  * 
- * Like Object.assign(), but it uses getOwnPropertyDescriptors()
- * to get the properties to copy and type.def() to assign them.
+ * Like Object.assign(), but it uses getOwnPropertyDescriptors() to get
+ * the properties to copy, and [dfa()]{@link module:@lumjs/core/obj.dfa} 
+ * to assign them.
  * 
  * Basically a super simple, non-recursive replacement for my copyProps()
  * and cp() functions that were overly complex and tried to do way too much.
@@ -21,8 +23,15 @@ function assignd (target, ...sources)
 {
   for (const src of sources)
   {
-    const descs = Object.getOwnPropertyDescriptors(src);
-    def(target, descs);
+    if (isObj(src))
+    {
+      const descs = Object.getOwnPropertyDescriptors(src);
+      dfa(target, descs);
+    }
+    else if (!isNil(src))
+    {
+      console.error("Invalid assignd source", {src, sources, target});
+    }
   }
   return target;
 }

package/lib/obj/df.js

@@ -3,7 +3,6 @@
 const {doesDescriptor,needObj,needType,lazy,B,TYPES} = require('../types');
 
 const DEF_DESC = {configurable: true}
-const DEF_OPTS = {autoDesc: true}
 
 const cp = Object.assign;
 const clone = (...args) => cp({}, ...args);
@@ -66,29 +65,38 @@ function descriptor(desc, opts)
  * @param {(string|symbol)} name  - Property identifier
  * @param {*} value - Value to assign
  * 
- * If `opts.autoDesc` is `true` and this is an `object` that passes the
- * {@link module:@lumjs/core/types.doesDescriptor} test, it will be
- * used as the template descriptor to assign the property.
- * 
- * In any other case, this will be used as the `value` property of
- * a generated descriptor to be assigned.
+ * See `opts.useDesc` for how this value is handled in regards to
+ * whether it is treated as a property descriptor or a plain data value.
  * 
  * @param {object} [opts] Options
  * 
+ * See {@link module:@lumjs/core/obj~descriptor} for options that
+ * are used as descriptor defaults when assigning the property.
+ * 
+ * @param {?boolean} [opts.useDesc=null] Treat `value` is a descriptor?
+ * 
+ * If this is set to `true` then the `value` will be assumed to be a
+ * valid descriptor object; no tests will be done to confirm, so be sure!
+ * 
+ * If this is set to `false` then a descriptor of `{value}` will be created.
+ * Again, no tests will be done, so this is a way to assign properties that
+ * have `value`, `get`, or `set` properties in them.
+ * 
+ * If this is `null` (the default), then the `value` will be tested with
+ * [doesDescriptor()]{@link module:@lumjs/core/types.doesDescriptor}, 
+ * and that will determine if the value is treated as a descriptor or not.
+ * 
  * @returns {object} `obj`
  * @alias module:@lumjs/core/obj.df
  */
-function df(obj, name, value, opts)
+function df(obj, name, value, opts={})
 {
   const log = {obj,name,value,opts};
   needObj(obj, {log, fun: true});
   needType(TYPES.PROP, name, {log});
 
-  opts = clone(DEF_OPTS, opts);
-
-  const desc = descriptor(((opts.autoDesc && doesDescriptor(value)) 
-    ? value 
-    : {value}), opts);
+  const useDesc = opts.useDesc ?? doesDescriptor(value);
+  const desc = descriptor((useDesc ? value : {value}), opts);
   
   return Object.defineProperty(obj, name, desc);
 }
@@ -121,11 +129,35 @@ function dfa(obj, values, opts)
   return obj;
 }
 
+df(df, 'all', dfa);
+
+/**
+ * A wrapper around df() that defines an *accessor property* with 
+ * BOTH a getter and a setter specified explicitly.
+ * 
+ * @param {(object|function)} obj - Target to define property in
+ * @param {(string|symbol)} name - Property identifier
+ * @param {function} getter - Getter function
+ * @param {function} setter - Setter function
+ * @param {object} [opts] Options
+ * 
+ * The actual options passed to df() will be a clone, with the
+ * `useDesc` option explicitly forced to `true`.
+ * 
+ */
+function dfb(obj, name, getter, setter, opts)
+{
+  const log = {obj,name,getter,setter,opts};
+  opts = clone(opts, {useDesc: true});
+  return df(obj, name, {get: getter, set: setter}, opts);
+}
+
+df(df, 'both', dfb);
+
 /**
  * Build magic closures to define properties using a chained syntax.
  * 
- * This actually creates three closures, one around df(), another
- * that wraps dfa(), and one that wraps the lazy() function.
+ * This actually creates closures for df(), dfa(), dfb(), and lazy().
  * You can switch between them using magic properties.
  * 
  * The closures when called will pass their arguments to the function
@@ -136,13 +168,15 @@ function dfa(obj, values, opts)
  * 
  * - `one(name, value)` → A closure that wraps df()
  * - `all(values)`      → A closure that wraps dfa()
+ * - `both(name, g, s)` → A closure that wraps dfb()
+ * - `lazy(name, func)` → A closure that wraps lazy()
  * - `update(opts)`     → Update the options used by the closures.
  *   Uses Object.assign() to copy options from the specied object
  *   to the internal options object from the original dfc() call.
  *   This is a method call, NOT a closure function.
  * - `opts`             → The actual options object used by the closures.
  * - `obj`              → The target object used by the closures.
- * - `next(obj)`        → A wrapper method that will call dfc().
+ * - `for(obj)`         → A wrapper method that will call dfc().
  *   When using this method, a *new set of closures* will be created,
  *   with the current options, but a new target object.
  *   If you use this in a chained statement, any calls after this
@@ -170,6 +204,12 @@ function dfc(obj, opts={})
     return fnAll;
   }
 
+  const fnBoth = function (name, getter, setter)
+  {
+    dfb(obj, name, getter, setter, opts);
+    return fnBoth;
+  }
+
   const fnLazy = function (name, initfunc)
   {
     lazy(obj, name, initfunc, opts);
@@ -182,6 +222,8 @@ function dfc(obj, opts={})
     opts: {value: opts},
     one:  {value: fnOne},
     all:  {value: fnAll},
+    both: {value: fnBoth},
+    lazy: {value: fnLazy},
     update: 
     {
       value()
@@ -190,7 +232,7 @@ function dfc(obj, opts={})
         return this;
       },
     },
-    next:
+    for:
     {
       value(newobj)
       {
@@ -199,15 +241,20 @@ function dfc(obj, opts={})
     },
   }
 
-  dps(fnOne, ctx);
-  dps(fnAll, ctx);
+  // Quick alias
+  ctx.next = ctx.for;
+
+  dps(fnOne,  ctx);
+  dps(fnAll,  ctx);
+  dps(fnBoth, ctx);
+  dps(fnLazy, ctx);
 
   return fnOne;
 }
 
-
+df(df, 'for', dfc);
 
 module.exports = 
 {
-  df, dfa, dfc, lazy,
+  df, dfa, dfb, dfc, lazy,
 }

package/lib/obj/index.js

@@ -8,7 +8,7 @@ const assignd = require('./assignd');
 const {copyAll,duplicateOne,duplicateAll} = require('./copyall');
 const copyProps = require('./copyprops');
 const {CLONE,clone,addClone,cloneIfLocked} = require('./clone');
-const {df,dfa,dfc,lazy} = require('./df');
+const {df,dfa,dfb,dfc,lazy} = require('./df');
 const {flip, flipKeyVal, flipMap} = require('./flip');
 const {getMethods,signatureOf,MethodFilter} = require('./getmethods');
 const getProperty = require('./getproperty');
@@ -27,7 +27,7 @@ const
 module.exports =
 {
   assignd, cp, CLONE, clone, addClone, cloneIfLocked, lock, addLock,
-  df, dfa, dfc, lazy,
+  df, dfa, dfb, dfc, lazy,
   mergeNested, syncNested, copyProps, copyAll, ns,
   getObjectPath, setObjectPath, getNamespace, setNamespace,
   getProperty, duplicateAll, duplicateOne, getMethods, signatureOf,

package/lib/types/def.js

@@ -7,13 +7,13 @@ const clone = (...args) => Object.assign({}, ...args);
 /**
  * A wrapper around `Object.defineProperty()` with added flair!
  * 
- * FUTURE DEPRECATION: When I release @lumjs/core 2.0, this function
- * will be deprecated! It's gotten almost as convoluted as the old
- * prop() method it replaced from my original Nano.js libraries.
+ * **FUTURE DEPRECATION**: this function will be deprecated in v1.19.0!
+ * It's gotten almost as convoluted as the old prop() method it replaced 
+ * from my original Nano.js libraries.
+ * 
  * I have written new `obj.{df,dfa,dfc}` functions that will replace this
  * function going forward. The related `types.lazy()` function will also
- * be refactored to use the new functions, and moved to the `obj` module,
- * although for the `2.x` lifetime an alias will remain in the `type` module.
+ * be refactored to use the new functions, and moved to the `obj` module.
  * 
  * @param {(object|function)} obj - The object to add a property to.
  * 

package/lib/types/lazy.js

@@ -101,11 +101,11 @@ const {doesDescriptor} = require('./basics');
  * This is an extension of the [def()]{@link module:@lumjs/core/types.def} 
  * method, and indeed an alias called `def.lazy()` is also available.
  * 
- * IMPORTANT: In version 2.x, this will be refactored to use the new
+ * IMPORTANT: In a later v1.18.x release, this will be refactored to use the
  * [obj.df()]{@link module:@lumjs/core/obj.df} function that will replace
  * def(). There's already an alias called `df.lazy()` available now.
- * This will also be moved to the `obj` module, with an alias left
- * in the `types` module for the duration of the 2.x lifecycle.
+ * This will also be moved to the `obj` module, with a deprecated alias left
+ * in the `types` module for the duration of the 1.x lifecycle.
  *
  * @param {(object|function)} target - The object to add the property to.
  * 

package/package.json

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