@lumjs/core 1.3.1 → 1.5.0

package/docs/changelogs/1.x.md

@@ -6,6 +6,23 @@ See [Changelogs](index.md) for more information on the changelogs.
 
 ## [Unreleased]
 
+## [1.5.0] - 2022-09-27
+### Changed
+- Updated a few DocBlocks.
+- Added a couple explicitly named options to `def()`
+- Rewrote the default module to use `def()` to define its exported properties.
+- Made `arrays`, `strings`, `flags`, `opt`, `modules`, and `observable` use `lazy()`.
+### Fixed
+- Fixed `def()` so that the descriptor defaults are applied properly.
+- Fixed `lazy()` so it returns a proper value and not a descriptor on first access.
+
+## [1.4.0] - 2022-09-26
+### Changed
+- Moved `lazy` into `types` module by default (leaving an alias in `core`).
+- Completely rewrote the `lazy` function entirely.
+- Greatly extended the documentation for `lazy` function.
+- Removed an unused development artefact from `types.needs`.
+
 ## [1.3.1] - 2022-09-23
 ### Fixed
 - The `arrays` module exports `powerset` and `random` as it should.
@@ -74,7 +91,9 @@ See [Changelogs](index.md) for more information on the changelogs.
 - See [1.0-beta.md](1.0-beta.md) for the beta versions of `1.0`
 - See [lum.js](https://github.com/supernovus/lum.js) for the original library set this is replacing.
 
-[Unreleased]: https://github.com/supernovus/lum.core.js/compare/v1.3.1...HEAD
+[Unreleased]: https://github.com/supernovus/lum.core.js/compare/v1.5.0...HEAD
+[1.5.0]: https://github.com/supernovus/lum.core.js/compare/v1.4.0...v1.5.0
+[1.4.0]: https://github.com/supernovus/lum.core.js/compare/v1.3.1...v1.4.0
 [1.3.1]: https://github.com/supernovus/lum.core.js/compare/v1.3.0...v1.3.1
 [1.3.0]: https://github.com/supernovus/lum.core.js/compare/v1.2.1...v1.3.0
 [1.2.1]: https://github.com/supernovus/lum.core.js/compare/v1.2.0...v1.2.1

package/lib/index.js

@@ -4,89 +4,161 @@
  * This is the foundation upon which all the rest of my JS libraries
  * are built. It provides fundamental helper functions and classes.
  * 
+ * Properties marked as «Lazy» will be loaded on-demand the first time
+ * the property is accessed. All other properties are always loaded.
+ * 
  * @module @lumjs/core
  */
 
 /**
- * Constants and functions for basic type checking.
+ * Constants and functions for type checks
+ * and other fundamental functions
+ * 
  * @alias module:@lumjs/core.types
  * @see module:@lumjs/core/types
  */
 const types = require('./types');
 
 /**
- * Array utility functions.
- * @alias module:@lumjs/core.arrays
- * @see module:@lumjs/core/arrays
+ * Define properties on an object or function
+ * @name module:@lumjs/core.def
+ * @function
+ * @see module:@lumjs/core/types.def
  */
-const arrays = require('./arrays');
 
 /**
- * Information about the JS context we're running in.
- * @alias module:@lumjs/core.context
- * @see module:@lumjs/core/context
+ * Define properties on an object or function
+ * @name module:@lumjs/core.lazy
+ * @function
+ * @see module:@lumjs/core/types.lazy
  */
-const context = require('./context');
+
+// Get a descriptor for one of our sub-modules.
+function lib(name, def={})
+{
+  let value = def.value;
+  
+  if (value === undefined)
+  {
+    const module = def.module ?? name;
+    value = require('./'+module);
+
+    if (value && def.prop && value[def.prop] !== undefined)
+    { 
+      value = value[def.prop];
+    }
+  }
+
+  const desc = 
+  {
+    configurable: false, 
+    enumerable: true, 
+    writable: false,
+    value,
+  }
+
+  return desc;
+}
+
+// Export one of our always loaded properties.
+function has(name, def)
+{
+  types.def(exports, name, lib(name, def));
+}
+
+// Export one of our lazy loaded properties.
+function can(name, def)
+{
+  types.lazy(exports, name, () => lib(name, def), {enumerable: true});
+}
+
+// Export a set of always loaded properties from a sub-module
+function from(modname, ...libs)
+{
+  for (const lib of libs)
+  {
+    has(lib, {module: modname, prop: lib});
+  }
+}
+
+// Our fundamental bits.
+has('types', {value: types});
+has('def',   {value: types.def});
+has('lazy',  {value: types.lazy});
+
+/**
+ * Array utility functions «Lazy»
+ * @name module:@lumjs/core.arrays
+ * @type {module:@lumjs/core/arrays}
+ */
+can('arrays');
 
 /**
- * Functions for working with strings and locales.
- * @alias module:@lumjs/core.strings
- * @see module:@lumjs/core/strings
+ * Information about the JS context we're running in
+ * @name module:@lumjs/core.context
+ * @type {module:@lumjs/core/context}
  */
-const strings = require('./strings');
+has('context');
 
 /**
- * Functions for working with binary flags.
- * @alias module:@lumjs/core.flags
- * @see module:@lumjs/core/flags
+ * Functions for working with strings and locales «Lazy»
+ * @name module:@lumjs/core.strings
+ * @type {module:@lumjs/core/strings}
  */
-const flags = require('./flags');
+can('strings');
 
 /**
- * Functions for manipulating objects.
- * @alis module:@lumjs/core.obj
- * @see module:@lumjs/core/obj
+ * Functions for working with binary flags «Lazy»
+ * @name module:@lumjs/core.flags
+ * @type {module:@lumjs/core/flags}
  */
-const obj = require('./obj');
+can('flags');
 
 /**
- * Functions for getting values and properties with fallback defaults.
- * @alias module:@lumjs/core.opt
- * @see module:@lumjs/core/opt
+ * Functions for manipulating objects
+ * @name module:@lumjs/core.obj
+ * @type {module:@lumjs/core/obj}
  */
-const opt = require('./opt');
+has('obj');
 
 /**
- * Meta functions related to JS modules.
+ * Functions for getting values and properties with fallback defaults «Lazy»
+ * @name module:@lumjs/core.opt
+ * @type {module:@lumjs/core/opt}
+ */
+can('opt');
+
+/**
+ * Meta functions related to JS modules «Lazy»
  * @alias module:@lumjs/core.modules
  * @see module:@lumjs/core/modules
  */
-const modules = require('./modules');
+can('modules');
 
 // ObjectID stuff is imported directly without registering a sub-module.
-const {randomNumber, InternalObjectId} = require('./objectid');
+from('objectid', 'randomNumber', 'InternalObjectId');
 
 /**
- * Get a simplistic debugging stacktrace.
+ * Get a simplistic debugging stacktrace
  * @name module:@lumjs/core.stacktrace
  * @function
  * @see module:@lumjs/core/meta.stacktrace
  */
 
 /**
- * A simple base class for making *abstract* classes.
+ * A simple base class for making *abstract* classes
  * @name module:@lumjs/core.AbstractClass
  * @see module:@lumjs/core/meta.AbstractClass
  */
 
 /**
- * A *factory* for special types of JS `function` constructors.
+ * A *factory* for special types of JS `function` constructors
  * @name module:@lumjs/core.Functions
  * @see module:@lumjs/core/meta.Functions
  */
 
 /**
- * Throw an `Error` saying that a feature is not yet implemented.
+ * Throw an `Error` saying that a feature is not yet implemented
  * @name module:@lumjs/core.NYI
  * @function
  * @see module:@lumjs/core/meta.NYI
@@ -94,38 +166,20 @@ const {randomNumber, InternalObjectId} = require('./objectid');
 
 // These are exported directly, but a meta sub-module also exists.
 // Unlike most sub-modules there is no `meta` property in the main library.
-const {stacktrace,AbstractClass,Functions,NYI} = require('./meta');
+from('meta', 'stacktrace', 'AbstractClass', 'Functions', 'NYI');
 
 /**
- * Create a magic *Enum* object.
- * @alias module:@lumjs/core.Enum
+ * Create a magic *Enum* object
+ * @name module:@lumjs/core.Enum
  * @function
  * @see module:@lumjs/core/enum
  */
-const Enum = require('./enum');
+has('Enum', {module: 'enum'});
 
 /**
- * Make an object support the *Observable* API.
- * @alias module:@lumjs/core.observable
+ * Make an object support the *Observable* API «Lazy»
+ * @name module:@lumjs/core.observable
  * @function
  * @see module:@lumjs/core/observable
  */
-const observable = require('./observable');
-
-// One function exported directly with no sub-module available.
-const lazy = require('./lazy');
-
-/**
- * Define properties on an object or function.
- * @alias module:@lumjs/core.def
- * @function
- * @see module:@lumjs/core/types.def
- */
-const def = types.def;
-
-module.exports =
-{
-  types, context, flags, obj, opt, modules, arrays, strings,
-  def, randomNumber, InternalObjectId, Enum, lazy, observable,
-  stacktrace, AbstractClass, Functions, NYI, 
-}
+can('observable');

package/lib/types/def.js

@@ -14,60 +14,83 @@ const clone = obj => copy({}, obj);
  * It replaces the `prop()` method from the old Lum.js v4.
  * 
  * @param {(object|function)} obj - The object to add a property to.
- * @param {?(string|boolean|object)} name - If a `string`, the property name.
- *   Property names may also be `symbol` values.
+ * @param {?(string|symbol|boolean|object)} name 
+ * If a `string` or `symbol`, it's the property name.
  * 
- *   If this is `null` or `undefined` then the `value` is ignored entirely,
- *   and instead a bound version of this function is created with the
- *   `obj` already passed as the first parameter, and any of the options from
- *   `opts` added to a new default set of options bound to the function.
- *   Can be useful if you need to add a lot of properties to the same object.
+ * If this is `null` or `undefined` then the `value` is ignored entirely,
+ * and instead a bound version of this function is created with the
+ * `obj` already passed as the first parameter, and any of the options from
+ * `opts` added to a new default set of options bound to the function.
+ * Can be useful if you need to add a lot of properties to the same object.
  * 
- *   If this is a `boolean`, then the same logic as if it was `null` or 
- *   `undefined` will apply, except that an `enumerable` property with this 
- *   value will also be added to the descriptors.
+ * If this is a `boolean`, then the same logic as if it was `null` or 
+ * `undefined` will apply, except that an `enumerable` property with this 
+ * value will also be added to the descriptors.
  * 
- *   If this is an `object`, we also ignore `value` entirely, as each of 
- *   the keys of this object will be used as the name of a property, 
- *   and the value associated with the key will be the value to assign it.
+ * If this is an `object`, we also ignore `value` entirely, as each of 
+ * the keys of this object will be used as the name of a property, 
+ * and the value associated with the key will be the value to assign it.
  * 
  * @param {*} value - Used to determine the value of the property.
  * 
- *   If it is an a valid descriptor object (as per `doesDescriptor()`),
- *   it will be used as the descriptor. If it has no `configurable`
- *   property defined, one will be added, and will be set to `true`.
- *   This behaviour may be overridden by the `opts` parameter.
+ * If it is an a valid descriptor object (as per `doesDescriptor()`),
+ * it will be used as the descriptor. If it has no `configurable`
+ * property defined, one will be added, and will be set to `true`.
+ * This behaviour may be overridden by the `opts` parameter.
  * 
- *   If this and `opts` are both `function` values, then this will
- *   be used as a *getter*, and `opts` will be used a *setter*.
+ * If this and `opts` are both `function` values, then this will
+ * be used as a *getter*, and `opts` will be used a *setter*.
  * 
- *   Any other value passed here will be used as the `value` in a
- *   pre-canned descriptor, also with `configurable` set to `true`.
+ * Any other value passed here will be used as the `value` in a
+ * pre-canned descriptor, also with `configurable` set to `true`.
  * 
  * @param {*} [opts] - A multi-purpose option.
  * 
- *   If this is an `object` then it is reserved for named options.
- *   The named options `configurable`, `enumerable`, and `writable`
- *   can be used to define default values to the descriptor properties
- *   of the same name.
+ * If this is an `object` then it is reserved for named options.
  * 
- *   If `value` and this are both `function` values, then `value` will
- *   be used as a *getter* and this will be used as a *setter*.
+ * The named options `configurable`, `enumerable`, and `writable`
+ * can be used to define default values to the descriptor properties
+ * of the same name.
  * 
- *   If `value` is a valid descriptor object, then setting this to `false`
- *   will disable the assumption that it is the descriptor to set.
- *   Setting this to `true` on will instruct the function to make a clone 
- *   of the descriptor object before modifying any properties in it.
+ * If `value` and this are both `function` values, then `value` will
+ * be used as a *getter* and this will be used as a *setter*.
  * 
- *   This defaults to `undefined`, except if 
+ * If this is `true`, it sets `opts.cloneDesc` to `true`.
+ *   
+ * If this is `false`, it sets `opts.autoDesc` to `false`.
+ * 
+ * This defaults to `undefined`, except in bound functions.
+ * 
+ * @param {boolean} [opts.autoDesc=true] Automatically detect descriptors?
+ * 
+ * If `true` (the default value) then the automatic descriptor detection
+ * is used any time the `value` is an `object`.
+ * 
+ * If `false` the descriptor detection is disabled, and we'll always
+ * wrap all values in a new internal descriptor.
+ * 
+ * @param {boolean} [opts.cloneDesc=false] Clone descriptors?
+ * 
+ * If `true` then we'll clone detected descriptors before making
+ * any changes to them.
+ * 
+ * If `false` (the default value), we'll use passed descriptors
+ * directly, so any changes will be made on the original.
+ * 
+ * @param {boolean} [opts.configurable=true] Default `configurable` value 
+ * @param {boolean} [opts.enumerable=false] Default `enumerable` value
+ * @param {boolean} [opts.writable=false] Default `writable` value
+ * 
+ * Only used with *data descriptors* and will be ignored with
+ * *accessor* descriptors.
  * 
  * @returns {*} Normally the `obj` argument with new property added.
  * 
- *   The exception is if this is a bound copy of the function created
- *   using the syntax described in the `name` parameter documentation.
- *   In that case the return value is the bound copy itself.
- *   While that might seem strange, it allows for chaining in a way
- *   that otherwise would not be possible, take this example:
+ * The exception is if this is a bound copy of the function created
+ * using the syntax described in the `name` parameter documentation.
+ * In that case the return value is the bound copy itself.
+ * While that might seem strange, it allows for chaining in a way
+ * that otherwise would not be possible, take this example:
  * 
  * ```
  *   def(myObj)('name', "Bob")('age', 42);
@@ -136,11 +159,31 @@ function def(obj, name, value, opts)
     throw new TypeError("Property name must be a string or a Symbol");
   }
 
+  function getOpt(name, defVal)
+  {
+    const revVal = !defVal;
+    if (isObj(opts) && typeof opts[name] === B)
+    { // Found the option.
+      return opts[name];
+    }
+    else if (opts === revVal)
+    { // A special default rule was found.
+      return revVal;
+    }
+    else 
+    { // Return the default.
+      return defVal;
+    }
+  }
+
+  const autoDesc  = getOpt('autoDesc',  true);
+  const cloneDesc = getOpt('cloneDesc', false);
+
   let desc;
 
-  if (opts !== false && doesDescriptor(value))
+  if (autoDesc && doesDescriptor(value))
   { // The value is a descriptor, let's use it.
-    desc = (opts === true) ? clone(value) : value;
+    desc = cloneDesc ? clone(value) : value;
   }
   else if (typeof value === F && typeof opts === F)
   { // A getter and setter were both specified.
@@ -151,27 +194,28 @@ function def(obj, name, value, opts)
     desc = {value};
   }
 
-  if (isObj(opts))
-  { // If opts is an object, let's look for some supported defaults.
-    const cd = (opt, defval) =>
-    {
-      if (typeof opts[opt] === B && typeof desc[opt] !== B)
-      { // Default descriptor option specified in `opts`
-        desc[opt] = opts[opt];
-      }
-      else if (typeof defval === B)
-      { // A fallback default. 
-        desc[opt] = defval;
-      }
+  const cd = (opt, defval) =>
+  {
+    if (typeof desc[opt] === B) 
+    { // Property was set explicitly.
+      return;
     }
-
-    cd('configurable', true);
-    cd('enumerable');
-    if (desc.get === undefined && desc.set === undefined)
-    { // Only look for this one on data descriptors.
-      cd('writable');
+    else if (isObj(opts) && typeof opts[opt] === B)
+    { // Default descriptor option specified in `opts`
+      desc[opt] = opts[opt];
+    }
+    else if (typeof defval === B)
+    { // A fallback default. 
+      desc[opt] = defval;
     }
-  } // if isObj(opts)
+  }
+
+  cd('configurable', true);
+  cd('enumerable');
+  if (desc.get === undefined && desc.set === undefined)
+  { // Only look for this one on data descriptors.
+    cd('writable');
+  }
 
   // Now after all that, let's actually define the property!
   Object.defineProperty(obj, name, desc);

package/lib/types/index.js

@@ -39,6 +39,7 @@ const {needObj, needType, needs} = require('./needs');
 // A few standalone items.
 
 const def   = require('./def');
+const lazy  = require('./lazy');
 const TYPES = require('./typelist');
 const stringify = require('./stringify');
 
@@ -46,7 +47,7 @@ const stringify = require('./stringify');
 // Further tests can be added by `TYPES.add()` later.
 module.exports =
 {
-  O, F, S, B, N, U, SY, BI, TYPES, root, unbound, def,
+  O, F, S, B, N, U, SY, BI, TYPES, root, unbound, def, lazy,
   isObj, isComplex, isNil, notNil, isScalar, isArray, isTypedArray, 
   nonEmptyArray, isArguments, isProperty, doesDescriptor, 
   isInstance, isType, isa, needObj, needType, needs, stringify,

package/lib/types/lazy.js

@@ -0,0 +1,213 @@
+const def = require('./def');
+const {S,F} = require('./js');
+const {COMPLEX} = require('./typelist');
+const {needType,needObj} = require('./needs');
+const {doesDescriptor} = require('./basics');
+
+/**
+ * Metadata for the property definition.
+ * 
+ * @typedef module:@lumjs/core/types~LazyDef
+ * @property {string} name - The `name` passed to `lazy()`
+ * @property {(object|function)} target - The `target` passed to `lazy()`
+ * @property {object} opts - The `opts` passed to `lazy()`
+ * @property {object} arguments - The full `arguments` passed to `lazy()`
+ * 
+ * @property {boolean} [assign] Override default assignment rules?
+ * 
+ * This property may be added by the `LazyGetter` or `LazySetter` 
+ * functions to override the default assignment rules. 
+ * 
+ * If this is `true` the return value will be assigned, replacing the 
+ * lazy accessor property, even if the value is `undefined`.
+ * 
+ * If this is `false`, the value will be returned, but will **not** be 
+ * *assigned*, so the lazy accessor property will remain.
+ * 
+ * @property {*} [def] Special options for `def()`
+ * 
+ * The [def()]{@link module:@lumjs/core/types.def} function has an
+ * optional fourth parameter called `opts` which is used for a few
+ * specialized purposes. If this property is set, it will be used as
+ * the value for `opts` when assigning the return value to the property.
+ * 
+ * Leave it `undefined` to use the default `def()` behaviour.
+ * 
+ */
+
+/**
+ * A function to generate the property value.
+ * 
+ * @callback module:@lumjs/core/types~LazyGetter 
+ * @returns {*} The generated *value* of the property
+ * 
+ * By default if this is `undefined` the value will **not** be
+ * assigned, and instead the accessor property will remain in
+ * place to be used on subsequent calls until a value other than
+ * `undefined` is returned.
+ * 
+ * This assignment behaviour can be overridden by the function
+ * if it sets `this.assign` to an explicit boolean value.
+ * 
+ * As we are using [def()]{@link module:@lumjs/core/types.def} 
+ * to assign the value, by default if the return value appears 
+ * to be a valid *Descriptor* object, it will be used as the 
+ * property descriptor. See `def()` for further details on how
+ * it handles the various arguments.
+ * 
+ * Regardless of the value of `this.assign`, this value will
+ * be *returned* as the property value.
+ * 
+ * @this {module:@lumjs/core/types~LazyDef} A metadata object.
+ */
+
+/**
+ * A function to handle attempts at assignment.
+ * 
+ * Very similar to [LazyGetter]{@link module:@lumjs/core/types~LazyGetter}
+ * but called when property assignment is attempted on the
+ * lazy accessor property.
+ * 
+ * If you explicitly want to forbid assignment, you can throw
+ * an `Error` from this function.
+ * 
+ * @callback module:@lumjs/core/types~LazySetter
+ * @param {*} value - The value attempting to be assigned.
+ * @returns {*} The *actual* assignment value (if any.)
+ * 
+ * The same assignment rules apply as in the
+ * [LazyGetter]{@link module:@lumjs/core/types~LazyGetter}
+ * callback.
+ * 
+ * @this {module:@lumjs/core/types~LazyDef} A metadata object.
+ */
+
+/**
+ * Build a lazy initializer property.
+ * 
+ * This builds an *accessor* property that will replace itself
+ * with a initialized property, the value of which is obtained from
+ * a supplied initialization function. Any subsequent use of the
+ * property will obviously be using the initialized property directly.
+ * 
+ * The general purpose is if there is a property that requires
+ * a fairly intensive load time, or requires a large library that
+ * you may not always *need* for basic things, you can use this
+ * to ensure that the property is only initialized when needed.
+ * 
+ * This is an extension of the [def()]{@link module:@lumjs/core/types.def} 
+ * method, and indeed an alias called `def.lazy()` is also available.
+ *
+ * @param {(object|function)} target - The object to add the property to.
+ * 
+ * As with `def()` itself, this can be either an `object` or `function`,
+ * as in Javascript the latter is an extension of the former.
+ * 
+ * @param {string} name - The name of the property to add.
+ * 
+ * @param {module:@lumjs/core/types~LazyGetter} initfunc 
+ * The function to initialize the property.
+ * 
+ * This will normally only ever be called the first time the property
+ * is accessed in a *read* operation. The return value from this
+ * will be assigned to the property using `def()`, replacing the
+ * lazy accessor property.
+ * 
+ * @param {object} [opts] Options to customize behavior.
+ * 
+ * @param {module:@lumjs/core/types~LazySetter} [opts.set]
+ * A function to handle assignment attempts.
+ * 
+ * This obviously only applies to the *lazy accessor* property,
+ * and will have no affect once the property has been replaced
+ * by its initialized value.
+ * 
+ * @param {boolean} [opts.enumerable=false] Is the property enumerable?
+ * 
+ * This applies to the *lazy accessor* property only.
+ * You can set custom descriptor rules in the `initfunc`
+ * if you need them on the initialized property.
+ * 
+ * @param {?boolean} [opts.assign] The *default* value for the `assign` property
+ * in the [LazyDef]{@link module:@lumjs/core/types~LazyDef} object.
+ * 
+ * @param {*} [opts.def] The *default* value for the `def` property in
+ * the [LazyDef]{@link module:@lumjs/core/types~LazyDef} object.
+ *
+ * @returns {(object|function)} The `target` argument
+ * 
+ * @alias module:@lumjs/core/types.lazy
+ */
+function lazy(target, name, initfunc, opts={})
+{
+  needType(COMPLEX, target, 'obj must be an object');
+  needType(S, name, 'name must be a string');
+  needType(F, initfunc, 'initfunc must be a function');
+  needObj(opts, 'opts parameter was not an object');
+
+  // The `this` object for the functions.
+  const context = 
+  { 
+    name, 
+    target, 
+    opts, 
+    arguments,
+    assign: opts.assign,
+    def: opts.def,
+  }
+
+  // The descriptor for the lazy accessor.
+  const desc = 
+  {
+    configurable: true, 
+    enumerable: opts.enumerable ?? false,
+  };
+
+  // Replace the property if rules are correct.
+  const defval = function(value)
+  {
+    const assign = (context.assign ?? value !== undefined);
+    if (assign)
+    { // Replace the lazy accessor with the returned value.
+      def(target, name, value, context.def);
+      // Now return the newly assigned value.
+      return target[name];
+    }
+    else if (doesDescriptor(value))
+    { // A descriptor was returned, extract the real value.
+      if (typeof value.get === F)
+      {
+        return value.get();
+      }
+      else 
+      {
+        return value.value;
+      }
+    }
+    else 
+    { // Just return the original value.
+      return value;
+    }
+  }
+
+  desc.get = function()
+  { 
+    return defval(initfunc.call(context));
+  }
+
+  if (typeof opts.set === F)
+  { // We want to assign a lazy setter as well.
+    desc.set = function(value)
+    {
+      defval(opts.set.call(context, value));
+    }
+  }
+
+  // Assign the lazy accessor property.
+  def(target, name, desc);
+}
+
+// Gotta be one of the greatest lines...
+def(def, 'lazy', lazy);
+
+module.exports = lazy;

package/lib/types/needs.js

@@ -59,15 +59,6 @@ function needType (type, v, msg, unused)
 }
 
 exports.needType = needType;
-
-// Options parser for needs();
-const NEEDS_PARSER = function(type, v)
-{ // `this` is the options object itself.
-  if (typeof type.is === F)
-  { // We assume `is()` methods are the type check.
-    if (type.is(v)) return true;
-  }
-}
  
 /**
 * A wrapper around `isa()` that will throw an error on failure.

package/package.json

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

package/lib/lazy.js

@@ -1,100 +0,0 @@
-
-const {S,F,TYPES:{COMPLEX},needType,needObj,def} = require('./types');
-
-/**
- * @callback module:@lumjs/core~InitFunc 
- * @param {string} name - The `name` parameter passed to `lazy()`
- * @this {object} - The `obj` parameter passed to `lazy()`
- */
-
-/**
- * Build a lazy initializer property.
- *
- * Basically the first time the property is accessed it's built.
- * Subsequent accesses will use the already built property.
- * This is an extension of the {@link def} method, and indeed an
- * alias called `def.lazy()` is also available.
- *
- * @param {Object} obj - The object to add the property to.
- * @param {string} name - The name of the property to add.
- * @param {module:@lumjs/core~InitFunc} initfunc 
- *   The function to initialize the property.
- * @param {*} [onset] How to handle assignment.
- * 
- *   If this is `true` then the new value will be assigned directly,
- *   skipping the initialization process entirely.
- * 
- *   If this is `false` then any attempt at assignment will throw
- *   a `ReferenceError` with a message indicating the property is read-only.
- * 
- *   If this is a `function` it will take two arguments, the
- *   first being the value that is trying to be assigned, and
- *   the second being the currently assigned value.
- *   As with any getter or setter, `this` will be the `obj` itself.
- *   The function must return the value to be assigned.
- *   If it returns `undefined`, then the value was not valid,
- *   and will not be assigned.
- * 
- *   If this is anything else, assignment will do nothing at all.
- * 
- * @param {Object} [desc={}] Descriptor rules for the property.
- *   We only support two descriptor rules with this function, and
- *   their default values are the same as the `def()` function.
- *   - `configurable` → `true`
- *   - `enumerable` → `false`
- *   Any other descriptor properties are invalid here.
- *
- * @return {Object} The object we defined the property on.
- * @alias module:@lumjs/core.lazy
- */
-function lazy(obj, name, initfunc, onset, desc={})
-{
-  needType(COMPLEX, obj, 'obj must be an object');
-  needType(S, name, 'name must be a string');
-  needType(F, initfunc, 'initfunc must be a function');
-  needObj(desc, 'desc parameter was not an object');
-
-  let value;
-
-  desc.get = function()
-  {
-    if (value === undefined)
-    {
-      value = initfunc.call(this, name);
-    }
-    return value;
-  }
-
-  if (onset === true)
-  { // Allow direct assignment.
-    desc.set = function(newval)
-    {
-      value = newval;
-    }
-  }
-  else if (onset === false)
-  { // Throw an error on assignment.
-    desc.set = function()
-    {
-      throw new ReferenceError("The "+name+" property is read-only");
-    }
-  }
-  else if (typeof onset === F)
-  { // A proxy method for assignment.
-    desc.set = function(newval)
-    {
-      const setval = onset.call(this, newval, value);
-      if (setval !== undefined)
-      {
-        value = setval;
-      }
-    }
-  }
-
-  def(obj, name, desc);
-}
-
-// Gotta be one of the greatest lines...
-def(def, 'lazy', lazy);
-
-module.exports = lazy;