eslint 8.57.1 → 9.39.1

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

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Applies default rule options
+ * @author JoshuaKGoldberg
+ */
+
+"use strict";
+
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @param {unknown} value an object
+ * @returns {boolean} Whether value is an object
+ */
+function isObjectNotArray(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Deeply merges second on top of first, creating a new {} object if needed.
+ * @param {T} first Base, default value.
+ * @param {U} second User-specified 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 (!isObjectNotArray(first) || !isObjectNotArray(second)) {
+		return 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]);
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Deeply merges second on top of first, creating a new [] array if needed.
+ * @param {T[]} first Base, default values.
+ * @param {U[]} second User-specified values.
+ * @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),
+	];
+}
+
+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

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Shared flags for ESLint.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * @typedef {Object} InactiveFlagData
+ * @property {string} description Flag description
+ * @property {string | null} [replacedBy] Can be either:
+ *   - An active flag (string) that enables the same feature.
+ *   - `null` if the feature is now enabled by default.
+ *   - Omitted if the feature has been abandoned.
+ */
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * The set of flags that change ESLint behavior with a description.
+ * @type {Map<string, string>}
+ */
+const activeFlags = new Map([
+	["test_only", "Used only for testing."],
+	["test_only_2", "Used only for testing."],
+	[
+		"v10_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.",
+	],
+]);
+
+/**
+ * The set of flags that used to be active.
+ * @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,
+		},
+	],
+	[
+		"unstable_config_lookup_from_file",
+		{
+			description:
+				"Look up `eslint.config.js` from the file being linted.",
+			replacedBy: "v10_config_lookup_from_file",
+		},
+	],
+]);
+
+/**
+ * Creates a message that describes the reason the flag is inactive.
+ * @param {InactiveFlagData} inactiveFlagData Data for the inactive flag.
+ * @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 === "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.";
+}
+
+module.exports = {
+	activeFlags,
+	inactiveFlags,
+	getInactivityReasonMessage,
+};

package/lib/shared/logging.js

@@ -9,22 +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.log
-     * @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.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/naming.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview Common helpers for naming of plugins, formatters and configs
+ */
+
+"use strict";
+
+const NAMESPACE_REGEX = /^@.*\//u;
+
+/**
+ * Brings package name to correct format based on prefix
+ * @param {string} name The name of the package.
+ * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
+ * @returns {string} Normalized name of the package
+ * @private
+ */
+function normalizePackageName(name, prefix) {
+	let normalizedName = name;
+
+	/**
+	 * On Windows, name can come in with Windows slashes instead of Unix slashes.
+	 * Normalize to Unix first to avoid errors later on.
+	 * https://github.com/eslint/eslint/issues/5644
+	 */
+	if (normalizedName.includes("\\")) {
+		normalizedName = normalizedName.replace(/\\/gu, "/");
+	}
+
+	if (normalizedName.charAt(0) === "@") {
+		/**
+		 * it's a scoped package
+		 * package name is the prefix, or just a username
+		 */
+		const scopedPackageShortcutRegex = new RegExp(
+				`^(@[^/]+)(?:/(?:${prefix})?)?$`,
+				"u",
+			),
+			scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
+
+		if (scopedPackageShortcutRegex.test(normalizedName)) {
+			normalizedName = normalizedName.replace(
+				scopedPackageShortcutRegex,
+				`$1/${prefix}`,
+			);
+		} else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
+			/**
+			 * for scoped packages, insert the prefix after the first / unless
+			 * the path is already @scope/eslint or @scope/eslint-xxx-yyy
+			 */
+			normalizedName = normalizedName.replace(
+				/^@([^/]+)\/(.*)$/u,
+				`@$1/${prefix}-$2`,
+			);
+		}
+	} else if (!normalizedName.startsWith(`${prefix}-`)) {
+		normalizedName = `${prefix}-${normalizedName}`;
+	}
+
+	return normalizedName;
+}
+
+/**
+ * Removes the prefix from a fullname.
+ * @param {string} fullname The term which may have the prefix.
+ * @param {string} prefix The prefix to remove.
+ * @returns {string} The term without prefix.
+ */
+function getShorthandName(fullname, prefix) {
+	if (fullname[0] === "@") {
+		let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(
+			fullname,
+		);
+
+		if (matchResult) {
+			return matchResult[1];
+		}
+
+		matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(
+			fullname,
+		);
+		if (matchResult) {
+			return `${matchResult[1]}/${matchResult[2]}`;
+		}
+	} else if (fullname.startsWith(`${prefix}-`)) {
+		return fullname.slice(prefix.length + 1);
+	}
+
+	return fullname;
+}
+
+/**
+ * Gets the scope (namespace) of a term.
+ * @param {string} term The term which may have the namespace.
+ * @returns {string} The namespace of the term if it has one.
+ */
+function getNamespaceFromTerm(term) {
+	const match = term.match(NAMESPACE_REGEX);
+
+	return match ? match[0] : "";
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+	normalizePackageName,
+	getShorthandName,
+	getNamespaceFromTerm,
+};

package/lib/shared/option-utils.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Utilities to operate on option objects.
+ * @author Josh Goldberg
+ */
+
+"use strict";
+
+/**
+ * Determines whether any of input's properties are different
+ * from values that already exist in original.
+ * @template T
+ * @param {Partial<T>} input New value.
+ * @param {T} original Original value.
+ * @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;
+}
+
+module.exports = {
+	containsDifferentProperty,
+};

package/lib/shared/relative-module-resolver.js

@@ -1,15 +1,3 @@
-/*
- * STOP!!! DO NOT MODIFY.
- *
- * This file is part of the ongoing work to move the eslintrc-style config
- * system into the @eslint/eslintrc package. This file needs to remain
- * unchanged in order for this work to proceed.
- *
- * If you think you need to change this file, please contact @nzakas first.
- *
- * Thanks in advance for your cooperation.
- */
-
 /**
  * Utility for resolving a module relative to another module
  * @author Teddy Katz
@@ -17,34 +5,24 @@
 
 "use strict";
 
-const { createRequire } = require("module");
+const Module = require("node:module");
 
-module.exports = {
+/*
+ * `Module.createRequire` is added in v12.2.0. It supports URL as well.
+ * We only support the case where the argument is a filepath, not a URL.
+ */
+const createRequire = Module.createRequire;
 
-    /**
-     * Resolves a Node module relative to another module
-     * @param {string} moduleName The name of a Node module, or a path to a Node module.
-     * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be
-     * a file rather than a directory, but the file need not actually exist.
-     * @throws {Error} Any error from `module.createRequire` or its `resolve`.
-     * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`
-     */
-    resolve(moduleName, relativeToPath) {
-        try {
-            return createRequire(relativeToPath).resolve(moduleName);
-        } catch (error) {
+/**
+ * Resolves a Node module relative to another module
+ * @param {string} moduleName The name of a Node module, or a path to a Node module.
+ * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be
+ * a file rather than a directory, but the file need not actually exist.
+ * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`
+ * @throws {Error} When the module cannot be resolved.
+ */
+function resolve(moduleName, relativeToPath) {
+	return createRequire(relativeToPath).resolve(moduleName);
+}
 
-            // This `if` block is for older Node.js than 12.0.0. We can remove this block in the future.
-            if (
-                typeof error === "object" &&
-                error !== null &&
-                error.code === "MODULE_NOT_FOUND" &&
-                !error.requireStack &&
-                error.message.includes(moduleName)
-            ) {
-                error.message += `\nRequire stack:\n- ${relativeToPath}`;
-            }
-            throw error;
-        }
-    }
-};
+exports.resolve = resolve;