@lumjs/core 1.38.8 → 1.39.0

package/lib/obj/df.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const {B,F,S,doesDescriptor} = require('../types/basics');
+const {doesDescriptor} = require('../types/basics');
 const {needObj,needType} = require('../types/needs');
 const TYPES = require('../types/typelist');
 
@@ -67,8 +67,8 @@ function descriptor(desc, opts)
 
   for (const dp of dps)
   {
-    if (typeof opts[dp] === B 
-      && (force.includes(dp) || typeof desc[dp] !== B))
+    if (typeof opts[dp] === 'boolean' 
+      && (force.includes(dp) || typeof desc[dp] !== 'boolean'))
     {
       desc[dp] = opts[dp];
     }
@@ -122,11 +122,11 @@ function df(obj, name, value, opts={})
   needObj(obj, {log, fun: true});
   needType(TYPES.PROP, name, {log});
 
-  if (typeof opts === B)
+  if (typeof opts === 'boolean')
   {
     opts = {useDesc: opts};
   }
-  else if (typeof opts === F && typeof value === F)
+  else if (typeof opts === 'function' && typeof value === 'function')
   {
     value = {get: value, set: opts};
     opts = {useDesc: true};
@@ -220,7 +220,7 @@ function dfor(obj, opts={}, prev=null)
 {
   const fnOne = function (name, value, setter)
   {
-    if (typeof setter === F && typeof value === F)
+    if (typeof setter === 'function' && typeof value === 'function')
     {
       value = {get: value, set: setter}
       opts = clone(opts, {useDesc: true});
@@ -334,7 +334,7 @@ function lazy(target, name, initfunc, opts={})
   let log = {target, name, initfunc, opts};
   needObj(target, {log, fun: true});
   needType(TYPES.PROP, name, {log});
-  needType(F, initfunc, {log});
+  needType('function', initfunc, {log});
   needObj(opts, {log});
 
   // The `this` object for the functions.
@@ -367,7 +367,7 @@ function lazy(target, name, initfunc, opts={})
     }
     else if (doesDescriptor(value))
     { // A descriptor was returned, extract the real value.
-      if (typeof value.get === F)
+      if (typeof value.get === 'function')
       {
         return value.get();
       }
@@ -387,7 +387,7 @@ function lazy(target, name, initfunc, opts={})
     return defval(initfunc.call(ctx,ctx));
   }
 
-  if (typeof opts.set === F)
+  if (typeof opts.set === 'function')
   { // We want to assign a lazy setter as well.
     desc.set = function(value)
     {

package/lib/obj/getproperty.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const {isComplex,isObj} = require('../types');
+const {isComplex,isObj} = require('../types/basics');
 
 /**
  * Get a property descriptor.

package/lib/obj/index.js

@@ -5,20 +5,15 @@
 
 const {apply,ApplyInfo,ApplyOpts,ApplyWith} = require('./apply');
 const assignd = require('./assignd');
-const {copyAll,duplicateOne,duplicateAll} = require('./copyall');
-const copyProps = require('./copyprops');
-const {CLONE,clone,addClone,cloneIfLocked} = require('./clone');
 const {df,dfa,dfor,lazy} = require('./df');
 const {flip, flipKeyVal, flipMap} = require('./flip');
 const {getMethods,signatureOf,MethodFilter} = require('./getmethods');
 const getProperty = require('./getproperty');
 const getPrototypesOf = require('./getprotos');
-const {lock,addLock} = require('./lock');
-const {mergeNested,syncNested} = require('./merge');
 const ns = require('./ns');
-const cp = require('./cp');
 const unlocked = require('./unlocked');
 const ownCount = require('./owncount');
+const {getOwnKeys,isEmptyObject} = require('./keys');
 
 const 
 {
@@ -26,6 +21,11 @@ const
   getNamespace,setNamespace,nsFactory,
 } = ns;
 
+// Deprecated functions; TODO: remove in 2.0
+const NSO = '@lumjs/core/obj';
+const { deprecateAll } = require('../meta');
+const cp = deprecateAll(require('./cp'), NSO+'/cp');
+
 /**
  * Create a new object with a `null` prototype.
  * 
@@ -43,13 +43,17 @@ const
 const discrete = (props) => Object.create(null, props);
 
 // TODO: reorder the following alphabetically, for sanity sake...
-module.exports =
+exports = module.exports =
 {
-  assignd, cp, CLONE, clone, addClone, cloneIfLocked, lock, addLock,
-  df, dfa, dfor, lazy, discrete,
-  mergeNested, syncNested, copyProps, copyAll, ns, nsFactory,
-  getObjectPath, setObjectPath, delObjectPath, getNamespace, setNamespace,
-  getProperty, duplicateAll, duplicateOne, getMethods, signatureOf,
-  MethodFilter, flip, flipKeyVal, flipMap, unlocked, getPrototypesOf,
-  apply, ApplyInfo, ApplyOpts, ApplyWith, ownCount,
+  cp, // TODO: remove this line in 2.0
+
+  apply, ApplyInfo, ApplyOpts, ApplyWith, assignd, 
+  delObjectPath, df, dfa, dfor, discrete, flip, flipKeyVal, flipMap,
+  getMethods, getNamespace, getObjectPath, getOwnKeys, getProperty, 
+  getPrototypesOf, isEmptyObject, lazy, MethodFilter, ns, nsFactory,
+  ownCount, setNamespace, setObjectPath, signatureOf, unlocked,
 }
+
+// Deprecated collections; TODO: remove in 2.0
+deprecateAll(require('@lumjs/cp/fun'), NSO, exports);
+deprecateAll(require('@lumjs/cp/util'), NSO, exports);

package/lib/obj/keys.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Get both string and symbol keys from an object.
+ * @param {object} obj - Target object.
+ * @returns {(string|symbol)[]}
+ */
+const getOwnKeys = obj => [
+  ...(Object.getOwnPropertyNames(obj)),
+  ...(Object.getOwnPropertySymbols(obj)),
+];
+
+/**
+ * See if an object has its own properties.
+ */
+const isEmptyObject = obj => getOwnKeys(obj).length === 0;
+
+/**
+ * Get the name of a property key.
+ * @param {(string|symbol)} key - Property key.
+ * 
+ * If this is a string it will be returned as-is.
+ * If this is a symbol then how it is formatted depends
+ * on the options specified.
+ * 
+ * @param {object} [opts] Options for handling symbol property keys.
+ * @param {string} [opts.prefix] Prefix character; default: `[`.
+ * @param {string} [opts.suffix] Suffix character; default: `]`.
+ * @param {boolean} [opts.toStr=false] Use toString method?
+ * 
+ * If this is false (default), then the return value will be the
+ * `key.description` value with the prefix and suffix values applied.
+ * 
+ * If this is true then the prefix/suffix options are ignored,
+ * and `key.toString()` will be used as the return value.
+ * 
+ * @returns {string}
+ */
+function keyName(key, opts={}) {
+  if (typeof key === 'string') return key;
+  if (typeof key === 'symbol') {
+    if (opts.toStr) {
+      return key.toString();
+    }
+
+    let pf = opts.prefix ?? '[';
+    let sf = opts.suffix ?? ']';
+    return pf+key.description+sf;
+  }
+  
+  console.error({key, opts});
+  throw new TypeError('Invalid key');
+}
+
+module.exports = {getOwnKeys, isEmptyObject, keyName}

package/lib/obj/lock.js

@@ -1,68 +1,2 @@
-// Import *most* required bits here.
-const {B, isObj, def} = require('../types');
-
-/**
- * Lock an object using Object.freeze()
- *
- * @param {object} obj - The object we want to lock.
- * @param {boolean} [clonable=true] Pass to `addClone()` first?
- * @param {object} [cloneOpts=null] Options for `addClone()`.
- * @param {boolean} [useSeal=false] Use Object.seal() instead of freeze.
- *
- * If cloneOpts is `null` then we will use the following:
- *
- * ```{mode: CLONE.DEF, addClone: true, addLock: true}```
- *
- * @return {object} The locked object.
- * @alias module:@lumjs/core/obj.lock
- */
- function lock(obj, clonable=true, cloneOpts=null, useSeal=false)
- {
-   if (clonable)
-   { // Add the clone method before freezing.
-     if (!isObj(cloneOpts))
-     {
-       cloneOpts = {addClone: true, addLock: true};
-     }
-     addClone(obj, cloneOpts);
-   }
- 
-   // Now freeze (or seal) the object.
-   return (useSeal ? Object.seal(obj) : Object.freeze(obj));
- }
- 
- exports.lock = lock;
- 
- /**
-  * Add a lock() method to an object.
-  *
-  * Adds a wrapper version of `lock()` to the object as a method.
-  *
-  * @param {object} obj - The object we're adding `lock()` to.
-  * @param {object} [opts] - Options and defaults. 
-  *   In addition to options specific to this function, any options
-  *   supported by `addClone()` may be specified here as well.
-  * @param {object} [opts.lockDesc] Descriptor rules the `lock()` method.
-  * @param {boolean} [opts.addClone=true] Default for `clonable` parameter.
-  * @param {object} [opts.useSeal=false] Default for `useSeal` parameter.
-  * @returns {object} `obj`
-  * @alias module:@lumjs/core/obj.addLock
-  */
- function addLock(obj, opts)
- {
-   const defDesc = opts.lockDesc ?? {};
-   defDesc.value = function(obj, cloneable, cloneOpts, useSeal)
-   {
-     if (typeof cloneable !== B) clonable = opts.addClone ?? true;
-     if (!isObj(cloneOpts)) cloneOpts = opts; // Yup, just a raw copy.
-     if (typeof useSeal !== B) useSeal = opts.useSeal ?? false;
-     return lock(obj, cloneable, cloneOpts, useSeal);
-   }
-   return def(obj, 'lock', defDesc);
- }
- 
- exports.addLock = addLock;
-
- // Importing addLock at the end, just because.
- const {addClone} = require('./clone');
- 
+// Moved to `cp` package
+module.exports = require('@lumjs/cp/util');

package/lib/obj/unlocked.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const {F,S,isObj,needObj} = require('../types');
+const {isObj} = require('../types/basics');
 
 const CLONE = 'clone';
 const clone = obj => Object.assign({}, obj);
@@ -48,19 +48,17 @@ const clone = obj => Object.assign({}, obj);
  * @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)
+  if (typeof opts === 'function')
   {
     opts = {fn: opts}
   }
-  else if (typeof opts === S)
+  else if (typeof opts === 'string')
   {
     opts = {method: opts}
   }
@@ -70,11 +68,11 @@ function unlocked(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];
+  const fn = (typeof opts.fn === 'function') ? opts.fn : clone;
+  const meth = (typeof opts.method === 'string') ? opts.method.trim() : CLONE;
+  const args = (Array.isArray(opts.args)) ? opts.args : [opts];
 
-  if (meth && typeof obj[meth] === F)
+  if (meth && typeof obj[meth] === 'function')
   { // Use a clone method
     return obj[meth](...args);
   }