Migrate to eslint.config.mjs

`.eslintrc.json` is deprecated.

node_modules/@eslint/eslintrc/lib/shared/config-validator.js

@@ -5,6 +5,12 @@
 
 /* eslint class-methods-use-this: "off" */
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../shared/types").Rule} Rule */
+
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
@@ -33,6 +39,13 @@ const severityMap = {
 
 const validated = new WeakSet();
 
+// JSON schema that disallows passing any options
+const noOptionsSchema = Object.freeze({
+    type: "array",
+    minItems: 0,
+    maxItems: 0
+});
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -44,17 +57,36 @@ export default class ConfigValidator {
 
     /**
      * Gets a complete options schema for a rule.
-     * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
-     * @returns {Object} JSON Schema for the rule's options.
+     * @param {Rule} 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 rule wasn't passed or its `meta.schema` is `false`.
      */
     getRuleOptionsSchema(rule) {
         if (!rule) {
             return null;
         }
 
-        const schema = rule.schema || rule.meta && rule.meta.schema;
+        if (!rule.meta) {
+            return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+        }
 
-        // Given a tuple of schemas, insert warning level at the beginning
+        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 {
@@ -64,16 +96,13 @@ export default class ConfigValidator {
                     maxItems: schema.length
                 };
             }
-            return {
-                type: "array",
-                minItems: 0,
-                maxItems: 0
-            };
 
+            // `schema:[]` is an explicit way to specify that the rule does not accept any options
+            return { ...noOptionsSchema };
         }
 
-        // Given a full schema, leave it alone
-        return schema || null;
+        // `schema:<object>` is assumed to be a valid JSON Schema definition
+        return schema;
     }
 
     /**
@@ -101,10 +130,18 @@ export default class ConfigValidator {
      */
     validateRuleSchema(rule, localOptions) {
         if (!ruleValidators.has(rule)) {
-            const schema = this.getRuleOptionsSchema(rule);
+            try {
+                const schema = this.getRuleOptionsSchema(rule);
 
-            if (schema) {
-                ruleValidators.set(rule, ajv.compile(schema));
+                if (schema) {
+                    ruleValidators.set(rule, ajv.compile(schema));
+                }
+            } catch (err) {
+                const errorWithCode = new Error(err.message, { cause: err });
+
+                errorWithCode.code = "ESLINT_INVALID_RULE_OPTIONS_SCHEMA";
+
+                throw errorWithCode;
             }
         }
 
@@ -137,13 +174,21 @@ export default class ConfigValidator {
                 this.validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
             }
         } catch (err) {
-            const enhancedMessage = `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;
+            let enhancedMessage = err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA"
+                ? `Error while processing options validation schema of rule '${ruleId}': ${err.message}`
+                : `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;
 
             if (typeof source === "string") {
-                throw new Error(`${source}:\n\t${enhancedMessage}`);
-            } else {
-                throw new Error(enhancedMessage);
+                enhancedMessage = `${source}:\n\t${enhancedMessage}`;
             }
+
+            const enhancedError = new Error(enhancedMessage, { cause: err });
+
+            if (err.code) {
+                enhancedError.code = err.code;
+            }
+
+            throw enhancedError;
         }
     }