@lumjs/core 1.38.7 → 1.39.0

package/lib/arrays/index.js

@@ -1,21 +1,33 @@
 /**
  * Array helper libraries
  * 
+ * A lot of this sub-module has been moved into the @lumjs/lists package now.
+ * Aliases will continue to exist here until v2.x is released.
+ * 
  * @module @lumjs/core/arrays
  */
 
 const {lazy} = require('../obj/df');
-const {powerset, random} = require('./util');
+const {move, powerset, random, swap} = require('./util');
+
+// Utils; the only bits that will remain here in v2.
+module.exports = exports = {move, powerset, random, swap};
+
+// TODO: wrap the following via wrapDepr for the v1.39.x; remove in v2.0.
 
-// Utils.
-exports.powerset = powerset;
-exports.random   = random;
+const loadLists = () => require('@lumjs/lists');
 
-// List stuff.
-lazy(exports, 'List', () => require('./list'));
-lazy(exports, 'containsAny', () => exports.List.containsAny);
-lazy(exports, 'containsAll', () => exports.List.containsAll);
-lazy(exports, 'removeItems', () => exports.List.removeItems);
+const listsExports = [
+  'add',
+  'containsAll',
+  'containsAny',
+  'ConvertType',
+  'List',
+  'makeTyped',
+  'removeItems',
+  'TypedArray',
+];
 
-// Add functions and At class.
-lazy(exports, 'add', () => require('./add'));
+for (let le of listsExports) {
+  lazy(exports, le, () => loadLists()[le]);
+}

package/lib/arrays/util.js

@@ -1,3 +1,74 @@
+'use strict';
+
+const indOf = (arr, ind) => (ind < 0) ? (arr.length + ind) : ind;
+const indexes = (arr, inds) => {
+  for (let ind in inds) {
+    inds[ind] = indOf(arr, inds[ind]);
+  }
+  return inds;
+}
+
+/**
+ * Move an array item to a new position.
+ *
+ * Negative position values will be from the end of the Array.
+ *
+ * This will directly MODIFY the array!
+ *
+ * @param {Array} array - Array we are moving the item in.
+ * @param {number} a - Current position of item to move.
+ * @param {number} b - Position to move the item to.
+ * @param {boolean} [rp=false] Return the calculated positions?
+ * @returns {(Array|module:@lumjs/core/arrays~Position)}
+ * If `rp` is false this will return the original array.
+ */
+function move(array, a, b, rp=false) {
+  let pos = indexes(array, {a, b});
+  if (pos.a !== pos.b) {
+    array.splice(pos.b, 0, ...array.splice(pos.a, 1));
+  }
+  return rp ? pos : array;
+}
+
+/**
+ * Swap the positions of two items in an array.
+ *
+ * Negative position values will be from the end of the Array.
+ *
+ * This will directly MODIFY the array!
+ * 
+ * @param {Array} array - Array we are swapping items in.
+ * @param {number} a - Current position of item to move.
+ * @param {number} b - Position to move the item to.
+ * @param {?Array} [moves=null] Return calculated positions?
+ * 
+ * If this argument is supplied, the array will be populated with
+ * either one or two Position objects (from the move() function).
+ * 
+ * If `a` and `b` are directly next to each other there will be
+ * only one Position object as only one call to move() is required.
+ * 
+ * If they are more than 1 position away from each other there
+ * will be two Position objects, the first being from moving `a`
+ * to `b` and the second moving `b` to `a`.
+ * 
+ * @returns {(Array|module:@lumjs/core/arrays~Position[])}
+ * The return value will be `moves` if it was set, or `array` otherwise.
+ */
+function swap(array, a, b, moves=null) {
+  let rp = Array.isArray(moves);
+  let pos = move(array, a, b, true);
+  if (rp) moves.push(pos); 
+  if (pos.a !== pos.b) {
+    let n2 = (pos.a < pos.b) ? pos.b -1 : pos.b + 1;
+    if (n2 !== pos.a) {
+      pos = move(array, n2, pos.a, true);
+      if (rp) moves.push(pos);
+    }
+  }
+
+  return rp ? moves : array;
+}
 
 /**
  * Return a Powerset of values in the array.
@@ -34,5 +105,16 @@ function random(array)
 
 module.exports = exports =
 {
-  powerset, random,
+  move, powerset, random, swap,
 }
+
+/**
+ * Position movement info.
+ * 
+ * All positions in this will be the final calculated positions
+ * after conversion of negative arguments and offsets in two-stage swaps.
+ * 
+ * @typedef {object} module:@lumjs/core/arrays~Position
+ * @prop {number} a - Position item was moved from.
+ * @prop {number} b - Position item was moved to.
+ */

package/lib/context.js

@@ -42,12 +42,12 @@
  * @property {boolean} isBundled - Is this a bundled app?
  * @property {boolean} isMain - Is this the main renderer frame?
  * @property {?string} type - `process.type`
- * @property {object} root - See {@link module:@lumjs/core/types.root}
  */
 
-const {root,B,F,U,O,isComplex,isObj} = require('./types');
-const { df, dfor } = require('./obj');
+const {B,F,U,O,isComplex,isObj} = require('./types/basics');
+const { df, dfor } = require('./obj/df');
 
+const root = globalThis;
 const fo = {enumerable: true}
 const ctx = {root};
 const rootHas = what => typeof root[what] !== U;

package/lib/enum.js

@@ -1,3 +1,4 @@
+const { deprecated } = require('./meta');
 const {S,F,def,notNil,isObj,needObj,TYPES} = require('./types');
 const {InternalObjectId} = require('./objectid');
 
@@ -79,6 +80,8 @@ const EOPT = Symbol(EID+':opts');
  * used as the `opts` for {@see module:@lumjs/core/obj.addLock addLock()},
  * which will be called on the open Enum object.
  * 
+ * This option is **deprecated** and will be removed in v2.0.
+ * 
  * @param {bool} [opts.configurable=false] Enum properties are configurable?
  * 
  * This option is ignored if `opts.open` is `false`.
@@ -188,7 +191,9 @@ function Enum (spec, opts={})
     { // Save the options into a special Symbol property.
       def(anEnum, EOPT, {value: opts});
       if (isObj(opts.lock))
-      { // Add lock() method.
+      { // Add lock() method; TODO: remove this in 2.0!
+        deprecated("Enum(opts.lock)");
+        let { addLock } = require('./obj/lock');
         addLock(anEnum, opts.lock);
       }
     }
@@ -196,7 +201,9 @@ function Enum (spec, opts={})
   else
   {
     if (notNil(opts.lock))
-    { // Use lock() function.
+    { // Use lock() function; TODO: remove this in 2.0!
+      deprecated("Enum(opts.lock)");
+      let { lock } = require('./obj/lock');
       let lockOpts;
       if (Array.isArray(opts.lock))
       { // Specified the lock parameters as an array.
@@ -250,6 +257,3 @@ def(Enum, 'is', isEnum);
 TYPES.add('ENUM', 'enum', isEnum, 'isEnum');
 
 module.exports = Enum;
-
-// Loading this at the end.
-const {lock,addLock} = require('./obj/lock');

package/lib/env.js

@@ -2,8 +2,8 @@
 
 const cp = Object.assign;
 const ctx = require('./context');
-const { df, lazy } = require('./obj');
-const { isObj } = require('./types');
+const { df, lazy } = require('./obj/df');
+const { isObj } = require('./types/basics');
 const NS = '@lumjs/core/env';
 const DataCache = Symbol(NS+'~DataCache');
 const Metadata = Symbol(NS+'~Metadata');
@@ -316,7 +316,8 @@ exports = module.exports =
     let info = {key, opts, env: this};
 
     let value = this.getStr(key),
-        cache = false;
+        cache = false,
+        isdef = false;
 
     if (typeof value === 'string')
     {
@@ -326,18 +327,22 @@ exports = module.exports =
     if (value === undefined)
     {
       value = (typeof opts.default === 'function')
-        ? opts.default.call(this, key, opts)
+        ? opts.default.call(this, key, opts, this)
         : opts.default;
+      isdef = true;
     }
 
-    if (isObj(value))
-    { 
-      cache = (opts.cache > 0);
-      this.extendObject(value, info);
-    }
-    else if (value !== undefined)
+    if (!isdef || opts.cache > 2) 
     {
-      cache = (opts.cache > 1);
+      if (isObj(value))
+      { 
+        cache = (opts.cache > 0);
+        this.extendObject(value, info);
+      }
+      else if (value !== undefined)
+      {
+        cache = (opts.cache > 1);
+      }
     }
 
     if (cache)
@@ -453,7 +458,7 @@ exports = module.exports =
       let meth = opts.dataSave;
       if (value[meth] !== undefined)
       {
-        console.error({key, opts, data: value});
+        console.error({meth, value, opts, info});
         throw new RangeError(meth+' property already exists');
       }
 
@@ -874,10 +879,14 @@ exports = module.exports =
  */
 exports.delete = exports.remove;
 
+//console.debug('Main env exports setup', exports);
+
 // Now the platform-specific methods are added!
 
 if (ctx.isNode)
 {
+  //console.debug('Adding node env helpers');
+
   exports.getStr = function(key)
   {
     return process.env[key];
@@ -893,6 +902,7 @@ if (ctx.isNode)
   exports.unset = function(key)
   {
     delete process.env[key];
+    return this;
   }
 
   exports.forEach = function(cb, opts)
@@ -907,6 +917,8 @@ if (ctx.isNode)
 }
 else if (ctx.isBrowser)
 {
+  console.debug('Adding browser env helpers');
+
   exports.getStr = function(key)
   { // getItem returns null for no value, but we want undefined.
     return localStorage.getItem(key) ?? undefined;
@@ -935,3 +947,7 @@ else if (ctx.isBrowser)
     return cb.done();
   }
 }
+else 
+{
+  throw new RangeError('Invalid environment');
+}

package/lib/index.js

@@ -24,18 +24,23 @@ exports = module.exports =
   Enum: require('./enum'),
   env: require('./env'),
   flags: require('./flags'),
-  lazy,
+  lazy, // ← TODO: nix in 2.x
   maps: require('./maps'),
   meta,
-  ...(meta), // ← TODO: nix in 2.x
   ...(require('./objectid')),
   // obj: require('./obj'), // ← TODO: uncomment in 2.x
   opt: require('./opt'),
+  proxy: require('./proxy'),
   state: require('./state'),
   strings: require('./strings'),
   types,
 }
 
+meta.deprecateAll(meta, {
+  dep: '@lumjs/core',
+  rep: '@lumjs/core.meta.{DEP}',
+}, exports);
+
 // ↓ TODO: nix everything below here in 2.x 
 
 df(exports, 'AbstractClass',