@lumjs/core 1.26.0 → 1.31.0

package/lib/meta.js

@@ -1,9 +1,14 @@
+"use strict";
 /**
- * Meta-programming helpers.
+ * Meta-programming helpers
+ * 
+ * All of the function exported by this module are also available
+ * in the main {@link module:@lumjs/core core object} itself.
+ * 
  * @module @lumjs/core/meta
  */
 
-const {F,S,isArray,isa,console} = require('./types');
+const {F} = require('./types/js');
 
 /**
  * Get a stacktrace. Differs from browser to browser.
@@ -25,85 +30,6 @@ function stacktrace(msg)
 
 exports.stacktrace = stacktrace;
 
-/**
- * Abstract classes for Javascript.
- * @deprecated Just use `throw new AbstractError()` instead.
- * @alias module:@lumjs/core/meta.AbstractClass
- */
-class AbstractClass
-{
-  /**
-   * If you want to mark a method as abstract use this.
-   */
-  $abstract(name)
-  {
-    if (name.indexOf('(') === -1)
-    { // Add empty method signature.
-      name += '()';
-    }
-    throw new Error(`Abstract method ${name} was not implemented`);
-  }
-
-  /**
-   * Check for required properties
-   * 
-   * @param {...(string|Array)} needs - What is needed
-   * 
-   * If this is a `string` it should be in a format like:
-   * 
-   * - `methodName(arg1,arg2,arg3)`
-   * - `anotherMethod(number, string, object) : boolean`
-   * - `yetAnother (className) : resultClass`
-   * 
-   * The names are case sensitive, and we'll look for the method after 
-   * stripping off anything from the first *non-word* character.
-   * 
-   * If this is an `Array`, the first item must be the name of a property,
-   * and each other item should be a type checking value, or array of type 
-   * checking values from the [TYPES]{@link module:@lumjs/core/types.TYPES} 
-   * object, as used by [isa()]{@link module:@lumjs/core/types.isa}.
-   * 
-   * If you are calling this in an abstract class constructor, likely only 
-   * the method checks will be useful, as the `super()` call must be done 
-   * *before* any instance property assignments.
-   * 
-   */
-  $needs(...needs)
-  {
-    const className = this.constructor.name;
-
-    const getName = fullName => fullName.replace(/\W.*/, '');
-    const missing = propName => 
-    { 
-      throw new Error(`${className} is missing ${propName}`); 
-    }
-
-    for (const need of needs)
-    {
-      if (typeof need === S)
-      { // A simple method
-        const meth = getName(need);
-        if (typeof this[meth] !== F)
-        {
-          missing(need);
-        }
-      }
-      else if (isArray(need))
-      {
-        const prop = getName(need[0]);
-        const types = need.slice(1);
-        if (!isa(this[prop], ...types))
-        {
-          missing(need);
-        }
-      }
-    }
-  }
-
-}
-
-exports.AbstractClass = AbstractClass;
-
 /**
  * An Error that can be thrown from abstract methods.
  * 
@@ -164,7 +90,6 @@ exports.AbstractError = AbstractError;
 
 /**
  * Function prototypes for async, generator, and async generator functions.
- * @namespace
  * @alias module:@lumjs/core/meta.Functions
  */
 const Functions =
@@ -208,3 +133,67 @@ function NYI(fatal=true, prefix='')
 }
 
 exports.NYI = NYI;
+
+/**
+ * Send a deprecation message with a stack trace.
+ * 
+ * @param {string} dep - Name of what is deprecated
+ * @param {(string|string[])} [rep] Replacement suggestion(s).
+ * @param {*} [ret] Value to return
+ * @returns {mixed} `ret`
+ * @alias module:@lumjs/core/meta.deprecated
+ */
+function deprecated(dep, rep, ret)
+{
+  const msgs = [dep,'is deprecated'];
+  if (rep)
+  {
+    msgs.push('replace with', rep);
+  }
+  console.trace(...msgs);
+  return ret;
+}
+
+exports.deprecated = deprecated;
+
+/**
+ * Assign a getter property that when accessed will
+ * show a deprecation message via `deprecated()` function
+ * before returning the deprecated property value.
+ * 
+ * @param {object} obj - Target to assign property on
+ * @param {string} prop - Property to assign
+ * @param {(object|function)} spec - Specification
+ * 
+ * If this is a `function` it will be used as the `spec.get` value.
+ * 
+ * @param {function} spec.get - The function that returns the real value
+ * @param {string} [spec.dep=prop] Name of what is deprecated;
+ * defaults to `prop` if omitted.
+ * @param {(string|string[])} [spec.rep] Replacement suggestion(s).
+ * @param {object} [spec.opts] Options for `def()` to add getter with.
+ * 
+ * @returns {object} `obj`
+ * 
+ * @alias module:@lumjs/core/meta.wrapDepr
+ */
+function wrapDepr(obj,prop,spec)
+{
+  if (typeof spec === F)
+    spec = {get: spec};
+  if (typeof spec.get !== F) 
+    throw new TypeError("invalid init");
+
+  return def(obj, prop, 
+  {
+    get: () =>
+      deprecated(spec.dep??prop, spec.rep, spec.get())
+  }, spec.opts);
+}
+
+exports.wrapDepr = wrapDepr;
+
+// This is near the bottom, but before any calls to wrapDepr.
+const def = require('./types/def');
+
+wrapDepr(exports, 'AbstractClass', () => require('./old/abstractclass'));

package/lib/obj/clone.js

@@ -1,5 +1,5 @@
 // Import *most* required bits here.
-const {N,F, isObj, isComplex, def, isArray, console} = require('../types');
+const {N,F, isObj, isComplex, def, isArray} = require('../types');
 const copyProps = require('./copyprops');
 const getProp = require('./getproperty');
  

package/lib/obj/copyprops.js

@@ -1,6 +1,6 @@
 
 // Get some constants
-const {S,B,N,F,isObj,isArray,needObj,def,console} = require('../types');
+const {S,B,N,F,isObj,isArray,needObj,def} = require('../types');
 const {copyAll, duplicateOne: clone} = require('./copyall');
 
 const RECURSE_NONE =  0;
@@ -406,7 +406,7 @@ copyProps.from = function(...sources)
   return ((new $CopyProps()).from(...sources));
 }
 
-const CPC = copyProps.cache =
+copyProps.cache =
 {
   into(target)
   {