@lumjs/core 1.12.1 → 1.14.0

package/lib/context.js

@@ -6,18 +6,42 @@
  * describing the current JS environment and execution context.
  * 
  * @module @lumjs/core/context
- * @property {boolean} AMD - AMD (*RequireJS*) module loading detected.
- * @property {boolean} CJS - CommonJS environment detected.
+ * @property {boolean} hasDefine - A global `define()` function was found.
  * @property {boolean} hasRequire - A global `require()` function was found.
- * @property {boolean} hasExports - A global `exports` object was found.
+ * @property {boolean} hasExports - A global `exports` variable was found.
  * @property {boolean} hasModule - A global `module` object was found.
- * @property {boolean} isNode - Is likely *Node.js*, *Electron*, etc.
+ * @property {boolean} hasModuleExports - A `module.exports` exists.
+ * @property {boolean} hasSyncedExports - `exports === module.exports`
+ * @property {boolean} isNode - An alias to `Node.ok`.
  * @property {boolean} isBrowser - A web-browser environment detected.
  * @property {boolean} isWindow - Is a browser `Window` context.
  * @property {boolean} isWorker - Is a browser `Worker` (sub-types below.)
  * @property {boolean} isServiceWorker - Is a `ServiceWorker` context.
  * @property {boolean} isDedicatedWorker - Is a `DedicatedWorker` context.
  * @property {boolean} isSharedWorker - Is a `SharedWorker` context.
+ * @property {object} AMD - Asynchronous Module Definition detection.
+ * @property {boolean} AMD.isSupported - The `define.amd` property is set.
+ * @property {boolean} AMD.isRequireJS - A global `requirejs` was found.
+ * @property {object} CJS - CommonJS detection.
+ * @property {boolean} CJS.standard - `hasDefine && hasRequire`
+ * @property {boolean} CJS.nodeLike - `CJS.standard && hasExports`
+ * @property {boolean} CJS.isLumV5 - Lum.js browser bundler detected.
+ * @property {boolean} CJS.isWebpack - Webpack bundler detected.
+ * @property {boolean} CJS.inBrowser - `CJS.isLumV5 || CJS.isWebpack`
+ * @property {object} Node - Node.js detection.
+ * @property {boolean} Node.isSane - `CJS.nodeLike && !CJS.inBrowser`
+ * @property {boolean} Node.hasProcess - A global `process` object exists.
+ * @property {boolean} Node.ok - `Node.isSane && Node.hasProcess`
+ * @property {?string} Node.ver - `process.versions.node ?? null`
+ * @property {?object} Node.versions - `process.versions ?? null`
+ * @property {Array} Node.args - Command line arguments.
+ * @property {string} Node.script - Command line script name.
+ * @property {object} Electron - Electron detection.
+ * @property {boolean} ok - Electron environment detected.
+ * @property {boolean} isDefault - Is this the default app?
+ * @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}
  */
 
@@ -28,37 +52,72 @@ const rootHas = what => typeof root[what] !== U;
 const cd = def(ctx, true);
 const CJS = {};
 const AMD = {};
+const Node = {};
+const Elec = {};
 const cjs = def(CJS, true);
 const amd = def(AMD, true);
+const node = def(Node, true);
+const elec = def(Elec, true);
 const isLumV5 = typeof module.$lib === O && module.$lib.$cached === module;
 
 cd('hasDefine', typeof define === F)
   ('hasRequire', typeof require === F)
-  ('hasExports', typeof exports !== U)
+  ('hasExports', typeof exports !== U && isComplex(exports))
   ('hasModule', typeof module === O && module !== null)
-  ('hasModuleExports', isComplex(module.exports))
-  ;
+  ('hasModuleExports', ctx.hasModule && isComplex(module.exports))
+  ('hasSyncedExports', ctx.hasExports && ctx.hasModuleExports 
+    && exports === module.exports)
 
 cjs('standard', ctx.hasModule && ctx.hasRequire)
    ('nodeLike', CJS.standard && ctx.hasExports)
    ('isLumV5', CJS.nodeLike && isLumV5)
    ('isWebpack', CJS.nodeLike && require.resolve === require)
    ('inBrowser', CJS.isLumV5 || CJS.isWebpack)
-   ;
+
+node('isSane', CJS.nodeLike && !CJS.inBrowser)
+    ('hasProcess', typeof process === O && process !== null)
+    ('ok', Node.isSane && Node.hasProcess)
+    ('versions', Node.hasProcess ? process.versions : null)
+    ('ver', Node.hasProcess ? process.versions.node : null)
+    ('args', {get: function()
+    { // Inspired by yargs hideBin() function.
+      if (Node.ok)
+      {
+        const o = (Elec.isBundled) ? 1 : 2;
+        return process.argv.slice(o);
+      }
+      return [];
+    }})
+    ('script', {get: function()
+    { // Inspired by yargs getProcessArgvBin() function.
+      if (Node.ok)
+      {
+        const i = (Elec.isBundled) ? 0 : 1;
+        return process.argv[i];
+      }
+      return '';
+    }})
+
+elec('ok', Node.ok && !!Node.versions.electron)
+    ('isDefault', Elec.ok && !!process.defaultApp)
+    ('isBundled', Elec.ok && !process.defaultApp)
+    ('isMain', Elec.ok && !!process.isMainFrame)
+    ('type', Elec.ok && process.type)
 
 amd('isSupported', ctx.hasDefine && isObj(define.amd))
    ('isRequireJS', AMD.isSupported && typeof requirejs === F)
 
 cd('CJS', CJS)
   ('AMD', AMD)
-  ('isNode', CJS.nodeLike && !CJS.inBrowser)
-  ('isWindow', rootHas('window'))
+  ('Node', Node)
+  ('Electron', Elec)
+  ('isNode', Node.ok)
+  ('isWindow', typeof Window === F && rootHas(window))
   ('isWorker', rootHas('WorkerGlobalScope'))
   ('isServiceWorker', rootHas('ServiceWorkerGlobalScope'))
   ('isDedicatedWorker', rootHas('DedicatedWorkerGlobalScope'))
   ('isSharedWorker', rootHas('SharedWorkerGlobalScope'))
   ('isBrowser', !ctx.isNode && (ctx.isWindow || ctx.isWorker))
-  ;
 
 /**
  * See if a root-level name is defined.

package/lib/obj/getmethods.js

@@ -0,0 +1,151 @@
+const types = require('../types');
+const {F, S, B, needType, needObj, isObj, notNil, def} = types;
+
+// Default method names we don't want to include.
+const DEFAULT_FILTER_NAMES =
+[
+  'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 
+  'toString', 'toLocaleString', 'valueOf',
+];
+
+// Default method prefixes we don't want to include.
+const DEFAULT_FILTER_PREFIXES = ['_', '$'];
+
+class MethodFilter
+{
+  constructor(opts, ...args)
+  {
+    if (typeof opts === B)
+    { // A simple way of specifying defaults mode.
+      opts = {defaults: opts};
+    }
+    else if (!isObj(opts) || opts instanceof RegExp)
+    { // Something other than options was passed.
+      if (notNil(opts))
+        args.unshift(opts);
+      opts = {};
+    }
+
+    const defaults = opts.defaults ?? true;
+    this.returns   = opts.returns  ?? !defaults;
+
+    this.names    = defaults ? Array.from(DEFAULT_FILTER_NAMES)    : [];
+    this.prefixes = defaults ? Array.from(DEFAULT_FILTER_PREFIXES) : [];
+    this.tests    = [];
+    this.rules    = [];
+
+    for (const arg of args)
+    {
+      this.add(arg);
+    }
+  }
+
+  add(arg)
+  {
+    if (typeof arg === S)
+    {
+      if (arg.length === 1)
+      {
+        this.prefixes.push(arg);
+      }
+      else 
+      {
+        this.names.push(arg);
+      }
+    }
+    else if (typeof arg === F)
+    {
+      this.tests.push(arg);
+    }
+    else if (arg instanceof RegExp)
+    {
+      this.rules.push(arg);
+    }
+    else 
+    {
+      console.error("Unsupported argument", arg, this);
+    }
+    return this;
+  }
+
+  test(elem)
+  {
+    const rt = this.returns;
+    const rf = !rt;
+
+    if (this.prefixes.includes(elem[0])) return rt;
+    if (this.names.includes(elem)) return rt;
+
+    for (const rule of this.rules)
+    {
+      if (rule.test(elem)) return rt;
+    }
+
+    for (const test of this.tests)
+    {
+      if (test.call(this, arguments)) return rt;
+    }
+    
+    return rf;
+  }
+
+  for(obj)
+  {
+    return getMethods(obj, this);
+  }
+}
+
+def(MethodFilter)
+  ('DEFAULT_FILTER_NAMES',    DEFAULT_FILTER_NAMES)
+  ('DEFAULT_FILTER_PREFIXES', DEFAULT_FILTER_PREFIXES)
+
+function getMethods(obj, filter)
+{
+  needObj(obj, true);
+
+  if (!(filter instanceof MethodFilter))
+  {
+    if (Array.isArray(filter))
+    {
+      filter = new MethodFilter(...filter);
+    }
+    else
+    {
+      filter = new MethodFilter(filter);
+    }
+  }
+
+  const props = new Set();
+  let cur = obj;
+  do
+  {
+    Object.getOwnPropertyNames(cur)
+      .filter(i => filter.test(i))
+      .map(i => props.add(i));
+  }
+  while ((cur = Object.getPrototypeOf(cur)));
+  return [...props.keys()].filter(i => typeof obj[i] === F);
+}
+
+def(getMethods, 'exclude', function()
+{ // Get a MethodFilter using defaults (exclude mode).
+  return new MethodFilter(true, ...arguments);
+});
+
+def(getMethods, 'include', function()
+{ // Get a MethodFilter using include mode (no defaults).
+  return new MethodFilter(false, ...arguments);
+})
+
+function signatureOf(fn, name)
+{
+  needType(F, fn);
+  const fns = fn.toString(); 
+  const fnt = fns.slice(0, fns.indexOf(')')+1);
+  return (typeof name === S) ? fnt.replace('function', name) : fnt;
+}
+
+module.exports =
+{
+  getMethods, signatureOf, MethodFilter,
+}

package/lib/obj/index.js

@@ -10,6 +10,7 @@ const {lock,addLock} = require('./lock');
 const {mergeNested,syncNested} = require('./merge');
 const ns = require('./ns');
 const getProperty = require('./getproperty');
+const {getMethods,signatureOf,MethodFilter} = require('./getmethods');
 const 
 {
   getObjectPath,setObjectPath,
@@ -21,5 +22,6 @@ module.exports =
   CLONE, clone, addClone, cloneIfLocked, lock, addLock,
   mergeNested, syncNested, copyProps, copyAll, ns,
   getObjectPath, setObjectPath, getNamespace, setNamespace,
-  getProperty, duplicateAll, duplicateOne,
+  getProperty, duplicateAll, duplicateOne, getMethods, signatureOf,
+  MethodFilter,
 }

package/lib/obj/ns.js

@@ -169,11 +169,12 @@ function setObjectPath(obj, proppath, opts={})
   const nsc = proppath.length;
   const lastns = nsc - 1;
 
-  //console.debug("setObjectPath", obj, proppath, opts, nsc, arguments);
+  //console.debug("setObjectPath", {obj, proppath, opts, nsc, arguments});
 
   for (let n = 0; n < nsc; n++)
   {
     const ns = proppath[n];
+    //console.debug("setObjectPath:loop", {n, ns, cns});
 
     if (cns[ns] === undefined)
     { // Nothing currently here. Let's fix that.

package/package.json

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