immosquare-cleaner 0.1.62 → 0.1.64

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: {

data/node_modules/eslint/lib/rules/array-element-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-element-newline",
+                        url: "https://eslint.style/rules/js/array-element-newline"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/arrow-body-style.js

@@ -24,6 +24,7 @@ module.exports = {
         docs: {
             description: "Require braces around arrow function bodies",
             recommended: false,
+            frozen: true,
             url: "https://eslint.org/docs/latest/rules/arrow-body-style"
         },
 
@@ -142,7 +143,7 @@ module.exports = {
 
                     if (blockBody.length === 0) {
                         messageId = "unexpectedEmptyBlock";
-                    } else if (blockBody.length > 1) {
+                    } else if (blockBody.length > 1 || blockBody[0].type !== "ReturnStatement") {
                         messageId = "unexpectedOtherBlock";
                     } else if (blockBody[0].argument === null) {
                         messageId = "unexpectedSingleBlock";

data/node_modules/eslint/lib/rules/arrow-parens.js

@@ -31,8 +31,26 @@ function hasBlockBody(node) {
 /** @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: "arrow-parens",
+                        url: "https://eslint.style/rules/js/arrow-parens"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/arrow-spacing.js

@@ -18,8 +18,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: "arrow-spacing",
+                        url: "https://eslint.style/rules/js/arrow-spacing"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/block-spacing.js

@@ -15,8 +15,26 @@ const util = 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: "block-spacing",
+                        url: "https://eslint.style/rules/js/block-spacing"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/brace-style.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: "brace-style",
+                        url: "https://eslint.style/rules/js/brace-style"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/callback-return.js

@@ -12,9 +12,25 @@
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
-        deprecated: true,
-
-        replacedBy: [],
+        deprecated: {
+            message: "Node.js rules were moved out of ESLint core.",
+            url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+            deprecatedSince: "7.0.0",
+            availableUntil: null,
+            replacedBy: [
+                {
+                    message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+                    plugin: {
+                        name: "eslint-plugin-n",
+                        url: "https://github.com/eslint-community/eslint-plugin-n"
+                    },
+                    rule: {
+                        name: "callback-return",
+                        url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/callback-return.md"
+                    }
+                }
+            ]
+        },
 
         type: "suggestion",
 

data/node_modules/eslint/lib/rules/camelcase.js

@@ -31,6 +31,7 @@ module.exports = {
         docs: {
             description: "Enforce camelcase naming convention",
             recommended: false,
+            frozen: true,
             url: "https://eslint.org/docs/latest/rules/camelcase"
         },
 

data/node_modules/eslint/lib/rules/capitalized-comments.js

@@ -107,6 +107,7 @@ module.exports = {
         docs: {
             description: "Enforce or disallow capitalization of the first letter of a comment",
             recommended: false,
+            frozen: true,
             url: "https://eslint.org/docs/latest/rules/capitalized-comments"
         },
 

data/node_modules/eslint/lib/rules/comma-dangle.js

@@ -74,8 +74,26 @@ function normalizeOptions(optionValue, ecmaVersion) {
 /** @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: "comma-dangle",
+                        url: "https://eslint.style/rules/js/comma-dangle"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/comma-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: "comma-spacing",
+                        url: "https://eslint.style/rules/js/comma-spacing"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/comma-style.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: "comma-style",
+                        url: "https://eslint.style/rules/js/comma-style"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/computed-property-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: "computed-property-spacing",
+                        url: "https://eslint.style/rules/js/computed-property-spacing"
+                    }
+                }
+            ]
+        },
         type: "layout",
 
         docs: {

data/node_modules/eslint/lib/rules/consistent-this.js

@@ -16,6 +16,7 @@ module.exports = {
         docs: {
             description: "Enforce consistent naming when capturing the current execution context",
             recommended: false,
+            frozen: true,
             url: "https://eslint.org/docs/latest/rules/consistent-this"
         },
 
@@ -118,8 +119,17 @@ module.exports = {
         function ensureWasAssigned(node) {
             const scope = sourceCode.getScope(node);
 
+            // if this is program scope we also need to check module scope
+            const extraScope = node.type === "Program" && node.sourceType === "module"
+                ? scope.childScopes[0]
+                : null;
+
             aliases.forEach(alias => {
                 checkWasAssigned(alias, scope);
+
+                if (extraScope) {
+                    checkWasAssigned(alias, extraScope);
+                }
             });
         }