js-build-tools 6.3.1 → 6.4.1

package/dist/partials/loadPeer.js

@@ -1,34 +1,35 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.requirePeer = exports.importPeer = exports.importModule = void 0;
-require("core-js/modules/es.array.includes.js");
-var _nodeModule = require("node:module");
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _nodeUrl = require("node:url");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// Several dependencies ship ESM-only (standard, gulp-ts-compile, typedoc), but this package also publishes a CommonJS
-// build (dist/*.js) whose babel transform would turn even a dynamic import() into a require() that cannot load an ES
-// module. Hiding the import() inside a Function constructor keeps it a genuine dynamic import that works from either
-// build, because babel cannot see (and so cannot rewrite) an import expression which only exists as a runtime string.
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requirePeer = exports.importPeer = exports.importModule = void 0;
+require("core-js/modules/es.array.includes.js");
+var _nodeModule = require("node:module");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeUrl = require("node:url");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Several dependencies ship ESM-only (standard, gulp-ts-compile, typedoc), but this package also publishes a CommonJS
+// build (dist/*.js) whose babel transform would turn even a dynamic import() into a require() that cannot load an ES
+// module. Hiding the import() inside a Function constructor keeps it a genuine dynamic import that works from either
+// build, because babel cannot see (and so cannot rewrite) an import expression which only exists as a runtime string.
+// eslint-disable-next-line no-new-func -- deliberate, see above
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+
 /**
  * Import an ES module (or any module) with a real dynamic import(), whichever build (ESM or CommonJS) this runs from.
  * @memberOf module:partials
  * @param {string} specifier - The package name, or the URL of a file.
  * @returns {Promise<Object>} The module namespace.
- */
-const importModule = specifier => dynamicImport(specifier);
-exports.importModule = importModule;
-const isMissing = (error, name) => error.code === 'MODULE_NOT_FOUND' && error.message.includes(`'${name}'`);
-const notInstalled = (name, {
-  task,
-  installHint
-}) => new Error(`The ${task} task needs the optional peer dependency ${name}, which is not installed. ${installHint}`);
-
+ */
+const importModule = specifier => dynamicImport(specifier);
+exports.importModule = importModule;
+const isMissing = (error, name) => error.code === 'MODULE_NOT_FOUND' && error.message.includes(`'${name}'`);
+const notInstalled = (name, {
+  task,
+  installHint
+}) => new Error(`The ${task} task needs the optional peer dependency ${name}, which is not installed. ${installHint}`);
+
 /**
  * Load an optional peer dependency (one which is only needed once a task runs, so projects which never use that task
  * do not have to install it) with require(), from the project being built rather than from this package. When it is
@@ -42,29 +43,29 @@ const notInstalled = (name, {
  * @param {string} [options.projectPath=process.cwd()] - The folder of the project (which has the package.json) being built.
  * @returns {*} Whatever the package exports.
  * @throws {Error} With install instructions when the package is not installed.
- */
-const requirePeer = (name, {
-  task,
-  installHint,
-  esmOnlyMessage,
-  projectPath = process.cwd()
-}) => {
-  try {
-    return (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json'))(name);
-  } catch (error) {
-    if (isMissing(error, name)) {
-      throw notInstalled(name, {
-        task,
-        installHint
-      });
-    }
-    if (error.code === 'ERR_REQUIRE_ESM' && esmOnlyMessage) {
-      throw new Error(esmOnlyMessage);
-    }
-    throw error;
-  }
-};
-
+ */
+const requirePeer = (name, {
+  task,
+  installHint,
+  esmOnlyMessage,
+  projectPath = process.cwd()
+}) => {
+  try {
+    return (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json'))(name);
+  } catch (error) {
+    if (isMissing(error, name)) {
+      throw notInstalled(name, {
+        task,
+        installHint
+      });
+    }
+    if (error.code === 'ERR_REQUIRE_ESM' && esmOnlyMessage) {
+      throw new Error(esmOnlyMessage);
+    }
+    throw error;
+  }
+};
+
 /**
  * Import an optional peer dependency which ships ESM-only, from the project being built. See {@link requirePeer}.
  * @memberOf module:partials
@@ -75,25 +76,25 @@ const requirePeer = (name, {
  * @param {string} [options.projectPath=process.cwd()] - The folder of the project (which has the package.json) being built.
  * @returns {Promise<Object>} The module namespace.
  * @throws {Error} With install instructions when the package is not installed.
- */
-exports.requirePeer = requirePeer;
-const importPeer = async (name, {
-  task,
-  installHint,
-  projectPath = process.cwd()
-}) => {
-  let resolved;
-  try {
-    resolved = (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json')).resolve(name);
-  } catch (error) {
-    if (isMissing(error, name)) {
-      throw notInstalled(name, {
-        task,
-        installHint
-      });
-    }
-    throw error;
-  }
-  return importModule((0, _nodeUrl.pathToFileURL)(resolved).href);
-};
+ */
+exports.requirePeer = requirePeer;
+const importPeer = async (name, {
+  task,
+  installHint,
+  projectPath = process.cwd()
+}) => {
+  let resolved;
+  try {
+    resolved = (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json')).resolve(name);
+  } catch (error) {
+    if (isMissing(error, name)) {
+      throw notInstalled(name, {
+        task,
+        installHint
+      });
+    }
+    throw error;
+  }
+  return importModule((0, _nodeUrl.pathToFileURL)(resolved).href);
+};
 exports.importPeer = importPeer;

package/dist/partials/minifyFor.js

@@ -1,21 +1,21 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.minifyFor = void 0;
-var _gulp = require("gulp");
-var _gulpUglifyEs = _interopRequireDefault(require("gulp-uglify-es"));
-var _gulpRename = _interopRequireDefault(require("gulp-rename"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const uglify = _gulpUglifyEs.default.hasOwnProperty('default') ? _gulpUglifyEs.default.default : _gulpUglifyEs.default;
-
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.minifyFor = void 0;
+var _gulp = require("gulp");
+var _gulpUglifyEs = _interopRequireDefault(require("gulp-uglify-es"));
+var _gulpRename = _interopRequireDefault(require("gulp-rename"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const uglify = Object.hasOwn(_gulpUglifyEs.default, 'default') ? _gulpUglifyEs.default.default : _gulpUglifyEs.default;
+
 /**
  * Minify files and rename the output with '.min' extension.
  * @memberOf module:partials
  * @returns {*}
- */
-const minifyFor = (srcSearch, destination) => (0, _gulp.src)(srcSearch).pipe(uglify()).pipe((0, _gulpRename.default)({
-  extname: '.min.js'
-})).pipe((0, _gulp.dest)(destination));
+ */
+const minifyFor = (srcSearch, destination) => (0, _gulp.src)(srcSearch).pipe(uglify()).pipe((0, _gulpRename.default)({
+  extname: '.min.js'
+})).pipe((0, _gulp.dest)(destination));
 exports.minifyFor = minifyFor;

package/dist/partials/neostandardLint.js

@@ -1,36 +1,36 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.neostandardLint = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.for-each.js");
-var _nodeFs = _interopRequireDefault(require("node:fs"));
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _through = _interopRequireDefault(require("through2"));
-var _eslint = require("eslint");
-var _loadPeer = require("./loadPeer.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// neostandard (js-build-tools' chosen style - a maintained, TypeScript-aware successor to `standard`, see
-// https://github.com/neostandard/neostandard) ships ESM-only, see importModule for how it is imported.
-const importNeostandard = () => (0, _loadPeer.importModule)('neostandard');
-
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.neostandardLint = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _through = _interopRequireDefault(require("through2"));
+var _eslint = require("eslint");
+var _loadPeer = require("./loadPeer.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// neostandard (js-build-tools' chosen style - a maintained, TypeScript-aware successor to `standard`, see
+// https://github.com/neostandard/neostandard) ships ESM-only, see importModule for how it is imported.
+const importNeostandard = () => (0, _loadPeer.importModule)('neostandard');
+
 /**
  * Read the `env` a project already declared for Standard (the `standard` field in its package.json), so a project
  * migrating from `standard` keeps its globals (jest, browser, ...) without touching package.json.
  * @param {string} cwd
  * @returns {Array<string>}
  * @private
- */
-const readEnv = cwd => {
-  try {
-    return JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(cwd, 'package.json'), 'utf8')).standard?.env ?? [];
-  } catch {
-    return [];
-  }
-};
-
+ */
+const readEnv = cwd => {
+  try {
+    return JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(cwd, 'package.json'), 'utf8')).standard?.env ?? [];
+  } catch {
+    return [];
+  }
+};
+
 /**
  * Build an ESLint instance configured with neostandard, honoring the project's own package.json `standard.env`,
  * plus an optional layer of rule overrides (see gulp.config.mjs's `lint.rules`) for a rule that is wrong for this
@@ -45,59 +45,60 @@ const readEnv = cwd => {
  * @param {Object<string, *>} [options.rules={}]
  * @returns {Promise<ESLint>} eslint's ESLint instance
  * @private
- */
-const buildEslint = async ({
-  cwd,
-  ts,
-  fix,
-  rules = {}
-}) => {
-  const {
-    neostandard,
-    defaultFilePatterns
-  } = await importNeostandard();
-  const baseConfig = neostandard({
-    ts,
-    env: readEnv(cwd)
-  });
-  if (Object.keys(rules).length) {
-    baseConfig.push({
-      files: defaultFilePatterns.all,
-      rules
-    });
-  }
-  return new _eslint.ESLint({
-    cwd,
-    fix,
-    overrideConfigFile: true,
-    baseConfig
-  });
-};
-
+ */
+const buildEslint = async ({
+  cwd,
+  ts,
+  fix,
+  rules = {}
+}) => {
+  const {
+    neostandard,
+    defaultFilePatterns
+  } = await importNeostandard();
+  const baseConfig = neostandard({
+    ts,
+    env: readEnv(cwd)
+  });
+  if (Object.keys(rules).length) {
+    baseConfig.push({
+      files: defaultFilePatterns.all,
+      rules
+    });
+  }
+  return new _eslint.ESLint({
+    cwd,
+    fix,
+    overrideConfigFile: true,
+    baseConfig
+  });
+};
+
 /**
  * Print a file's lint messages, if it has any.
  * @memberOf module:partials
  * @param {Vinyl} file
  * @param {{messages: Array<{line: number, column: number, message: string}>, errorCount: number, warningCount: number}} result
  * @returns {undefined}
- */
-const printFileReport = (file, result) => {
-  if (!result.messages.length) {
-    return;
-  }
-  console.log(_nodePath.default.relative(file.cwd, file.path));
-  result.messages.forEach(({
-    line,
-    column,
-    message
-  }) => console.log(`line ${line}:${column}\t${message}`));
-  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`);
-};
-
+ */
+const printFileReport = (file, result) => {
+  if (!result.messages.length) {
+    return;
+  }
+  console.log(_nodePath.default.relative(file.cwd, file.path));
+  result.messages.forEach(({
+    line,
+    column,
+    message
+  }) => console.log(`line ${line}:${column}\t${message}`));
+  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`);
+};
+
 /**
  * Lint every file streaming through with neostandard and, unless `fix` is false, apply the automatic fixes to the
  * file's contents so a following `dest()` writes the fixed version. Remaining problems are printed along with a
- * summary once the stream ends; they never fail the build.
+ * summary once the stream ends; they only fail the stream when `failOnError` is set (the standalone `lint` task),
+ * never during `build`.
  *
  * One ESLint instance is built from the first file's own cwd and reused for the rest of the stream, since every
  * file in a given lint pass shares the same project (and so the same config).
@@ -107,59 +108,69 @@ const printFileReport = (file, result) => {
  * @param {boolean} [options.ts=false] - Lint `.ts` files too, with type-aware rules (see neostandard's `ts` option).
  * @param {Object<string, *>} [options.rules={}] - ESLint rule overrides layered on top of neostandard's own rules
  * (see gulp.config.mjs's `lint.rules`).
+ * @param {boolean} [options.failOnError=false] - Emit an error once the stream ends if any lint errors remain after
+ * fixing, so a command-line run exits non-zero.
  * @param {function(Object): Promise<{lintText: Function}>} [loadEslint] - Resolves an ESLint-shaped linter. Real
  * callers should never need to pass this - it exists so tests can supply a stand-in, since this project's
  * CommonJS-transform-based Jest setup cannot execute a real dynamic import() of neostandard (ESM-only).
- * @returns {stream.Transform}
- */
-const neostandardLint = ({
-  fix = true,
-  ts = false,
-  rules = {}
-} = {}, loadEslint = buildEslint) => {
-  const totals = {
-    errors: 0,
-    warnings: 0
-  };
-  let eslintPromise = null;
-  return _through.default.obj(function (file, enc, callback) {
-    if (file.isNull()) {
-      callback(null, file);
-      return;
-    }
-    if (file.isStream()) {
-      callback(new Error('neostandardLint: streaming file contents are not supported.'));
-      return;
-    }
-    if (!eslintPromise) {
-      eslintPromise = loadEslint({
-        cwd: file.cwd,
-        ts,
-        fix,
-        rules
-      });
-    }
-    eslintPromise.then(eslint => eslint.lintText(file.contents.toString(), {
-      filePath: file.path
-    })).then(results => {
-      // No result at all means the file is ignored by the project's ESLint configuration.
-      const [result] = results;
-      if (result) {
-        if (typeof result.output === 'string') {
-          file.contents = Buffer.from(result.output);
-        }
-        totals.errors += result.errorCount;
-        totals.warnings += result.warningCount;
-        printFileReport(file, result);
-      }
-      callback(null, file);
-    }, callback);
-  }, function (callback) {
-    console.log('neostandard linter results');
-    console.log('======================================');
-    console.log(`✖ Errors total: ${totals.errors}`);
-    console.log(`⚠ Warnings total: ${totals.warnings}\n`);
-    callback();
-  });
-};
+ * @returns {stream.Transform} With a `totals` property ({errors, warnings}), complete once the stream ends.
+ */
+const neostandardLint = ({
+  fix = true,
+  ts = false,
+  rules = {},
+  failOnError = false
+} = {}, loadEslint = buildEslint) => {
+  const totals = {
+    errors: 0,
+    warnings: 0
+  };
+  let eslintPromise = null;
+  const linter = _through.default.obj(function (file, enc, callback) {
+    if (file.isNull()) {
+      callback(null, file);
+      return;
+    }
+    if (file.isStream()) {
+      callback(new Error('neostandardLint: streaming file contents are not supported.'));
+      return;
+    }
+    if (!eslintPromise) {
+      eslintPromise = loadEslint({
+        cwd: file.cwd,
+        ts,
+        fix,
+        rules
+      });
+    }
+    eslintPromise.then(eslint => eslint.lintText(file.contents.toString(), {
+      filePath: file.path
+    })).then(results => {
+      // No result at all means the file is ignored by the project's ESLint configuration.
+      const [result] = results;
+      if (result) {
+        if (typeof result.output === 'string') {
+          file.contents = Buffer.from(result.output);
+        }
+        totals.errors += result.errorCount;
+        totals.warnings += result.warningCount;
+        printFileReport(file, result);
+      }
+      callback(null, file);
+    }, callback);
+  }, function (callback) {
+    console.log('neostandard linter results');
+    console.log('======================================');
+    console.log(`✖ Errors total: ${totals.errors}`);
+    console.log(`⚠ Warnings total: ${totals.warnings}\n`);
+    if (failOnError && totals.errors) {
+      callback(new Error(`neostandard found ${totals.errors} lint error(s) that could not be fixed automatically.`));
+      return;
+    }
+    callback();
+  });
+  // Read by lintSource, which can only fail once the fixed files have been written, after this stream has ended.
+  linter.totals = totals;
+  return linter;
+};
 exports.neostandardLint = neostandardLint;