immosquare-cleaner 0.1.62 → 0.1.63

data/node_modules/eslint/lib/cli.js

@@ -128,6 +128,7 @@ async function translateOptions({
     quiet,
     reportUnusedDisableDirectives,
     reportUnusedDisableDirectivesSeverity,
+    reportUnusedInlineConfigs,
     resolvePluginsRelativeTo,
     rule,
     rulesdir,
@@ -180,10 +181,23 @@ async function translateOptions({
             };
         }
 
+        if (reportUnusedInlineConfigs !== void 0) {
+            overrideConfig[0].linterOptions = {
+                ...overrideConfig[0].linterOptions,
+                reportUnusedInlineConfigs: normalizeSeverityToString(reportUnusedInlineConfigs)
+            };
+        }
+
         if (plugin) {
             overrideConfig[0].plugins = await loadPlugins(importer, plugin);
         }
 
+        if (ext) {
+            overrideConfig.push({
+                files: ext.map(extension => `**/*${extension.startsWith(".") ? "" : "."}${extension}`)
+            });
+        }
+
     } else {
         overrideConfigFile = config;
 
@@ -341,16 +355,15 @@ const cli = {
     /**
      * Calculates the command string for the --inspect-config operation.
      * @param {string} configFile The path to the config file to inspect.
-     * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
      * @returns {Promise<string>} The command string to execute.
      */
-    async calculateInspectConfigFlags(configFile, hasUnstableTSConfigFlag) {
+    async calculateInspectConfigFlags(configFile) {
 
         // find the config file
         const {
             configFilePath,
             basePath
-        } = await locateConfigFileToUse({ cwd: process.cwd(), configFile }, hasUnstableTSConfigFlag);
+        } = await locateConfigFileToUse({ cwd: process.cwd(), configFile });
 
         return ["--config", configFilePath, "--basePath", basePath];
     },
@@ -451,7 +464,7 @@ const cli = {
             try {
                 const flatOptions = await translateOptions(options, "flat");
                 const spawn = require("cross-spawn");
-                const flags = await cli.calculateInspectConfigFlags(flatOptions.overrideConfigFile, flatOptions.flags ? flatOptions.flags.includes("unstable_ts_config") : false);
+                const flags = await cli.calculateInspectConfigFlags(flatOptions.overrideConfigFile);
 
                 spawn.sync("npx", ["@eslint/config-inspector@latest", ...flags], { encoding: "utf8", stdio: "inherit" });
             } catch (error) {
@@ -482,6 +495,23 @@ const cli = {
             return 2;
         }
 
+        if (usingFlatConfig && options.ext) {
+
+            // Passing `--ext ""` results in `options.ext` being an empty array.
+            if (options.ext.length === 0) {
+                log.error("The --ext option value cannot be empty.");
+                return 2;
+            }
+
+            // Passing `--ext ,ts` results in an empty string at index 0. Passing `--ext ts,,tsx` results in an empty string at index 1.
+            const emptyStringIndex = options.ext.indexOf("");
+
+            if (emptyStringIndex >= 0) {
+                log.error(`The --ext option arguments cannot be empty strings. Found an empty string at index ${emptyStringIndex}.`);
+                return 2;
+            }
+        }
+
         const ActiveESLint = usingFlatConfig ? ESLint : LegacyESLint;
         const eslintOptions = await translateOptions(options, usingFlatConfig ? "flat" : "eslintrc");
         const engine = new ActiveESLint(eslintOptions);

data/node_modules/eslint/lib/config/config-loader.js

@@ -31,7 +31,6 @@ const { FlatConfigArray } = require("./flat-config-array");
  * @property {Array<FlatConfigObject>} [defaultConfigs] The default configs to use.
  * @property {Array<string>} [ignorePatterns] The ignore patterns to use.
  * @property {FlatConfigObject|Array<FlatConfigObject>} overrideConfig The override config to use.
- * @property {boolean} allowTS Indicates if TypeScript configuration files are allowed.
  */
 
 //------------------------------------------------------------------------------
@@ -41,10 +40,7 @@ const { FlatConfigArray } = require("./flat-config-array");
 const FLAT_CONFIG_FILENAMES = [
     "eslint.config.js",
     "eslint.config.mjs",
-    "eslint.config.cjs"
-];
-
-const TS_FLAT_CONFIG_FILENAMES = [
+    "eslint.config.cjs",
     "eslint.config.ts",
     "eslint.config.mts",
     "eslint.config.cts"
@@ -119,10 +115,9 @@ function isRunningInDeno() {
 /**
  * Load the config array from the given filename.
  * @param {string} filePath The filename to load from.
- * @param {boolean} allowTS Indicates if TypeScript configuration files are allowed.
  * @returns {Promise<any>} The config loaded from the config file.
  */
-async function loadConfigFile(filePath, allowTS) {
+async function loadConfigFile(filePath) {
 
     debug(`Loading config from ${filePath}`);
 
@@ -171,7 +166,7 @@ async function loadConfigFile(filePath, allowTS) {
      *
      * When Node.js supports native TypeScript imports, we can remove this check.
      */
-    if (allowTS && isTS && !isDeno && !isBun) {
+    if (isTS && !isDeno && !isBun) {
 
         // eslint-disable-next-line no-use-before-define -- `ConfigLoader.loadJiti` can be overwritten for testing
         const { createJiti } = await ConfigLoader.loadJiti().catch(() => {
@@ -261,8 +256,7 @@ class ConfigLoader {
         const resultPromise = ConfigLoader.locateConfigFileToUse({
             useConfigFile: this.#options.configFile,
             cwd: this.#options.cwd,
-            fromDirectory,
-            allowTS: this.#options.allowTS
+            fromDirectory
         });
 
         // ensure `ConfigLoader.locateConfigFileToUse` is called only once for `fromDirectory`
@@ -443,15 +437,10 @@ class ConfigLoader {
      * @param {string|false|undefined} options.useConfigFile The path to the config file to use.
      * @param {string} options.cwd Path to a directory that should be considered as the current working directory.
      * @param {string} [options.fromDirectory] The directory from which to start searching. Defaults to `cwd`.
-     * @param {boolean} options.allowTS Indicates if TypeScript configuration files are allowed.
      * @returns {Promise<{configFilePath:string|undefined,basePath:string}>} Location information for
      *      the config file.
      */
-    static async locateConfigFileToUse({ useConfigFile, cwd, fromDirectory = cwd, allowTS }) {
-
-        const configFilenames = allowTS
-            ? [...FLAT_CONFIG_FILENAMES, ...TS_FLAT_CONFIG_FILENAMES]
-            : FLAT_CONFIG_FILENAMES;
+    static async locateConfigFileToUse({ useConfigFile, cwd, fromDirectory = cwd }) {
 
         // determine where to load config file from
         let configFilePath;
@@ -464,7 +453,7 @@ class ConfigLoader {
         } else if (useConfigFile !== false) {
             debug("Searching for eslint.config.js");
             configFilePath = await findUp(
-                configFilenames,
+                FLAT_CONFIG_FILENAMES,
                 { cwd: fromDirectory }
             );
 
@@ -497,8 +486,7 @@ class ConfigLoader {
             ignoreEnabled,
             ignorePatterns,
             overrideConfig,
-            defaultConfigs = [],
-            allowTS
+            defaultConfigs = []
         } = options;
 
         debug(`Calculating config array from config file ${configFilePath} and base path ${basePath}`);
@@ -509,13 +497,43 @@ class ConfigLoader {
         if (configFilePath) {
 
             debug(`Loading config file ${configFilePath}`);
-            const fileConfig = await loadConfigFile(configFilePath, allowTS);
+            const fileConfig = await loadConfigFile(configFilePath);
 
-            if (Array.isArray(fileConfig)) {
-                configs.push(...fileConfig);
-            } else {
-                configs.push(fileConfig);
+            /*
+             * It's possible that a config file could be empty or else
+             * have an empty object or array. In this case, we want to
+             * warn the user that they have an empty config.
+             *
+             * An empty CommonJS file exports an empty object while
+             * an empty ESM file exports undefined.
+             */
+
+            let emptyConfig = typeof fileConfig === "undefined";
+
+            debug(`Config file ${configFilePath} is ${emptyConfig ? "empty" : "not empty"}`);
+
+            if (!emptyConfig) {
+                if (Array.isArray(fileConfig)) {
+                    if (fileConfig.length === 0) {
+                        debug(`Config file ${configFilePath} is an empty array`);
+                        emptyConfig = true;
+                    } else {
+                        configs.push(...fileConfig);
+                    }
+                } else {
+                    if (typeof fileConfig === "object" && fileConfig !== null && Object.keys(fileConfig).length === 0) {
+                        debug(`Config file ${configFilePath} is an empty object`);
+                        emptyConfig = true;
+                    } else {
+                        configs.push(fileConfig);
+                    }
+                }
             }
+
+            if (emptyConfig) {
+                globalThis.process?.emitWarning?.(`Running ESLint with an empty config (from ${configFilePath}). Please double-check that this is what you want. If you want to run ESLint with an empty config, export [{}] to remove this warning.`, "ESLintEmptyConfigWarning");
+            }
+
         }
 
         // add in any configured defaults
@@ -618,8 +636,7 @@ class LegacyConfigLoader extends ConfigLoader {
         if (!this.#configFilePath) {
             this.#configFilePath = ConfigLoader.locateConfigFileToUse({
                 useConfigFile: this.#options.configFile,
-                cwd: this.#options.cwd,
-                allowTS: this.#options.allowTS
+                cwd: this.#options.cwd
             });
         }
 

data/node_modules/eslint/lib/config/config.js

@@ -110,7 +110,12 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
             }
 
             if (typeof value === "function") {
-                throw new TypeError(`Cannot serialize key "${key}" in ${objectKey}: Function values are not supported.`);
+                const error = new TypeError(`Cannot serialize key "${key}" in ${objectKey}: Function values are not supported.`);
+
+                error.messageTemplate = "config-serialize-function";
+                error.messageData = { key, objectKey };
+
+                throw error;
             }
 
         }

data/node_modules/eslint/lib/config/flat-config-schema.js

@@ -304,6 +304,20 @@ const disableDirectiveSeveritySchema = {
     }
 };
 
+/** @type {ObjectPropertySchema} */
+const unusedInlineConfigsSeveritySchema = {
+    merge(first, second) {
+        const value = second === void 0 ? first : second;
+
+        return normalizeSeverityToNumber(value);
+    },
+    validate(value) {
+        if (!ALLOWED_SEVERITIES.has(value)) {
+            throw new TypeError("Expected one of: \"error\", \"warn\", \"off\", 0, 1, or 2.");
+        }
+    }
+};
+
 /** @type {ObjectPropertySchema} */
 const deepObjectAssignSchema = {
     merge(first = {}, second = {}) {
@@ -555,7 +569,8 @@ const flatConfigSchema = {
     linterOptions: {
         schema: {
             noInlineConfig: booleanSchema,
-            reportUnusedDisableDirectives: disableDirectiveSeveritySchema
+            reportUnusedDisableDirectives: disableDirectiveSeveritySchema,
+            reportUnusedInlineConfigs: unusedInlineConfigsSeveritySchema
         }
     },
     language: languageSchema,

data/node_modules/eslint/lib/config/rule-validator.js

@@ -36,7 +36,10 @@ function throwRuleNotFoundError({ pluginName, ruleName }, config) {
     const ruleId = pluginName === "@" ? ruleName : `${pluginName}/${ruleName}`;
 
     const errorMessageHeader = `Key "rules": Key "${ruleId}"`;
-    let errorMessage = `${errorMessageHeader}: Could not find plugin "${pluginName}".`;
+
+    let errorMessage = `${errorMessageHeader}: Could not find plugin "${pluginName}" in configuration.`;
+
+    const missingPluginErrorMessage = errorMessage;
 
     // if the plugin exists then we need to check if the rule exists
     if (config.plugins && config.plugins[pluginName]) {
@@ -63,7 +66,14 @@ function throwRuleNotFoundError({ pluginName, ruleName }, config) {
         // falls through to throw error
     }
 
-    throw new TypeError(errorMessage);
+    const error = new TypeError(errorMessage);
+
+    if (errorMessage === missingPluginErrorMessage) {
+        error.messageTemplate = "config-plugin-missing";
+        error.messageData = { pluginName, ruleId };
+    }
+
+    throw error;
 }
 
 /**

data/node_modules/eslint/lib/eslint/eslint.js

@@ -203,7 +203,13 @@ function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
                 const meta = rule && rule.meta;
 
                 if (meta && meta.deprecated) {
-                    retv.push({ ruleId, replacedBy: meta.replacedBy || [] });
+                    const usesNewFormat = typeof meta.deprecated === "object";
+
+                    retv.push({
+                        ruleId,
+                        replacedBy: usesNewFormat ? meta.deprecated.replacedBy?.map(replacement => `${replacement.plugin?.name !== void 0 ? `${naming.getShorthandName(replacement.plugin.name, "eslint-plugin")}/` : ""}${replacement.rule?.name ?? ""}`) ?? [] : meta.replacedBy || [],
+                        info: usesNewFormat ? meta.deprecated : void 0
+                    });
                 }
             }
         }
@@ -266,15 +272,13 @@ function compareResultsByFilePath(a, b) {
  * This function is used primarily by the `--inspect-config` option. For now,
  * we will maintain the existing behavior, which is to search up from the cwd.
  * @param {ESLintOptions} options The ESLint instance options.
- * @param {boolean} allowTS `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
  * @returns {Promise<{configFilePath:string|undefined;basePath:string}>} Location information for
  *      the config file.
  */
-async function locateConfigFileToUse({ configFile, cwd }, allowTS) {
+async function locateConfigFileToUse({ configFile, cwd }) {
 
     const configLoader = new ConfigLoader({
         cwd,
-        allowTS,
         configFile
     });
 
@@ -469,11 +473,10 @@ class ESLint {
             configFile: processedOptions.configFile,
             ignoreEnabled: processedOptions.ignore,
             ignorePatterns: processedOptions.ignorePatterns,
-            defaultConfigs,
-            allowTS: processedOptions.flags.includes("unstable_ts_config")
+            defaultConfigs
         };
 
-        this.#configLoader = processedOptions.flags.includes("unstable_config_lookup_from_file")
+        this.#configLoader = linter.hasFlag("unstable_config_lookup_from_file")
             ? new ConfigLoader(configLoaderOptions)
             : new LegacyConfigLoader(configLoaderOptions);
 

data/node_modules/eslint/lib/linter/linter.js

@@ -40,10 +40,10 @@ const { FlatConfigArray } = require("../config/flat-config-array");
 const { startTime, endTime } = require("../shared/stats");
 const { RuleValidator } = require("../config/rule-validator");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
-const { normalizeSeverityToString } = require("../shared/severity");
+const { normalizeSeverityToString, normalizeSeverityToNumber } = require("../shared/severity");
 const { deepMergeArrays } = require("../shared/deep-merge-arrays");
 const jslang = require("../languages/js");
-const { activeFlags, inactiveFlags } = require("../shared/flags");
+const { activeFlags, inactiveFlags, getInactivityReasonMessage } = require("../shared/flags");
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
 const DEFAULT_PARSER_NAME = "espree";
@@ -56,6 +56,7 @@ const { VFile } = require("./vfile");
 const { ParserService } = require("../services/parser-service");
 const { FileContext } = require("./file-context");
 const { ProcessorService } = require("../services/processor-service");
+const { containsDifferentProperty } = require("../shared/option-utils");
 const STEP_KIND_VISIT = 1;
 const STEP_KIND_CALL = 2;
 
@@ -76,6 +77,7 @@ const STEP_KIND_CALL = 2;
 /** @typedef {import("@eslint/core").Language} Language */
 /** @typedef {import("@eslint/core").RuleSeverity} RuleSeverity */
 /** @typedef {import("@eslint/core").RuleConfig} RuleConfig */
+/** @typedef {import("../types").Linter.StringSeverity} StringSeverity */
 
 
 /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
@@ -141,7 +143,8 @@ const STEP_KIND_CALL = 2;
 /**
  * @typedef {Object} InternalOptions
  * @property {string | null} warnInlineConfig The config name what `noInlineConfig` setting came from. If `noInlineConfig` setting didn't exist, this is null. If this is a config name, then the linter warns directive comments.
- * @property {"off" | "warn" | "error"} reportUnusedDisableDirectives (boolean values were normalized)
+ * @property {StringSeverity} reportUnusedDisableDirectives Severity to report unused disable directives, if not "off" (boolean values were normalized).
+ * @property {StringSeverity} reportUnusedInlineConfigs Severity to report unused inline configs, if not "off".
  */
 
 //------------------------------------------------------------------------------
@@ -314,6 +317,62 @@ function createLintingProblem(options) {
     };
 }
 
+/**
+ * Wraps the value in an Array if it isn't already one.
+ * @template T
+ * @param {T|T[]} value Value to be wrapped.
+ * @returns {Array} The value as an array.
+ */
+function asArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+
+/**
+ * Pushes a problem to inlineConfigProblems if ruleOptions are redundant.
+ * @param {ConfigData} config Provided config.
+ * @param {Object} loc A line/column location
+ * @param {Array} problems Problems that may be added to.
+ * @param {string} ruleId The rule ID.
+ * @param {Array} ruleOptions The rule options, merged with the config's.
+ * @param {Array} ruleOptionsInline The rule options from the comment.
+ * @param {"error"|"warn"} severity The severity to report.
+ * @returns {void}
+ */
+function addProblemIfSameSeverityAndOptions(config, loc, problems, ruleId, ruleOptions, ruleOptionsInline, severity) {
+    const existingConfigRaw = config.rules?.[ruleId];
+    const existingConfig = existingConfigRaw ? asArray(existingConfigRaw) : ["off"];
+    const existingSeverity = normalizeSeverityToString(existingConfig[0]);
+    const inlineSeverity = normalizeSeverityToString(ruleOptions[0]);
+    const sameSeverity = existingSeverity === inlineSeverity;
+
+    if (!sameSeverity) {
+        return;
+    }
+
+    const alreadyConfigured = existingConfigRaw
+        ? `is already configured to '${existingSeverity}'`
+        : "is not enabled so can't be turned off";
+    let message;
+
+    if ((existingConfig.length === 1 && ruleOptions.length === 1) || existingSeverity === "off") {
+        message = `Unused inline config ('${ruleId}' ${alreadyConfigured}).`;
+    } else if (!containsDifferentProperty(ruleOptions.slice(1), existingConfig.slice(1))) {
+        message = ruleOptionsInline.length === 1
+            ? `Unused inline config ('${ruleId}' ${alreadyConfigured}).`
+            : `Unused inline config ('${ruleId}' ${alreadyConfigured} with the same options).`;
+    }
+
+    if (message) {
+        problems.push(createLintingProblem({
+            ruleId: null,
+            message,
+            loc,
+            language: config.language,
+            severity: normalizeSeverityToNumber(severity)
+        }));
+    }
+}
+
 /**
  * Creates a collection of disable directives from a comment
  * @param {Object} options to create disable directives
@@ -517,7 +576,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                             return;
                         }
 
-                        let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+                        let ruleOptions = asArray(ruleValue);
 
                         /*
                          * If the rule was already configured, inline rule configuration that
@@ -555,7 +614,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                              */
                             ruleOptions = [
                                 ruleOptions[0], // severity from the inline config
-                                ...Array.isArray(config.rules[name]) ? config.rules[name].slice(1) : [] // options from the provided config
+                                ...asArray(config.rules[name]).slice(1) // options from the provided config
                             ];
                         }
 
@@ -774,6 +833,8 @@ function normalizeVerifyOptions(providedOptions, config) {
         }
     }
 
+    const reportUnusedInlineConfigs = linterOptions.reportUnusedInlineConfigs === void 0 ? "off" : normalizeSeverityToString(linterOptions.reportUnusedInlineConfigs);
+
     let ruleFilter = providedOptions.ruleFilter;
 
     if (typeof ruleFilter !== "function") {
@@ -787,6 +848,7 @@ function normalizeVerifyOptions(providedOptions, config) {
             ? `your config${configNameOfNoInlineConfig}`
             : null,
         reportUnusedDisableDirectives,
+        reportUnusedInlineConfigs,
         disableFixes: Boolean(providedOptions.disableFixes),
         stats: providedOptions.stats,
         ruleFilter
@@ -1264,19 +1326,40 @@ class Linter {
      */
     constructor({ cwd, configType = "flat", flags = [] } = {}) {
 
+        const processedFlags = [];
+
         flags.forEach(flag => {
             if (inactiveFlags.has(flag)) {
-                throw new Error(`The flag '${flag}' is inactive: ${inactiveFlags.get(flag)}`);
+                const inactiveFlagData = inactiveFlags.get(flag);
+                const inactivityReason = getInactivityReasonMessage(inactiveFlagData);
+
+                if (typeof inactiveFlagData.replacedBy === "undefined") {
+                    throw new Error(`The flag '${flag}' is inactive: ${inactivityReason}`);
+                }
+
+                // if there's a replacement, enable it instead of original
+                if (typeof inactiveFlagData.replacedBy === "string") {
+                    processedFlags.push(inactiveFlagData.replacedBy);
+                }
+
+                globalThis.process?.emitWarning?.(
+                    `The flag '${flag}' is inactive: ${inactivityReason}`,
+                    `ESLintInactiveFlag_${flag}`
+                );
+
+                return;
             }
 
             if (!activeFlags.has(flag)) {
                 throw new Error(`Unknown flag '${flag}'.`);
             }
+
+            processedFlags.push(flag);
         });
 
         internalSlotsMap.set(this, {
             cwd: normalizeCwd(cwd),
-            flags,
+            flags: processedFlags,
             lastConfigArray: null,
             lastSourceCode: null,
             lastSuppressedMessages: [],
@@ -1787,7 +1870,8 @@ class Linter {
 
                             try {
 
-                                let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+                                const ruleOptionsInline = asArray(ruleValue);
+                                let ruleOptions = ruleOptionsInline;
 
                                 assertIsRuleSeverity(ruleId, ruleOptions[0]);
 
@@ -1850,6 +1934,12 @@ class Linter {
                                     }
                                 }
 
+                                if (options.reportUnusedInlineConfigs !== "off") {
+                                    addProblemIfSameSeverityAndOptions(
+                                        config, loc, inlineConfigProblems, ruleId, ruleOptions, ruleOptionsInline, options.reportUnusedInlineConfigs
+                                    );
+                                }
+
                                 if (shouldValidateOptions) {
                                     ruleValidator.validate({
                                         plugins: config.plugins,

data/node_modules/eslint/lib/options.js

@@ -123,6 +123,12 @@ module.exports = function(usingFlatConfig) {
             type: "[String]",
             description: "Specify JavaScript file extensions"
         };
+    } else {
+        extFlag = {
+            option: "ext",
+            type: "[String]",
+            description: "Specify additional file extensions to lint"
+        };
     }
 
     let resolvePluginsFlag;
@@ -187,6 +193,18 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let reportUnusedInlineConfigsFlag;
+
+    if (usingFlatConfig) {
+        reportUnusedInlineConfigsFlag = {
+            option: "report-unused-inline-configs",
+            type: "String",
+            default: void 0,
+            description: "Adds reported errors for unused eslint inline config comments",
+            enum: ["off", "warn", "error", "0", "1", "2"]
+        };
+    }
+
     return optionator({
         prepend: "eslint [options] file.js [file.js] [dir]",
         defaults: {
@@ -350,6 +368,7 @@ module.exports = function(usingFlatConfig) {
                 description: "Chooses severity level for reporting unused eslint-disable and eslint-enable directives",
                 enum: ["off", "warn", "error", "0", "1", "2"]
             },
+            reportUnusedInlineConfigsFlag,
             {
                 heading: "Caching"
             },

data/node_modules/eslint/lib/rules/array-bracket-newline.js

@@ -15,8 +15,26 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
-        deprecated: true,
-        replacedBy: [],
+        deprecated: {
+            message: "Formatting rules are being moved out of ESLint core.",
+            url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+            deprecatedSince: "8.53.0",
+            availableUntil: "10.0.0",
+            replacedBy: [
+                {
+                    message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+                    url: "https://eslint.style/guide/migration",
+                    plugin: {
+                        name: "@stylistic/eslint-plugin-js",
+                        url: "https://eslint.style/packages/js"
+                    },
+                    rule: {
+                        name: "array-bracket-newline",
+                        url: "https://eslint.style/rules/js/array-bracket-newline"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/array-bracket-spacing.js

@@ -14,8 +14,26 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
-        deprecated: true,
-        replacedBy: [],
+        deprecated: {
+            message: "Formatting rules are being moved out of ESLint core.",
+            url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+            deprecatedSince: "8.53.0",
+            availableUntil: "10.0.0",
+            replacedBy: [
+                {
+                    message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+                    url: "https://eslint.style/guide/migration",
+                    plugin: {
+                        name: "@stylistic/eslint-plugin-js",
+                        url: "https://eslint.style/packages/js"
+                    },
+                    rule: {
+                        name: "array-bracket-spacing",
+                        url: "https://eslint.style/rules/js/array-bracket-spacing"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {