gulp-eslint-new 1.7.0 → 1.7.2

package/README.md

@@ -4,14 +4,16 @@
 
 ## Installation
 
-[Use](https://docs.npmjs.com/cli/install) [npm](https://docs.npmjs.com/about-npm):
+Make sure that you are using a version of Node.js [supported by ESLint 8](https://eslint.org/docs/user-guide/getting-started#prerequisites).
+
+To install gulp-eslint-new, [use](https://docs.npmjs.com/cli/install) [npm](https://docs.npmjs.com/about-npm):
 
 ```console
 npm i -D gulp-eslint-new
 ```
 
-gulp-eslint-new will install the latest version of ESLint 8, unless another one is found.
-To use a particular version of ESLint 8, make sure to have it installed.
+gulp-eslint-new will also install the latest version of ESLint 8, unless another one is found.
+To use a particular version of ESLint 8, install it by yourself.
 For example, to use ESLint 8.8.0:
 
 ```console
@@ -36,38 +38,36 @@ const gulpESLintNew = require('gulp-eslint-new');
 
 // Define the default gulp task.
 exports.default =
-() => src(['scripts/*.js'])                 // Read files.
-    .pipe(gulpESLintNew({ fix: true }))     // Lint files, create fixes.
-    .pipe(gulpESLintNew.fix())              // Fix files if necessary.
-    .pipe(gulpESLintNew.format())           // Output lint results to the console.
-    .pipe(gulpESLintNew.failAfterError());  // Exit with an error if problems are found.
+() =>
+src(['scripts/*.js'])                   // Read files.
+.pipe(gulpESLintNew({ fix: true }))     // Lint files, create fixes.
+.pipe(gulpESLintNew.fix())              // Fix files if necessary.
+.pipe(gulpESLintNew.format())           // Output lint results to the console.
+.pipe(gulpESLintNew.failAfterError());  // Exit with an error if problems are found.
 ```
 
 Or use the plugin API to do things like:
 
 ```javascript
 gulp.src(['**/*.js', '!node_modules/**'])
-    .pipe(gulpESLintNew(
+.pipe
+(
+    gulpESLintNew
+    (
         {
-            overrideConfig: {
-                env: {
-                    browser: true,
-                    commonjs: true,
-                    jquery: true,
-                },
-                extends: ['eslint:recommended', 'plugin:jquery/slim'],
-                globals: {
-                    chrome: 'readonly',
-                },
-                plugins: ['jquery'],
-                rules: {
-                    'strict': 'error',
-                },
+            overrideConfig:
+            {
+                env:        { browser: true, commonjs: true, jquery: true },
+                extends:    ['eslint:recommended', 'plugin:jquery/slim'],
+                globals:    { chrome: 'readonly' },
+                plugins:    ['jquery'],
+                rules:      { 'strict': 'error' },
             },
             warnIgnored: true,
         },
-    ))
-    .pipe(gulpESLintNew.formatEach('compact', process.stderr));
+    ),
+)
+.pipe(gulpESLintNew.formatEach('compact', process.stderr));
 ```
 
 For additional examples, look through the [example directory](https://github.com/origin-1/gulp-eslint-new/tree/main/example).
@@ -76,18 +76,44 @@ For additional examples, look through the [example directory](https://github.com
 
 ### `gulpESLintNew()`
 
-*No explicit configuration.* A `.eslintrc` file may be resolved relative to each linted file.
+Run ESLint with default settings. A [configuration file](https://eslint.org/docs/user-guide/configure/configuration-files) may be resolved relative to each linted file.
 
 ### `gulpESLintNew(options)`
 
 Param type: `Record<string, unknown>`
 
-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.
-Please, refer to the ESLint documentation for information about the usage of those options.
-Check also the notes about the [autofix function](#autofix).
-Additionally, gulp-eslint-new supports the options listed below.
+Run ESLint with the specified options.
+All supported options are listed below.
+See the linked content for details about each option.
+
+**General options**
+* [`configType`](#optionsconfigtype)
+* [`cwd`](#optionscwd)
+
+**File enumeration options**
+* [`ignore`](#optionsignore)
+* [`ignorePath`](#optionsignorepath)
+
+**Linting options**
+* [`allowInlineConfig`][linting options]
+* [`baseConfig`][linting options]
+* [`overrideConfig`][linting options]
+* [`overrideConfigFile`][linting options]
+* [`plugins`][linting options]
+* [`reportUnusedDisableDirectives`][linting options]
+* [`resolvePluginsRelativeTo`][linting options]
+* [`rulePaths`][linting options]
+* [`useEslintrc`][linting options]
 
-#### Additional Options
+**Autofix options**
+* [`fix`](#optionsfix)
+* [`fixTypes`](#optionsfixtypes)
+
+**Reporting options**
+* [`quiet`](#optionsquiet)
+* [`warnIgnored`](#optionswarnignored)
+
+#### General Options
 
 ##### `options.configType`
 
@@ -113,6 +139,8 @@ The working directory is where ESLint will look for a `.eslintignore` file by de
 It is also the base directory for any relative paths specified in the options (e.g. `overrideConfigFile`, `resolvePluginsRelativeTo`, `rulePaths`, `overrideConfig.extends`, etc.).
 The location of the files to be linted is not related to the working directory.
 
+#### File Enumeration Options
+
 ##### `options.ignore`
 
 Type: `boolean`
@@ -125,6 +153,25 @@ Type: `string`
 
 The path to a file ESLint uses instead of `.eslintignore` in the current working directory.
 
+#### Autofix Options
+
+##### `options.fix`
+
+Type: `boolean | (message: LintMessage) => boolean`
+
+Set to `true` or a function to generate fixes when possible, or set to `false` to explicitly disable autofixing.
+If a predicate function is present, it will be invoked once for each lint message, and only the lint messages for which the function returned `true` will be reported.
+
+**See the [Autofix](#autofix) section for more information and examples.**
+
+##### `options.fixTypes`
+
+Type: `("directive" | "problem" | "suggestion" | "layout")[]`
+
+The types of fixes to apply. Default is all types.
+
+#### Reporting Options
+
 ##### `options.quiet`
 
 Type: `boolean`
@@ -179,19 +226,30 @@ Call a function for each ESLint file result. No returned value is expected. If a
 
 ```javascript
 gulp.src(['**/*.js', '!node_modules/**'])
-    .pipe(gulpESLintNew())
-    .pipe(gulpESLintNew.result(
-        result => {
+.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} (${
+            console.log
+            (
+                `# Warnings: ${result.warningCount} (${
+                result.fixableWarningCount} fixable)`,
+            );
+            console.log
+            (
+                `# Errors: ${result.errorCount} (${
                 result.fixableErrorCount} fixable, ${
-                result.fatalErrorCount} fatal)`);
+                result.fatalErrorCount} fatal)`,
+            );
         },
-    ));
+    ),
+);
 ```
 
 Param Type: `(result: Object, callback: Function) => void`
@@ -235,18 +293,29 @@ The results list has additional properties that indicate the number of messages
 
 ```javascript
 gulp.src(['**/*.js', '!node_modules/**'])
-    .pipe(gulpESLintNew())
-    .pipe(gulpESLintNew.results(
-        results => {
+.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} (${
+            console.log
+            (
+                `Total Warnings: ${results.warningCount} (${
+                results.fixableWarningCount} fixable)`,
+            );
+            console.log
+            (
+                `Total Errors: ${results.errorCount} (${
                 results.fixableErrorCount} fixable, ${
-                results.fatalErrorCount} fatal)`);
+                results.fatalErrorCount} fatal)`,
+            );
         },
-    ));
+    ),
+);
 ```
 
 Param type: `(results: Object[], callback: Function) => void`
@@ -264,8 +333,8 @@ Stop a task/stream if an ESLint error has been reported for any file.
 ```javascript
 // Cause the stream to stop (fail) without processing more files.
 gulp.src(['**/*.js', '!node_modules/**'])
-    .pipe(gulpESLintNew())
-    .pipe(gulpESLintNew.failOnError());
+.pipe(gulpESLintNew())
+.pipe(gulpESLintNew.failOnError());
 ```
 
 ### `gulpESLintNew.failAfterError()`
@@ -276,17 +345,19 @@ Stop a task/stream if an ESLint error has been reported for any file, but wait f
 // 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());
+.pipe(gulpESLintNew())
+.pipe(gulpESLintNew.failAfterError());
 ```
 
 ### `gulpESLintNew.format(formatter, writer)`
 
+`formatter` param type: `string | Object | Function | undefined`
+
+`writer` param type: `NodeJS.WritableStream | Function | undefined`
+
 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.
 
-`formatter` param type: `string | Object | Function | undefined`
-
 The `formatter` argument determines the [ESLint formatter](https://eslint.org/docs/user-guide/formatters/) used to format linting results.
 If a `string` is provided, a formatter module by that name or path will be resolved.
 The resolved formatter will be either one of the built-in ESLint formatters, or a formatter exported by a module with the specified 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).
@@ -305,8 +376,6 @@ gulpESLintNew.format('checkstyle')
 gulpESLintNew.format('pretty')
 ```
 
-`writer` param type: `NodeJS.WritableStream | Function | undefined`
-
 The `writer` argument may be a writable stream, `Function`, or `undefined`.
 As a writable stream, the formatter output will be written to the stream.
 If `undefined`, the formatter output will be written to [gulp's log](https://github.com/gulpjs/fancy-log#logmsg).
@@ -322,6 +391,10 @@ gulpESLintNew.format('junit', process.stdout)
 
 ### `gulpESLintNew.formatEach(formatter, writer)`
 
+`formatter` param type: `string | Object | Function | undefined`
+
+`writer` param type: `NodeJS.WritableStream | Function | undefined`
+
 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.
 
@@ -332,7 +405,8 @@ The arguments for `gulpESLintNew.formatEach` are the same as the arguments for [
 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 fix and files that were not processed by ESLint will be left untouched.
-See the [Autofix](#autofix) section for more information and examples.
+
+**See the [Autofix](#autofix) section for more information and examples.**
 
 ## Autofix
 
@@ -342,8 +416,8 @@ To enable autofix with gulp-eslint-new, set the option `fix` to `true` in [`gulp
 
 ```javascript
 gulp.src(['**/*.{js,ts}', '!node_modules/**'])
-    .pipe(gulpESLintNew({ fix: true }))
-    .pipe(gulpESLintNew.fix());
+.pipe(gulpESLintNew({ fix: true }))
+.pipe(gulpESLintNew.fix());
 ```
 
 See also the [autofix examples](https://github.com/origin-1/gulp-eslint-new/blob/main/example/fix.js).
@@ -360,5 +434,6 @@ This is available to streams that follow the initial gulp-eslint-new stream.
 The functions [`gulpESLintNew.result`](#gulpeslintnewresultaction) and [`gulpESLintNew.results`](#gulpeslintnewresultsaction) 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/lib/eslint.d.ts

@@ -1,22 +1,24 @@
-import { ESLint, Linter } from 'eslint';
+import type { ESLint, Linter } from 'eslint';
 
 type ConfigData = Linter.Config;
 
 type ESLintOptions = ESLint.Options;
 
-interface FlatConfig {
-    files?: string[] | undefined;
-    ignores?: string[] | undefined;
-    languageOptions?: LanguageOptions | undefined;
-    linterOptions?: {
-        noInlineConfig?:                boolean | undefined;
-        reportUnusedDisableDirectives?: boolean | undefined;
+interface FlatConfig
+{
+    files?:             string[];
+    ignores?:           string[];
+    languageOptions?:   LanguageOptions;
+    linterOptions?:
+    {
+        noInlineConfig?:                boolean;
+        reportUnusedDisableDirectives?: boolean;
     };
-    name?: string | undefined;
-    plugins?: Record<string, Plugin> | undefined;
-    processor?: string | Linter.Processor | undefined;
-    rules?: Linter.RulesRecord | undefined;
-    settings?: Linter.Config['settings'];
+    name?:              string;
+    plugins?:           Record<string, Plugin>;
+    processor?:         string | Linter.Processor;
+    rules?:             Linter.RulesRecord;
+    settings?:          Record<string, unknown>;
 }
 
 type FormatterContext = ESLint.LintResultData & ResultsMeta;
@@ -26,26 +28,28 @@ type FormatterFunction =
 
 type GlobalConf = boolean | 'off' | 'readable' | 'readonly' | 'writable' | 'writeable';
 
-interface LanguageOptions {
-    ecmaVersion?:   number | 'latest' | undefined;
-    globals?:       Record<string, GlobalConf> | undefined;
-    parser?:        string | Linter.ParserModule | undefined;
-    parserOptions?: object | undefined;
-    sourceType?:    'script' | 'module' | 'commonjs' | undefined;
+interface LanguageOptions
+{
+    ecmaVersion?:   number | 'latest';
+    globals?:       Record<string, GlobalConf>;
+    parser?:        string | Linter.ParserModule;
+    parserOptions?: Linter.ParserOptions;
+    sourceType?:    'script' | 'module' | 'commonjs';
 }
 
 type LintMessage = Linter.LintMessage;
 
 type LintResult = ESLint.LintResult;
 
-interface LoadedFormatter {
-    format(results: ESLint.LintResult[], resultsMeta: ResultsMeta): string | Promise<string>;
-}
+interface LoadedFormatter
+{ format(results: ESLint.LintResult[], resultsMeta: ResultsMeta): string | Promise<string>; }
 
-type Plugin = ESLint.Plugin & { parsers?: Record<string, Linter.ParserModule> | undefined };
+type Plugin = ESLint.Plugin & { parsers?: Record<string, Linter.ParserModule> | undefined; };
 
-interface ResultsMeta {
-    maxWarningsExceeded?: {
+interface ResultsMeta
+{
+    maxWarningsExceeded?:
+    {
         foundWarnings: number;
         maxWarnings: number;
     };

package/lib/gulp-eslint-new.d.ts

@@ -1,4 +1,5 @@
-import {
+import type
+{
     ConfigData,
     ESLintOptions,
     FlatConfig,
@@ -7,18 +8,20 @@ import {
     LintMessage,
     LintResult,
     LoadedFormatter,
-    ResultsMeta,
     Plugin,
+    ResultsMeta,
 }
-    from './eslint';
-import                          'node';
-import { TransformCallback }    from 'stream';
+from './eslint';
+import                              'node';
+import type { TransformCallback }   from 'stream';
+
+type Awaitable<T = unknown> = T | Promise<T>;
 
-export { FormatterContext, FormatterFunction };
+export type { FormatterContext, FormatterFunction };
 
 export type GulpESLintOptions =
-(GulpESLintrcOptions & { configType?: 'eslintrc' | undefined }) |
-(GulpFlatESLintOptions & { configType: 'flat' });
+(GulpESLintrcOptions & { configType?: 'eslintrc' | undefined; }) |
+(GulpFlatESLintOptions & { configType: 'flat'; });
 
 export type GulpESLintResult = LintResult;
 
@@ -33,19 +36,19 @@ GulpESLintResult[] &
     fixableWarningCount: number;
 };
 
-export type GulpESLintWriter = (str: string) => unknown | Promise<unknown>;
+export type GulpESLintWriter = (str: string) => Awaitable;
 
 type GulpESLintrcOptions
 =
 Omit<
-ESLintOptions,
-| 'cache'
-| 'cacheLocation'
-| 'cacheStrategy'
-| 'errorOnUnmatchedPattern'
-| 'extensions'
-| 'globInputPaths'
-| 'plugins'
+    ESLintOptions,
+    | 'cache'
+    | 'cacheLocation'
+    | 'cacheStrategy'
+    | 'errorOnUnmatchedPattern'
+    | 'extensions'
+    | 'globInputPaths'
+    | 'plugins'
 > &
 {
     /** @deprecated Use `overrideConfigFile` instead. */
@@ -97,13 +100,13 @@ ESLintOptions,
 type GulpFlatESLintOptions
 =
 Pick<
-ESLintOptions,
-| 'allowInlineConfig'
-| 'cwd'
-| 'fix'
-| 'fixTypes'
-| 'ignore'
-| 'reportUnusedDisableDirectives'
+    ESLintOptions,
+    | 'allowInlineConfig'
+    | 'cwd'
+    | 'fix'
+    | 'fixTypes'
+    | 'ignore'
+    | 'reportUnusedDisableDirectives'
 > &
 {
     baseConfig?: FlatConfig | undefined;
@@ -124,11 +127,12 @@ ESLintOptions,
 
 type LintResultStreamFunction<Type> =
 ((action: (value: Type, callback: TransformCallback) => void) => NodeJS.ReadWriteStream) &
-((action: (value: Type) => unknown | Promise<unknown>) => NodeJS.ReadWriteStream);
+((action: (value: Type) => Awaitable) => NodeJS.ReadWriteStream);
 
-export { LoadedFormatter, ResultsMeta };
+export type { LoadedFormatter, ResultsMeta };
 
-declare const gulpESLintNew: {
+declare const gulpESLintNew:
+{
     /**
      * Append ESLint result to each file.
      *
@@ -187,7 +191,8 @@ declare const gulpESLintNew: {
      * Defaults to gulp's [fancy-log](https://github.com/gulpjs/fancy-log#readme).
      * @returns gulp file stream.
      */
-    formatEach(
+    formatEach
+    (
         formatter?: string | LoadedFormatter | FormatterFunction,
         writer?: GulpESLintWriter | NodeJS.WritableStream
     ): NodeJS.ReadWriteStream;
@@ -204,7 +209,8 @@ declare const gulpESLintNew: {
      * Defaults to gulp's [fancy-log](https://github.com/gulpjs/fancy-log#readme).
      * @returns gulp file stream.
      */
-    format(
+    format
+    (
         formatter?: string | LoadedFormatter | FormatterFunction,
         writer?: GulpESLintWriter | NodeJS.WritableStream
     ): NodeJS.ReadWriteStream;
@@ -216,4 +222,5 @@ declare const gulpESLintNew: {
      */
     fix(): NodeJS.ReadWriteStream;
 };
+
 export default gulpESLintNew;

package/lib/gulp-eslint-new.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const {
+const
+{
     GULP_DEST_KEY,
     GULP_WARN_KEY,
     createIgnoreResult,
@@ -17,30 +18,32 @@ const {
 } = require('#util');
 const { promisify } = require('util');
 
-function wrapAction(action) {
-    if (typeof action !== 'function') {
+function wrapAction(action)
+{
+    if (typeof action !== 'function')
         throw TypeError('Argument is not a function');
-    }
-    if (action.length > 1) {
+    if (action.length > 1)
         action = promisify(action);
-    }
     return action;
 }
 
 const createResultStream =
-action => {
+action =>
+{
     action = wrapAction(action);
-    return createTransform(
-        async ({ eslint: result }) => {
-            if (result) {
+    return createTransform
+    (
+        async ({ eslint: result }) =>
+        {
+            if (result)
                 await action(result);
-            }
         },
     );
 };
 
 const createResultsStream =
-action => {
+action =>
+{
     action = wrapAction(action);
     const results = [];
     results.errorCount          = 0;
@@ -48,9 +51,12 @@ action => {
     results.fixableErrorCount   = 0;
     results.fixableWarningCount = 0;
     results.fatalErrorCount     = 0;
-    return createTransform(
-        ({ eslint: result }) => {
-            if (result) {
+    return createTransform
+    (
+        ({ eslint: result }) =>
+        {
+            if (result)
+            {
                 results.push(result);
                 // Collect total error/warning count.
                 results.errorCount          += result.errorCount;
@@ -60,64 +66,68 @@ action => {
                 results.fatalErrorCount     += result.fatalErrorCount;
             }
         },
-        async () => {
+        async () =>
+        {
             await action(results);
         },
     );
 };
 
-function getESLintInfo(file) {
+function getESLintInfo(file)
+{
     const eslintInfo = file._eslintInfo;
-    if (eslintInfo != null) {
+    if (eslintInfo != null)
         return eslintInfo;
-    }
     throw createPluginError({ fileName: file.path, message: 'ESLint information not available' });
 }
 
 const warn =
 (message, gulpWarn = require('fancy-log').warn) =>
-    gulpWarn(`\x1b[1;37m\x1b[40mgulp-eslint-new\x1b[0m \x1b[30m\x1b[43mWARN\x1b[0m\n${message}`);
+gulpWarn(`\x1b[1;37m\x1b[40mgulp-eslint-new\x1b[0m \x1b[30m\x1b[43mWARN\x1b[0m\n${message}`);
 
-function formatMigratedOptionWarningLine({ oldName, newName, formatChanged }) {
+function formatMigratedOptionWarningLine({ oldName, newName, formatChanged })
+{
     let line = ` • ${oldName} → ${newName}`;
-    if (formatChanged) {
+    if (formatChanged)
         line += ' (format changed)';
-    }
     return line;
 }
 
-async function lintFile(eslintInfo, file, quiet, warnIgnored) {
-    if (file.isNull()) {
+async function lintFile(eslintInfo, file, quiet, warnIgnored)
+{
+    if (file.isNull())
         return;
-    }
-    if (file.isStream()) {
+    if (file.isStream())
         throw 'gulp-eslint-new doesn\'t support Vinyl files with Stream contents.';
-    }
     const { eslint } = eslintInfo;
     // The "path" property of a Vinyl file should be always an absolute path.
     // See https://gulpjs.com/docs/en/api/vinyl/#instance-properties.
     const filePath = file.path;
     let result;
-    if (await eslint.isPathIgnored(filePath)) {
+    if (await eslint.isPathIgnored(filePath))
+    {
         // 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.
-        if (!warnIgnored) {
+        if (!warnIgnored)
             return;
-        }
         // Warn that gulp.src is needlessly reading files that ESLint ignores.
         result = createIgnoreResult(filePath, eslintInfo.cwd, eslint.constructor.version);
-    } else {
+    }
+    else
+    {
         [result] = await eslint.lintText(file.contents.toString(), { filePath });
         // Note: Fixes are applied as part of `lintText`.
         // Any applied fix messages have been removed from the result.
-        if (quiet) {
+        if (quiet)
+        {
             // Ignore some messages.
             const filter = typeof quiet === 'function' ? quiet : isErrorMessage;
             result = filterResult(result, filter);
         }
         // Update the fixed output; otherwise, fixable messages are simply ignored.
-        if (hasOwn(result, 'output')) {
+        if (hasOwn(result, 'output'))
+        {
             file.contents = Buffer.from(result.output);
             result.fixed = true;
         }
@@ -127,21 +137,22 @@ async function lintFile(eslintInfo, file, quiet, warnIgnored) {
 }
 
 module.exports = exports =
-options => {
+options =>
+{
     const { ESLint, eslintOptions, gulpWarn, migratedOptions, quiet, warnIgnored } =
     organizeOptions(options);
-    if (eslintOptions.cwd === undefined) {
+    if (eslintOptions.cwd === undefined)
         eslintOptions.cwd = process.cwd();
-    }
     {
         const migratedOptionCount = migratedOptions.length;
-        if (migratedOptionCount) {
+        if (migratedOptionCount)
+        {
             const migratedOptionWarningText =
             migratedOptions.map(formatMigratedOptionWarningLine).join('\n');
             const messageIntro =
             migratedOptionCount > 1 ?
-                'The following top-level options passed to gulpESLintNew() have been migrated' :
-                'The following top-level option passed to gulpESLintNew() has been migrated';
+            'The following top-level options passed to gulpESLintNew() have been migrated' :
+            'The following top-level option passed to gulpESLintNew() has been migrated';
             const message =
             `${messageIntro}:\n${migratedOptionWarningText}\nSee ${makeNPMLink('legacy-options')
             } for more information.`;
@@ -158,16 +169,20 @@ exports.result = createResultStream;
 
 exports.results = createResultsStream;
 
-function failOnErrorAction(result) {
+function failOnErrorAction(result)
+{
     const { messages } = result;
-    if (messages) {
+    if (messages)
+    {
         const error = messages.find(isErrorMessage);
-        if (error) {
-            throw createPluginError(
+        if (error)
+        {
+            throw createPluginError
+            (
                 {
-                    name: 'ESLintError',
-                    fileName: result.filePath,
-                    message: error.message,
+                    name:       'ESLintError',
+                    fileName:   result.filePath,
+                    message:    error.message,
                     lineNumber: error.line,
                 },
             );
@@ -177,12 +192,15 @@ function failOnErrorAction(result) {
 
 exports.failOnError = () => createResultStream(failOnErrorAction);
 
-function failAfterErrorAction({ errorCount }) {
-    if (errorCount) {
-        throw createPluginError(
+function failAfterErrorAction({ errorCount })
+{
+    if (errorCount)
+    {
+        throw createPluginError
+        (
             {
-                name: 'ESLintError',
-                message: `Failed with ${errorCount} ${errorCount === 1 ? 'error' : 'errors'}`,
+                name:       'ESLintError',
+                message:    `Failed with ${errorCount} ${errorCount === 1 ? 'error' : 'errors'}`,
             },
         );
     }
@@ -191,17 +209,22 @@ function failAfterErrorAction({ errorCount }) {
 exports.failAfterError = () => createResultsStream(failAfterErrorAction);
 
 exports.formatEach =
-(formatter, writer) => {
+(formatter, writer) =>
+{
     writer = resolveWriter(writer);
     const eslintToFormatterMap = new Map();
-    return createTransform(
-        async file => {
+    return createTransform
+    (
+        async file =>
+        {
             const result = file.eslint;
-            if (result) {
+            if (result)
+            {
                 const eslintInfo = getESLintInfo(file);
                 const { eslint } = eslintInfo;
                 let formatterObj = eslintToFormatterMap.get(eslint);
-                if (!formatterObj) {
+                if (!formatterObj)
+                {
                     formatterObj = await resolveFormatter(eslintInfo, formatter);
                     eslintToFormatterMap.set(eslint, formatterObj);
                 }
@@ -213,32 +236,38 @@ exports.formatEach =
 
 const ERROR_MULTIPLE_ESLINT_INSTANCES =
 {
-    name: 'ESLintError',
-    message: 'The files in the stream were not processed by the same instance of ESLint',
+    name:       'ESLintError',
+    message:    'The files in the stream were not processed by the same instance of ESLint',
 };
 
 exports.format =
-(formatter, writer) => {
+(formatter, writer) =>
+{
     writer = resolveWriter(writer);
     const results = [];
     let commonInfo;
-    return createTransform(
-        file => {
+    return createTransform
+    (
+        file =>
+        {
             const result = file.eslint;
-            if (result) {
+            if (result)
+            {
                 const eslintInfo = getESLintInfo(file);
-                if (commonInfo == null) {
+                if (commonInfo == null)
                     commonInfo = eslintInfo;
-                } else {
-                    if (eslintInfo !== commonInfo) {
+                else
+                {
+                    if (eslintInfo !== commonInfo)
                         throw createPluginError(ERROR_MULTIPLE_ESLINT_INSTANCES);
-                    }
                 }
                 results.push(result);
             }
         },
-        async () => {
-            if (results.length) {
+        async () =>
+        {
+            if (results.length)
+            {
                 const formatterObj = await resolveFormatter(commonInfo, formatter);
                 await writeResults(results, formatterObj, writer);
             }
@@ -248,15 +277,19 @@ exports.format =
 
 const getBase = ({ base }) => base;
 exports.fix =
-({ [GULP_DEST_KEY]: gulpDest = require('vinyl-fs').dest, [GULP_WARN_KEY]: gulpWarn } = { }) => {
+({ [GULP_DEST_KEY]: gulpDest = require('vinyl-fs').dest, [GULP_WARN_KEY]: gulpWarn } = { }) =>
+{
     const ternaryStream = require('ternary-stream');
     let warned = false;
     const isFixed =
-    file => {
+    file =>
+    {
         const result = file.eslint;
-        if (result) {
+        if (result)
+        {
             const eslintInfo = getESLintInfo(file);
-            if (eslintInfo.fix == null && !warned) {
+            if (eslintInfo.fix == null && !warned)
+            {
                 warned = true;
                 const message =
                 'gulpESLintNew.fix() received a file that was linted without the option "fix".\n' +

package/lib/util.js

@@ -15,6 +15,7 @@
  * @param {LintResultData} [data]
  * @returns {string | Promise<string>}
  */
+
 const { relative }  = require('path');
 const { Transform } = require('stream');
 
@@ -22,27 +23,26 @@ const ESLINT_KEY    = Symbol('ESLint');
 const GULP_DEST_KEY = Symbol('require("vinyl-fs").dest');
 const GULP_WARN_KEY = Symbol('require("fancy-log").warn');
 
-function compareResultsByFilePath({ filePath: filePath1 }, { filePath: filePath2 }) {
-    if (filePath1 > filePath2) {
+function compareResultsByFilePath({ filePath: filePath1 }, { filePath: filePath2 })
+{
+    if (filePath1 > filePath2)
         return 1;
-    }
-    if (filePath1 < filePath2) {
+    if (filePath1 < filePath2)
         return -1;
-    }
     return 0;
 }
 
 const PLUGIN_ERROR_OPTIONS = { showStack: true };
 
-function createPluginError(error) {
+function createPluginError(error)
+{
     const PluginError = require('plugin-error');
-    if (error instanceof PluginError) {
+    if (error instanceof PluginError)
         return error;
-    }
-    if (error == null) {
+    if (error == null)
         error = 'Unknown Error';
-    }
-    return PluginError('gulp-eslint-new', error, PLUGIN_ERROR_OPTIONS);
+    const pluginError = PluginError('gulp-eslint-new', error, PLUGIN_ERROR_OPTIONS);
+    return pluginError;
 }
 
 const { defineProperty } = Object;
@@ -111,19 +111,25 @@ const isInNodeModulesRegExp = /(?<![^/\\])node_modules[/\\]/u;
  * @returns {LintResult} Result with warning by ignore settings.
  */
 exports.createIgnoreResult =
-(filePath, baseDir, eslintVersion) => {
+(filePath, baseDir, eslintVersion) =>
+{
     const { ltr } = require('semver');
     let message;
     const relativePath = relative(baseDir, filePath);
-    if (isHiddenRegExp.test(relativePath)) {
+    if (isHiddenRegExp.test(relativePath))
+    {
         message =
         'File ignored by default. Use a negated ignore pattern (like ' +
         '"!<relative/path/to/filename>") to override.';
-    } else if (isInNodeModulesRegExp.test(relativePath)) {
+    }
+    else if (isInNodeModulesRegExp.test(relativePath))
+    {
         message =
         'File ignored by default. Use a negated ignore pattern like "!node_modules/*" to ' +
         'override.';
-    } else {
+    }
+    else
+    {
         message =
         'File ignored because of a matching ignore pattern. Set "ignore" option to false to ' +
         'override.';
@@ -131,26 +137,30 @@ exports.createIgnoreResult =
     const result =
     {
         filePath,
-        messages: [{ fatal: false, severity: 1, message }],
-        errorCount: 0,
-        warningCount: 1,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0,
-        fatalErrorCount: 0,
+        messages:               [{ fatal: false, severity: 1, message }],
+        errorCount:             0,
+        warningCount:           1,
+        fixableErrorCount:      0,
+        fixableWarningCount:    0,
+        fatalErrorCount:        0,
     };
-    if (!ltr(eslintVersion, '8.8.0')) {
+    if (!ltr(eslintVersion, '8.8.0'))
         result.suppressedMessages = [];
-    }
     return result;
 };
 
 exports.createPluginError = createPluginError;
 
-async function awaitHandler(handler, data, done) {
-    try {
+async function awaitHandler(handler, data, done)
+{
+    try
+    {
         await handler();
-    } catch (err) {
-        done(createPluginError(err));
+    }
+    catch (error)
+    {
+        const pluginError = createPluginError(error);
+        done(pluginError);
         return;
     }
     done(null, data);
@@ -173,29 +183,33 @@ async function awaitHandler(handler, data, done) {
  * @returns {Transform} A transform stream.
  */
 exports.createTransform =
-(handleFile, handleFinal) => {
+(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 });
+    return new Transform({ autoDestroy: false, objectMode: true, transform, final });
 };
 
+/**
+ * @callback CountMessagePredicate
+ * @param {LintMessage} message - ESLint message.
+ * @returns {boolean} `true` or `false`, depending on the input.
+ */
+
 /**
  * Count the number of messages for which a predicate function returns `true`.
  *
  * @param {LintMessage[]} messages - ESLint messages to count.
  * @param {CountMessagePredicate} predicate - Function to call for each message.
  * @returns {number} The number of messages for which the predicate function returns `true`.
- *
- * @callback CountMessagePredicate
- * @param {LintMessage} message - ESLint message.
- * @returns {boolean} `true` or `false`, depending on the input.
  */
-function countMessages(messages, predicate) {
+function countMessages(messages, predicate)
+{
     let count = 0;
-    for (const message of messages) {
-        if (predicate(message)) {
+    for (const message of messages)
+    {
+        if (predicate(message))
             ++count;
-        }
     }
     return count;
 }
@@ -208,7 +222,8 @@ function countMessages(messages, predicate) {
  * @returns {LintResult} A filtered ESLint result.
  */
 exports.filterResult =
-(result, filter) => {
+(result, filter) =>
+{
     const { messages, ...newResult } = result;
     const newMessages = messages.filter(filter, result);
     newResult.messages = newMessages;
@@ -227,7 +242,8 @@ exports.isErrorMessage = isErrorMessage;
 exports.isWarningMessage = isWarningMessage;
 
 const makeNPMLink =
-anchor => {
+anchor =>
+{
     const { version } = require('gulp-eslint-new/package.json');
     const npmLink = `https://www.npmjs.com/package/gulp-eslint-new/v/${version}#${anchor}`;
     return npmLink;
@@ -235,7 +251,8 @@ anchor => {
 
 exports.makeNPMLink = makeNPMLink;
 
-const FORBIDDEN_OPTIONS = [
+const FORBIDDEN_OPTIONS =
+[
     'cache',
     'cacheFile',
     'cacheLocation',
@@ -247,8 +264,10 @@ const FORBIDDEN_OPTIONS = [
 
 const requireESLint = (ESLint = require('eslint').ESLint) => ESLint;
 
-function requireFlatESLint(ESLint = require('eslint/use-at-your-own-risk').FlatESLint) {
-    if (ESLint == null) {
+function requireFlatESLint(ESLint = require('eslint/use-at-your-own-risk').FlatESLint)
+{
+    if (ESLint == null)
+    {
         const message =
         'The version of ESLint you are using does not support flat config. ' +
         'To use flat config, upgrade to ESLint 8.21 or later.';
@@ -261,34 +280,38 @@ function requireFlatESLint(ESLint = require('eslint/use-at-your-own-risk').FlatE
  * Throws an error about invalid options passed to gulp-eslint-new.
  *
  * @param {string} message - The error message.
- * @throws An error with code "ESLINT_INVALID_OPTIONS" and the specified message.
+ * @throws An error with code `"ESLINT_INVALID_OPTIONS"` and the specified message.
  */
-function throwInvalidOptionError(message) {
+function throwInvalidOptionError(message)
+{
     const error = Error(message);
     Error.captureStackTrace(error, throwInvalidOptionError);
     error.code = 'ESLINT_INVALID_OPTIONS';
     throw error;
 }
 
+// Adapted from https://github.com/eslint/eslint/blob/v6.8.0/lib/cli-engine/cli-engine.js#L455-L480.
 /**
  * Convert a string array to a boolean map.
  *
- * @param {string[] | null} keys - The keys to assign true.
+ * @param {string[] | null} strs - The strings to be mapped.
  * @param {boolean} defaultValue - The default value for each property.
  * @param {string} displayName - The property name which is used in error message.
- * @returns {Record<string, boolean>} The boolean map.
+ * @returns {Object.<string, boolean> | undefined} A boolean map or `undefined`.
  */
-function toBooleanMap(keys, defaultValue, displayName) {
-    if (keys && !Array.isArray(keys)) {
+function toBooleanMap(keys, defaultValue, displayName)
+{
+    if (keys && !Array.isArray(keys))
         throwInvalidOptionError(`Option ${displayName} must be an array`);
-    }
-    if (keys && keys.length > 0) {
-        return keys.reduce(
-            (map, def) => {
+    if (keys && keys.length > 0)
+    {
+        return keys.reduce
+        (
+            (map, def) =>
+            {
                 const [key, value] = def.split(':');
-                if (key !== '__proto__') {
+                if (key !== '__proto__')
                     map[key] = value === undefined ? defaultValue : value === 'true';
-                }
                 return map;
             },
             { },
@@ -299,36 +322,38 @@ function toBooleanMap(keys, defaultValue, displayName) {
 /**
  * Organize, migrate and partially validate the options passed to gulp-eslint-new.
  *
- * @param {Record<string | symbol, unknown>} [options] - Options to organize.
+ * @param {Object.<string | symbol, unknown>} [options] - Options to organize.
  * @returns {OrganizedOptions} Organized options.
  *
  * @typedef {Object} OrganizedOptions
  * @property {Function} [ESLint]
- * @property {Record<string, unknown>} eslintOptions
+ * @property {Object.<string, unknown>} eslintOptions
  * @property {Function} [gulpWarn]
  * @property {Object[]} migratedOptions
  * @property {boolean | undefined} [quiet]
  * @property {boolean | undefined} [warnIgnored]
  */
 exports.organizeOptions =
-(options = { }) => {
+(options = { }) =>
+{
     const migratedOptions = [];
-    if (typeof options === 'string') {
+    if (typeof options === 'string')
+    {
         const organizedOptions =
         {
-            ESLint: requireESLint(),
-            eslintOptions: { overrideConfigFile: options },
+            ESLint:         requireESLint(),
+            eslintOptions:  { overrideConfigFile: options },
             migratedOptions,
         };
         return organizedOptions;
     }
     {
         const invalidOptions = FORBIDDEN_OPTIONS.filter(option => hasOwn(options, option));
-        if (invalidOptions.length) {
+        if (invalidOptions.length)
             throwInvalidOptionError(`Invalid options: ${invalidOptions.join(', ')}`);
-        }
     }
-    const {
+    const
+    {
         [ESLINT_KEY]:       rawESLint,
         [GULP_WARN_KEY]:    gulpWarn,
         configType,
@@ -337,30 +362,32 @@ exports.organizeOptions =
         ...eslintOptions
     } =
     options;
-    if (configType != null && configType !== 'eslintrc' && configType !== 'flat') {
+    if (configType != null && configType !== 'eslintrc' && configType !== 'flat')
         throwInvalidOptionError('Option configType must be one of "eslintrc", "flat", or null');
-    }
     const useEslintrcConfig = configType !== 'flat';
     const ESLint =
-        (useEslintrcConfig ? requireESLint : requireFlatESLint)(rawESLint);
+    (useEslintrcConfig ? requireESLint : requireFlatESLint)(rawESLint);
     const organizedOptions =
     { ESLint, eslintOptions, gulpWarn, migratedOptions, quiet, warnIgnored };
-    if (useEslintrcConfig) {
+    if (useEslintrcConfig)
+    {
         let { overrideConfig } = eslintOptions;
-        if (overrideConfig != null && typeof overrideConfig !== 'object') {
+        if (overrideConfig != null && typeof overrideConfig !== 'object')
             throwInvalidOptionError('Option overrideConfig must be an object or null');
-        }
         overrideConfig = eslintOptions.overrideConfig =
         overrideConfig != null ? { ...overrideConfig } : { };
         const migrateOption =
-        function (
+        function
+        (
             oldName,
             newName = oldName,
             newOptions = overrideConfig,
             needsMigration = hasOwn(eslintOptions, oldName),
             convert,
-        ) {
-            if (needsMigration) {
+        )
+        {
+            if (needsMigration)
+            {
                 const value = eslintOptions[oldName];
                 delete eslintOptions[oldName];
                 {
@@ -374,7 +401,8 @@ exports.organizeOptions =
             }
         };
         migrateOption('configFile', 'overrideConfigFile', eslintOptions);
-        migrateOption(
+        migrateOption
+        (
             'envs',
             'env',
             undefined,
@@ -382,7 +410,8 @@ exports.organizeOptions =
             envs => toBooleanMap(envs, true, 'envs'),
         );
         migrateOption('extends');
-        migrateOption(
+        migrateOption
+        (
             'globals',
             undefined,
             undefined,
@@ -413,30 +442,36 @@ exports.organizeOptions =
  * @returns {Promise<LoadedFormatter>} An ESLint formatter.
  */
 exports.resolveFormatter =
-async ({ cwd, eslint }, formatter) => {
-    if (formatter === undefined) {
+async ({ cwd, eslint }, formatter) =>
+{
+    if (formatter === undefined)
+    {
         const { format } = await eslint.loadFormatter();
         return {
             format: results =>
-                format(results)
-                    .replace(
-                        / with the `--fix` option\.(?=(\u001b\[\d+m|\n)+$)/,
-                        ` - see ${makeNPMLink('autofix')}`,
-                    ),
+            format(results)
+            .replace
+            (
+                / with the `--fix` option\.(?=(\u001b\[\d+m|\n)+$)/,
+                ` - see ${makeNPMLink('autofix')}`,
+            ),
         };
     }
-    if (isObject(formatter) && typeof formatter.format === 'function') {
+    if (isObject(formatter) && typeof formatter.format === 'function')
         return formatter;
-    }
-    if (typeof formatter === 'function') {
+    if (typeof formatter === 'function')
+    {
         return {
-            format: results => {
+            format: results =>
+            {
                 results.sort(compareResultsByFilePath);
-                return formatter(
+                return formatter
+                (
                     results,
                     {
                         cwd,
-                        get rulesMeta() {
+                        get rulesMeta()
+                        {
                             const rulesMeta = eslint.getRulesMetaForResults(results);
                             defineProperty(this, 'rulesMeta', { value: rulesMeta });
                             return rulesMeta;
@@ -458,12 +493,13 @@ async ({ cwd, eslint }, formatter) => {
  * @returns {GulpESLintWriter} A function that writes formatted messages.
  */
 exports.resolveWriter =
-(writer = require('fancy-log')) => {
-    if (isObject(writer)) {
+(writer = require('fancy-log')) =>
+{
+    if (isObject(writer))
+    {
         const { write } = writer;
-        if (typeof write === 'function') {
+        if (typeof write === 'function')
             writer = write.bind(writer);
-        }
     }
     return writer;
 };
@@ -481,9 +517,9 @@ exports.resolveWriter =
  * A function used to write formatted ESLint messages.
  */
 exports.writeResults =
-async (results, formatterObj, writer) => {
+async (results, formatterObj, writer) =>
+{
     const message = await formatterObj.format(results, { });
-    if (writer && message != null && message !== '') {
+    if (writer && message != null && message !== '')
         await writer(message);
-    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gulp-eslint-new",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "A gulp plugin to lint code with ESLint 8",
   "keywords": [
     "gulpplugin",
@@ -33,38 +33,38 @@
   "scripts": {
     "build": "npm install && gulp",
     "coverage": "gulp test",
-    "lint": "eslint .",
+    "lint": "eslint . --format compact",
     "test": "mocha --check-leaks test/*.spec.js",
     "ts-test": "tsc --project test/tsconfig.json"
   },
   "dependencies": {
-    "@types/eslint": "^8.4.9",
+    "@types/eslint": "^8.21.0",
     "@types/node": ">=12",
     "eslint": "8",
     "fancy-log": "^2.0.0",
-    "plugin-error": "^2.0.0",
+    "plugin-error": "^2.0.1",
     "semver": "^7.3.8",
     "ternary-stream": "^3.0.0",
     "vinyl-fs": "^3.0.3"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.42.0",
-    "@typescript-eslint/parser": "^5.42.0",
+    "@origin-1/eslint-config": "^0.10.0",
+    "@typescript-eslint/parser": "^5.51.0",
     "c8js": "^0.3.0",
     "eslint-8.0": "npm:eslint@8.0",
     "eslint-8.21": "npm:eslint@8.21",
     "eslint-8.x": "npm:eslint@8.x",
-    "eslint-formatter-~formatter": "file:test/formatter",
     "eslint-config-~shareable": "file:test/config",
+    "eslint-formatter-~formatter": "file:test/formatter",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-tsdoc": "^0.2.17",
     "gulp": "^4.0.2",
     "mocha": "^9.2.2",
-    "typescript": "^4.8.4",
+    "typescript": "^4.9.5",
     "vinyl": "^3.0.0"
   },
   "engines": {
-    "node": "12 >=12.20 || 14 >=14.13 || >=16"
+    "node": "^12.20 || ^14.13 || >=16"
   },
   "exports": {
     ".": "./lib/gulp-eslint-new.js",