eslint 9.22.0 → 9.24.0

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

@@ -31,43 +31,41 @@ const META_FIELDS = new Set(["name"]);
  * @returns {TypeError} The new error with details.
  */
 function wrapConfigErrorWithDetails(error, originalLength, baseLength) {
-
-    let location = "user-defined";
-    let configIndex = error.index;
-
-    /*
-     * A config array is set up in this order:
-     * 1. Base config
-     * 2. Original configs
-     * 3. User-defined configs
-     * 4. CLI-defined configs
-     *
-     * So we need to adjust the index to account for the base config.
-     *
-     * - If the index is less than the base length, it's in the base config
-     *   (as specified by `baseConfig` argument to `FlatConfigArray` constructor).
-     * - If the index is greater than the base length but less than the original
-     *   length + base length, it's in the original config. The original config
-     *   is passed to the `FlatConfigArray` constructor as the first argument.
-     * - Otherwise, it's in the user-defined config, which is loaded from the
-     *   config file and merged with any command-line options.
-     */
-    if (error.index < baseLength) {
-        location = "base";
-    } else if (error.index < originalLength + baseLength) {
-        location = "original";
-        configIndex = error.index - baseLength;
-    } else {
-        configIndex = error.index - originalLength - baseLength;
-    }
-
-    return new TypeError(
-        `${error.message.slice(0, -1)} at ${location} index ${configIndex}.`,
-        { cause: error }
-    );
+	let location = "user-defined";
+	let configIndex = error.index;
+
+	/*
+	 * A config array is set up in this order:
+	 * 1. Base config
+	 * 2. Original configs
+	 * 3. User-defined configs
+	 * 4. CLI-defined configs
+	 *
+	 * So we need to adjust the index to account for the base config.
+	 *
+	 * - If the index is less than the base length, it's in the base config
+	 *   (as specified by `baseConfig` argument to `FlatConfigArray` constructor).
+	 * - If the index is greater than the base length but less than the original
+	 *   length + base length, it's in the original config. The original config
+	 *   is passed to the `FlatConfigArray` constructor as the first argument.
+	 * - Otherwise, it's in the user-defined config, which is loaded from the
+	 *   config file and merged with any command-line options.
+	 */
+	if (error.index < baseLength) {
+		location = "base";
+	} else if (error.index < originalLength + baseLength) {
+		location = "original";
+		configIndex = error.index - baseLength;
+	} else {
+		configIndex = error.index - originalLength - baseLength;
+	}
+
+	return new TypeError(
+		`${error.message.slice(0, -1)} at ${location} index ${configIndex}.`,
+		{ cause: error },
+	);
 }
 
-
 const originalBaseConfig = Symbol("originalBaseConfig");
 const originalLength = Symbol("originalLength");
 const baseLength = Symbol("baseLength");
@@ -80,143 +78,140 @@ const baseLength = Symbol("baseLength");
  * Represents an array containing configuration information for ESLint.
  */
 class FlatConfigArray extends ConfigArray {
-
-    /**
-     * Creates a new instance.
-     * @param {*[]} configs An array of configuration information.
-     * @param {{basePath: string, shouldIgnore: boolean, baseConfig: FlatConfig}} options The options
-     *      to use for the config array instance.
-     */
-    constructor(configs, {
-        basePath,
-        shouldIgnore = true,
-        baseConfig = defaultConfig
-    } = {}) {
-        super(configs, {
-            basePath,
-            schema: flatConfigSchema
-        });
-
-        /**
-         * The original length of the array before any modifications.
-         * @type {number}
-         */
-        this[originalLength] = this.length;
-
-        if (baseConfig[Symbol.iterator]) {
-            this.unshift(...baseConfig);
-        } else {
-            this.unshift(baseConfig);
-        }
-
-        /**
-         * The length of the array after applying the base config.
-         * @type {number}
-         */
-        this[baseLength] = this.length - this[originalLength];
-
-        /**
-         * The base config used to build the config array.
-         * @type {Array<FlatConfig>}
-         */
-        this[originalBaseConfig] = baseConfig;
-        Object.defineProperty(this, originalBaseConfig, { writable: false });
-
-        /**
-         * Determines if `ignores` fields should be honored.
-         * If true, then all `ignores` fields are honored.
-         * if false, then only `ignores` fields in the baseConfig are honored.
-         * @type {boolean}
-         */
-        this.shouldIgnore = shouldIgnore;
-        Object.defineProperty(this, "shouldIgnore", { writable: false });
-    }
-
-    /**
-     * Normalizes the array by calling the superclass method and catching/rethrowing
-     * any ConfigError exceptions with additional details.
-     * @param {any} [context] The context to use to normalize the array.
-     * @returns {Promise<FlatConfigArray>} A promise that resolves when the array is normalized.
-     */
-    normalize(context) {
-        return super.normalize(context)
-            .catch(error => {
-                if (error.name === "ConfigError") {
-                    throw wrapConfigErrorWithDetails(error, this[originalLength], this[baseLength]);
-                }
-
-                throw error;
-
-            });
-    }
-
-    /**
-     * Normalizes the array by calling the superclass method and catching/rethrowing
-     * any ConfigError exceptions with additional details.
-     * @param {any} [context] The context to use to normalize the array.
-     * @returns {FlatConfigArray} The current instance.
-     * @throws {TypeError} If the config is invalid.
-     */
-    normalizeSync(context) {
-
-        try {
-
-            return super.normalizeSync(context);
-
-        } catch (error) {
-
-            if (error.name === "ConfigError") {
-                throw wrapConfigErrorWithDetails(error, this[originalLength], this[baseLength]);
-            }
-
-            throw error;
-
-        }
-
-    }
-
-    /* eslint-disable class-methods-use-this -- Desired as instance method */
-    /**
-     * Replaces a config with another config to allow us to put strings
-     * in the config array that will be replaced by objects before
-     * normalization.
-     * @param {Object} config The config to preprocess.
-     * @returns {Object} The preprocessed config.
-     */
-    [ConfigArraySymbol.preprocessConfig](config) {
-
-        /*
-         * If a config object has `ignores` and no other non-meta fields, then it's an object
-         * for global ignores. If `shouldIgnore` is false, that object shouldn't apply,
-         * so we'll remove its `ignores`.
-         */
-        if (
-            !this.shouldIgnore &&
-            !this[originalBaseConfig].includes(config) &&
-            config.ignores &&
-            Object.keys(config).filter(key => !META_FIELDS.has(key)).length === 1
-        ) {
-            /* eslint-disable-next-line no-unused-vars -- need to strip off other keys */
-            const { ignores, ...otherKeys } = config;
-
-            return otherKeys;
-        }
-
-        return config;
-    }
-
-    /**
-     * Finalizes the config by replacing plugin references with their objects
-     * and validating rule option schemas.
-     * @param {Object} config The config to finalize.
-     * @returns {Object} The finalized config.
-     * @throws {TypeError} If the config is invalid.
-     */
-    [ConfigArraySymbol.finalizeConfig](config) {
-        return new Config(config);
-    }
-    /* eslint-enable class-methods-use-this -- Desired as instance method */
-
+	/**
+	 * Creates a new instance.
+	 * @param {*[]} configs An array of configuration information.
+	 * @param {{basePath: string, shouldIgnore: boolean, baseConfig: FlatConfig}} options The options
+	 *      to use for the config array instance.
+	 */
+	constructor(
+		configs,
+		{ basePath, shouldIgnore = true, baseConfig = defaultConfig } = {},
+	) {
+		super(configs, {
+			basePath,
+			schema: flatConfigSchema,
+		});
+
+		/**
+		 * The original length of the array before any modifications.
+		 * @type {number}
+		 */
+		this[originalLength] = this.length;
+
+		if (baseConfig[Symbol.iterator]) {
+			this.unshift(...baseConfig);
+		} else {
+			this.unshift(baseConfig);
+		}
+
+		/**
+		 * The length of the array after applying the base config.
+		 * @type {number}
+		 */
+		this[baseLength] = this.length - this[originalLength];
+
+		/**
+		 * The base config used to build the config array.
+		 * @type {Array<FlatConfig>}
+		 */
+		this[originalBaseConfig] = baseConfig;
+		Object.defineProperty(this, originalBaseConfig, { writable: false });
+
+		/**
+		 * Determines if `ignores` fields should be honored.
+		 * If true, then all `ignores` fields are honored.
+		 * if false, then only `ignores` fields in the baseConfig are honored.
+		 * @type {boolean}
+		 */
+		this.shouldIgnore = shouldIgnore;
+		Object.defineProperty(this, "shouldIgnore", { writable: false });
+	}
+
+	/**
+	 * Normalizes the array by calling the superclass method and catching/rethrowing
+	 * any ConfigError exceptions with additional details.
+	 * @param {any} [context] The context to use to normalize the array.
+	 * @returns {Promise<FlatConfigArray>} A promise that resolves when the array is normalized.
+	 */
+	normalize(context) {
+		return super.normalize(context).catch(error => {
+			if (error.name === "ConfigError") {
+				throw wrapConfigErrorWithDetails(
+					error,
+					this[originalLength],
+					this[baseLength],
+				);
+			}
+
+			throw error;
+		});
+	}
+
+	/**
+	 * Normalizes the array by calling the superclass method and catching/rethrowing
+	 * any ConfigError exceptions with additional details.
+	 * @param {any} [context] The context to use to normalize the array.
+	 * @returns {FlatConfigArray} The current instance.
+	 * @throws {TypeError} If the config is invalid.
+	 */
+	normalizeSync(context) {
+		try {
+			return super.normalizeSync(context);
+		} catch (error) {
+			if (error.name === "ConfigError") {
+				throw wrapConfigErrorWithDetails(
+					error,
+					this[originalLength],
+					this[baseLength],
+				);
+			}
+
+			throw error;
+		}
+	}
+
+	/* eslint-disable class-methods-use-this -- Desired as instance method */
+	/**
+	 * Replaces a config with another config to allow us to put strings
+	 * in the config array that will be replaced by objects before
+	 * normalization.
+	 * @param {Object} config The config to preprocess.
+	 * @returns {Object} The preprocessed config.
+	 */
+	[ConfigArraySymbol.preprocessConfig](config) {
+		/*
+		 * If a config object has `ignores` and no other non-meta fields, then it's an object
+		 * for global ignores. If `shouldIgnore` is false, that object shouldn't apply,
+		 * so we'll remove its `ignores`.
+		 */
+		if (
+			!this.shouldIgnore &&
+			!this[originalBaseConfig].includes(config) &&
+			config.ignores &&
+			Object.keys(config).filter(key => !META_FIELDS.has(key)).length ===
+				1
+		) {
+			/* eslint-disable-next-line no-unused-vars -- need to strip off other keys */
+			const { ignores, ...otherKeys } = config;
+
+			return otherKeys;
+		}
+
+		return config;
+	}
+
+	/**
+	 * Finalizes the config by replacing plugin references with their objects
+	 * and validating rule option schemas.
+	 * @param {Object} config The config to finalize.
+	 * @returns {Object} The finalized config.
+	 * @throws {TypeError} If the config is invalid.
+	 */
+	[ConfigArraySymbol.finalizeConfig](config) {
+		return new Config(config);
+	}
+	/* eslint-enable class-methods-use-this -- Desired as instance method */
 }
 
 exports.FlatConfigArray = FlatConfigArray;

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

@@ -9,7 +9,10 @@
 // Typedefs
 //------------------------------------------------------------------------------
 
-/** @typedef {import("../shared/types").Rule} Rule */
+/**
+ * @import { RuleDefinition } from "@eslint/core";
+ * @import { Linter } from "eslint";
+ */
 
 //------------------------------------------------------------------------------
 // Private Members
@@ -17,9 +20,9 @@
 
 // JSON schema that disallows passing any options
 const noOptionsSchema = Object.freeze({
-    type: "array",
-    minItems: 0,
-    maxItems: 0
+	type: "array",
+	minItems: 0,
+	maxItems: 0,
 });
 
 //-----------------------------------------------------------------------------
@@ -33,96 +36,93 @@ const noOptionsSchema = Object.freeze({
  *      parts of the ruleId;
  */
 function parseRuleId(ruleId) {
-    let pluginName, ruleName;
-
-    // distinguish between core rules and plugin rules
-    if (ruleId.includes("/")) {
-
-        // mimic scoped npm packages
-        if (ruleId.startsWith("@")) {
-            pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
-        } else {
-            pluginName = ruleId.slice(0, ruleId.indexOf("/"));
-        }
-
-        ruleName = ruleId.slice(pluginName.length + 1);
-    } else {
-        pluginName = "@";
-        ruleName = ruleId;
-    }
-
-    return {
-        pluginName,
-        ruleName
-    };
+	let pluginName, ruleName;
+
+	// distinguish between core rules and plugin rules
+	if (ruleId.includes("/")) {
+		// mimic scoped npm packages
+		if (ruleId.startsWith("@")) {
+			pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
+		} else {
+			pluginName = ruleId.slice(0, ruleId.indexOf("/"));
+		}
+
+		ruleName = ruleId.slice(pluginName.length + 1);
+	} else {
+		pluginName = "@";
+		ruleName = ruleId;
+	}
+
+	return {
+		pluginName,
+		ruleName,
+	};
 }
 
 /**
  * Retrieves a rule instance from a given config based on the ruleId.
  * @param {string} ruleId The rule ID to look for.
- * @param {FlatConfig} config The config to search.
- * @returns {import("../shared/types").Rule|undefined} The rule if found
+ * @param {Linter.Config} config The config to search.
+ * @returns {RuleDefinition|undefined} The rule if found
  *      or undefined if not.
  */
 function getRuleFromConfig(ruleId, config) {
-    const { pluginName, ruleName } = parseRuleId(ruleId);
+	const { pluginName, ruleName } = parseRuleId(ruleId);
 
-    return config.plugins?.[pluginName]?.rules?.[ruleName];
+	return config.plugins?.[pluginName]?.rules?.[ruleName];
 }
 
 /**
  * Gets a complete options schema for a rule.
- * @param {Rule} rule A rule object
+ * @param {RuleDefinition} rule A rule object
  * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
  * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`.
  */
 function getRuleOptionsSchema(rule) {
-
-    if (!rule.meta) {
-        return { ...noOptionsSchema }; // default if `meta.schema` is not specified
-    }
-
-    const schema = rule.meta.schema;
-
-    if (typeof schema === "undefined") {
-        return { ...noOptionsSchema }; // default if `meta.schema` is not specified
-    }
-
-    // `schema:false` is an allowed explicit opt-out of options validation for the rule
-    if (schema === false) {
-        return null;
-    }
-
-    if (typeof schema !== "object" || schema === null) {
-        throw new TypeError("Rule's `meta.schema` must be an array or object");
-    }
-
-    // ESLint-specific array form needs to be converted into a valid JSON Schema definition
-    if (Array.isArray(schema)) {
-        if (schema.length) {
-            return {
-                type: "array",
-                items: schema,
-                minItems: 0,
-                maxItems: schema.length
-            };
-        }
-
-        // `schema:[]` is an explicit way to specify that the rule does not accept any options
-        return { ...noOptionsSchema };
-    }
-
-    // `schema:<object>` is assumed to be a valid JSON Schema definition
-    return schema;
+	if (!rule.meta) {
+		return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+	}
+
+	const schema = rule.meta.schema;
+
+	if (typeof schema === "undefined") {
+		return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+	}
+
+	// `schema:false` is an allowed explicit opt-out of options validation for the rule
+	if (schema === false) {
+		return null;
+	}
+
+	if (typeof schema !== "object" || schema === null) {
+		throw new TypeError("Rule's `meta.schema` must be an array or object");
+	}
+
+	// ESLint-specific array form needs to be converted into a valid JSON Schema definition
+	if (Array.isArray(schema)) {
+		if (schema.length) {
+			return {
+				type: "array",
+				items: schema,
+				minItems: 0,
+				maxItems: schema.length,
+			};
+		}
+
+		// `schema:[]` is an explicit way to specify that the rule does not accept any options
+		return { ...noOptionsSchema };
+	}
+
+	// `schema:<object>` is assumed to be a valid JSON Schema definition
+	return schema;
 }
 
-
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
 
 module.exports = {
-    parseRuleId,
-    getRuleFromConfig,
-    getRuleOptionsSchema
+	parseRuleId,
+	getRuleFromConfig,
+	getRuleOptionsSchema,
 };