@lumjs/core 1.18.0 → 1.19.0

package/lib/{types/console.js → console.js}

@@ -1,5 +1,5 @@
-const def = require('./def');
-const {F} = require('./js');
+const def = require('./types/def');
+const {F} = require('./types/js');
 
 /**
  * A super simple singleton wrapper around the Javascript console.
@@ -7,7 +7,7 @@ const {F} = require('./js');
  * By default includes `info`, `log`, `warn`, and `error` methods.
  * It may be expanded further using the `addMethod` method.
  * 
- * @exports module:@lumjs/core/types/console
+ * @exports module:@lumjs/core/console
  */
 const LC = 
 {
@@ -80,7 +80,7 @@ const LC =
 
 /** 
  * A reference to the real console object.
- * @alias module:@lumjs/core/types/console.real
+ * @alias module:@lumjs/core/console.real
  */ 
 const RC = globalThis.console;
 def(LC, 'real', RC);
@@ -97,14 +97,14 @@ const HANDLER_OPTIONS =
 /**
  * Add a wrapper method to the console wrapper object.
  * @param {string} method - The console method to wrap.
- * @alias module:@lumjs/core/types/console.addMethod
+ * @alias module:@lumjs/core/console.addMethod
  */
 function addMethod(method)
 {
   def(LC, method, function(...args)
   {
     if (typeof LC.trigger === F)
-    { // Support for core.observable(core.types.console);
+    { // Support for core.observable(core.console);
       LC.trigger(method, ...args);
     }
 

package/lib/index.js

@@ -79,6 +79,13 @@ lazy(exports, 'flags', () => require('./flags'));
  */
 lazy(exports, 'obj', () => require('./obj'));
 
+/**
+ * A wrapper around the Javascript console.
+ * @name module:@lumjs/core.console
+ * @type {module:@lumjs/core/console}
+ */
+lazy(exports, 'console', () => require('./console'));
+
 /**
  * Functions for getting values and properties with fallback defaults «Lazy»
  * @name module:@lumjs/core.opt

package/lib/types/basics.js

@@ -6,92 +6,92 @@ const {O, F, S, SY} = require('./js');
  * @returns {boolean}
  * @alias module:@lumjs/core/types.isObj
  */
- function isObj(v) { return (typeof v === O && v !== null); }
-
- /**
-  * See if a value is *complex* (i.e. either `object` or `function`).
-  * Like `isObj()`, `null` does not count as an `object`.
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.isComplex
-  */
- function isComplex(v) { return (typeof v === F || isObj(v)); }
- 
- /**
-  * See if a value is *nil* (i.e. either `null` or `undefined`).
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.isNil
-  */
- function isNil(v) { return (v === undefined || v === null); }
- 
- /**
-  * See if a value is not *nil* (i.e. neither `null` nor `undefined`).
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.notNil
-  */
- function notNil(v) { return (v !== undefined && v !== null); }
- 
- /**
-  * See if a value is a scalar.
-  * For the purposes of this, a scalar is any value which
-  * is neither *nil* nor *complex*.
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.isScalar
-  */
- function isScalar(v) { return (notNil(v) && !isComplex(v)); }
- 
- /**
-  * See if a value is an `Array` object.
-  * This is literally just a copy of `Array.isArray`.
-  * @function
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.isArray
-  */
- const isArray = Array.isArray;
- 
- /**
-  * See if a value is a `TypedArray` object.
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.isTypedArray
-  */
- function isTypedArray(v)
- {
-   return (ArrayBuffer.isView(v) && !(v instanceof DataView));
- }
- 
- /**
-  * See if a value is a non-empty Array.
-  * @param {*} v - The value we're testing.
-  * @param {boolean} [typed=false] If `true` we want a `TypedArray`.
-  *   If `false` (default) we want a regular `Array`.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.nonEmptyArray
-  */
- function nonEmptyArray(v, typed=false)
- {
-   if (typed)
-     return (isTypedArray(v) && v.length > 0);
-   else
-     return (isArray(v) && v.length > 0);
- }
- 
- /**
-  * See if a value is an `arguments` object.
-  * @param {*} v - The value we're testing.
-  * @returns {boolean}
-  * @alias module:@lumjs/core/types.isArguments
-  */
- function isArguments(v) 
- {
-   return Object.prototype.toString.call(v) === '[object Arguments]';
- }
-
- /**
+function isObj(v) { return (typeof v === O && v !== null); }
+
+/**
+ * See if a value is *complex* (i.e. either `object` or `function`).
+ * Like `isObj()`, `null` does not count as an `object`.
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.isComplex
+ */
+function isComplex(v) { return (typeof v === F || isObj(v)); }
+
+/**
+ * See if a value is *nil* (i.e. either `null` or `undefined`).
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.isNil
+ */
+function isNil(v) { return (v === undefined || v === null); }
+
+/**
+ * See if a value is not *nil* (i.e. neither `null` nor `undefined`).
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.notNil
+ */
+function notNil(v) { return (v !== undefined && v !== null); }
+
+/**
+ * See if a value is a scalar.
+ * For the purposes of this, a scalar is any value which
+ * is neither *nil* nor *complex*.
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.isScalar
+ */
+function isScalar(v) { return (notNil(v) && !isComplex(v)); }
+
+/**
+ * See if a value is an `Array` object.
+ * This is literally just a copy of `Array.isArray`.
+ * @function
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.isArray
+ */
+const isArray = Array.isArray;
+
+/**
+ * See if a value is a `TypedArray` object.
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.isTypedArray
+ */
+function isTypedArray(v)
+{
+  return (ArrayBuffer.isView(v) && !(v instanceof DataView));
+}
+
+/**
+ * See if a value is a non-empty Array.
+ * @param {*} v - The value we're testing.
+ * @param {boolean} [typed=false] If `true` we want a `TypedArray`.
+ *   If `false` (default) we want a regular `Array`.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.nonEmptyArray
+ */
+function nonEmptyArray(v, typed=false)
+{
+  if (typed)
+    return (isTypedArray(v) && v.length > 0);
+  else
+    return (isArray(v) && v.length > 0);
+}
+
+/**
+ * See if a value is an `arguments` object.
+ * @param {*} v - The value we're testing.
+ * @returns {boolean}
+ * @alias module:@lumjs/core/types.isArguments
+ */
+function isArguments(v) 
+{
+  return Object.prototype.toString.call(v) === '[object Arguments]';
+}
+
+/**
  * See if a value is a Property name.
  * @param {*} v - The value we're testing.
  * @returns {boolean}
@@ -122,28 +122,28 @@ function isProperty(v)
  * @returns {boolean} - Is the object a valid descriptor?
  * @alias module:@lumjs/core/types.doesDescriptor
  */
- function doesDescriptor(obj)
- {
-   if (isObj(obj))
-   {
-     const hasValue    = (obj.value !== undefined);
-     const hasGetter   = (typeof obj.get === F);
-     const hasSetter   = (typeof obj.set === F);
-     const hasWritable = (obj.writable !== undefined);
- 
-     if (hasValue && !hasGetter && !hasSetter)
-     { // We have a value, and no getter or setter.
-       return true;
-     }
-     else if ((hasGetter || hasSetter) && !hasValue && !hasWritable)
-     { // We have a getter or setter, and no value or writable properties.
-       return true;
-     }
-   }
- 
-   // Nothing matched, not a valid descriptor rule.
-   return false;
- }
+function doesDescriptor(obj)
+{
+  if (isObj(obj))
+  {
+    const hasValue    = (obj.value !== undefined);
+    const hasGetter   = (typeof obj.get === F);
+    const hasSetter   = (typeof obj.set === F);
+    const hasWritable = (obj.writable !== undefined);
+
+    if (hasValue && !hasGetter && !hasSetter)
+    { // We have a value, and no getter or setter.
+      return true;
+    }
+    else if ((hasGetter || hasSetter) && !hasValue && !hasWritable)
+    { // We have a getter or setter, and no value or writable properties.
+      return true;
+    }
+  }
+
+  // Nothing matched, not a valid descriptor rule.
+  return false;
+}
 
 /**
  * See if an object can be used as a valid *descriptor template*.
@@ -195,6 +195,6 @@ function doesDescriptorTemplate(obj, accessor=false, strict=true)
 // Now export those.
 module.exports =
 {
-isObj, isComplex, isNil, notNil, isScalar, isArray, isTypedArray,
-nonEmptyArray, isArguments, isProperty, doesDescriptor, doesDescriptorTemplate,
+  isObj, isComplex, isNil, notNil, isScalar, isArray, isTypedArray,
+  nonEmptyArray, isArguments, isProperty, doesDescriptor, doesDescriptorTemplate,
 }

package/lib/types/index.js

@@ -42,8 +42,10 @@ const def   = require('./def');
 const lazy  = require('./lazy');
 const TYPES = require('./typelist');
 const stringify = require('./stringify');
+const ownCount = require('./owncount');
 
-const console = require('./console');
+// An alias for legacy reasons.
+const console = require('../console');
 
 // Okay, add all those to our exports.
 // Further tests can be added by `TYPES.add()` later.
@@ -53,7 +55,8 @@ module.exports =
   isObj, isComplex, isNil, notNil, isScalar, isArray, isTypedArray, 
   nonEmptyArray, isArguments, isProperty, doesDescriptor, 
   isInstance, isType, isa, needObj, needType, needs, stringify,
-  doesDescriptorTemplate, console,
+  doesDescriptorTemplate, ownCount,
+  console,
 }
 
 // Last but not least, this will be the module for TYPES.add()

package/lib/types/needs.js

@@ -1,7 +1,7 @@
 const {F, S, B} = require('./js');
 const {isType, isa} = require('./isa');
 const {isObj, isComplex} = require('./basics');
-const console = require('./console');
+const console = require('../console');
 
 /**
  * If a value is not an object, throw an error.

package/lib/types/owncount.js

@@ -0,0 +1,50 @@
+/**
+ * Return the number of _local_ properties in an object.
+ * 
+ * @param {(object|function)} v - The value we want the property count of.
+ * 
+ * This can be any kind of `object`, or it can be a `function` that has
+ * a `prototype` property which is a `object`. Anything else is invalid.
+ * 
+ * @param {number} [level=0] Determine which properties to count.
+ * 
+ * - `== 0` : Counts only enumerable properties.
+ * - `> 0`  : Includes all properties with string names.
+ * - `> 1`  : Also includes symbol properties.
+ * 
+ * @returns {number} The number of matching properties.
+ * 
+ * If `v` was an invalid value, this will return `-1`.
+ * 
+ * @alias module:@lumjs/core/types.ownCount
+ */
+function ownCount(v, level=0)
+{
+  if (typeof v === F && isObj(v.prototype))
+  { // If a class constructor is passed, we use the prototype.
+    v = v.prototype;
+  }
+  
+  if (!isObj(v))
+  { // Nothing more to do here.
+    return -1;
+  }
+
+  if (level == 0)
+  { // Enumerable properties only.
+    return Object.keys(v).length;
+  }
+
+  // Include all properties with string names.
+
+  let count = Object.getOwnPropertyNames(v).length;
+
+  if (level > 1)
+  { // Also include symbol properties.
+    count += Object.getOwnPropertySymbols(v).length;
+  }
+
+  return count;
+}
+
+module.exports = ownCount;

package/package.json

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