eslint 8.24.0 → 8.26.0

package/lib/cli.js

@@ -25,7 +25,6 @@ const fs = require("fs"),
     RuntimeInfo = require("./shared/runtime-info");
 const { Legacy: { naming } } = require("@eslint/eslintrc");
 const { findFlatConfigFile } = require("./eslint/flat-eslint");
-const { gitignoreToMinimatch } = require("@humanwhocodes/gitignore-to-minimatch");
 const { ModuleImporter } = require("@humanwhocodes/module-importer");
 
 const debug = require("debug")("eslint:cli");
@@ -38,6 +37,7 @@ const debug = require("debug")("eslint:cli");
 /** @typedef {import("./eslint/eslint").LintMessage} LintMessage */
 /** @typedef {import("./eslint/eslint").LintResult} LintResult */
 /** @typedef {import("./options").ParsedCLIOptions} ParsedCLIOptions */
+/** @typedef {import("./shared/types").ResultsMeta} ResultsMeta */
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -143,12 +143,6 @@ async function translateOptions({
             overrideConfig[0].plugins = plugins;
         }
 
-        if (ignorePattern) {
-            overrideConfig.push({
-                ignores: ignorePattern.map(gitignoreToMinimatch)
-            });
-        }
-
     } else {
         overrideConfigFile = config;
 
@@ -182,17 +176,19 @@ async function translateOptions({
         fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true),
         fixTypes: fixType,
         ignore,
-        ignorePath,
         overrideConfig,
         overrideConfigFile,
         reportUnusedDisableDirectives: reportUnusedDisableDirectives ? "error" : void 0
     };
 
-    if (configType !== "flat") {
+    if (configType === "flat") {
+        options.ignorePatterns = ignorePattern;
+    } else {
         options.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
         options.rulePaths = rulesdir;
         options.useEslintrc = eslintrc;
         options.extensions = ext;
+        options.ignorePath = ignorePath;
     }
 
     return options;
@@ -201,7 +197,7 @@ async function translateOptions({
 /**
  * Count error messages.
  * @param {LintResult[]} results The lint results.
- * @returns {{errorCount:number;warningCount:number}} The number of error messages.
+ * @returns {{errorCount:number;fatalErrorCount:number,warningCount:number}} The number of error messages.
  */
 function countErrors(results) {
     let errorCount = 0;
@@ -239,10 +235,11 @@ async function isDirectory(filePath) {
  * @param {LintResult[]} results The results to print.
  * @param {string} format The name of the formatter to use or the path to the formatter.
  * @param {string} outputFile The path for the output file.
+ * @param {ResultsMeta} resultsMeta Warning count and max threshold.
  * @returns {Promise<boolean>} True if the printing succeeds, false if not.
  * @private
  */
-async function printResults(engine, results, format, outputFile) {
+async function printResults(engine, results, format, outputFile, resultsMeta) {
     let formatter;
 
     try {
@@ -252,7 +249,7 @@ async function printResults(engine, results, format, outputFile) {
         return false;
     }
 
-    const output = await formatter.format(results);
+    const output = await formatter.format(results, resultsMeta);
 
     if (output) {
         if (outputFile) {
@@ -278,6 +275,31 @@ async function printResults(engine, results, format, outputFile) {
     return true;
 }
 
+/**
+ * Returns whether flat config should be used.
+ * @param {boolean} [allowFlatConfig] Whether or not to allow flat config.
+ * @returns {Promise<boolean>} Where flat config should be used.
+ */
+async function shouldUseFlatConfig(allowFlatConfig) {
+    if (!allowFlatConfig) {
+        return false;
+    }
+
+    switch (process.env.ESLINT_USE_FLAT_CONFIG) {
+        case "true":
+            return true;
+        case "false":
+            return false;
+        default:
+
+            /*
+             * If neither explicitly enabled nor disabled, then use the presence
+             * of a flat config file to determine enablement.
+             */
+            return !!(await findFlatConfigFile(process.cwd()));
+    }
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -307,7 +329,7 @@ const cli = {
          * switch to flat config we can remove this logic.
          */
 
-        const usingFlatConfig = allowFlatConfig && !!(await findFlatConfigFile(process.cwd()));
+        const usingFlatConfig = await shouldUseFlatConfig(allowFlatConfig);
 
         debug("Using flat config?", usingFlatConfig);
 
@@ -407,17 +429,24 @@ const cli = {
             resultsToPrint = ActiveESLint.getErrorResults(resultsToPrint);
         }
 
-        if (await printResults(engine, resultsToPrint, options.format, options.outputFile)) {
+        const resultCounts = countErrors(results);
+        const tooManyWarnings = options.maxWarnings >= 0 && resultCounts.warningCount > options.maxWarnings;
+        const resultsMeta = tooManyWarnings
+            ? {
+                maxWarningsExceeded: {
+                    maxWarnings: options.maxWarnings,
+                    foundWarnings: resultCounts.warningCount
+                }
+            }
+            : {};
 
-            // Errors and warnings from the original unfiltered results should determine the exit code
-            const { errorCount, fatalErrorCount, warningCount } = countErrors(results);
+        if (await printResults(engine, resultsToPrint, options.format, options.outputFile, resultsMeta)) {
 
-            const tooManyWarnings =
-                options.maxWarnings >= 0 && warningCount > options.maxWarnings;
+            // Errors and warnings from the original unfiltered results should determine the exit code
             const shouldExitForFatalErrors =
-                options.exitOnFatalError && fatalErrorCount > 0;
+                options.exitOnFatalError && resultCounts.fatalErrorCount > 0;
 
-            if (!errorCount && tooManyWarnings) {
+            if (!resultCounts.errorCount && tooManyWarnings) {
                 log.error(
                     "ESLint found too many warnings (maximum: %s).",
                     options.maxWarnings
@@ -428,7 +457,7 @@ const cli = {
                 return 2;
             }
 
-            return (errorCount || tooManyWarnings) ? 1 : 0;
+            return (resultCounts.errorCount || tooManyWarnings) ? 1 : 0;
         }
 
         return 2;

package/lib/config/default-config.js

@@ -52,7 +52,7 @@ exports.defaultConfig = [
     {
         ignores: [
             "**/node_modules/**",
-            ".git/**"
+            ".git/"
         ]
     },
 

package/lib/config/flat-config-array.js

@@ -70,7 +70,7 @@ class FlatConfigArray extends ConfigArray {
         }
 
         /**
-         * The baes config used to build the config array.
+         * The base config used to build the config array.
          * @type {Array<FlatConfig>}
          */
         this[originalBaseConfig] = baseConfig;

package/lib/eslint/eslint-helpers.js

@@ -13,9 +13,19 @@ const path = require("path");
 const fs = require("fs");
 const fsp = fs.promises;
 const isGlob = require("is-glob");
-const globby = require("globby");
 const hash = require("../cli-engine/hash");
 const minimatch = require("minimatch");
+const util = require("util");
+const fswalk = require("@nodelib/fs.walk");
+const globParent = require("glob-parent");
+const isPathInside = require("is-path-inside");
+
+//-----------------------------------------------------------------------------
+// Fixup references
+//-----------------------------------------------------------------------------
+
+const doFsWalk = util.promisify(fswalk.walk);
+const Minimatch = minimatch.Minimatch;
 
 //-----------------------------------------------------------------------------
 // Errors
@@ -67,9 +77,9 @@ function isNonEmptyString(x) {
 }
 
 /**
- * Check if a given value is an array of non-empty stringss or not.
+ * Check if a given value is an array of non-empty strings or not.
  * @param {any} x The value to check.
- * @returns {boolean} `true` if `x` is an array of non-empty stringss.
+ * @returns {boolean} `true` if `x` is an array of non-empty strings.
  */
 function isArrayOfNonEmptyString(x) {
     return Array.isArray(x) && x.every(isNonEmptyString);
@@ -97,6 +107,141 @@ function isGlobPattern(pattern) {
     return isGlob(path.sep === "\\" ? normalizeToPosix(pattern) : pattern);
 }
 
+/**
+ * Searches a directory looking for matching glob patterns. This uses
+ * the config array's logic to determine if a directory or file should
+ * be ignored, so it is consistent with how ignoring works throughout
+ * ESLint.
+ * @param {Object} options The options for this function.
+ * @param {string} options.basePath The directory to search.
+ * @param {Array<string>} options.patterns An array of glob patterns
+ *      to match.
+ * @param {FlatConfigArray} options.configs The config array to use for
+ *      determining what to ignore.
+ * @returns {Promise<Array<string>>} An array of matching file paths
+ *      or an empty array if there are no matches.
+ */
+async function globSearch({ basePath, patterns, configs }) {
+
+    if (patterns.length === 0) {
+        return [];
+    }
+
+    const matchers = patterns.map(pattern => {
+        const patternToUse = path.isAbsolute(pattern)
+            ? normalizeToPosix(path.relative(basePath, pattern))
+            : pattern;
+
+        return new minimatch.Minimatch(patternToUse);
+    });
+
+    return (await doFsWalk(basePath, {
+
+        deepFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+            const matchesPattern = matchers.some(matcher => matcher.match(relativePath, true));
+
+            return matchesPattern && !configs.isDirectoryIgnored(entry.path);
+        },
+        entryFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            // entries may be directories or files so filter out directories
+            if (entry.dirent.isDirectory()) {
+                return false;
+            }
+
+            const matchesPattern = matchers.some(matcher => matcher.match(relativePath));
+
+            return matchesPattern && !configs.isFileIgnored(entry.path);
+        }
+    })).map(entry => entry.path);
+
+}
+
+/**
+ * Performs multiple glob searches in parallel.
+ * @param {Object} options The options for this function.
+ * @param {Array<{patterns:Array<string>,rawPatterns:Array<string>}>} options.searches
+ *      An array of glob patterns to match.
+ * @param {FlatConfigArray} options.configs The config array to use for
+ *      determining what to ignore.
+ * @returns {Promise<Array<string>>} An array of matching file paths
+ *      or an empty array if there are no matches.
+ */
+async function globMultiSearch({ searches, configs }) {
+
+    const results = await Promise.all(
+        [...searches].map(
+            ([basePath, { patterns }]) => globSearch({ basePath, patterns, configs })
+        )
+    );
+
+    return [...new Set(results.flat())];
+}
+
+/**
+ * Determines if a given glob pattern will return any results.
+ * Used primarily to help with useful error messages.
+ * @param {Object} options The options for the function.
+ * @param {string} options.basePath The directory to search.
+ * @param {string} options.pattern A glob pattern to match.
+ * @returns {Promise<boolean>} True if there is a glob match, false if not.
+ */
+function globMatch({ basePath, pattern }) {
+
+    let found = false;
+    const patternToUse = path.isAbsolute(pattern)
+        ? normalizeToPosix(path.relative(basePath, pattern))
+        : pattern;
+
+    const matcher = new Minimatch(patternToUse);
+
+    const fsWalkSettings = {
+
+        deepFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            return !found && matcher.match(relativePath, true);
+        },
+
+        entryFilter(entry) {
+            if (found || entry.dirent.isDirectory()) {
+                return false;
+            }
+
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            if (matcher.match(relativePath)) {
+                found = true;
+                return true;
+            }
+
+            return false;
+        }
+    };
+
+    return new Promise(resolve => {
+
+        // using a stream so we can exit early because we just need one match
+        const globStream = fswalk.walkStream(basePath, fsWalkSettings);
+
+        globStream.on("data", () => {
+            globStream.destroy();
+            resolve(true);
+        });
+
+        // swallow errors as they're not important here
+        globStream.on("error", () => {});
+
+        globStream.on("end", () => {
+            resolve(false);
+        });
+        globStream.read();
+    });
+
+}
+
 /**
  * Finds all files matching the options specified.
  * @param {Object} args The arguments objects.
@@ -120,8 +265,10 @@ async function findFiles({
 }) {
 
     const results = [];
-    const globbyPatterns = [];
     const missingPatterns = [];
+    let globbyPatterns = [];
+    let rawPatterns = [];
+    const searches = new Map([[cwd, { patterns: globbyPatterns, rawPatterns: [] }]]);
 
     // check to see if we have explicit files and directories
     const filePaths = patterns.map(filePath => path.resolve(cwd, filePath));
@@ -142,76 +289,25 @@ async function findFiles({
             if (stat.isFile()) {
                 results.push({
                     filePath,
-                    ignored: configs.isIgnored(filePath)
+                    ignored: configs.isFileIgnored(filePath)
                 });
             }
 
             // directories need extensions attached
             if (stat.isDirectory()) {
 
-                // filePatterns are all relative to cwd
-                const filePatterns = configs.files
-                    .filter(filePattern => {
-
-                        // can only do this for strings, not functions
-                        if (typeof filePattern !== "string") {
-                            return false;
-                        }
-
-                        // patterns starting with ** always apply
-                        if (filePattern.startsWith("**")) {
-                            return true;
-                        }
-
-                        // patterns ending with * are not used for file search
-                        if (filePattern.endsWith("*")) {
-                            return false;
-                        }
-
-                        // not sure how to handle negated patterns yet
-                        if (filePattern.startsWith("!")) {
-                            return false;
-                        }
-
-                        // check if the pattern would be inside the config base path or not
-                        const fullFilePattern = path.join(cwd, filePattern);
-                        const patternRelativeToConfigBasePath = path.relative(configs.basePath, fullFilePattern);
-
-                        if (patternRelativeToConfigBasePath.startsWith("..")) {
-                            return false;
-                        }
-
-                        // check if the pattern matches
-                        if (minimatch(filePath, path.dirname(fullFilePattern), { partial: true })) {
-                            return true;
-                        }
-
-                        // check if the pattern is inside the directory or not
-                        const patternRelativeToFilePath = path.relative(filePath, fullFilePattern);
-
-                        if (patternRelativeToFilePath.startsWith("..")) {
-                            return false;
-                        }
-
-                        return true;
-                    })
-                    .map(filePattern => {
-                        if (filePattern.startsWith("**")) {
-                            return path.join(pattern, filePattern);
-                        }
-
-                        // adjust the path to be relative to the cwd
-                        return path.relative(
-                            cwd,
-                            path.join(configs.basePath, filePattern)
-                        );
-                    })
-                    .map(normalizeToPosix);
-
-                if (filePatterns.length) {
-                    globbyPatterns.push(...filePatterns);
+                // group everything in cwd together and split out others
+                if (isPathInside(filePath, cwd)) {
+                    ({ patterns: globbyPatterns, rawPatterns } = searches.get(cwd));
+                } else {
+                    if (!searches.has(filePath)) {
+                        searches.set(filePath, { patterns: [], rawPatterns: [] });
+                    }
+                    ({ patterns: globbyPatterns, rawPatterns } = searches.get(filePath));
                 }
 
+                globbyPatterns.push(`${normalizeToPosix(filePath)}/**`);
+                rawPatterns.push(pattern);
             }
 
             return;
@@ -219,39 +315,59 @@ async function findFiles({
 
         // save patterns for later use based on whether globs are enabled
         if (globInputPaths && isGlobPattern(filePath)) {
-            globbyPatterns.push(pattern);
+
+            const basePath = globParent(filePath);
+
+            // group in cwd if possible and split out others
+            if (isPathInside(basePath, cwd)) {
+                ({ patterns: globbyPatterns, rawPatterns } = searches.get(cwd));
+            } else {
+                if (!searches.has(basePath)) {
+                    searches.set(basePath, { patterns: [], rawPatterns: [] });
+                }
+                ({ patterns: globbyPatterns, rawPatterns } = searches.get(basePath));
+            }
+
+            globbyPatterns.push(filePath);
+            rawPatterns.push(pattern);
         } else {
             missingPatterns.push(pattern);
         }
     });
 
-    // note: globbyPatterns can be an empty array
-    const globbyResults = (await globby(globbyPatterns, {
-        cwd,
-        absolute: true,
-        ignore: configs.ignores.filter(matcher => typeof matcher === "string")
-    }));
+    const globbyResults = await globMultiSearch({
+        searches,
+        configs
+    });
 
     // if there are no results, tell the user why
     if (!results.length && !globbyResults.length) {
 
-        // try globby without ignoring anything
-        /* eslint-disable no-unreachable-loop -- We want to exit early. */
-        for (const globbyPattern of globbyPatterns) {
+        for (const [basePath, { patterns: patternsToCheck, rawPatterns: patternsToReport }] of searches) {
 
-            /* eslint-disable-next-line no-unused-vars -- Want to exit early. */
-            for await (const filePath of globby.stream(globbyPattern, { cwd, absolute: true })) {
+            let index = 0;
 
-                // files were found but ignored
-                throw new AllFilesIgnoredError(globbyPattern);
-            }
+            // try globby without ignoring anything
+            for (const patternToCheck of patternsToCheck) {
 
-            // no files were found
-            if (errorOnUnmatchedPattern) {
-                throw new NoFilesFoundError(globbyPattern, globInputPaths);
+                // check if there are any matches at all
+                const patternHasMatch = await globMatch({
+                    basePath,
+                    pattern: patternToCheck
+                });
+
+                if (patternHasMatch) {
+                    throw new AllFilesIgnoredError(patternsToReport[index]);
+                }
+
+                // otherwise no files were found
+                if (errorOnUnmatchedPattern) {
+                    throw new NoFilesFoundError(patternsToReport[index], globInputPaths);
+                }
+
+                index++;
             }
         }
-        /* eslint-enable no-unreachable-loop -- Go back to normal. */
 
     }
 
@@ -410,7 +526,6 @@ function processOptions({
     fixTypes = null, // ← should be null by default because if it's an array then it suppresses rules that don't have the `meta.type` property.
     globInputPaths = true,
     ignore = true,
-    ignorePath = null, // ← should be null by default because if it's a string then it may throw ENOENT.
     ignorePatterns = null,
     overrideConfig = null,
     overrideConfigFile = null,
@@ -441,6 +556,9 @@ function processOptions({
         if (unknownOptionKeys.includes("globals")) {
             errors.push("'globals' has been removed. Please use the 'overrideConfig.languageOptions.globals' option instead.");
         }
+        if (unknownOptionKeys.includes("ignorePath")) {
+            errors.push("'ignorePath' has been removed.");
+        }
         if (unknownOptionKeys.includes("ignorePattern")) {
             errors.push("'ignorePattern' has been removed. Please use the 'overrideConfig.ignorePatterns' option instead.");
         }
@@ -493,9 +611,6 @@ function processOptions({
     if (typeof ignore !== "boolean") {
         errors.push("'ignore' must be a boolean.");
     }
-    if (!isNonEmptyString(ignorePath) && ignorePath !== null) {
-        errors.push("'ignorePath' must be a non-empty string or null.");
-    }
     if (typeof overrideConfig !== "object") {
         errors.push("'overrideConfig' must be an object or null.");
     }
@@ -538,7 +653,6 @@ function processOptions({
         fixTypes,
         globInputPaths,
         ignore,
-        ignorePath,
         ignorePatterns,
         reportUnusedDisableDirectives
     };

package/lib/eslint/eslint.js

@@ -36,11 +36,12 @@ const { version } = require("../../package.json");
 /** @typedef {import("../shared/types").Plugin} Plugin */
 /** @typedef {import("../shared/types").Rule} Rule */
 /** @typedef {import("../shared/types").LintResult} LintResult */
+/** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
 
 /**
  * The main formatter object.
  * @typedef LoadedFormatter
- * @property {function(LintResult[]): string | Promise<string>} format format function.
+ * @property {(results: LintResult[], resultsMeta: ResultsMeta) => string | Promise<string>} format format function.
  */
 
 /**
@@ -625,14 +626,16 @@ class ESLint {
             /**
              * The main formatter method.
              * @param {LintResult[]} results The lint results to format.
+             * @param {ResultsMeta} resultsMeta Warning count and max threshold.
              * @returns {string | Promise<string>} The formatted lint results.
              */
-            format(results) {
+            format(results, resultsMeta) {
                 let rulesMeta = null;
 
                 results.sort(compareResultsByFilePath);
 
                 return formatter(results, {
+                    ...resultsMeta,
                     get cwd() {
                         return options.cwd;
                     },

package/lib/eslint/flat-eslint.js

@@ -16,7 +16,6 @@ const findUp = require("find-up");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
-const { gitignoreToMinimatch } = require("@humanwhocodes/gitignore-to-minimatch");
 const {
     Legacy: {
         ConfigOps: {
@@ -28,7 +27,6 @@ const {
 } = require("@eslint/eslintrc");
 
 const {
-    fileExists,
     findFiles,
     getCacheFile,
 
@@ -59,6 +57,7 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
 /** @typedef {import("../shared/types").LintMessage} LintMessage */
 /** @typedef {import("../shared/types").ParserOptions} ParserOptions */
 /** @typedef {import("../shared/types").Plugin} Plugin */
+/** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
 /** @typedef {import("../shared/types").RuleConf} RuleConf */
 /** @typedef {import("../shared/types").Rule} Rule */
 /** @typedef {ReturnType<ConfigArray.extractConfig>} ExtractedConfig */
@@ -76,9 +75,8 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
  * @property {boolean|Function} [fix] Execute in autofix mode. If a function, should return a boolean.
  * @property {string[]} [fixTypes] Array of rule types to apply fixes for.
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
- * @property {boolean} [ignore] False disables use of .eslintignore.
- * @property {string} [ignorePath] The ignore file to use instead of .eslintignore.
- * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to .eslintignore.
+ * @property {boolean} [ignore] False disables all ignore patterns except for the default ones.
+ * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores.
  * @property {ConfigData} [overrideConfig] Override config object, overrides all configs used with this instance
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
@@ -151,30 +149,6 @@ function calculateStatsPerRun(results) {
     });
 }
 
-/**
- * Loads global ignore patterns from an ignore file (usually .eslintignore).
- * @param {string} filePath The filename to load.
- * @returns {ignore} A function encapsulating the ignore patterns.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-async function loadIgnoreFilePatterns(filePath) {
-    debug(`Loading ignore file: ${filePath}`);
-
-    try {
-        const ignoreFileText = await fs.readFile(filePath, { encoding: "utf8" });
-
-        return ignoreFileText
-            .split(/\r?\n/gu)
-            .filter(line => line.trim() !== "" && !line.startsWith("#"));
-
-    } catch (e) {
-        debug(`Error reading ignore file: ${filePath}`);
-        e.message = `Cannot read ignore file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
 /**
  * Create rulesMeta object.
  * @param {Map<string,Rule>} rules a map of rules from which to generate the object.
@@ -288,24 +262,16 @@ function findFlatConfigFile(cwd) {
 /**
  * Load the config array from the given filename.
  * @param {string} filePath The filename to load from.
- * @param {Object} options Options to help load the config file.
- * @param {string} options.basePath The base path for the config array.
- * @param {boolean} options.shouldIgnore Whether to honor ignore patterns.
- * @returns {Promise<FlatConfigArray>} The config array loaded from the config file.
+ * @returns {Promise<any>} The config loaded from the config file.
  */
-async function loadFlatConfigFile(filePath, { basePath, shouldIgnore }) {
+async function loadFlatConfigFile(filePath) {
     debug(`Loading config from ${filePath}`);
 
     const fileURL = pathToFileURL(filePath);
 
     debug(`Config file URL is ${fileURL}`);
 
-    const module = await import(fileURL);
-
-    return new FlatConfigArray(module.default, {
-        basePath,
-        shouldIgnore
-    });
+    return (await import(fileURL)).default;
 }
 
 /**
@@ -316,10 +282,10 @@ async function loadFlatConfigFile(filePath, { basePath, shouldIgnore }) {
  */
 async function calculateConfigArray(eslint, {
     cwd,
+    baseConfig,
     overrideConfig,
     configFile,
     ignore: shouldIgnore,
-    ignorePath,
     ignorePatterns
 }) {
 
@@ -348,38 +314,24 @@ async function calculateConfigArray(eslint, {
         basePath = path.resolve(path.dirname(configFilePath));
     }
 
-    // load config array
-    let configs;
 
+    const configs = new FlatConfigArray(baseConfig || [], { basePath, shouldIgnore });
+
+    // load config file
     if (configFilePath) {
-        configs = await loadFlatConfigFile(configFilePath, {
-            basePath,
-            shouldIgnore
-        });
-    } else {
-        configs = new FlatConfigArray([], { basePath, shouldIgnore });
+        const fileConfig = await loadFlatConfigFile(configFilePath);
+
+        if (Array.isArray(fileConfig)) {
+            configs.push(...fileConfig);
+        } else {
+            configs.push(fileConfig);
+        }
     }
 
     // add in any configured defaults
     configs.push(...slots.defaultConfigs);
 
     let allIgnorePatterns = [];
-    let ignoreFilePath;
-
-    // load ignore file if necessary
-    if (shouldIgnore) {
-        if (ignorePath) {
-            ignoreFilePath = path.resolve(cwd, ignorePath);
-            allIgnorePatterns = await loadIgnoreFilePatterns(ignoreFilePath);
-        } else {
-            ignoreFilePath = path.resolve(cwd, ".eslintignore");
-
-            // no error if .eslintignore doesn't exist`
-            if (fileExists(ignoreFilePath)) {
-                allIgnorePatterns = await loadIgnoreFilePatterns(ignoreFilePath);
-            }
-        }
-    }
 
     // append command line ignore patterns
     if (ignorePatterns) {
@@ -405,17 +357,6 @@ async function calculateConfigArray(eslint, {
             const negated = pattern.startsWith("!");
             const basePattern = negated ? pattern.slice(1) : pattern;
 
-            /*
-             * Ignore patterns are considered relative to a directory
-             * when the pattern contains a slash in a position other
-             * than the last character. If that's the case, we need to
-             * add the relative ignore path to the current pattern to
-             * get the correct behavior. Otherwise, no change is needed.
-             */
-            if (!basePattern.includes("/") || basePattern.endsWith("/")) {
-                return pattern;
-            }
-
             return (negated ? "!" : "") +
                 path.posix.join(relativeIgnorePath, basePattern);
         });
@@ -428,7 +369,7 @@ async function calculateConfigArray(eslint, {
          * so they can override default ignores.
          */
         configs.push({
-            ignores: allIgnorePatterns.map(gitignoreToMinimatch)
+            ignores: allIgnorePatterns
         });
     }
 
@@ -708,13 +649,12 @@ class FlatESLint {
      */
     getRulesMetaForResults(results) {
 
-        const resultRules = new Map();
-
         // short-circuit simple case
         if (results.length === 0) {
-            return resultRules;
+            return {};
         }
 
+        const resultRules = new Map();
         const { configs } = privateMembers.get(this);
 
         /*
@@ -743,6 +683,10 @@ class FlatESLint {
             const allMessages = result.messages.concat(result.suppressedMessages);
 
             for (const { ruleId } of allMessages) {
+                if (!ruleId) {
+                    continue;
+                }
+
                 const rule = getRuleFromConfig(ruleId, config);
 
                 // ensure the rule exists
@@ -872,7 +816,7 @@ class FlatESLint {
                 }
 
 
-                // set up fixer for fixtypes if necessary
+                // set up fixer for fixTypes if necessary
                 let fixer = fix;
 
                 if (fix && fixTypesSet) {
@@ -1048,7 +992,7 @@ class FlatESLint {
      * The following values are allowed:
      * - `undefined` ... Load `stylish` builtin formatter.
      * - A builtin formatter name ... Load the builtin formatter.
-     * - A thirdparty formatter name:
+     * - A third-party formatter name:
      *   - `foo` → `eslint-formatter-foo`
      *   - `@foo` → `@foo/eslint-formatter`
      *   - `@foo/bar` → `@foo/eslint-formatter-bar`
@@ -1114,14 +1058,16 @@ class FlatESLint {
             /**
              * The main formatter method.
              * @param {LintResults[]} results The lint results to format.
+             * @param {ResultsMeta} resultsMeta Warning count and max threshold.
              * @returns {string} The formatted lint results.
              */
-            format(results) {
+            format(results, resultsMeta) {
                 let rulesMeta = null;
 
                 results.sort(compareResultsByFilePath);
 
                 return formatter(results, {
+                    ...resultsMeta,
                     cwd,
                     get rulesMeta() {
                         if (!rulesMeta) {

package/lib/linter/linter.js

@@ -213,6 +213,7 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
 
         if (variable) {
             variable.eslintUsed = true;
+            variable.eslintExported = true;
         }
     });
 

package/lib/options.js

@@ -67,7 +67,7 @@ const optionator = require("optionator");
 /**
  * Creates the CLI options for ESLint.
  * @param {boolean} usingFlatConfig Indicates if flat config is being used.
- * @returns {Object} The opinionator instance.
+ * @returns {Object} The optionator instance.
  */
 module.exports = function(usingFlatConfig) {
 
@@ -129,6 +129,16 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let ignorePathFlag;
+
+    if (!usingFlatConfig) {
+        ignorePathFlag = {
+            option: "ignore-path",
+            type: "path::String",
+            description: "Specify path of ignore file"
+        };
+    }
+
     return optionator({
         prepend: "eslint [options] file.js [file.js] [dir]",
         defaults: {
@@ -203,11 +213,7 @@ module.exports = function(usingFlatConfig) {
             {
                 heading: "Ignoring files"
             },
-            {
-                option: "ignore-path",
-                type: "path::String",
-                description: "Specify path of ignore file"
-            },
+            ignorePathFlag,
             {
                 option: "ignore",
                 type: "Boolean",

package/lib/rules/getter-return.js

@@ -112,18 +112,24 @@ module.exports = {
                 }
                 if (parent.type === "Property" && astUtils.getStaticPropertyName(parent) === "get" && parent.parent.type === "ObjectExpression") {
 
-                    // Object.defineProperty()
-                    if (parent.parent.parent.type === "CallExpression" &&
-                        astUtils.getStaticPropertyName(parent.parent.parent.callee) === "defineProperty") {
-                        return true;
+                    // Object.defineProperty() or Reflect.defineProperty()
+                    if (parent.parent.parent.type === "CallExpression") {
+                        const callNode = parent.parent.parent.callee;
+
+                        if (astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperty") ||
+                            astUtils.isSpecificMemberAccess(callNode, "Reflect", "defineProperty")) {
+                            return true;
+                        }
                     }
 
-                    // Object.defineProperties()
+                    // Object.defineProperties() or Object.create()
                     if (parent.parent.parent.type === "Property" &&
                         parent.parent.parent.parent.type === "ObjectExpression" &&
-                        parent.parent.parent.parent.parent.type === "CallExpression" &&
-                        astUtils.getStaticPropertyName(parent.parent.parent.parent.parent.callee) === "defineProperties") {
-                        return true;
+                        parent.parent.parent.parent.parent.type === "CallExpression") {
+                        const callNode = parent.parent.parent.parent.parent.callee;
+
+                        return astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperties") ||
+                               astUtils.isSpecificMemberAccess(callNode, "Object", "create");
                     }
                 }
             }

package/lib/rules/id-length.js

@@ -6,6 +6,45 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+const GraphemeSplitter = require("grapheme-splitter");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks if the string given as argument is ASCII or not.
+ * @param {string} value A string that you want to know if it is ASCII or not.
+ * @returns {boolean} `true` if `value` is ASCII string.
+ */
+function isASCII(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    return /^[\u0020-\u007f]*$/u.test(value);
+}
+
+/** @type {GraphemeSplitter | undefined} */
+let splitter;
+
+/**
+ * Gets the length of the string. If the string is not in ASCII, counts graphemes.
+ * @param {string} value A string that you want to get the length.
+ * @returns {number} The length of `value`.
+ */
+function getStringLength(value) {
+    if (isASCII(value)) {
+        return value.length;
+    }
+    if (!splitter) {
+        splitter = new GraphemeSplitter();
+    }
+    return splitter.countGraphemes(value);
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -130,8 +169,10 @@ module.exports = {
                 const name = node.name;
                 const parent = node.parent;
 
-                const isShort = name.length < minLength;
-                const isLong = name.length > maxLength;
+                const nameLength = getStringLength(name);
+
+                const isShort = nameLength < minLength;
+                const isLong = nameLength > maxLength;
 
                 if (!(isShort || isLong) || exceptions.has(name) || matchesExceptionPattern(name)) {
                     return; // Nothing to report

package/lib/rules/lines-around-comment.js

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /**
- * Return an array with with any line numbers that are empty.
+ * Return an array with any line numbers that are empty.
  * @param {Array} lines An array of each line of the file.
  * @returns {Array} An array of line numbers.
  */
@@ -29,7 +29,7 @@ function getEmptyLineNums(lines) {
 }
 
 /**
- * Return an array with with any line numbers that contain comments.
+ * Return an array with any line numbers that contain comments.
  * @param {Array} comments An array of comment tokens.
  * @returns {Array} An array of line numbers.
  */

package/lib/rules/no-implicit-globals.js

@@ -77,6 +77,11 @@ module.exports = {
                         return;
                     }
 
+                    // Variables exported by "exported" block comments
+                    if (variable.eslintExported) {
+                        return;
+                    }
+
                     variable.defs.forEach(def => {
                         const defNode = def.node;
 

package/lib/rules/no-loss-of-precision.js

@@ -105,7 +105,7 @@ module.exports = {
         }
 
         /**
-         * Converts an integer to to an object containing the integer's coefficient and order of magnitude
+         * Converts an integer to an object containing the integer's coefficient and order of magnitude
          * @param {string} stringInteger the string representation of the integer being converted
          * @returns {Object} the object containing the integer's coefficient and order of magnitude
          */
@@ -120,7 +120,7 @@ module.exports = {
 
         /**
          *
-         * Converts a float to to an object containing the floats's coefficient and order of magnitude
+         * Converts a float to an object containing the floats's coefficient and order of magnitude
          * @param {string} stringFloat the string representation of the float being converted
          * @returns {Object} the object containing the integer's coefficient and order of magnitude
          */

package/lib/rules/no-use-before-define.js

@@ -68,7 +68,7 @@ function isInClassStaticInitializerRange(node, location) {
 }
 
 /**
- * Checks whether a given scope is the scope of a a class static initializer.
+ * Checks whether a given scope is the scope of a class static initializer.
  * Static initializers are static blocks and initializers of static fields.
  * @param {eslint-scope.Scope} scope A scope to check.
  * @returns {boolean} `true` if the scope is a class static initializer scope.

package/lib/shared/traverser.js

@@ -74,7 +74,7 @@ class Traverser {
     }
 
     /**
-     * Gives a a copy of the ancestor nodes.
+     * Gives a copy of the ancestor nodes.
      * @returns {ASTNode[]} The ancestor nodes.
      */
     parents() {

package/lib/shared/types.js

@@ -190,10 +190,23 @@ module.exports = {};
  * @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules.
  */
 
+/**
+ * Information provided when the maximum warning threshold is exceeded.
+ * @typedef {Object} MaxWarningsExceeded
+ * @property {number} maxWarnings Number of warnings to trigger nonzero exit code.
+ * @property {number} foundWarnings Number of warnings found while linting.
+ */
+
+/**
+ * Metadata about results for formatters.
+ * @typedef {Object} ResultsMeta
+ * @property {MaxWarningsExceeded} [maxWarningsExceeded] Present if the maxWarnings threshold was exceeded.
+ */
+
 /**
  * A formatter function.
  * @callback FormatterFunction
  * @param {LintResult[]} results The list of linting results.
- * @param {{cwd: string, rulesMeta: Record<string, RuleMeta>}} [context] A context object.
+ * @param {{cwd: string, maxWarningsExceeded?: MaxWarningsExceeded, rulesMeta: Record<string, RuleMeta>}} [context] A context object.
  * @returns {string | Promise<string>} Formatted text.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.24.0",
+  "version": "8.26.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -55,10 +55,10 @@
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "@eslint/eslintrc": "^1.3.2",
-    "@humanwhocodes/config-array": "^0.10.5",
-    "@humanwhocodes/gitignore-to-minimatch": "^1.0.2",
+    "@eslint/eslintrc": "^1.3.3",
+    "@humanwhocodes/config-array": "^0.11.6",
     "@humanwhocodes/module-importer": "^1.0.1",
+    "@nodelib/fs.walk": "^1.2.8",
     "ajv": "^6.10.0",
     "chalk": "^4.0.0",
     "cross-spawn": "^7.0.2",
@@ -74,14 +74,14 @@
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^6.0.1",
     "find-up": "^5.0.0",
-    "glob-parent": "^6.0.1",
+    "glob-parent": "^6.0.2",
     "globals": "^13.15.0",
-    "globby": "^11.1.0",
     "grapheme-splitter": "^1.0.4",
     "ignore": "^5.2.0",
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
     "is-glob": "^4.0.0",
+    "is-path-inside": "^3.0.3",
     "js-sdsl": "^4.1.4",
     "js-yaml": "^4.1.0",
     "json-stable-stringify-without-jsonify": "^1.0.1",
@@ -121,7 +121,6 @@
     "glob": "^7.1.6",
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
-    "jsdoc": "^3.5.5",
     "karma": "^6.1.1",
     "karma-chrome-launcher": "^3.1.0",
     "karma-mocha": "^2.0.1",