@lumjs/core 1.0.0-beta.1 → 1.0.0-beta.2

package/CHANGELOG.md

@@ -6,6 +6,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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.
@@ -13,5 +20,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Refactored and reorganized the libraries a lot.
 
 [Unreleased]: https://github.com/supernovus/lum.core.js/compare/v1.0.0-beta.1...HEAD
+[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/TODO.md

@@ -1,6 +1,7 @@
 # TODO
 
 - Proper tests using new [@lumjs/tests](https://github.com/supernovus/lum.tests.js) library.
+  - [ ] `index`
   - [x] `types`
   - [ ] `context`
   - [ ] `strings`

package/{index.js → lib/index.js}

@@ -5,32 +5,32 @@
  * Constants and functions for basic type checking.
  * @namespace types
  */
-const types = require('./src/types');
+const types = require('./types');
 const def = types.def;
 
 /**
  * Information about the JS context we're running in.
  * @namespace context
  */
-const context = require('./src/context');
+const context = require('./context');
 
 /**
  * Functions for working with strings and locales.
  * @namespace strings
  */
-const strings = require('./src/strings');
+const strings = require('./strings');
 
 /**
  * Functions for working with binary flags.
  * @namespace flags
  */
-const flags = require('./src/flags');
+const flags = require('./flags');
 
 /**
  * Functions and Enums for working with Descriptors.
  * @namespace descriptors
  */
-const descriptors = require('./src/descriptors');
+const descriptors = require('./descriptors');
 // The *primary* export from descriptors is DESC.
 const DESC = descriptors.DESC;
 
@@ -38,27 +38,32 @@ const DESC = descriptors.DESC;
  * Functions for manipulating objects.
  * @namespace obj
  */
-const obj = require('./src/obj');
+const obj = require('./obj');
 
 /**
- * Function for getting values and properties with fallback defaults.
+ * Functions for getting values and properties with fallback defaults.
  * @namespace opt
  */
-const opt = require('./src/opt');
+const opt = require('./opt');
+
+/**
+ * Meta functions related to JS modules.
+ */
+const modules = require('./modules');
 
 // A few modules that we're going to expand into the main exports. 
-const {randomNumber, InternalObjectId} = require('./src/objectid');
-const {stacktrace,AbstractClass,Functions} = require('./src/meta');
+const {randomNumber, InternalObjectId} = require('./objectid');
+const {stacktrace,AbstractClass,Functions} = require('./meta');
 
 // And finally some standalone functions.
-const Enum = require('./src/enum');
-const prop = require('./src/prop');
-const lazy = require('./src/lazy');
-const observable = require('./src/observable');
+const Enum = require('./enum');
+const prop = require('./prop');
+const lazy = require('./lazy');
+const observable = require('./observable');
 
 module.exports =
 {
   types, context, strings, flags, descriptors, obj, opt,
   randomNumber, InternalObjectId, Enum, prop, lazy, observable,
-  stacktrace, AbstractClass, Functions, def, DESC,
+  stacktrace, AbstractClass, Functions, def, DESC, modules,
 }

package/lib/modules.js

@@ -0,0 +1,77 @@
+// Stuff specific to mostly Node.js, but browser-shims may wrap this.
+
+const path = require('path');
+const {S,needObj,needType,isObj} = require('./types');
+const replace = require('./strings').replaceItems;
+
+/**
+ * Get the name of a module.
+ *
+ * TODO: document this.
+ */
+function name(module, opts={})
+{
+  needObj(module);
+  needType(S, module.filename);
+
+  let filename = module.filename;
+  const ext = path.extname(filename);
+
+  let useFallback = true;
+  let useAuto = !opts.noAuto;
+
+  if (opts.basename)
+  { // We want to run the basename sequence first.
+    filename = path.basename(filename, ext);
+    useFallback = false;
+    useAuto = false;
+  }
+  
+  if (isObj(opts.replace))
+  { // Replacements using replace() or replaceAll() based on parameter format.
+    useFallback = false;
+    filename = replace(filename, opts.replace);
+  }
+
+  if (isObj(opts.replaceOne))
+  { // Replacements using replace() regardless of parameter format.
+    useFallback = false;
+    filename = replace(filename, opts.replaceOne, false);
+  }
+
+  if (isObj(opts.replaceAll))
+  { // Replacements using replaceAll() regardless of parameter format.
+    useFallback = false;
+    filename = replace(filename, opts.replaceAll, true);
+  }
+
+  if (typeof opts.strip === S)
+  { // A prefix. This always uses replace(), never replaceAll(). 
+    filename = filename.replace(opts.strip, '');
+    useFallback = false;
+  }
+  else if (Array.isArray(opts.strip))
+  { // A list of strings or regexps to strip. Ditto on the use of replace().
+    for (const strip of opts.strip)
+    {
+      filename = filename.replace(strip, '');
+    }
+    useFallback = false;
+  }
+
+  if (useFallback)
+  { // We're going to use the basename, either as a fallback
+    filename = path.basename(filename, ext);
+    useAuto = false;
+  }
+
+  if (useAuto)
+  { // A few automatic rules that normally apply if the fallback was not used.
+    filename = filename
+      .replace(/^[./]+/, '')
+      .replace(RegExp(ext+'$'), '');
+  }
+
+}
+
+exports.name = name;

package/{src → lib}/strings.js

@@ -1,5 +1,5 @@
 // String methods.
-const {isObj,root} = require('./types')
+const {S,B,F,isObj,root,isArray,needType,needObj} = require('./types')
 
 /**
  * Get the locale/language string.
@@ -74,3 +74,80 @@ function ucwords(string, unicode = false, lcrest = false, locale = getLocale())
 }
 
 exports.ucwords = ucwords;
+
+/**
+ * Is the passed in value a valid `String.replace` search value.
+ */
+function isSearch(value)
+{
+  return (typeof value === S || value instanceof RegExp);
+}
+
+exports.isSearch = isSearch;
+
+/**
+ * Is the passed in value a valid `String.replace` replacement value.
+ */
+function isReplacement(value)
+{
+  return (typeof value === S || typeof value === F);
+}
+
+exports.isReplacement = isReplacement;
+
+function replaceItems(string, replacements, useAll)
+{
+  needType(S, string);
+  needObj(replacements);
+
+  // This will call the appropriate method.
+  function replace()
+  {
+    if (useAll)
+      string = string.replaceAll(...arguments);
+    else
+      string = string.replace(...arguments);
+  }
+
+  if (isArray(replacements))
+  { // An array of arrays of replace/replaceAll parameters.
+    useAll = useAll ?? false; // Defaults to false here if it wasn't set.
+    for (const replacement of replacements)
+    {
+      if (isArray(replacement) && replacement.length == 2
+        && isSearch(replacement[0]) && isReplacement(replacement[1]))
+      { // A set of parameters for the function.
+        replace(...replacement);
+      }
+      else if (typeof replacement === B)
+      { // A boolean will override the current useAll value.
+        useAll = replacement;
+      }
+      else 
+      { // That's not valid.
+        console.error("Invalid replacement value", replacement);
+      }
+    }
+  }
+  else 
+  { // Any other object is a map of find strings to replacement values.
+    useAll = useAll ?? true; // Defaults to true here if it wasn't set.
+    for (const find in replacements)
+    {
+      const value = replacements[find];
+      if (isReplacement(value))
+      { 
+        replace(find, value);
+      }
+      else 
+      { 
+        console.error("Invalid replacement value", value);
+      }
+    }
+  }
+
+  return string;
+}
+
+exports.replaceItems = replaceItems;
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lumjs/core",
-  "version": "1.0.0-beta.1",
-  "main": "index.js",
+  "version": "1.0.0-beta.2",
+  "main": "lib/index.js",
   "license": "MIT",
   "repository":
   {

package/test/types.js

@@ -3,7 +3,7 @@ const plan = 91;
 // A new test instance.
 const t = require('@lumjs/tests').new({module, plan});
 // The types core module
-const types = require('../index').types;
+const types = require('../lib/types');
 
 // And a quick reference to the type names.
 const TYP = types.TYPES;