eslint 9.22.0 → 9.24.0

package/lib/shared/flags.js

@@ -26,8 +26,15 @@
  * @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.",
+	],
+	[
+		"unstable_native_nodejs_ts_config",
+		"Use native Node.js to load TypeScript configuration.",
+	],
 ]);
 
 /**
@@ -35,10 +42,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 +80,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,
 };

package/lib/shared/runtime-info.js

@@ -24,129 +24,138 @@ const packageJson = require("../../package.json");
  * @returns {string} A string that contains execution environment information.
  */
 function environment() {
-    const cache = new Map();
-
-    /**
-     * Checks if a path is a child of a directory.
-     * @param {string} parentPath The parent path to check.
-     * @param {string} childPath The path to check.
-     * @returns {boolean} Whether or not the given path is a child of a directory.
-     */
-    function isChildOfDirectory(parentPath, childPath) {
-        return !path.relative(parentPath, childPath).startsWith("..");
-    }
-
-    /**
-     * Synchronously executes a shell command and formats the result.
-     * @param {string} cmd The command to execute.
-     * @param {Array} args The arguments to be executed with the command.
-     * @throws {Error} As may be collected by `cross-spawn.sync`.
-     * @returns {string} The version returned by the command.
-     */
-    function execCommand(cmd, args) {
-        const key = [cmd, ...args].join(" ");
-
-        if (cache.has(key)) {
-            return cache.get(key);
-        }
-
-        const process = spawn.sync(cmd, args, { encoding: "utf8" });
-
-        if (process.error) {
-            throw process.error;
-        }
-
-        const result = process.stdout.trim();
-
-        cache.set(key, result);
-        return result;
-    }
-
-    /**
-     * Normalizes a version number.
-     * @param {string} versionStr The string to normalize.
-     * @returns {string} The normalized version number.
-     */
-    function normalizeVersionStr(versionStr) {
-        return versionStr.startsWith("v") ? versionStr : `v${versionStr}`;
-    }
-
-    /**
-     * Gets bin version.
-     * @param {string} bin The bin to check.
-     * @throws {Error} As may be collected by `cross-spawn.sync`.
-     * @returns {string} The normalized version returned by the command.
-     */
-    function getBinVersion(bin) {
-        const binArgs = ["--version"];
-
-        try {
-            return normalizeVersionStr(execCommand(bin, binArgs));
-        } catch (e) {
-            log.error(`Error finding ${bin} version running the command \`${bin} ${binArgs.join(" ")}\``);
-            throw e;
-        }
-    }
-
-    /**
-     * Gets installed npm package version.
-     * @param {string} pkg The package to check.
-     * @param {boolean} global Whether to check globally or not.
-     * @throws {Error} As may be collected by `cross-spawn.sync`.
-     * @returns {string} The normalized version returned by the command.
-     */
-    function getNpmPackageVersion(pkg, { global = false } = {}) {
-        const npmBinArgs = ["bin", "-g"];
-        const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
-
-        if (global) {
-            npmLsArgs.push("-g");
-        }
-
-        try {
-            const parsedStdout = JSON.parse(execCommand("npm", npmLsArgs));
-
-            /*
-             * Checking globally returns an empty JSON object, while local checks
-             * include the name and version of the local project.
-             */
-            if (Object.keys(parsedStdout).length === 0 || !(parsedStdout.dependencies && parsedStdout.dependencies.eslint)) {
-                return "Not found";
-            }
-
-            const [, processBinPath] = process.argv;
-            let npmBinPath;
-
-            try {
-                npmBinPath = execCommand("npm", npmBinArgs);
-            } catch (e) {
-                log.error(`Error finding npm binary path when running command \`npm ${npmBinArgs.join(" ")}\``);
-                throw e;
-            }
-
-            const isGlobal = isChildOfDirectory(npmBinPath, processBinPath);
-            let pkgVersion = parsedStdout.dependencies.eslint.version;
-
-            if ((global && isGlobal) || (!global && !isGlobal)) {
-                pkgVersion += " (Currently used)";
-            }
-
-            return normalizeVersionStr(pkgVersion);
-        } catch (e) {
-            log.error(`Error finding ${pkg} version running the command \`npm ${npmLsArgs.join(" ")}\``);
-            throw e;
-        }
-    }
-
-    return [
-        "Environment Info:",
-        "",
-        `Node version: ${getBinVersion("node")}`,
-        `npm version: ${getBinVersion("npm")}`,
-        `Local ESLint version: ${getNpmPackageVersion("eslint", { global: false })}`,
-        `Global ESLint version: ${getNpmPackageVersion("eslint", { global: true })}`,
-        `Operating System: ${os.platform()} ${os.release()}`
-    ].join("\n");
+	const cache = new Map();
+
+	/**
+	 * Checks if a path is a child of a directory.
+	 * @param {string} parentPath The parent path to check.
+	 * @param {string} childPath The path to check.
+	 * @returns {boolean} Whether or not the given path is a child of a directory.
+	 */
+	function isChildOfDirectory(parentPath, childPath) {
+		return !path.relative(parentPath, childPath).startsWith("..");
+	}
+
+	/**
+	 * Synchronously executes a shell command and formats the result.
+	 * @param {string} cmd The command to execute.
+	 * @param {Array} args The arguments to be executed with the command.
+	 * @throws {Error} As may be collected by `cross-spawn.sync`.
+	 * @returns {string} The version returned by the command.
+	 */
+	function execCommand(cmd, args) {
+		const key = [cmd, ...args].join(" ");
+
+		if (cache.has(key)) {
+			return cache.get(key);
+		}
+
+		const process = spawn.sync(cmd, args, { encoding: "utf8" });
+
+		if (process.error) {
+			throw process.error;
+		}
+
+		const result = process.stdout.trim();
+
+		cache.set(key, result);
+		return result;
+	}
+
+	/**
+	 * Normalizes a version number.
+	 * @param {string} versionStr The string to normalize.
+	 * @returns {string} The normalized version number.
+	 */
+	function normalizeVersionStr(versionStr) {
+		return versionStr.startsWith("v") ? versionStr : `v${versionStr}`;
+	}
+
+	/**
+	 * Gets bin version.
+	 * @param {string} bin The bin to check.
+	 * @throws {Error} As may be collected by `cross-spawn.sync`.
+	 * @returns {string} The normalized version returned by the command.
+	 */
+	function getBinVersion(bin) {
+		const binArgs = ["--version"];
+
+		try {
+			return normalizeVersionStr(execCommand(bin, binArgs));
+		} catch (e) {
+			log.error(
+				`Error finding ${bin} version running the command \`${bin} ${binArgs.join(" ")}\``,
+			);
+			throw e;
+		}
+	}
+
+	/**
+	 * Gets installed npm package version.
+	 * @param {string} pkg The package to check.
+	 * @param {boolean} global Whether to check globally or not.
+	 * @throws {Error} As may be collected by `cross-spawn.sync`.
+	 * @returns {string} The normalized version returned by the command.
+	 */
+	function getNpmPackageVersion(pkg, { global = false } = {}) {
+		const npmBinArgs = ["bin", "-g"];
+		const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
+
+		if (global) {
+			npmLsArgs.push("-g");
+		}
+
+		try {
+			const parsedStdout = JSON.parse(execCommand("npm", npmLsArgs));
+
+			/*
+			 * Checking globally returns an empty JSON object, while local checks
+			 * include the name and version of the local project.
+			 */
+			if (
+				Object.keys(parsedStdout).length === 0 ||
+				!(parsedStdout.dependencies && parsedStdout.dependencies.eslint)
+			) {
+				return "Not found";
+			}
+
+			const [, processBinPath] = process.argv;
+			let npmBinPath;
+
+			try {
+				npmBinPath = execCommand("npm", npmBinArgs);
+			} catch (e) {
+				log.error(
+					`Error finding npm binary path when running command \`npm ${npmBinArgs.join(" ")}\``,
+				);
+				throw e;
+			}
+
+			const isGlobal = isChildOfDirectory(npmBinPath, processBinPath);
+			let pkgVersion = parsedStdout.dependencies.eslint.version;
+
+			if ((global && isGlobal) || (!global && !isGlobal)) {
+				pkgVersion += " (Currently used)";
+			}
+
+			return normalizeVersionStr(pkgVersion);
+		} catch (e) {
+			log.error(
+				`Error finding ${pkg} version running the command \`npm ${npmLsArgs.join(" ")}\``,
+			);
+			throw e;
+		}
+	}
+
+	return [
+		"Environment Info:",
+		"",
+		`Node version: ${getBinVersion("node")}`,
+		`npm version: ${getBinVersion("npm")}`,
+		`Local ESLint version: ${getNpmPackageVersion("eslint", { global: false })}`,
+		`Global ESLint version: ${getNpmPackageVersion("eslint", { global: true })}`,
+		`Operating System: ${os.platform()} ${os.release()}`,
+	].join("\n");
 }
 
 /**
@@ -154,7 +163,7 @@ function environment() {
  * @returns {string} The version from the currently executing ESLint's package.json.
  */
 function version() {
-    return `v${packageJson.version}`;
+	return `v${packageJson.version}`;
 }
 
 //------------------------------------------------------------------------------
@@ -162,7 +171,7 @@ function version() {
 //------------------------------------------------------------------------------
 
 module.exports = {
-    __esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
-    environment,
-    version
+	__esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
+	environment,
+	version,
 };

package/lib/shared/serialization.js

@@ -12,14 +12,14 @@
  * @private
  */
 function isSerializablePrimitiveOrPlainObject(val) {
-    return (
-        val === null ||
-        typeof val === "string" ||
-         typeof val === "boolean" ||
-         typeof val === "number" ||
-         (typeof val === "object" && val.constructor === Object) ||
-         Array.isArray(val)
-    );
+	return (
+		val === null ||
+		typeof val === "string" ||
+		typeof val === "boolean" ||
+		typeof val === "number" ||
+		(typeof val === "object" && val.constructor === Object) ||
+		Array.isArray(val)
+	);
 }
 
 /**
@@ -30,26 +30,26 @@ function isSerializablePrimitiveOrPlainObject(val) {
  * @returns {boolean} true if the value is serializable
  */
 function isSerializable(val) {
-    if (!isSerializablePrimitiveOrPlainObject(val)) {
-        return false;
-    }
-    if (typeof val === "object") {
-        for (const property in val) {
-            if (Object.hasOwn(val, property)) {
-                if (!isSerializablePrimitiveOrPlainObject(val[property])) {
-                    return false;
-                }
-                if (typeof val[property] === "object") {
-                    if (!isSerializable(val[property])) {
-                        return false;
-                    }
-                }
-            }
-        }
-    }
-    return true;
+	if (!isSerializablePrimitiveOrPlainObject(val)) {
+		return false;
+	}
+	if (typeof val === "object") {
+		for (const property in val) {
+			if (Object.hasOwn(val, property)) {
+				if (!isSerializablePrimitiveOrPlainObject(val[property])) {
+					return false;
+				}
+				if (typeof val[property] === "object") {
+					if (!isSerializable(val[property])) {
+						return false;
+					}
+				}
+			}
+		}
+	}
+	return true;
 }
 
 module.exports = {
-    isSerializable
+	isSerializable,
 };

package/lib/shared/severity.js

@@ -12,16 +12,16 @@
  * @returns {string} severity string
  */
 function normalizeSeverityToString(severity) {
-    if ([2, "2", "error"].includes(severity)) {
-        return "error";
-    }
-    if ([1, "1", "warn"].includes(severity)) {
-        return "warn";
-    }
-    if ([0, "0", "off"].includes(severity)) {
-        return "off";
-    }
-    throw new Error(`Invalid severity value: ${severity}`);
+	if ([2, "2", "error"].includes(severity)) {
+		return "error";
+	}
+	if ([1, "1", "warn"].includes(severity)) {
+		return "warn";
+	}
+	if ([0, "0", "off"].includes(severity)) {
+		return "off";
+	}
+	throw new Error(`Invalid severity value: ${severity}`);
 }
 
 /**
@@ -31,19 +31,19 @@ function normalizeSeverityToString(severity) {
  * @returns {number} severity number
  */
 function normalizeSeverityToNumber(severity) {
-    if ([2, "2", "error"].includes(severity)) {
-        return 2;
-    }
-    if ([1, "1", "warn"].includes(severity)) {
-        return 1;
-    }
-    if ([0, "0", "off"].includes(severity)) {
-        return 0;
-    }
-    throw new Error(`Invalid severity value: ${severity}`);
+	if ([2, "2", "error"].includes(severity)) {
+		return 2;
+	}
+	if ([1, "1", "warn"].includes(severity)) {
+		return 1;
+	}
+	if ([0, "0", "off"].includes(severity)) {
+		return 0;
+	}
+	throw new Error(`Invalid severity value: ${severity}`);
 }
 
 module.exports = {
-    normalizeSeverityToString,
-    normalizeSeverityToNumber
+	normalizeSeverityToString,
+	normalizeSeverityToNumber,
 };