gulp-eslint-new 1.1.2 → 1.2.0

package/README.md

@@ -12,7 +12,7 @@ npm i -D gulp-eslint-new
 
 ## Migrating
 
-If you are migrating from gulp-eslint, you probably won't need to change any settings in your Gulp task.
+If you are migrating from [gulp-eslint][gulp-eslint], you probably won't need to change any settings in your gulp task.
 gulp-eslint-new can handle most of the options used with gulp-eslint, although some of them are now deprecated in favor of a new name or format.
 
 Anyway, since gulp-eslint-new uses ESLint 8 while gulp-eslint sticks to ESLint 6, you may need to make some changes to your project to address incompatibilities between the versions of ESLint.
@@ -24,27 +24,27 @@ You can find more information at the links below.
 
 ```javascript
 const { src } = require('gulp');
-const eslint = require('gulp-eslint-new');
+const gulpESLintNew = require('gulp-eslint-new');
 
 // Define the default gulp task.
 exports.default =
     () => src(['scripts/*.js'])
-    // eslint() attaches the lint output to the "eslint" property of
-    // the file object so it can be used by other modules.
-    .pipe(eslint())
-    // eslint.format() outputs the lint results to the console.
-    // Alternatively use eslint.formatEach() (see docs).
-    .pipe(eslint.format())
-    // To have the process exit with an error code (1) on lint error,
-    // return the stream and pipe to failAfterError last.
-    .pipe(eslint.failAfterError());
+    // gulpESLintNew() attaches the lint output to the "eslint" property of the
+    // file object so it can be used by other modules.
+    .pipe(gulpESLintNew())
+    // gulpESLintNew.format() outputs the lint results to the console.
+    // Alternatively use gulpESLintNew.formatEach() (see docs).
+    .pipe(gulpESLintNew.format())
+    // To have the process exit with an error code (1) on lint error, return the
+    // stream and pipe to failAfterError last.
+    .pipe(gulpESLintNew.failAfterError());
 ```
 
 Or use the plugin API to do things like:
 
 ```javascript
 gulp.src(['**/*.js', '!node_modules/**'])
-    .pipe(eslint({
+    .pipe(gulpESLintNew({
         overrideConfig: {
             rules: {
                 'my-custom-rule': 1,
@@ -60,22 +60,22 @@ gulp.src(['**/*.js', '!node_modules/**'])
         },
         warnIgnored: true
     }))
-    .pipe(eslint.formatEach('compact', process.stderr));
+    .pipe(gulpESLintNew.formatEach('compact', process.stderr));
 ```
 
 For additional examples, look through the [example directory](https://github.com/fasttime/gulp-eslint-new/tree/main/example).
 
 ## API
 
-### `eslint()`
+### `gulpESLintNew()`
 
 *No explicit configuration.* A `.eslintrc` file may be resolved relative to each linted file.
 
-### `eslint(options)`
+### `gulpESLintNew(options)`
 
 Param type: `Object`
 
-Supported options include all [linting options](https://eslint.org/docs/developer-guide/nodejs-api#linting) and [autofix options](https://eslint.org/docs/developer-guide/nodejs-api#autofix) of the `ESLint` constructor.
+Supported options include all [linting options][linting options] and [autofix options](https://eslint.org/docs/developer-guide/nodejs-api#autofix) of the `ESLint` constructor.
 Please, refer to the ESLint documentation for information about the usage of those options.
 Check also the notes about the [Autofix Function](#autofix-function).
 Additionally, gulp-eslint-new supports the options listed below.
@@ -96,7 +96,7 @@ The location of the files to be linted is not related to the working directory.
 
 Type: `boolean`
 
-When `false`, .eslintignore files or ignore patterns in your configurations will not be respected.
+When `false`, ESLint will not respect `.eslintignore` files or ignore patterns in your configurations.
 
 ##### `options.ignorePath`
 
@@ -110,7 +110,7 @@ Type: `boolean`
 
 When `true`, this option will filter warning messages from ESLint results. This mimics the ESLint CLI [`--quiet` option](https://eslint.org/docs/user-guide/command-line-interface#--quiet).
 
-Type: `(message, index, list) => boolean`
+Type: `(message: string, index: number, list: Object[]) => unknown`
 
 When a function is provided, it will be used to filter ESLint result messages, removing any messages that do not return a `true` (or truthy) value.
 
@@ -118,123 +118,107 @@ When a function is provided, it will be used to filter ESLint result messages, r
 
 Type: `boolean`
 
-When `true`, add a result warning when ESLint ignores a file. This can be used to find files that are needlessly being loaded by `gulp.src`. For example, since ESLint automatically ignores "node_modules" file paths and `gulp.src` does not, a gulp task may take seconds longer just reading files from the "node_modules" directory.
+When `true`, add a result warning when ESLint ignores a file.
+This can be used to find files that are needlessly being loaded by `gulp.src`.
+For example, since ESLint automatically ignores file paths inside a `node_modules` directory but `gulp.src` does not, a gulp task may take seconds longer just reading files from `node_modules`.
 
 #### Legacy Options
 
-The following options are provided for backward compatibility with [gulp-eslint](https://github.com/adametry/gulp-eslint).
+The following options are provided for backward compatibility with [gulp-eslint][gulp-eslint].
 Their usage is discouraged because preferable alternatives exist, that are more in line with the present ESLint conventions.
 
 ##### `options.configFile`
 
 Type: `string`
 
-_A legacy synonym for `options.overrideConfigFile`._
+_A legacy synonym for `options.overrideConfigFile` (see [linting options][linting options])._
 
 ##### `options.envs`
 
 Type: `string[]`
 
-Specify a list of [environments](https://eslint.org/docs/user-guide/configuring/language-options#specifying-environments) to be applied.
+Specify a list of environments to be applied.
 
-_Prefer using `options.overrideConfig.env` instead. Note the different option name and format._
+_Prefer using [`options.overrideConfig.env`](https://eslint.org/docs/user-guide/configuring/language-options#specifying-environments) instead. Note the different option name and format._
 
 ##### `options.globals`
 
 Type: `string[]`
 
-Specify [global variables](https://eslint.org/docs/user-guide/configuring/language-options#specifying-globals) to declare.
+Specify a list of global variables to declare.
+Variables declared with this option are considered readonly.
 
-```javascript
-{
-    "globals": [
-        "jQuery",
-        "$"
-    ]
-}
-```
-
-_Prefer using `options.overrideConfig.globals` instead. Note the different format._
+_Prefer using [`options.overrideConfig.globals`](https://eslint.org/docs/user-guide/configuring/language-options#specifying-globals) instead. Note the different format._
 
 ##### `options.parser`
 
 Type: `string`
 
-_Prefer using `options.overrideConfig.parser` instead._
+_Prefer using [`options.overrideConfig.parser`](https://eslint.org/docs/user-guide/configuring/plugins#specifying-parser) instead._
 
 ##### `options.parserOptions`
 
 Type: `Object`
 
-_Prefer using `options.overrideConfig.parserOptions` instead._
+_Prefer using [`options.overrideConfig.parserOptions`](https://eslint.org/docs/user-guide/configuring/language-options#specifying-parser-options) instead._
 
 ##### `options.rules`
 
 Type: `Object`
 
-Set [configuration](https://eslint.org/docs/user-guide/configuring/rules#configuring-rules) of [rules](https://eslint.org/docs/rules/).
-
-```javascript
-{
-    "rules": {
-        "camelcase": 1,
-        "comma-dangle": 2,
-        "quotes": 0
-    }
-}
-```
-
-_Prefer using `options.overrideConfig.rules` instead._
+_Prefer using [`options.overrideConfig.rules`](https://eslint.org/docs/user-guide/configuring/rules) instead._
 
 ##### `options.warnFileIgnored`
 
 Type: `boolean`
 
-_A legacy synonym for `options.warnIgnored`._
+_A legacy synonym for [`options.warnIgnored`](#optionswarnignored)._
 
 #### Autofix Function
 
 When the `fix` option is specified, fixes are applied to the gulp stream.
-The fixed content can be saved to file using `gulp.dest` (See [example/fix.js](https://github.com/fasttime/gulp-eslint-new/blob/main/example/fix.js)).
+The fixed content can be saved to file using [`gulpESLintNew.fix()`](#gulpeslintnewfix) (See [example/fix.js](https://github.com/fasttime/gulp-eslint-new/blob/main/example/fix.js)).
 Rules that are fixable can be found in ESLint's [rules list](https://eslint.org/docs/rules/).
 When fixes are applied, a "fixed" property is set to `true` on the fixed file's ESLint result.
 
-### `eslint(overrideConfigFile)`
+### `gulpESLintNew(overrideConfigFile)`
 
 Param type: `string`
 
 Shorthand for defining `options.overrideConfigFile`.
 
-### `eslint.result(action)`
+### `gulpESLintNew.result(action)`
 
-Param type: `(result) => void`
+Param type: `(result: Object) => void`
 
 Call a function for each ESLint file result. No returned value is expected. If an error is thrown, it will be wrapped in a gulp `PluginError` and emitted from the stream.
 
 ```javascript
-gulp.src(['**/*.js','!node_modules/**'])
-    .pipe(eslint())
-    .pipe(eslint.result(result => {
+gulp.src(['**/*.js', '!node_modules/**'])
+    .pipe(gulpESLintNew())
+    .pipe(gulpESLintNew.result(result => {
         // Called for each ESLint result.
         console.log(`ESLint result: ${result.filePath}`);
         console.log(`# Messages: ${result.messages.length}`);
-        console.log(`# Warnings: ${result.warningCount} (${result.fixableWarningCount} fixable)`);
-        console.log(`# Errors: ${result.errorCount} (${result.fixableErrorCount} fixable, ${
+        console.log(`# Warnings: ${result.warningCount} (${
+            result.fixableWarningCount} fixable)`);
+        console.log(`# Errors: ${result.errorCount} (${
+            result.fixableErrorCount} fixable, ${
             result.fatalErrorCount} fatal)`);
     }));
 ```
 
-Type: `(result, callback) => void`
+Type: `(result: Object, callback: Function) => void`
 
 Call an asynchronous, Node-style callback-based function for each ESLint file result. The callback must be called for the stream to finish. If an error is passed to the callback, it will be wrapped in a gulp `PluginError` and emitted from the stream.
 
-Type: `result => Promise<void>`
+Type: `(result: Object) => Promise<void>`
 
 Call an asynchronous, promise-based function for each ESLint file result. If the promise is rejected, the rejection reason will be wrapped in a gulp `PluginError` and emitted from the stream.
 
-### `eslint.results(action)`
+### `gulpESLintNew.results(action)`
 
-Param type: `(results) => void`
+Param type: `(results: Object[]) => void`
 
 Call a function once for all ESLint file results before a stream finishes. No returned value is expected. If an error is thrown, it will be wrapped in a gulp `PluginError` and emitted from the stream.
 
@@ -264,94 +248,115 @@ The results list has additional properties that indicate the number of messages
 </table>
 
 ```javascript
-gulp.src(['**/*.js','!node_modules/**'])
-    .pipe(eslint())
-    .pipe(eslint.results(results => {
+gulp.src(['**/*.js', '!node_modules/**'])
+    .pipe(gulpESLintNew())
+    .pipe(gulpESLintNew.results(results => {
         // Called once for all ESLint results.
         console.log(`Total Results: ${results.length}`);
         console.log(`Total Warnings: ${results.warningCount} (${
             results.fixableWarningCount} fixable)`);
-        console.log(`Total Errors: ${results.errorCount} (${results.fixableErrorCount} fixable, ${
+        console.log(`Total Errors: ${results.errorCount} (${
+            results.fixableErrorCount} fixable, ${
             results.fatalErrorCount} fatal)`);
     }));
 ```
 
-Param type: `(results, callback) => void`
+Param type: `(results: Object[], callback: Function) => void`
 
 Call an asynchronous, Node-style callback-based function once for all ESLint file results before a stream finishes. The callback must be called for the stream to finish. If an error is passed to the callback, it will be wrapped in a gulp `PluginError` and emitted from the stream.
 
-Param type: `results => Promise<void>`
+Param type: `(results: Object[]) => Promise<void>`
 
 Call an asynchronous, promise-based function once for all ESLint file results before a stream finishes. If the promise is rejected, the rejection reason will be wrapped in a gulp `PluginError` and emitted from the stream.
 
-### `eslint.failOnError()`
+### `gulpESLintNew.failOnError()`
 
 Stop a task/stream if an ESLint error has been reported for any file.
 
 ```javascript
-// Cause the stream to stop (fail) before copying an invalid JS file to the output directory.
-gulp.src(['**/*.js','!node_modules/**'])
-    .pipe(eslint())
-    .pipe(eslint.failOnError());
+// Cause the stream to stop (fail) without processing more files.
+gulp.src(['**/*.js', '!node_modules/**'])
+    .pipe(gulpESLintNew())
+    .pipe(gulpESLintNew.failOnError());
 ```
 
-### `eslint.failAfterError()`
+### `gulpESLintNew.failAfterError()`
 
 Stop a task/stream if an ESLint error has been reported for any file, but wait for all of them to be processed first.
 
 ```javascript
-// Cause the stream to stop(/fail) when the stream ends if any ESLint error(s) occurred.
-gulp.src(['**/*.js','!node_modules/**'])
-    .pipe(eslint())
-    .pipe(eslint.failAfterError());
+// Cause the stream to stop (fail) when the stream ends if any ESLint error(s)
+// occurred.
+gulp.src(['**/*.js', '!node_modules/**'])
+    .pipe(gulpESLintNew())
+    .pipe(gulpESLintNew.failAfterError());
 ```
 
-### `eslint.format(formatter, output)`
+### `gulpESLintNew.format(formatter, output)`
 
-Format all linted files once. This should be used in the stream after piping through `eslint`; otherwise, this will find no ESLint results to format.
+Format all linted files once.
+This should be used in the stream after piping through `gulpESLintNew`; otherwise, this will find no ESLint results to format.
 
-The `formatter` argument may be a `string`, `Function`, or `undefined`. As a `string`, a formatter module by that name or path will be resolved as a module, relative to the current working directory, or as one of the [built-in ESLint formatters](https://eslint.org/docs/user-guide/formatters/#eslint-formatters). If `undefined`, the ESLint "stylish" formatter will be resolved. A `Function` will be called with an `Array` of file linting results to format.
+The `formatter` argument may be a `string`, `Function`, or `undefined`.
+As a `string`, a formatter module by that name or path will be resolved.
+The resolved formatter will be either one of the [built-in ESLint formatters](https://eslint.org/docs/user-guide/formatters/#eslint-formatters), or a formatter exported by a module with the specied path (located relative to the ESLint working directory), or a formatter exported by a package installed as a dependency (the prefix "eslint-formatter-" in the package name can be omitted).
+If `undefined`, the ESLint "stylish" formatter will be resolved.
+A `Function` will be called with an `Array` of file linting results to format.
 
 ```javascript
-// use the default "stylish" ESLint formatter
-eslint.format()
+// Use the default "stylish" ESLint formatter.
+gulpESLintNew.format()
 
-// use the "checkstyle" ESLint formatter
-eslint.format('checkstyle')
+// Use the "checkstyle" ESLint formatter.
+gulpESLintNew.format('checkstyle')
 
-// use the "eslint-path-formatter" module formatter
-// (@see https://github.com/Bartvds/eslint-path-formatter)
-eslint.format('node_modules/eslint-path-formatter')
+// Use "eslint-formatter-pretty" as a formatter (must be installed with `npm`).
+// See https://github.com/sindresorhus/eslint-formatter-pretty.
+gulpESLintNew.format('pretty')
 ```
 
-The `output` argument may be a `WritableStream`, `Function`, or `undefined`. As a `WritableStream`, the formatter results will be written to the stream. If `undefined`, the formatter results will be written to [gulp's log](https://github.com/gulpjs/fancy-log#logmsg). A `Function` will be called with the formatter results as the only parameter.
+The `output` argument may be a writable stream, `Function`, or `undefined`. As a writable stream, the formatter results will be written to the stream.
+If `undefined`, the formatter results will be written to [gulp's log](https://github.com/gulpjs/fancy-log#logmsg).
+A `Function` will be called with the formatter results as the only parameter.
 
 ```javascript
 // write to gulp's log (default)
-eslint.format();
+gulpESLintNew.format()
 
 // write messages to stdout
-eslint.format('junit', process.stdout)
+gulpESLintNew.format('junit', process.stdout)
 ```
 
-### `eslint.formatEach(formatter, output)`
+### `gulpESLintNew.formatEach(formatter, output)`
 
-Format each linted file individually. This should be used in the stream after piping through `eslint`; otherwise, this will find no ESLint results to format.
+Format each linted file individually.
+This should be used in the stream after piping through `gulpESLintNew`; otherwise, this will find no ESLint results to format.
 
 The arguments for `formatEach` are the same as the arguments for `format`.
 
+### `gulpESLintNew.fix()`
+
+Overwrite files with the fixed content provided by ESLint.
+This should be used in conjunction with the option `fix` in [`gulpESLintNew(options)`](#gulpeslintnewoptions).
+Files without a fixed content will be ignored.
+
+```javascript
+gulp.src(['**/*.js', '!node_modules/**'])
+    .pipe(gulpESLintNew({ fix: true }))
+    .pipe(gulpESLintNew.fix());
+```
+
 ## Configuration
 
 ESLint may be configured explicity by using any of the supported [configuration options](https://eslint.org/docs/user-guide/configuring/). Unless the `useEslintrc` option is set to `false`, ESLint will attempt to resolve a file by the name of `.eslintrc` within the same directory as the file to be linted. If not found there, parent directories will be searched until `.eslintrc` is found or the directory root is reached.
 
 ## Custom Extensions
 
-ESLint results are attached as an `eslint` property to the Vinyl files that pass through a gulp stream pipeline. This is available to streams that follow the initial gulp-eslint-new stream. The [`eslint.result`](#eslintresultaction) and [`eslint.results`](#eslintresultsaction) methods are made available to support extensions and custom handling of ESLint results.
-
-### Extension Packages
-
-* [gulp-eslint-if-fixed](https://github.com/lukeapage/gulp-eslint-if-fixed)
-* [gulp-eslint-threshold](https://github.com/krmbkt/gulp-eslint-threshold)
+ESLint results are attached as an `eslint` property to the Vinyl files that pass through a gulp stream pipeline.
+This is available to streams that follow the initial gulp-eslint-new stream.
+The [`gulpESLintNew.result`](#gulpeslintnewresultaction) and [`gulpESLintNew.results`](#gulpeslintnewresultsaction) methods are made available to support extensions and custom handling of ESLint results.
 
+[gulp-eslint]: https://github.com/adametry/gulp-eslint
+[linting options]: https://eslint.org/docs/developer-guide/nodejs-api#linting
 [npm badge]: https://badge.fury.io/js/gulp-eslint-new.svg
 [npm URL]: https://www.npmjs.com/package/gulp-eslint-new

package/index.js

@@ -3,17 +3,18 @@
 const {
 	createIgnoreResult,
 	createPluginError,
+	createTransform,
 	filterResult,
-	firstResultMessage,
+	fix,
 	hasOwn,
 	isErrorMessage,
 	migrateOptions,
 	resolveWritable,
-	createTransform,
 	writeResults
 } = require('./util');
 const { ESLint }    = require('eslint');
 const { promisify } = require('util');
+const { dest }      = require('vinyl-fs');
 
 function getESLintInfo(file) {
 	const eslintInfo = file._eslintInfo;
@@ -23,6 +24,16 @@ function getESLintInfo(file) {
 	throw createPluginError({ fileName: file.path, message: 'ESLint information not available' });
 }
 
+function wrapAction(action) {
+	if (typeof action !== 'function') {
+		throw TypeError('Argument is not a function');
+	}
+	if (action.length > 1) {
+		action = promisify(action);
+	}
+	return action;
+}
+
 async function lintFile(eslintInfo, file, quiet, warnIgnored) {
 	if (file.isNull()) {
 		return;
@@ -39,8 +50,6 @@ async function lintFile(eslintInfo, file, quiet, warnIgnored) {
 		// Note: ESLint doesn't adjust file paths relative to an ancestory .eslintignore path.
 		// E.g., If ../.eslintignore has "foo/*.js", ESLint will ignore ./foo/*.js, instead of
 		// ../foo/*.js.
-		// ESLint rolls this into `ESLint.prototype.lintText`. So, gulp-eslint-new must account for
-		// this limitation.
 		if (!warnIgnored) {
 			return;
 		}
@@ -66,38 +75,28 @@ async function lintFile(eslintInfo, file, quiet, warnIgnored) {
 	file._eslintInfo = eslintInfo;
 }
 
-function gulpEslint(options) {
+module.exports = exports = options => {
 	const { eslintOptions, quiet, warnIgnored } = migrateOptions(options);
 	const cwd = eslintOptions.cwd || process.cwd();
 	const eslint = new ESLint(eslintOptions);
 	const eslintInfo = { cwd, eslint };
-	return createTransform(
-		file => lintFile(eslintInfo, file, quiet, warnIgnored)
-	);
-}
+	return createTransform(file => lintFile(eslintInfo, file, quiet, warnIgnored));
+};
 
-gulpEslint.result = action => {
-	if (typeof action !== 'function') {
-		throw Error('Expected callable argument');
-	}
-	if (action.length > 1) {
-		action = promisify(action);
-	}
-	return createTransform(async file => {
-		const { eslint } = file;
-		if (eslint) {
-			await action(eslint);
+exports.result = action => {
+	action = wrapAction(action);
+	return createTransform(
+		async file => {
+			const { eslint } = file;
+			if (eslint) {
+				await action(eslint);
+			}
 		}
-	});
+	);
 };
 
-gulpEslint.results = function (action) {
-	if (typeof action !== 'function') {
-		throw Error('Expected callable argument');
-	}
-	if (action.length > 1) {
-		action = promisify(action);
-	}
+exports.results = action => {
+	action = wrapAction(action);
 	const results = [];
 	results.errorCount          = 0;
 	results.warningCount        = 0;
@@ -105,8 +104,7 @@ gulpEslint.results = function (action) {
 	results.fixableWarningCount = 0;
 	results.fatalErrorCount     = 0;
 	return createTransform(
-		file => {
-			const { eslint } = file;
+		({ eslint }) => {
 			if (eslint) {
 				results.push(eslint);
 				// Collect total error/warning count.
@@ -116,52 +114,51 @@ gulpEslint.results = function (action) {
 				results.fixableWarningCount += eslint.fixableWarningCount;
 				results.fatalErrorCount     += eslint.fatalErrorCount;
 			}
-		}, async () => {
+		},
+		async () => {
 			await action(results);
 		}
 	);
 };
 
-gulpEslint.failOnError = () => {
-	return gulpEslint.result(result => {
-		const error = firstResultMessage(result, isErrorMessage);
-		if (!error) {
-			return;
+exports.failOnError = () => exports.result(result => {
+	const { messages } = result;
+	if (messages) {
+		const error = messages.find(isErrorMessage);
+		if (error) {
+			throw createPluginError({
+				name: 'ESLintError',
+				fileName: result.filePath,
+				message: error.message,
+				lineNumber: error.line
+			});
 		}
-		throw createPluginError({
-			name: 'ESLintError',
-			fileName: result.filePath,
-			message: error.message,
-			lineNumber: error.line
-		});
-	});
-};
+	}
+});
 
-gulpEslint.failAfterError = () => {
-	return gulpEslint.results(results => {
-		const count = results.errorCount;
-		if (!count) {
-			return;
-		}
+exports.failAfterError = () => exports.results(({ errorCount }) => {
+	if (errorCount) {
 		throw createPluginError({
 			name: 'ESLintError',
-			message: `Failed with ${count} ${count === 1 ? 'error' : 'errors'}`
+			message: `Failed with ${errorCount} ${errorCount === 1 ? 'error' : 'errors'}`
 		});
-	});
-};
+	}
+});
 
-gulpEslint.formatEach = (formatter, writable) => {
+exports.formatEach = (formatter, writable) => {
 	writable = resolveWritable(writable);
-	return createTransform(async file => {
-		const { eslint } = file;
-		if (eslint) {
-			const eslintInfo = getESLintInfo(file);
-			await writeResults([eslint], eslintInfo, formatter, writable);
+	return createTransform(
+		async file => {
+			const { eslint } = file;
+			if (eslint) {
+				const eslintInfo = getESLintInfo(file);
+				await writeResults([eslint], eslintInfo, formatter, writable);
+			}
 		}
-	});
+	);
 };
 
-gulpEslint.format = (formatter, writable) => {
+exports.format = (formatter, writable) => {
 	writable = resolveWritable(writable);
 	const results = [];
 	let commonInfo;
@@ -192,4 +189,4 @@ gulpEslint.format = (formatter, writable) => {
 	);
 };
 
-module.exports = gulpEslint;
+exports.fix = () => fix(dest);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gulp-eslint-new",
-	"version": "1.1.2",
+	"version": "1.2.0",
 	"description": "A gulp plugin to lint code with ESLint 8",
 	"keywords": [
 		"gulpplugin",
@@ -38,24 +38,26 @@
 		"test": "mocha --check-leaks test/*.spec.js"
 	},
 	"dependencies": {
-		"@types/eslint": "^8.2.2",
-		"@types/node": "^17.0.8",
-		"eslint": "^8.6.0",
+		"@types/eslint": "^8.4.1",
+		"@types/node": "^17.0.13",
+		"eslint": "^8.8.0",
 		"fancy-log": "^2.0.0",
-		"plugin-error": "^1.0.1"
+		"plugin-error": "^1.0.1",
+		"ternary-stream": "^3.0.0",
+		"vinyl-fs": "^3.0.3"
 	},
 	"devDependencies": {
-		"@typescript-eslint/eslint-plugin": "^5.9.0",
-		"@typescript-eslint/parser": "^5.9.0",
+		"@typescript-eslint/eslint-plugin": "^5.10.0",
+		"@typescript-eslint/parser": "^5.10.0",
 		"c8": "^7.11.0",
 		"eslint-plugin-eslint-comments": "^3.2.0",
 		"gulp": "^4.0.2",
-		"mocha": "^9.1.3",
+		"mocha": "^9.1.4",
 		"typescript": "^4.5.4",
 		"vinyl": "^2.2.1"
 	},
 	"engines": {
-		"node": ">=12.0.0"
+		"node": "12 >=12.20 || 14 >=14.13 || >=16"
 	},
 	"exports": {
 		".": "./index.js",

package/util.js

@@ -4,6 +4,17 @@ const fancyLog      = require('fancy-log');
 const { relative }  = require('path');
 const PluginError   = require('plugin-error');
 const { Transform } = require('stream');
+const ternaryStream = require('ternary-stream');
+
+function compareResultsByFilePath({ filePath: filePath1 }, { filePath: filePath2 }) {
+	if (filePath1 > filePath2) {
+		return 1;
+	}
+	if (filePath1 < filePath2) {
+		return -1;
+	}
+	return 0;
+}
 
 function createPluginError(error) {
 	if (error instanceof PluginError) {
@@ -14,52 +25,80 @@ function createPluginError(error) {
 	}
 	return new PluginError('gulp-eslint-new', error);
 }
-exports.createPluginError = createPluginError;
 
-async function awaitHandler(handler, data, done) {
-	try {
-		await handler();
-	} catch (err) {
-		done(createPluginError(err));
-		return;
-	}
-	done(null, data);
+const { defineProperty } = Object;
+
+/** Determine if the specified object has the indicated property as its own property. */
+const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+
+/**
+ * Determine if a message is an error.
+ *
+ * @param {Linter.LintMessage} { severity } - An ESLint message.
+ * @returns {boolean} Whether the message is an error message.
+ */
+function isErrorMessage({ severity }) {
+	return severity > 1;
 }
 
 /**
- * Create a transform stream in object mode from synchronous or asynchronous handler functions.
- * All files are passed through the stream.
- * Errors thrown by the handlers will be wrapped inside a `PluginError` and emitted from the stream.
+ * Determine if a message is a warning.
  *
- * @param {Function} handleFile
- * A function that is called for each file, with the file object as the only parameter.
- * If the function returns a promise, the file will be passed through the stream after the promise
- * is resolved.
+ * @param {Linter.LintMessage} { severity } - An ESLint message.
+ * @returns {boolean} Whether the message is a warning message.
+ */
+function isWarningMessage({ severity }) {
+	return severity === 1;
+}
+
+/**
+ * Resolve formatter from string.
+ * If a function is specified, it will be treated as an ESLint 6 style formatter function and
+ * wrapped into an object appropriately.
  *
- * @param {Function} [handleFinal]
- * A function that is called with no parameters before closing the stream.
- * If the function returns a promise, the stream will be closed after the promise is resolved.
+ * @param {{ cwd: string, eslint: ESLint }} eslintInfo
+ * Current directory and instance of ESLint used to load and configure the formatter.
  *
- * @returns {Stream} A transform stream.
+ * @param {string|Function} [formatter]
+ * A name or path of a formatter, or an ESLint 6 style formatter function to resolve as a formatter.
+ *
+ * @returns {Promise<ESLint.Formatter>} An ESLint formatter.
  */
-exports.createTransform = (handleFile, handleFinal) => {
-	const transform = (file, enc, done) => void awaitHandler(() => handleFile(file), file, done);
-	const final = handleFinal ? done => void awaitHandler(handleFinal, null, done) : undefined;
-	return new Transform({ objectMode: true, transform, final });
-};
+function resolveFormatter({ cwd, eslint }, formatter) {
+	if (typeof formatter === 'function') {
+		return {
+			format: results => {
+				results.sort(compareResultsByFilePath);
+				return formatter(
+					results,
+					{
+						cwd,
+						get rulesMeta() {
+							const rulesMeta = eslint.getRulesMetaForResults(results);
+							defineProperty(this, 'rulesMeta', { value: rulesMeta });
+							return rulesMeta;
+						}
+					}
+				);
+			}
+		};
+	}
+	// Use ESLint to look up formatter references.
+	return eslint.loadFormatter(formatter);
+}
+
+exports.compareResultsByFilePath = compareResultsByFilePath;
 
 const isHiddenRegExp = /(?<![^/\\])\.(?!\.)/u;
 const isInNodeModulesRegExp = /(?<![^/\\])node_modules[/\\]/u;
 
 /**
- * This is a remake of the CLI object `createIgnoreResult` function with no reference to ESLint
- * CLI options and with a better detection of the ignore reason in some edge cases.
- * Additionally, this function addresses an issue in ESLint that consists in the property
- * `fatalErrorCount` not being set in the result.
+ * This is a remake of the CLI engine `createIgnoreResult` function with no reference to ESLint CLI
+ * options and with a better detection of the ignore reason in some edge cases.
  *
  * @param {string} filePath - Absolute path of checked code file.
  * @param {string} baseDir - Absolute path of base directory.
- * @returns {LintResult} Result with warning by ignore settings.
+ * @returns {ESLint.LintResult} Result with warning by ignore settings.
  */
 exports.createIgnoreResult = (filePath, baseDir) => {
 	let message;
@@ -88,10 +127,134 @@ exports.createIgnoreResult = (filePath, baseDir) => {
 	};
 };
 
-/* Determine if the specified object has the indicated property as its own property. */
-const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+exports.createPluginError = createPluginError;
+
+async function awaitHandler(handler, data, done) {
+	try {
+		await handler();
+	} catch (err) {
+		done(createPluginError(err));
+		return;
+	}
+	done(null, data);
+}
+
+/**
+ * Create a transform stream in object mode from synchronous or asynchronous handler functions.
+ * All files are passed through the stream.
+ * Errors thrown by the handlers will be wrapped inside a `PluginError` and emitted from the stream.
+ *
+ * @param {Function} handleFile
+ * A function that is called for each file, with the file object as the only parameter.
+ * If the function returns a promise, the file will be passed through the stream after the promise
+ * is resolved.
+ *
+ * @param {Function} [handleFinal]
+ * A function that is called with no parameters before closing the stream.
+ * If the function returns a promise, the stream will be closed after the promise is resolved.
+ *
+ * @returns {Stream} A transform stream.
+ */
+exports.createTransform = (handleFile, handleFinal) => {
+	const transform = (file, enc, done) => void awaitHandler(() => handleFile(file), file, done);
+	const final = handleFinal ? done => void awaitHandler(handleFinal, null, done) : undefined;
+	return new Transform({ objectMode: true, transform, final });
+};
+
+/**
+ * Increment count if message is an error.
+ *
+ * @param {number} count - Number of errors.
+ * @param {Linter.LintMessage} message - An ESLint message.
+ * @returns {number} The number of errors, message included.
+ */
+function countErrorMessage(count, message) {
+	return count + Number(isErrorMessage(message));
+}
+
+/**
+ * Increment count if message is a warning.
+ *
+ * @param {number} count - Number of warnings.
+ * @param {Linter.LintMessage} message - An ESLint message.
+ * @returns {number} The number of warnings, message included.
+ */
+function countWarningMessage(count, message) {
+	return count + Number(isWarningMessage(message));
+}
+
+/**
+ * Increment count if message is a fixable error.
+ *
+ * @param {number} count - Number of fixable errors.
+ * @param {Linter.LintMessage} message - An ESLint message.
+ * @returns {number} The number of fixable errors, message included.
+ */
+function countFixableErrorMessage(count, message) {
+	return count + Number(isErrorMessage(message) && message.fix !== undefined);
+}
+
+/**
+ * Increment count if message is a fixable warning.
+ *
+ * @param {Number} count - Number of fixable warnings.
+ * @param {Linter.LintMessage} message - An ESLint message.
+ * @returns {Number} The number of fixable warnings, message included.
+ */
+function countFixableWarningMessage(count, message) {
+	return count + Number(isWarningMessage(message) && message.fix !== undefined);
+}
+
+/**
+ * Increment count if message is a fatal error.
+ *
+ * @param {Number} count - Number of fatal errors.
+ * @param {Linter.LintMessage} message - An ESLint message.
+ * @returns {Number} The number of fatal errors, message included.
+ */
+function countFatalErrorMessage(count, message) {
+	return count + Number(isErrorMessage(message) && !!message.fatal);
+}
+
+/**
+ * Filter result messages, update error and warning counts.
+ *
+ * @param {ESLint.LintResult} result - An ESLint result.
+ * @param {Function} filter - A function that evaluates what messages to keep.
+ * @returns {ESLint.LintResult} A filtered ESLint result.
+ */
+exports.filterResult = (result, filter) => {
+	const { messages, ...newResult } = result;
+	const newMessages = messages.filter(filter, result);
+	newResult.messages = newMessages;
+	newResult.errorCount          = newMessages.reduce(countErrorMessage, 0);
+	newResult.warningCount        = newMessages.reduce(countWarningMessage, 0);
+	newResult.fixableErrorCount   = newMessages.reduce(countFixableErrorMessage, 0);
+	newResult.fixableWarningCount = newMessages.reduce(countFixableWarningMessage, 0);
+	newResult.fatalErrorCount     = newMessages.reduce(countFatalErrorMessage, 0);
+	return newResult;
+};
+
+const isFixed = ({ eslint }) => eslint && eslint.fixed;
+const getBase = ({ base }) => base;
+exports.fix = dest => ternaryStream(isFixed, dest(getBase));
+
 exports.hasOwn = hasOwn;
 
+exports.isErrorMessage = isErrorMessage;
+
+exports.isWarningMessage = isWarningMessage;
+
+const forbiddenOptions = [
+	'cache',
+	'cacheFile',
+	'cacheLocation',
+	'cacheStrategy',
+	'errorOnUnmatchedPattern',
+	'extensions',
+	'globInputPaths'
+];
+
 /**
  * Throws an error about invalid options passed to gulp-eslint-new.
  *
@@ -131,20 +294,10 @@ function toBooleanMap(keys, defaultValue, displayName) {
 	}
 }
 
-const forbiddenOptions = [
-	'cache',
-	'cacheFile',
-	'cacheLocation',
-	'cacheStrategy',
-	'errorOnUnmatchedPattern',
-	'extensions',
-	'globInputPaths'
-];
-
 /**
  * Create config helper to merge various config sources.
  *
- * @param {Object} options - Options to migrate.
+ * @param {Object} [options] - Options to migrate.
  * @returns {Object} Migrated options.
  */
 exports.migrateOptions = (options = { }) => {
@@ -202,174 +355,6 @@ exports.migrateOptions = (options = { }) => {
 	return returnValue;
 };
 
-/**
- * Get first message in an ESLint result to meet a condition.
- *
- * @param {LintResult} result
- * An ESLint result.
- * @param {Function} condition
- * A condition function that is passed a message and returns a boolean.
- * @returns {Object} The first message to pass the condition or null.
- */
-exports.firstResultMessage = (result, condition) => {
-	if (!result.messages) {
-		return null;
-	}
-	return result.messages.find(condition);
-};
-
-/**
- * Determine if a message is an error.
- *
- * @param {Object} message - An ESLint message.
- * @returns {boolean} Whether the message is an error message.
- */
-function isErrorMessage({ severity }) {
-	return severity > 1;
-}
-exports.isErrorMessage = isErrorMessage;
-
-/**
- * Determine if a message is a warning.
- *
- * @param {Object} message - An ESLint message.
- * @returns {boolean} Whether the message is a warning message.
- */
-function isWarningMessage({ severity }) {
-	return severity === 1;
-}
-exports.isWarningMessage = isWarningMessage;
-
-/**
- * Increment count if message is an error.
- *
- * @param {number} count - Number of errors.
- * @param {Object} message - An ESLint message.
- * @returns {number} The number of errors, message included.
- */
-function countErrorMessage(count, message) {
-	return count + Number(isErrorMessage(message));
-}
-
-/**
- * Increment count if message is a warning.
- *
- * @param {number} count - Number of warnings.
- * @param {Object} message - An ESLint message.
- * @returns {number} The number of warnings, message included.
- */
-function countWarningMessage(count, message) {
-	return count + Number(isWarningMessage(message));
-}
-
-/**
- * Increment count if message is a fixable error.
- *
- * @param {number} count - Number of fixable errors.
- * @param {Object} message - An ESLint message.
- * @returns {number} The number of fixable errors, message included.
- */
-function countFixableErrorMessage(count, message) {
-	return count + Number(isErrorMessage(message) && message.fix !== undefined);
-}
-
-/**
- * Increment count if message is a fixable warning.
- *
- * @param {Number} count - Number of fixable warnings.
- * @param {Object} message - An ESLint message.
- * @returns {Number} The number of fixable warnings, message included.
- */
-function countFixableWarningMessage(count, message) {
-	return count + Number(isWarningMessage(message) && message.fix !== undefined);
-}
-
-/**
- * Increment count if message is a fatal error.
- *
- * @param {Number} count - Number of fatal errors.
- * @param {Object} message - An ESLint message.
- * @returns {Number} The number of fatal errors, message included.
- */
-function countFatalErrorMessage(count, message) {
-	return count + Number(isErrorMessage(message) && !!message.fatal);
-}
-
-/**
- * Filter result messages, update error and warning counts.
- *
- * @param {LintResult} result - An ESLint result.
- * @param {Function} filter - A function that evaluates what messages to keep.
- * @returns {LintResult} A filtered ESLint result.
- */
-exports.filterResult = (result, filter) => {
-	const messages = result.messages.filter(filter, result);
-	const newResult = {
-		filePath: result.filePath,
-		messages: messages,
-		errorCount: messages.reduce(countErrorMessage, 0),
-		warningCount: messages.reduce(countWarningMessage, 0),
-		fixableErrorCount: messages.reduce(countFixableErrorMessage, 0),
-		fixableWarningCount: messages.reduce(countFixableWarningMessage, 0),
-		fatalErrorCount: messages.reduce(countFatalErrorMessage, 0)
-	};
-	if ('output' in result) {
-		newResult.output = result.output;
-	}
-	if ('source' in result) {
-		newResult.source = result.source;
-	}
-	return newResult;
-};
-
-function compareResultsByFilePath({ filePath: filePath1 }, { filePath: filePath2 }) {
-	if (filePath1 > filePath2) {
-		return 1;
-	}
-	if (filePath1 < filePath2) {
-		return -1;
-	}
-	return 0;
-}
-exports.compareResultsByFilePath = compareResultsByFilePath;
-
-const { defineProperty } = Object;
-
-/**
- * Resolve formatter from string.
- * If a function is specified, it will be treated as an ESLint 6 style formatter function and
- * wrapped into an object appropriately.
- *
- * @param {{ cwd: string, eslint: ESLint }} eslintInfo
- * Current directory and instance of ESLint used to load and configure the formatter.
- *
- * @param {string|Function} [formatter]
- * A name or path of a formatter, or an ESLint 6 style formatter function to resolve as a formatter.
- *
- * @returns {Promise<ESLint.Formatter>} An ESLint formatter.
- */
-async function resolveFormatter({ cwd, eslint }, formatter) {
-	if (typeof formatter === 'function') {
-		return {
-			format: results => {
-				results.sort(compareResultsByFilePath);
-				return formatter(
-					results,
-					{
-						cwd,
-						get rulesMeta() {
-							const rulesMeta = eslint.getRulesMetaForResults(results);
-							defineProperty(this, 'rulesMeta', { value: rulesMeta });
-							return rulesMeta;
-						}
-					}
-				);
-			}
-		};
-	}
-	// Use ESLint to look up formatter references.
-	return eslint.loadFormatter(formatter);
-}
 exports.resolveFormatter = resolveFormatter;
 
 /**