@gkalpak/aliases 0.9.4 → 0.10.1

package/lib/utils.js

@@ -1,45 +1,65 @@
-'use strict';
-
 // Imports
-const isWsl = require('is-wsl');
+import {existsSync, readFileSync, realpathSync} from 'node:fs';
+import {createRequire} from 'node:module';
+import {fileURLToPath, pathToFileURL} from 'node:url';
+
+import isWsl from 'is-wsl';
+
 
 // Constants
 const LINE_LIMIT = 75;
 const INDENT_PER_LEVEL = 2;
-
-// Variables
-const platform = isWsl ? 'wsl' : process.platform;
+const PLATFORM = isWsl ? 'wsl' : process.platform;
+const internal = {
+  _fsExistsSync,
+  _fsRealpathSync,
+  _getPlatform,
+  _import,
+  _onError,
+  _wrapLine,
+};
 
 // Exports
-const utils = module.exports = {
-  capitalize: _capitalize,
-  finallyAsPromised: _finallyAsPromised,
-  getPlatform: _getPlatform,
-  onError: _onError,
-  padRight: _padRight,
-  require: _require,
-  requireWithEnv: _requireWithEnv,
-  stripIndentation: _stripIndentation,
-  wrapLine: _wrapLine,
+export {
+  capitalize,
+  getPlatform,
+  hasOwnProperty,
+  importWithEnv,
+  isMain,
+  loadJson,
+  onError,
+  padRight,
+  stripIndentation,
+  wrapLine,
+
+  // Exposed for testing purposes only.
+  internal as _testing,
 };
 
-// Functions - Definitions
-function _capitalize(str) {
-  return `${str[0].toUpperCase()}${str.slice(1)}`;
+// Helpers
+function _fsExistsSync(path) {
+  return existsSync(path);
 }
 
-function _finallyAsPromised(promise, callback) {
-  return promise.then(
-      val => Promise.resolve(callback()).then(() => val),
-      err => Promise.resolve(callback()).then(() => Promise.reject(err)));
+function _fsRealpathSync(path) {
+  return realpathSync(path);
 }
 
 function _getPlatform() {
-  return platform;
+  return PLATFORM;
+}
+
+function _import(filePath) {
+  return import(filePath);
 }
 
-function _onError(err) {
-  const chalk = require('chalk');
+async function _onError(err) {
+  // NOTE:
+  //   Avoid eagerly loading `chalk` at the top of the file to allow for it to be imported (directly
+  //   or transitively) with `importWithEnv()`. This is, for example, useful for being able to force
+  //   the use of colors.
+  const {default: chalk} = await import('chalk');
+
   const isExitCode = err && (typeof err === 'number');
   const errorMsg = (err instanceof Error) ? err.stack : `${isExitCode ? 'Exit code' : 'Error'}: ${err}`;
 
@@ -47,41 +67,89 @@ function _onError(err) {
   process.exit(isExitCode ? err : 1);
 }
 
-function _padRight(str, len) {
-  const padLen = Math.max(0, len - str.length);
-  const pad = ' '.repeat(padLen);
+function _wrapLine(line, indent) {
+  if (line.length <= LINE_LIMIT) {
+    return line;
+  }
 
-  return `${str}${pad}`;
+  const extraIndent = ' '.repeat(INDENT_PER_LEVEL);
+  const sep = Date.now() + Math.random();
+  const re = new RegExp(/\s&&/.test(line) ? '(\\s)(&&)' : `(.{${LINE_LIMIT},}?\\s)()`, 'g');
+
+  let lines = line.replace(re, `$1${sep}$2`).split(sep).filter(l => l.trim());
+  if (lines.length > 1) {
+    lines = lines.map(l => wrapLine(l, `${indent}${extraIndent}`));
+  }
+
+  return lines.join(`\n${indent}${extraIndent}`);
 }
 
-function _require(depName) {
-  return require(depName);
+function capitalize(str) {
+  return `${str[0].toUpperCase()}${str.slice(1)}`;
 }
 
-function _requireWithEnv(depName, env, tempEnvVars) {
-  if (depName.startsWith('.')) {
-    throw new Error(utils.stripIndentation(`
-      Unable to resolve '${depName}'. Relative paths are not supported.
-      (To load relative files use \`requireWithEnv(require.resolve('${depName}'), ...)\`.)
-    `));
-  }
+function getPlatform() {
+  return internal._getPlatform();
+}
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+async function importWithEnv(targetImportPath, sourceImportMetaUrl, tempEnvVars) {
+  const {env} = process;
 
   const tempEnvVarNames = Object.keys(tempEnvVars);
   const originalValues = tempEnvVarNames.
-    filter(name => env.hasOwnProperty(name)).
+    filter(name => hasOwnProperty(env, name)).
     reduce((aggr, name) => Object.assign(aggr, {[name]: env[name]}), {});
 
+  const req = createRequire(sourceImportMetaUrl);
+  const resolvedImportPath = req.resolve(targetImportPath);
+  const resolvedImportUrl = ((resolvedImportPath === targetImportPath) && !/[\\/]/.test(resolvedImportPath)) ?
+    // It's a built-in module: Do not convert to file URL.
+    resolvedImportPath :
+    // It's a relative path: Convert to file URL.
+    pathToFileURL(resolvedImportPath).href;
+
   try {
     Object.assign(env, tempEnvVars);
-    return utils.require(depName);
+    return await internal._import(resolvedImportUrl);
   } finally {
-    tempEnvVarNames.forEach(name => originalValues.hasOwnProperty(name) ?
+    tempEnvVarNames.forEach(name => hasOwnProperty(originalValues, name) ?
       env[name] = originalValues[name] :
       delete env[name]);
   }
 }
 
-function _stripIndentation(str) {
+function isMain(fileUrl) {
+  const mainExt = ['', '.js'].find(ext => internal._fsExistsSync(`${process.argv[1]}${ext}`)) ?? '';
+  const mainPath = internal._fsRealpathSync(`${process.argv[1]}${mainExt}`);
+  const filePath = fileURLToPath(fileUrl);
+
+  return filePath === mainPath;
+}
+
+function loadJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    throw new Error(`Failed to load and parse JSON file '${filePath}': ${err?.message || err}`);
+  }
+}
+
+function onError(err) {
+  return internal._onError(err);
+}
+
+function padRight(str, len) {
+  const padLen = Math.max(0, len - str.length);
+  const pad = ' '.repeat(padLen);
+
+  return `${str}${pad}`;
+}
+
+function stripIndentation(str) {
   const lines = str.replace(/^ *\n/, '').replace(/\n *$/, '').split('\n');
   const minIndentation = Math.min(...lines.
     filter(l => !/^ *$/.test(l)).
@@ -91,19 +159,6 @@ function _stripIndentation(str) {
   return lines.map(l => l.replace(re, '')).join('\n');
 }
 
-function _wrapLine(line, indent = '') {
-  if (line.length <= LINE_LIMIT) {
-    return line;
-  }
-
-  const extraIndent = ' '.repeat(INDENT_PER_LEVEL);
-  const sep = Date.now() + Math.random();
-  const re = new RegExp(/\s&&/.test(line) ? '(\\s)(&&)' : `(.{${LINE_LIMIT},}?\\s)()`, 'g');
-
-  let lines = line.replace(re, `$1${sep}$2`).split(sep).filter(l => l.trim());
-  if (lines.length > 1) {
-    lines = lines.map(l => _wrapLine(l, `${indent}${extraIndent}`));
-  }
-
-  return lines.join(`\n${indent}${extraIndent}`);
+function wrapLine(line, indent = '') {
+  return internal._wrapLine(line, indent);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gkalpak/aliases",
-  "version": "0.9.4",
+  "version": "0.10.1",
   "description": "My global aliases.",
   "keywords": [
     "Utility"
@@ -171,6 +171,7 @@
     "yud": "./bin/node/yud.js",
     "yup": "./bin/node/yup.js"
   },
+  "type": "module",
   "license": "Unlicense",
   "author": "gkalpak <kalpakas.g@gmail.com>",
   "homepage": "https://github.com/gkalpak/aliases#readme",
@@ -188,17 +189,18 @@
   },
   "dependencies": {
     "@gkalpak/cli-utils": "^0.1.10",
-    "chalk": "^4.1.2",
-    "inquirer": "^8.2.4",
+    "chalk": "^5.2.0",
+    "inquirer": "^9.1.5",
     "is-wsl": "^2.2.0"
   },
   "devDependencies": {
-    "eslint": "^8.23.0",
+    "eslint": "^8.36.0",
     "eslint-plugin-jasmine": "^4.1.3",
-    "jasmine": "^4.3.0",
+    "eslint-plugin-ordered-imports": "^0.6.0",
+    "jasmine": "^4.6.0",
     "npm-run-all": "^4.1.5",
     "shelljs": "^0.8.5",
-    "strip-ansi": "^6.0.1",
+    "strip-ansi": "^7.0.1",
     "watch": "^1.0.2"
   }
 }

package/scripts/build.js

@@ -1,21 +1,22 @@
 #!/usr/bin/env/ node
-'use strict';
-
 // Imports
-const {mkdirSync, writeFileSync} = require('fs');
-const {join} = require('path');
-const {rm, set} = require('shelljs');
-const {ALIASES, BIN_DIR} = require('../lib/constants');
+import {mkdirSync, writeFileSync} from 'node:fs';
+import {join} from 'node:path';
+
+import sh from 'shelljs';
+
+import {ALIASES, BIN_DIR} from '../lib/constants.js';
+
+sh.set('-e');
+
 
 // Run
 _main();
 
-// Function - Definitions
+// Helpers
 function _main() {
-  set('-e');
-
   // Clean up `bin/`.
-  rm('-rf', BIN_DIR);
+  sh.rm('-rf', BIN_DIR);
   mkdirSync(BIN_DIR);
 
   // For each alias category...

package/scripts/platformize-bin.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env/ node
-'use strict';
-
 // Imports
-const {chmodSync, copyFileSync, existsSync, readdirSync, renameSync, statSync} = require('fs');
-const {join} = require('path');
-const {BIN_DIR} = require('../lib/constants');
-const {getPlatform} = require('../lib/utils');
+import {chmodSync, copyFileSync, existsSync, readdirSync, renameSync, statSync} from 'node:fs';
+import {join} from 'node:path';
+
+import {BIN_DIR} from '../lib/constants.js';
+import {getPlatform} from '../lib/utils.js';
+
 
 // Run
 _main();
 
-// Function - Definitions
+// Helpers
 function _main() {
   // Nothing to do if `bin/` does not exist (e.g. first local `npm install`).
   if (!existsSync(BIN_DIR)) return;

package/scripts/test-pkg.js

@@ -1,21 +1,23 @@
 #!/usr/bin/env node
-'use strict';
-
 // Imports
-const {green, red} = require('chalk');
-const {existsSync} = require('fs');
-const {resolve} = require('path');
-const {ALIASES, ROOT_DIR} = require('../lib/constants');
-const {bin, main, types, typings} = require('../package.json');
+import {existsSync} from 'node:fs';
+import {resolve as pathResolve} from 'node:path';
+
+import chalk from 'chalk';
+
+import {ALIASES, ROOT_DIR} from '../lib/constants.js';
+import {loadPackageJson} from '../test/test-utils.js';
+
 
 // Constants
-const CHECK_MARK = green('\u2714');
-const X_MARK = red('\u2716');
+const CHECK_MARK = chalk.green('\u2714');
+const X_MARK = chalk.red('\u2716');
+const {bin, main, types, typings} = loadPackageJson();
 
 // Run
 _main();
 
-// Function - Definitions
+// Helpers
 function _main() {
   checkBin(bin || {}, ROOT_DIR, ALIASES);
   checkFile('main', main || '', ROOT_DIR);
@@ -43,7 +45,7 @@ function checkBin(bin, rootDir, aliases) {
 function checkFile(propName, filePath, rootDir) {
   if (!filePath) return;
 
-  const missingFile = !existsSync(resolve(rootDir, filePath));
+  const missingFile = !existsSync(pathResolve(rootDir, filePath));
 
   reportResults(
       `The file mentioned in \`package.json > ${propName}\` exists.`,
@@ -68,7 +70,7 @@ function compareToAliases(bin, aliases) {
 
 function compareToBinDir(bin, rootDir) {
   const missingScripts = Object.keys(bin).
-    map(key => resolve(rootDir, bin[key])).
+    map(key => pathResolve(rootDir, bin[key])).
     filter(path => !existsSync(path));
 
   reportResults(