@lumjs/core 1.5.1 → 1.6.0

package/lib/index.js

@@ -19,6 +19,17 @@
  */
 const types = require('./types');
 
+/**
+ * A helper for building modules
+ * 
+ * @alias module:@lumjs/core.ModuleBuilder
+ * @see module:@lumjs/core/modulebuilder
+ */
+const Builder = require('./modulebuilder');
+
+// And we'll use the builder to define the rest of this.
+const {has,can,from} = Builder.build(module);
+
 /**
  * Define properties on an object or function
  * @name module:@lumjs/core.def
@@ -33,59 +44,14 @@ const types = require('./types');
  * @see module:@lumjs/core/types.lazy
  */
 
-// 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});
 
+// The module builder itself.
+has('ModuleBuilder', {value: Builder});
+
 /**
  * Array utility functions «Lazy»
  * @name module:@lumjs/core.arrays
@@ -119,7 +85,7 @@ can('flags');
  * @name module:@lumjs/core.obj
  * @type {module:@lumjs/core/obj}
  */
-has('obj');
+can('obj');
 
 /**
  * Functions for getting values and properties with fallback defaults «Lazy»
@@ -174,7 +140,7 @@ from('meta', 'stacktrace', 'AbstractClass', 'Functions', 'NYI');
  * @function
  * @see module:@lumjs/core/enum
  */
-has('Enum', {module: 'enum'});
+can('Enum', {module: 'enum'});
 
 /**
  * Make an object support the *Observable* API «Lazy»

package/lib/modulebuilder.js

@@ -0,0 +1,336 @@
+
+const {S,F,B,isObj,needObj,needType,def,lazy} = require('./types');
+
+function clone(obj)
+{
+  const copy = {};
+  for (const name in obj)
+  {
+    copy[name] = obj[name];
+  }
+  return copy;
+}
+
+// Methods we want to export in the functional API.
+const BUILD_METHODS = ['has', 'can', 'from'];
+
+/**
+ * A class to make building modules easier.
+ * 
+ * Basically wraps calls to `require()`, `def()`, `lazy()`,
+ * and assignments to `module.exports` into a simple set of methods.
+ * 
+ * @exports module:@lumjs/core/modulebuilder
+ */
+class ModuleBuilder
+{
+  /**
+   * Build a new ModuleBuilder instance.
+   * 
+   * @param {object} targetModule - The `module` context variable.
+   * @param {object} [opts] - Options to change some default settings.
+   * @param {boolean} [opts.configurable=false] Default `configurable` value.
+   * @param {boolean} [opts.enumerable=true] Default `enumerable` value.
+   * @param {boolean} [opts.writable=false] Default `writable` value.
+   * 
+   * @param {number} [opts.nested=NESTED_ERROR] How to handle nested names.
+   * 
+   * If the `name` parameter in either the `has()` or `can()` method is passed 
+   * as the path to a nested module with one or more `/` characters, 
+   * this mode will determine how we derive the property name. 
+   * 
+   * For each mode, we'll use an example `name` of `./some/nested/path`.
+   * 
+   * - `ModuleBuilder.NESTED_ERROR` `[0]` (default mode)
+   *   Throw an `Error` saying paths are unhandled.
+   * - `ModuleBuilder.NESTED_FIRST` `[1]`
+   *   Use the first (non-dot) path element, e.g. `some`
+   * - `ModuleBuilder.NESTED_LAST` `[2]`
+   *   Use the last path element, e.g. `path`
+   * - `ModuleBuilder.NESTED_CAMEL` `[3]`
+   *   Convert the name to camelCase, e.g. `someNestedPath`
+   * 
+   * It's always possible to set the `conf.module` parameter manually as well,
+   * which avoids the need to generate a separate parameter name.
+   * 
+   */
+  constructor(targetModule, opts={})
+  {
+    needObj(opts, 'opts was not an object');
+    needObj(targetModule, 'targetModule was not an object');
+    needObj(targetModule.exports, 'targetModule.exports was not an object');
+    needType(F, targetModule.require, 'targetModule.require was not a function');
+
+    this.module = targetModule;
+
+    this.configurable = opts.configurable ?? false;
+    this.enumerable   = opts.enumerable   ?? true;
+    this.writable     = opts.writable     ?? false;
+
+    this.nested = opts.nested ?? ModuleBuilder.NESTED_ERROR;
+
+    this.strings = opts.strings;
+    this.locale = opts.locale;
+  }
+
+  // Get a descriptor for a module export.
+  requireDescriptor(name, conf={})
+  {
+    let value = conf.value;
+    
+    if (value === undefined)
+    {
+      if (typeof conf.module === S)
+        name = conf.module; 
+      if (!name.startsWith('./'))
+        name = './'+name;
+
+      value = this.module.require(name);
+
+      if (value && conf.prop && value[conf.prop] !== undefined)
+      { 
+        value = value[conf.prop];
+      }
+    }
+
+    const configurable = conf.configurable ?? this.configurable;
+    const enumerable   = conf.enumerable   ?? this.enumerable;
+    const writable     = conf.writable     ?? this.writable;
+
+    return {configurable, enumerable, writable, value};
+  }
+
+  // Normalize a property name.
+  $normalizeProperty(name)
+  {
+    if (name.startsWith('./'))
+    { // Get rid of the prefix.
+      name = name.substring(2);
+    }
+
+    if (name.includes('/'))
+    { // Multiple paths found.
+      const names = name.split('/');
+      if (this.nested === ModuleBuilder.NESTED_FIRST)
+      {
+        name = names[0];
+      }
+      else if (this.nested === ModuleBuilder.NESTED_LAST)
+      {
+        name = names[names.length-1];
+      }
+      else if (this.nested === ModuleBuilder.NESTED_CAMEL)
+      {
+        name = this.$normalizeWithCamelCase(names);
+      }
+      else 
+      {
+        throw new Error("No valid nested path handling method was set");
+      }
+    }
+
+    return name;
+  }
+
+  $normalizeWithCamelCase(names)
+  {
+    if (this.strings === undefined)
+    {
+      this.strings = require('./strings');
+    }
+    if (this.locale === undefined)
+    {
+      this.locale = this.strings.getLocale();
+    }
+    let name = names.shift().toLocaleLowerCase(this.locale);
+    for (const path in names)
+    {
+      name += this.strings.ucfirst(path, true, this.locale);
+    }
+    return name;
+  }
+  
+  /**
+   * Export a module directly.
+   * 
+   * @param {string} name - The property name to export.
+   *
+   * @param {object} [conf] Additional export configuration options.
+   * @param {string} [conf.module=`./${name}`] The module to `require()`.
+   * @param {string} [conf.prop] If set, we want an exported property
+   * of this name from the loaded module.
+   * 
+   * If not set, the entire loaded module will be our exported value.
+   * 
+   * @param {boolean} [conf.configurable=this.configurable] 
+   * Descriptor `configurable` value.
+   * @param {boolean} [conf.enumerable=this.enumerable] 
+   * Descriptor `enumerable` value.
+   * @param {boolean} [conf.writable=this.writable] 
+   * Descriptor `writable` value.
+   * 
+   * @param {*} [conf.value] An explicit value to set.
+   * 
+   * This skips the `require()` call entirely.
+   * 
+   * @returns {object} `this`
+   */
+  has(name, conf={})
+  {
+    const pname = this.$normalizeProperty(name);
+    const desc = this.requireDescriptor(name, conf);
+    def(this.module.exports, pname, desc);
+    return this;
+  }
+
+  /**
+   * Export a lazy-loaded module.
+   * 
+   * @param {string} name - The property name to export.
+   * 
+   * @param {object} [conf] Additional export configuration options.
+   * 
+   * In addition to all the options supported by 
+   * [has()]{@link module:@lumjs/core/modules.has}
+   * this also supports one further option.
+   * 
+   * @param {object} [conf.lazy] Advanced options for the `lazy()` call.
+   * 
+   * If not specified, sane defaults will be used, that ensures the
+   * `enumerable` descriptor property for the lazy getter is set the
+   * same as the final descriptor property once its loaded.
+   * 
+   * @returns {object} `this`
+   */
+  can(name, conf={})
+  {
+    const pname = this.$normalizeProperty(name);
+    const enumerable = conf.enumerable ?? this.enumerable;
+    const lazyOpts = isObj(conf.lazy) ? conf.lazy : {enumerable};
+    const getter = () => this.requireDescriptor(name, conf);
+    lazy(this.module.exports, pname, getter, lazyOpts);
+    return this;
+  }
+
+  /**
+   * Re-export some exported properties from a module.
+   * 
+   * By default this uses `has()` to define the exports, but that
+   * can be changed using special parameter values.
+   * 
+   * @param {string} modname - The module to export the properties from.
+   * @param  {...any} libs - What we're exporting.
+   * 
+   * If this is a `string` it is the name of an exported property we want to
+   * re-export directly.
+   * 
+   * If this is `true`, all subsequent values will be exported using `can()`.
+   * 
+   * If this is `false`, all subsequent values will be exported using `has()`.
+   * 
+   * If this is an `object`, then it's considered the `conf` parameter for
+   * the `has()` or `can()` methods. If the `conf` does not have a `module`
+   * property, the `modname` will be assigned as the `module` property.
+   * You cannot set the `prop` property, as it's overwritten for every 
+   * exported property.
+   * 
+   * @returns {object} `this`
+   */
+  from(modname, ...libs)
+  {
+    let func = 'has';
+    let curConf = {module: modname};
+    for (const lib of libs)
+    {
+      if (isObj(lib))
+      { // Change the current config.
+        curConf = clone(lib);
+        if (curConf.module === undefined)
+        { // Make sure the module name is assigned.
+          curConf.module = modname;
+        }
+      }
+      else if (typeof lib === B)
+      { // Change the function we're calling.
+        func = lib ? 'can' : 'has';
+      }
+      else if (typeof lib === S)
+      {
+        const conf = clone(curConf);
+        conf.prop = lib;
+        this[func](lib, conf);
+      }
+      else 
+      {
+        throw new TypeError("libs must be strings, booleans, or objects");
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Create a functional API for the Builder class.
+   * 
+   * Basically makes a new `Builder` instance, then creates standalone 
+   * closure functions that wrap the main instance methods.
+   * 
+   * These functions can be imported into a namespace directly.
+   * They each have a special `builder` property which is a reference
+   * to the underlying `Builder` instance.
+   * 
+   * There's also a `builder` property in the exported function list.
+   * 
+   * Example usage:
+   * 
+   * ```js
+   * const {has,can,from} = require('@lumjs/core').modules.build(module);
+   * 
+   * 
+   * // exports.foo = require('./foo');
+   * has('foo'); 
+   * 
+   * // exports.someNestedPath = require('./some/nested/path');
+   * has('./some/nested/path'); 
+   * 
+   * ```
+   * 
+   * @param {object} targetModule - The `module` for the Builder instance.
+   * @param {object} [opts] - Any options for the Builder instance.
+   * @returns {object} An object containing the closure functions.
+   */
+  static build(targetModule, opts)
+  {
+    const builder = new this(targetModule, opts);
+    const funcs = {builder};
+    for (const name of BUILD_METHODS)
+    {
+      const func = function()
+      {
+        return builder[name](...arguments);
+      }
+      def(func, 'builder', builder);
+      funcs[name] = func;
+    }
+    return funcs;
+  }
+
+  /**
+   * A static alternative to `new ModuleBuilder()`;
+   * 
+   * @param {object} targetModule 
+   * @param {object} [opts] 
+   * @returns {object} The new `ModuleBuilder` instance.
+   */
+  static new(targetModule, opts)
+  {
+    return new this(targetModule, opts);
+  }
+
+}
+
+def(ModuleBuilder, 'NESTED_ERROR', 0)
+def(ModuleBuilder, 'NESTED_FIRST', 1);
+def(ModuleBuilder, 'NESTED_LAST',  2);
+def(ModuleBuilder, 'NESTED_CAMEL', 3);
+
+module.exports = ModuleBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/core",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "main": "lib/index.js",
   "exports":
   {
@@ -12,6 +12,7 @@
     "./flags": "./lib/flags.js",
     "./obj": "./lib/obj/index.js",
     "./opt": "./lib/opt.js",
+    "./modulebuilder": "./lib/modulebuilder.js",
     "./modules": "./lib/modules.js",
     "./meta": "./lib/meta.js",
     "./enum": "./lib/enum.js",

package/docs/changelogs/1.0-beta.md

@@ -1,93 +0,0 @@
-# Changelog → 1.0-beta.x
-
-This is the changelog for the `1.0-beta.x` versions.
-
-See [Changelogs](index.md) for more information on the changelogs.
-
-## [1.0.0-beta.6]
-- This is the **final** beta version. 
-- Version `1.0.0` will be this but with the docs updated a bit.
-### Added
-- More tests for the `types` module.
-- Changelog file for the upcoming `1.x` *stable* releases.
-### Changed
-- Removed some convoluted options from `def()`.
-- Reworked `types.stringify()` to handle recursive mode better.
-- Added `Error` stringification to `types.stringify()`
-
-## [1.0.0-beta.5] - 2022-07-18
-### Added
-- A new `types.stringify()` method.
-- Shortcut `string` options for the `types.def()` method.
-- A `build-docs` script in `package.json`.
-### Changed
-- Overhauled all DocBlocks to conform to `JSDoc 3` format.
-- Changed `context.has` to support a magic `Proxy` version.
-- Some tweaks to `Enum` to cleanup some things.
-- Both `Enum` and `observable` use `TYPES.add()` now.
-- In `modules.name()` nixed `opts.noAuto` and added `opts.useAuto` instead.
-- Created explicit `exports` definition in `package.json` with our sub-modules.
-### Fixed
-- Fixed a property definition issue in `obj.SOA()`. 
-
-## [1.0.0-beta.4] - 2022-07-15
-### Added
-- Two new clone modes:
-  - `CLONE.DEEP` : A recursive clone of enumerable properties.
-  - `CLONE.ENTIRE` : A recursive clone of all properties.
-- Added `types.isa()` which wraps `isType()` and `isInstance()` along with some added magic that makes it a generic *smart match* function.
-- Added `types.needs()` which does for `isa()` what `needOb()` and `needType()` do for `isObj()` and `isType()` respectively.
-- A `jsdoc.json` based on the one from the old [Lum.js](https://github.com/supernovus/lum.js) codebase.
-- A temporary `test` script to the `package.json` which uses the `prove` utility from Perl 5.
-### Removed
-- Removed `descriptors` and `prop()` modules.
-  - They'll be in a new `@lumjs/compat` library for legacy compatibility code.
-### Changed
-- Updated this *changelog* which I forgot to do last time.
-- Fixed some formatting in the changelog.
-- Split `types` into separated files.
-- Moved/renamed a few functions:
-  - `types.containsAny()` → `arrays.containsAny()`
-  - `types.containsAll()` → `arrays.containsAll()`
-  - `types.removeFromArray()` → `arrays.removeItems()`
-  - `types.NYI()` → `meta.NYI()`
-- Updated tests to reflect the moved/renamed functions.
-- Enhanced `def()` function as it has fully replaced `prop()` now.
-  - Has a new `opts` parameter which can be used for a few different options.
-  - Allows assigning a *getter* and *setter* without using a descriptor.
-- Updated `lazy()` to be an extension of `def()` instead of `prop()`.
-- Updated `obj/clone` and `obj/lock` to remove use of `descriptors` magic.
-- Updated `CLONE` mode documentation to use a table format.
-- A few minor tweaks and cleanups related to the rest of the above changes.
-- Updated [../../TODO.md](TODO.md) with the plans for the final `1.0.0` release.
-
-## [1.0.0-beta.3] - 2022-07-11
-### Added
-- `core.context.hasRequire`: A boolean value indicating `require()`
-- `core.context.isNode`: A boolean value guessing the environment is node.js
-### Changed
-- `core.context.CJS`: Made slightly tighter in definition.
-- `core.modules.name()`: Made it more flexible.
-- `core.obj`: Changed namespace exports.
-### Fixed
-- `core.modules.name()`: Actually return the value!
-
-## [1.0.0-beta.2] - 2022-07-08
-### Changed
-- Renamed `src` to `lib` as we're not compiling/transpiling this code.
-- Moved `index.js` into `lib` with the rest of the module files.
-- Added `modules.js` with a method for generating a name/id for a module.
-- Added `isSearch()`,`isReplacement()`, and `replaceItems()` to `strings.js`.
-
-## [1.0.0-beta.1] - 2022-07-07
-### Added
-- Initial release.
-- Pulled a bunch of the core libraries from the old Lum.js project.
-- Refactored and reorganized the libraries a lot.
-
-[1.0.0-beta.6]: https://github.com/supernovus/lum.core.js/compare/v1.0.0-beta.5...v1.0.0-beta.6
-[1.0.0-beta.5]: https://github.com/supernovus/lum.core.js/compare/v1.0.0-beta.4...v1.0.0-beta.5
-[1.0.0-beta.4]: https://github.com/supernovus/lum.core.js/compare/v1.0.0-beta.3...v1.0.0-beta.4
-[1.0.0-beta.3]: https://github.com/supernovus/lum.core.js/compare/v1.0.0-beta.2...v1.0.0-beta.3
-[1.0.0-beta.2]: https://github.com/supernovus/lum.core.js/compare/v1.0.0-beta.1...v1.0.0-beta.2
-[1.0.0-beta.1]: https://github.com/supernovus/lum.core.js/releases/tag/v1.0.0-beta.1

package/docs/changelogs/1.x.md

@@ -1,111 +0,0 @@
-# Changelog → 1.x
-
-This is the changelog for the `1.x` versions.
-
-See [Changelogs](index.md) for more information on the changelogs.
-
-## [Unreleased]
-
-## [1.5.1] - 2022-09-29
-### Changed
-- Removed `constructor()` from `AbstractClass`.
-- Added `$needs()` to `AbstractClass`.
-### Fixed
-- `AbstractClass` actually works properly now.
-
-## [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.
-- Recursive dependency order issues with `clone`, `lock`, and `enum` resolved.
-- Custom `lock` options in `enum` module actually work now.
-### Changed
-- The `Enum()` function now has `configurable` and `enumerable` options.
-- The `configurable` property in `enums` defaults to `false` now.
-- Tweaked the *changelogs* a bit and added a new [changelog listing](index.md).
-
-## [1.3.0] - 2022-09-11
-### Changed
-- Overhauled the `obj.clone()` method.
-- Added *named options* for all of the behaviours that the `CLONE` *modes* affect.
-  While this technically could make the *modes* obsolete, I'm leaving them in as
-  simple sets of default options that can be used instead of manually choosing all
-  of the individual options.
-- Added a new `CLONE.N` *mode* which has **no** options turned on.
-  It will always remain first in the *enum* list so it's value will always be `0`.
-- Added the ability to clone properties using their descriptors.
-  It is enabled by default on most of the *modes* now, as it simply makes sense.
-- Added the ability to set the `prototype` on the cloned object.
-- The `opts` parameter of `clone()` may be a `CLONE.*` enum value.
-  It's a shortcut for `{mode: CLONE.MODE}` for convenience.
-- A small tweak to `obj.copyProps()`, not important, just a cleanup.
-### Fixed
-- A reference in the DocBlock for `obj.getProperty()`.
-
-## [1.2.1] - 2022-09-05
-### Added
-- `core.InternalObjectId#untag()`
-### Changed
-- Cleaned up the wording in a docblock, and updated a test to use `done()`.
-
-## [1.2.0] - 2022-08-10
-### Added
-- Moved the `array.powerset()` and `array.random()` methods from Lum.js v4 into `core.arrays`.
-- Added a new `core.context.isCommonJS()` method which is only used in certain circumstances.
-
-### Fixed 
-- A typo in one of the `package.json` exports.
-- Commented out a debugging line.
-
-## [1.1.1] - 2022-08-02
-### Fixed
-- A couple missing constants in some functions.
-
-## [1.1.0] - 2022-07-29
-### Added
-- `types.doesDescriptorTemplate()` method.
-- `obj.getProperty()` method (used to be in the `descriptors` sub-module.)
-### Changed
-- Tweaked documentation for:
-  - `obj.getObjectPath()`
-  - `obj.setObjectPath()`
-  - `obj.getNamespace()`
-  - `obj.setNamespace()`
-- Updated error messages in `obj.setObjectPath()`
-- Made `obj.setObjectPath()` use `types.doesDescriptorTemplate()` for validation of `opts.desc` option.
-- Changed `obj.getObjectPath()` and `obj.setObjectPath()` to support `function` parent objects.
-- Enhanced `types.stringify()` to support `RegExp` as well as supporting custom extensions down the road.
-
-## [1.0.0] - 2022-07-27
-### Changed
-- Initial *stable* release.
-- 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.5.1...HEAD
-[1.5.1]: https://github.com/supernovus/lum.core.js/compare/v1.5.0...v1.5.1
-[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
-[1.2.0]: https://github.com/supernovus/lum.core.js/compare/v1.1.1...v1.2.0
-[1.1.1]: https://github.com/supernovus/lum.core.js/compare/v1.1.0...v1.1.1
-[1.1.0]: https://github.com/supernovus/lum.core.js/compare/v1.0.0...v1.1.0
-[1.0.0]: https://github.com/supernovus/lum.core.js/releases/tag/v1.0.0

package/docs/changelogs/index.md

@@ -1,19 +0,0 @@
-# Changelogs
-
-All notable changes to this project will be documented in these files.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## Versions
-
-To avoid the changelogs getting too big, I'm planning on splitting them up based
-on the major version changes.
-
-Each major version will be listed here in reverse chronological order (newest first.)
-
-- [1.x](1.x.md) → The first standalone core library.
-- [1.0-beta.x](1.0-beta.md)
-  → The *pre-releases* from when this split off of the older 
-  [Lum.js](https://github.com/supernovus/lum.js) library collection.
-

package/test/arrays.js

@@ -1,19 +0,0 @@
-// Current test count.
-const plan = 5;
-// A new test instance.
-const t = require('@lumjs/tests').new({module, plan});
-// The arrays core module
-const arr = require('../lib/arrays');
-
-t.ok(arr.containsAny(['hello','world'], 'world'), 'containsAny([a], a)');
-t.ok(!arr.containsAny(['hello','world'], 'universe'), '!containsAny([a], b)');
-t.ok(arr.containsAll(['hello','darkness','my','old','friend'], 'hello', 'friend'), 'containsAll([a,b,c], a, c)');
-t.ok(!arr.containsAll(['nothing','to','see'], 'nothing', 'here'), '!containsAll([a,b,c], a, d)');
-
-const a1 = ['hello', 'darkness', 'my', 'old', 'friend'];
-arr.removeItems(a1, 'darkness');
-t.isJSON(a1, ['hello','my','old','friend'], 'removeFromArray(...)');
-
-// All done.
-t.output();
-

package/test/meta.js

@@ -1,17 +0,0 @@
-// Current test count.
-const plan = 1;
-// A new test instance.
-const t = require('@lumjs/tests').new({module, plan});
-// The meta core module
-const meta = require('../lib/meta');
-
-t.dies(()=>meta.NYI(), 'NYI()');
-
-// TODO:
-// - stacktrace()
-// - AbstractClass
-// - Functions.*
-
-// All done.
-t.output();
-

package/test/types.js

@@ -1,268 +0,0 @@
-// Current test count.
-const plan = 120;
-// A new test instance.
-const t = require('@lumjs/tests').new({module, plan});
-// The types core module
-const types = require('../lib/types');
-
-// A quick reference to the type names.
-const TYP = types.TYPES;
-// And the stringify function.
-const stringify = types.stringify;
-
-// Now for some further basics.
-t.ok(types.isObj({}), 'isObj({})');
-t.ok(types.isComplex({}), 'isComplex(object)');
-t.ok(types.isComplex(function(){}), 'isComplex(function)');
-t.ok(types.isNil(undefined), 'isNil(undefined)');
-t.ok(types.isNil(null), 'isNil(null)');
-t.ok(types.notNil(true), 'notNil(true)');
-t.ok(types.notNil(false), 'notNil(false)');
-t.ok(types.notNil(''), "notNil('')");
-t.ok(types.isScalar(true), 'isScalar(true)');
-t.ok(types.isScalar(0), 'isScalar(0)');
-t.ok(!types.isScalar({}), '!isScalar({})');
-t.ok(!types.isScalar(null), '!isScalar(null)');
-t.ok(types.isArray([]), 'isArray([])');
-t.ok(types.isTypedArray(new Int8Array(8)), 'isTypedArray(Int8Array)');
-t.ok(types.nonEmptyArray([1,2,3]), 'nonEmptyArray([1,2,3])');
-t.ok(!types.nonEmptyArray([]), '!nonEmptyArray([])');
-t.ok(types.isProperty('hi'), 'isProperty(string)');
-t.ok(types.isProperty(Symbol('hi')), 'isProperty(Symbol)');
-t.ok(!types.isProperty(false), '!isProperty(false)')
-
-function getArguments() { return arguments; }
-
-t.ok(types.isArguments(getArguments()), 'isArguments(arguments)');
-t.ok(!types.isArguments({}), '!isArguments({})');
-
-class TypeClass 
-{
-  notUnbound()
-  {
-    t.ok(!types.unbound(this), '!unbound(instanceThis)');
-  }
-}
-
-class SubtypeClass extends TypeClass {}
-
-const typesInstance = new TypeClass();
-const subtypeInstance = new SubtypeClass();
-
-class DifferentClass {}
-
-const differentInstance = new DifferentClass();
-
-t.ok(types.isInstance(typesInstance, TypeClass), 'isInstance(typeInstance,TypeClass)');
-t.ok(types.isInstance(subtypeInstance, SubtypeClass), 'isInstance(subtypeInstance, SubtypeClass)');
-t.ok(types.isInstance(subtypeInstance, TypeClass), 'isInstance(subtypeInstance, TypeClass)');
-t.ok(!types.isInstance(typesInstance, SubtypeClass), '!isInstance(typeInstance, SubtypeClass)');
-t.ok(!types.isInstance(differentInstance, TypeClass), '!isInstance(differentInstance, TypeClass)');
-t.ok(!types.isInstance(typesInstance, DifferentClass), '!isInstance(typesInstance, DifferentClass)');
-
-function doesDesc (tests, not=false)
-{
-  for (const it of tests)
-  {
-    let result = types.doesDescriptor(it);
-    if (not) result = !result;
-    const desc = (not?'!':'')+'doesDescriptor'+stringify(it)+')';
-    t.ok(result, desc);
-  }
-}
-
-doesDesc(
-[
-  {value: true},
-  {value: {}, writable: true},
-  {get: function(){}},
-  {set: function(){}},
-  {get: function(){}, set: function(){}},
-  {get: function(){}, configurable: true},
-]);
-
-doesDesc(
-[
-  {},
-  {value: true, get: function(){}},
-  {value: true, set: function(){}},
-  {get: function(){}, writable: true},
-  {set: function(){}, writable: true},
-], true);
-
-function testIsType (tests, not=false)
-{
-  for (const it of tests)
-  {
-    let result = types.isType(it[0], it[1]);
-    if (not) result = !result;
-    const desc = (it.length > 2) 
-      ? it[2] 
-      : (it[0]+','+stringify(it[1]));
-    t.ok(result, (not?'!':'')+'isType('+desc+')');
-  }
-}
-
-testIsType(
-[
-  [TYP.O, {}],
-  [TYP.F, function(){}],
-  [TYP.S, 'hello'],
-  [TYP.B, true],
-  [TYP.B, false],
-  [TYP.N, 100],
-  [TYP.U, undefined],
-  [TYP.SY, Symbol('foo'), TYP.SY+',Symbol'],
-  [TYP.BI, BigInt(12345), TYP.BI+',BigInt(12345)'],
-  [TYP.BI, 54321n, TYP.BI+',54321n'],
-  [TYP.ARGS, getArguments()],
-  [TYP.ARRAY, []],
-  [TYP.NULL, null],
-  [TYP.TYPEDARRAY, new Int16Array(16), TYP.TYPEDARRAY+',Int16Array(16)'],
-  [TYP.DESCRIPTOR, {value: true}],
-  [TYP.DESCRIPTOR, {get: function(){}}],
-  [TYP.COMPLEX, {}],
-  [TYP.COMPLEX, function(){}],
-  [TYP.SCALAR, true],
-  [TYP.SCALAR, 'hi'],
-  [TYP.PROP, 'woah'],
-  [TYP.PROP, Symbol('woah')],
-]);
-
-testIsType(
-[
-  [TYP.O, 'foo'],
-  [TYP.O, null],
-  [TYP.F, {}],
-  [TYP.B, 0],
-  [TYP.B, 1],
-  [TYP.N, '0'],
-  [TYP.U, null],
-  [TYP.SY, 'foo'],
-  [TYP.BI, 12345],
-  [TYP.ARGS, {}],
-  [TYP.ARRAY, {}],
-  [TYP.NULL, false],
-  [TYP.TYPEDARRAY, []],
-  [TYP.DESCRIPTOR, {value: true, get: function(){}}],
-  [TYP.DESCRIPTOR, {}],
-  [TYP.COMPLEX, 'a string'],
-  [TYP.SCALAR, {}],
-  [TYP.PROP, null],
-], true);
-
-(function(){ t.ok(types.unbound(this), 'unbound(unboundThis)'); })();
-(function(){ t.ok(!types.unbound(this), '!unbound(boundThis)') }).bind({})();
-typesInstance.notUnbound();
-
-t.ok((function(){types.needObj({}); return true})(), 'needObj({})');
-t.dies(function(){types.needObj(null); return true}, '!needObj(null)');
-
-t.ok((function(){types.needType(TYP.S, 'hi'); return true})(), "needType('string','hi')");
-t.dies(function(){types.needType(TYP.O, null); return true}, "!needType('object',null)");
-
-{ // Tests of isa() method.
-  let wants = [TYP.S, TYP.N];
-  t.ok(types.isa('hi', ...wants), 'isa(val, ...types)');
-  t.isa('hello', wants, ' ^ using Test.isa()');
-  t.isa(42, wants, ' ^ with second type');
-  t.ok(!types.isa({}, ...wants), '!isa(val, ...types)');
-  t.nota({}, wants, ' ^ using Test.nota()');
-
-  wants = [SubtypeClass, DifferentClass];
-  t.isa(subtypeInstance, wants, 'isa(val, ...classes)');
-  t.isa(differentInstance, wants, ' ^ with second class');
-  t.nota(typesInstance, wants, 'nota(val, ...classes)');
-
-  wants = [TYP.B, TypeClass];
-  t.isa(true, wants, 'isa() → with mixed types/classes');
-  t.isa(subtypeInstance, wants, ' ^ with second type/class');
-}
-
-{ // Tests of needs() method.
-  let needs = [TYP.S, TYP.N];
-  t.lives(() => types.needs('hi', ...needs), 'needs(val, ...types)');
-  t.lives(() => types.needs(42, ...needs), ' ^ with second type');
-  t.dies(() => types.needs({}, ...needs), ' ^ throws on failure');
-
-  needs = [SubtypeClass, DifferentClass];
-  t.lives(() => types.needs(subtypeInstance, ...needs), 'needs(val, ...classes)');
-  t.lives(() => types.needs(differentInstance, ...needs), ' ^ with second class');
-  t.dies(() => types.needs(typesInstance, ...needs), ' ^ throws on failure');
-
-  needs = [TYP.B, TypeClass];
-  t.lives(() => types.needs(true, ...needs), 'needs() → with mixed types/classes');
-  t.lives(() => types.needs(subtypeInstance, ...needs), ' ^ with second type/class');
-}
-
-{ // Try a few versions of 'def'
-  const obj = {};
-  types.def(obj, 'test1', 'Test 1');
-  t.is(obj.test1, 'Test 1', 'def(obj, name, value)');
-  types.def(obj)('test2', 'Test 2');
-  t.is(obj.test2, 'Test 2', 'def(obj)(name, value)');
-  obj.test2 = '2 Test';
-  t.is(obj.test2, 'Test 2', 'def() is read-only by default');
-
-  types.def(obj, true)('test3', 'Test 3');
-  t.is(Object.keys(obj).length, 1, 'def(obj, true)(...)');
-  
-  types.def(obj, 'a1', function()
-  { // Returning a different property.
-    return this.test2;
-  },
-  function(val)
-  { // Assigning to a different property.
-    this.$$ = val;
-  });
-
-  const gs = 'def(obj, name, getter, setter)';
-  t.is(obj.a1, 'Test 2', gs+'~getter');
-  obj.a1 = 'A1->$$';
-  t.is(obj.$$, 'A1->$$', gs+'~setter');
-
-  types.def(obj, 'test4', 'Test 4', {writable: true});
-  t.is(obj.test4, 'Test 4', 'def(..., {writable}) → added property');
-  obj.test4 = '4 Test';
-  t.is(obj.test4, '4 Test', ' ^ and it was writable');
-
-  const td = types.def(obj);
-  td('getOnly', {get: function() { return 'GETTER'; }});
-  obj.getOnly = 'blah blah blah';
-  t.is(obj.getOnly, 'GETTER', 'def(..., {get: getter}) → getter worked');
-  td('setOnly', {set: function(val) { this.__ = val; }});
-  obj.setOnly = 'SETTER';
-  t.is(obj.__, 'SETTER', 'def(..., {set: setter}) → setter worked');
-  t.is(obj.setOnly, undefined, ' ^ get is undefined');
-
-  td('foobar', {value: 'FOO BAR'});
-  t.is(obj.foobar, 'FOO BAR', 'def(..., {value})');
-
-  let anObj = {value: 'BAR FOO'};
-  td('barfoo', anObj, false);
-  t.is(obj.barfoo, anObj, 'def(..., descriptor, false) → assigned object as value');
-  
-  td('barfoo2', anObj);
-  t.is(anObj.configurable, true, 'def(..., descriptor) → descriptor is a reference');
-
-  anObj = {value: 'new test'};
-  td('barfoo3', anObj, true);
-
-  t.is(anObj.configurable, undefined, 'def(..., descriptor, true) → cloned descriptor');
-  t.is(obj.barfoo3, 'new test', ' ^ value was correct')
-
-  td(
-  {
-    hello: 'World',
-    goodbye: 'Universe',
-  });
-
-  t.ok((obj.hello === 'World' && obj.goodbye === 'Universe'), 'def(obj, {prop1: value1, prop2: value2})')
-}
-
-// TODO: isa() and needs()
-// TODO: stringify()
-
-// All done.
-t.done();
-