eslint 9.21.0 → 9.23.0

package/lib/services/parser-service.js

@@ -22,44 +22,44 @@
  * The parser for ESLint.
  */
 class ParserService {
+	/**
+	 * Parses the given file synchronously.
+	 * @param {VFile} file The file to parse.
+	 * @param {{language:Language,languageOptions:LanguageOptions}} config The configuration to use.
+	 * @returns {Object} An object with the parsed source code or errors.
+	 * @throws {Error} If the parser returns a promise.
+	 */
+	parseSync(file, config) {
+		const { language, languageOptions } = config;
+		const result = language.parse(file, { languageOptions });
 
-    /**
-     * Parses the given file synchronously.
-     * @param {VFile} file The file to parse.
-     * @param {{language:Language,languageOptions:LanguageOptions}} config The configuration to use.
-     * @returns {Object} An object with the parsed source code or errors.
-     * @throws {Error} If the parser returns a promise.
-     */
-    parseSync(file, config) {
+		if (typeof result.then === "function") {
+			throw new Error("Unsupported: Language parser returned a promise.");
+		}
 
-        const { language, languageOptions } = config;
-        const result = language.parse(file, { languageOptions });
+		if (result.ok) {
+			return {
+				ok: true,
+				sourceCode: language.createSourceCode(file, result, {
+					languageOptions,
+				}),
+			};
+		}
 
-        if (typeof result.then === "function") {
-            throw new Error("Unsupported: Language parser returned a promise.");
-        }
-
-        if (result.ok) {
-            return {
-                ok: true,
-                sourceCode: language.createSourceCode(file, result, { languageOptions })
-            };
-        }
-
-        // if we made it to here there was an error
-        return {
-            ok: false,
-            errors: result.errors.map(error => ({
-                ruleId: null,
-                nodeType: null,
-                fatal: true,
-                severity: 2,
-                message: `Parsing error: ${error.message}`,
-                line: error.line,
-                column: error.column
-            }))
-        };
-    }
+		// if we made it to here there was an error
+		return {
+			ok: false,
+			errors: result.errors.map(error => ({
+				ruleId: null,
+				nodeType: null,
+				fatal: true,
+				severity: 2,
+				message: `Parsing error: ${error.message}`,
+				line: error.line,
+				column: error.column,
+			})),
+		};
+	}
 }
 
 module.exports = { ParserService };

package/lib/services/processor-service.js

@@ -31,79 +31,72 @@ const { VFile } = require("../linter/vfile.js");
  * The service that applies processors to files.
  */
 class ProcessorService {
-
-    /**
-     * Preprocesses the given file synchronously.
-     * @param {VFile} file The file to preprocess.
-     * @param {{processor:Processor}} config The configuration to use.
-     * @returns {{ok:boolean, files?: Array<VFile>, errors?: Array<LintMessage>}} An array of preprocessed files or errors.
-     * @throws {Error} If the preprocessor returns a promise.
-     */
-    preprocessSync(file, config) {
-
-        const { processor } = config;
-        let blocks;
-
-        try {
-            blocks = processor.preprocess(file.rawBody, file.path);
-        } catch (ex) {
-
-            // If the message includes a leading line number, strip it:
-            const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
-
-            return {
-                ok: false,
-                errors: [
-                    {
-                        ruleId: null,
-                        fatal: true,
-                        severity: 2,
-                        message,
-                        line: ex.lineNumber,
-                        column: ex.column,
-                        nodeType: null
-                    }
-                ]
-            };
-        }
-
-        if (typeof blocks.then === "function") {
-            throw new Error("Unsupported: Preprocessor returned a promise.");
-        }
-
-        return {
-            ok: true,
-            files: blocks.map((block, i) => {
-
-                // Legacy behavior: return the block as a string
-                if (typeof block === "string") {
-                    return block;
-                }
-
-                const filePath = path.join(file.path, `${i}_${block.filename}`);
-
-                return new VFile(filePath, block.text, {
-                    physicalPath: file.physicalPath
-                });
-            })
-        };
-
-    }
-
-    /**
-     * Postprocesses the given messages synchronously.
-     * @param {VFile} file The file to postprocess.
-     * @param {LintMessage[][]} messages The messages to postprocess.
-     * @param {{processor:Processor}} config The configuration to use.
-     * @returns {LintMessage[]} The postprocessed messages.
-     */
-    postprocessSync(file, messages, config) {
-
-        const { processor } = config;
-
-        return processor.postprocess(messages, file.path);
-    }
-
+	/**
+	 * Preprocesses the given file synchronously.
+	 * @param {VFile} file The file to preprocess.
+	 * @param {{processor:Processor}} config The configuration to use.
+	 * @returns {{ok:boolean, files?: Array<VFile>, errors?: Array<LintMessage>}} An array of preprocessed files or errors.
+	 * @throws {Error} If the preprocessor returns a promise.
+	 */
+	preprocessSync(file, config) {
+		const { processor } = config;
+		let blocks;
+
+		try {
+			blocks = processor.preprocess(file.rawBody, file.path);
+		} catch (ex) {
+			// If the message includes a leading line number, strip it:
+			const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
+
+			return {
+				ok: false,
+				errors: [
+					{
+						ruleId: null,
+						fatal: true,
+						severity: 2,
+						message,
+						line: ex.lineNumber,
+						column: ex.column,
+						nodeType: null,
+					},
+				],
+			};
+		}
+
+		if (typeof blocks.then === "function") {
+			throw new Error("Unsupported: Preprocessor returned a promise.");
+		}
+
+		return {
+			ok: true,
+			files: blocks.map((block, i) => {
+				// Legacy behavior: return the block as a string
+				if (typeof block === "string") {
+					return block;
+				}
+
+				const filePath = path.join(file.path, `${i}_${block.filename}`);
+
+				return new VFile(filePath, block.text, {
+					physicalPath: file.physicalPath,
+				});
+			}),
+		};
+	}
+
+	/**
+	 * Postprocesses the given messages synchronously.
+	 * @param {VFile} file The file to postprocess.
+	 * @param {LintMessage[][]} messages The messages to postprocess.
+	 * @param {{processor:Processor}} config The configuration to use.
+	 * @returns {LintMessage[]} The postprocessed messages.
+	 */
+	postprocessSync(file, messages, config) {
+		const { processor } = config;
+
+		return processor.postprocess(messages, file.path);
+	}
 }
 
 module.exports = { ProcessorService };

package/lib/shared/ajv.js

@@ -9,26 +9,26 @@
 //------------------------------------------------------------------------------
 
 const Ajv = require("ajv"),
-    metaSchema = require("ajv/lib/refs/json-schema-draft-04.json");
+	metaSchema = require("ajv/lib/refs/json-schema-draft-04.json");
 
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
 
 module.exports = (additionalOptions = {}) => {
-    const ajv = new Ajv({
-        meta: false,
-        useDefaults: true,
-        validateSchema: false,
-        missingRefs: "ignore",
-        verbose: true,
-        schemaId: "auto",
-        ...additionalOptions
-    });
+	const ajv = new Ajv({
+		meta: false,
+		useDefaults: true,
+		validateSchema: false,
+		missingRefs: "ignore",
+		verbose: true,
+		schemaId: "auto",
+		...additionalOptions,
+	});
 
-    ajv.addMetaSchema(metaSchema);
-    // eslint-disable-next-line no-underscore-dangle -- Ajv's API
-    ajv._opts.defaultMeta = metaSchema.id;
+	ajv.addMetaSchema(metaSchema);
+	// eslint-disable-next-line no-underscore-dangle -- Ajv's API
+	ajv._opts.defaultMeta = metaSchema.id;
 
-    return ajv;
+	return ajv;
 };

package/lib/shared/assert.js

@@ -13,10 +13,9 @@
  * @throws {Error} When the condition is not truthy.
  */
 function ok(value, message = "Assertion failed.") {
-    if (!value) {
-        throw new Error(message);
-    }
+	if (!value) {
+		throw new Error(message);
+	}
 }
 
-
 module.exports = ok;

package/lib/shared/ast-utils.js

@@ -8,7 +8,8 @@
  */
 "use strict";
 
-const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
+const breakableTypePattern =
+	/^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
 const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
 const shebangPattern = /^#!([^\r\n]+)/u;
 
@@ -18,12 +19,12 @@ const shebangPattern = /^#!([^\r\n]+)/u;
  * @returns {RegExp} A global regular expression that matches line terminators
  */
 function createGlobalLinebreakMatcher() {
-    return new RegExp(lineBreakPattern.source, "gu");
+	return new RegExp(lineBreakPattern.source, "gu");
 }
 
 module.exports = {
-    breakableTypePattern,
-    lineBreakPattern,
-    createGlobalLinebreakMatcher,
-    shebangPattern
+	breakableTypePattern,
+	lineBreakPattern,
+	createGlobalLinebreakMatcher,
+	shebangPattern,
 };

package/lib/shared/deep-merge-arrays.js

@@ -11,7 +11,7 @@
  * @returns {boolean} Whether value is an object
  */
 function isObjectNotArray(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 /**
@@ -21,23 +21,23 @@ function isObjectNotArray(value) {
  * @returns {T | U | (T & U)} Merged equivalent of second on top of first.
  */
 function deepMergeObjects(first, second) {
-    if (second === void 0) {
-        return first;
-    }
+	if (second === void 0) {
+		return first;
+	}
 
-    if (!isObjectNotArray(first) || !isObjectNotArray(second)) {
-        return second;
-    }
+	if (!isObjectNotArray(first) || !isObjectNotArray(second)) {
+		return second;
+	}
 
-    const result = { ...first, ...second };
+	const result = { ...first, ...second };
 
-    for (const key of Object.keys(second)) {
-        if (Object.prototype.propertyIsEnumerable.call(first, key)) {
-            result[key] = deepMergeObjects(first[key], second[key]);
-        }
-    }
+	for (const key of Object.keys(second)) {
+		if (Object.prototype.propertyIsEnumerable.call(first, key)) {
+			result[key] = deepMergeObjects(first[key], second[key]);
+		}
+	}
 
-    return result;
+	return result;
 }
 
 /**
@@ -47,14 +47,16 @@ function deepMergeObjects(first, second) {
  * @returns {(T | U | (T & U))[]} Merged equivalent of second on top of first.
  */
 function deepMergeArrays(first, second) {
-    if (!first || !second) {
-        return second || first || [];
-    }
-
-    return [
-        ...first.map((value, i) => deepMergeObjects(value, i < second.length ? second[i] : void 0)),
-        ...second.slice(first.length)
-    ];
+	if (!first || !second) {
+		return second || first || [];
+	}
+
+	return [
+		...first.map((value, i) =>
+			deepMergeObjects(value, i < second.length ? second[i] : void 0),
+		),
+		...second.slice(first.length),
+	];
 }
 
 module.exports = { deepMergeArrays };

package/lib/shared/directives.js

@@ -8,8 +8,9 @@
  */
 "use strict";
 
-const directivesPattern = /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u;
+const directivesPattern =
+	/^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u;
 
 module.exports = {
-    directivesPattern
+	directivesPattern,
 };

package/lib/shared/flags.js

@@ -26,8 +26,11 @@
  * @type {Map<string, string>}
  */
 const activeFlags = new Map([
-    ["test_only", "Used only for testing."],
-    ["unstable_config_lookup_from_file", "Look up `eslint.config.js` from the file being linted."]
+	["test_only", "Used only for testing."],
+	[
+		"unstable_config_lookup_from_file",
+		"Look up `eslint.config.js` from the file being linted.",
+	],
 ]);
 
 /**
@@ -35,10 +38,36 @@ const activeFlags = new Map([
  * @type {Map<string, InactiveFlagData>}
  */
 const inactiveFlags = new Map([
-    ["test_only_replaced", { description: "Used only for testing flags that have been replaced by other flags.", replacedBy: "test_only" }],
-    ["test_only_enabled_by_default", { description: "Used only for testing flags whose features have been enabled by default.", replacedBy: null }],
-    ["test_only_abandoned", { description: "Used only for testing flags whose features have been abandoned." }],
-    ["unstable_ts_config", { description: "Enable TypeScript configuration files.", replacedBy: null }]
+	[
+		"test_only_replaced",
+		{
+			description:
+				"Used only for testing flags that have been replaced by other flags.",
+			replacedBy: "test_only",
+		},
+	],
+	[
+		"test_only_enabled_by_default",
+		{
+			description:
+				"Used only for testing flags whose features have been enabled by default.",
+			replacedBy: null,
+		},
+	],
+	[
+		"test_only_abandoned",
+		{
+			description:
+				"Used only for testing flags whose features have been abandoned.",
+		},
+	],
+	[
+		"unstable_ts_config",
+		{
+			description: "Enable TypeScript configuration files.",
+			replacedBy: null,
+		},
+	],
 ]);
 
 /**
@@ -47,20 +76,20 @@ const inactiveFlags = new Map([
  * @returns {string} Message describing the reason the flag is inactive.
  */
 function getInactivityReasonMessage({ replacedBy }) {
-    if (typeof replacedBy === "undefined") {
-        return "This feature has been abandoned.";
-    }
+	if (typeof replacedBy === "undefined") {
+		return "This feature has been abandoned.";
+	}
 
-    if (typeof replacedBy === "string") {
-        return `This flag has been renamed '${replacedBy}' to reflect its stabilization. Please use '${replacedBy}' instead.`;
-    }
+	if (typeof replacedBy === "string") {
+		return `This flag has been renamed '${replacedBy}' to reflect its stabilization. Please use '${replacedBy}' instead.`;
+	}
 
-    // null
-    return "This feature is now enabled by default.";
+	// null
+	return "This feature is now enabled by default.";
 }
 
 module.exports = {
-    activeFlags,
-    inactiveFlags,
-    getInactivityReasonMessage
+	activeFlags,
+	inactiveFlags,
+	getInactivityReasonMessage,
 };

package/lib/shared/logging.js

@@ -9,31 +9,30 @@
 
 /* c8 ignore next */
 module.exports = {
+	/**
+	 * Cover for console.info
+	 * @param {...any} args The elements to log.
+	 * @returns {void}
+	 */
+	info(...args) {
+		console.log(...args);
+	},
 
-    /**
-     * Cover for console.info
-     * @param {...any} args The elements to log.
-     * @returns {void}
-     */
-    info(...args) {
-        console.log(...args);
-    },
+	/**
+	 * Cover for console.warn
+	 * @param {...any} args The elements to log.
+	 * @returns {void}
+	 */
+	warn(...args) {
+		console.warn(...args);
+	},
 
-    /**
-     * Cover for console.warn
-     * @param {...any} args The elements to log.
-     * @returns {void}
-     */
-    warn(...args) {
-        console.warn(...args);
-    },
-
-    /**
-     * Cover for console.error
-     * @param {...any} args The elements to log.
-     * @returns {void}
-     */
-    error(...args) {
-        console.error(...args);
-    }
+	/**
+	 * Cover for console.error
+	 * @param {...any} args The elements to log.
+	 * @returns {void}
+	 */
+	error(...args) {
+		console.error(...args);
+	},
 };

package/lib/shared/option-utils.js

@@ -14,43 +14,50 @@
  * @returns {boolean} Whether input includes an explicit difference.
  */
 function containsDifferentProperty(input, original) {
-    if (input === original) {
-        return false;
-    }
-
-    if (
-        typeof input !== typeof original ||
-        Array.isArray(input) !== Array.isArray(original)
-    ) {
-        return true;
-    }
-
-    if (Array.isArray(input)) {
-        return (
-            input.length !== original.length ||
-            input.some((value, i) =>
-                containsDifferentProperty(value, original[i]))
-        );
-    }
-
-    if (typeof input === "object") {
-        if (input === null || original === null) {
-            return true;
-        }
-
-        const inputKeys = Object.keys(input);
-        const originalKeys = Object.keys(original);
-
-        return inputKeys.length !== originalKeys.length || inputKeys.some(
-            inputKey =>
-                !Object.hasOwn(original, inputKey) ||
-                containsDifferentProperty(input[inputKey], original[inputKey])
-        );
-    }
-
-    return true;
+	if (input === original) {
+		return false;
+	}
+
+	if (
+		typeof input !== typeof original ||
+		Array.isArray(input) !== Array.isArray(original)
+	) {
+		return true;
+	}
+
+	if (Array.isArray(input)) {
+		return (
+			input.length !== original.length ||
+			input.some((value, i) =>
+				containsDifferentProperty(value, original[i]),
+			)
+		);
+	}
+
+	if (typeof input === "object") {
+		if (input === null || original === null) {
+			return true;
+		}
+
+		const inputKeys = Object.keys(input);
+		const originalKeys = Object.keys(original);
+
+		return (
+			inputKeys.length !== originalKeys.length ||
+			inputKeys.some(
+				inputKey =>
+					!Object.hasOwn(original, inputKey) ||
+					containsDifferentProperty(
+						input[inputKey],
+						original[inputKey],
+					),
+			)
+		);
+	}
+
+	return true;
 }
 
 module.exports = {
-    containsDifferentProperty
+	containsDifferentProperty,
 };