@lumjs/core 1.12.0 → 1.13.0

package/lib/obj/clone.js

@@ -272,7 +272,7 @@ function addClone(obj, defOpts=null)
 {
   if (!isObj(defOpts))
   { // Assign a default set of defaults.
-    defOpts = {mode: CLONE.DEF, addClone: true, addLock: false};
+    defOpts = {addClone: true};
   }
 
   const defDesc = defOpts.cloneDesc ?? {};

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/lock.js

@@ -22,7 +22,7 @@ const {B, isObj, def} = require('../types');
    { // Add the clone method before freezing.
      if (!isObj(cloneOpts))
      {
-       cloneOpts = {mode: CLONE.DEF, addClone: true, addLock: true};
+       cloneOpts = {addClone: true, addLock: true};
      }
      addClone(obj, cloneOpts);
    }
@@ -64,4 +64,5 @@ const {B, isObj, def} = require('../types');
  exports.addLock = addLock;
 
  // Importing addLock at the end, just because.
- const {addClone} = require('./clone');
+ const {addClone} = require('./clone');
+ 

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/lib/types/lazy.js

@@ -206,7 +206,7 @@ function lazy(target, name, initfunc, opts={})
   }
 
   // Assign the lazy accessor property.
-  def(target, name, desc);
+  return def(target, name, desc);
 }
 
 // Gotta be one of the greatest lines...

package/package.json

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