immosquare-cleaner 0.1.40 → 0.1.41

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

@@ -45,6 +45,7 @@ const { RuleValidator } = require("../config/rule-validator");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const { normalizeSeverityToString } = require("../shared/severity");
 const jslang = require("../languages/js");
+const { activeFlags } = require("../shared/flags");
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
 const DEFAULT_PARSER_NAME = "espree";
@@ -71,6 +72,10 @@ const STEP_KIND_CALL = 2;
 /** @typedef {import("../shared/types").Processor} Processor */
 /** @typedef {import("../shared/types").Rule} Rule */
 /** @typedef {import("../shared/types").Times} Times */
+/** @typedef {import("@eslint/core").Language} Language */
+/** @typedef {import("@eslint/core").RuleSeverity} RuleSeverity */
+/** @typedef {import("@eslint/core").RuleConfig} RuleConfig */
+
 
 /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
 /**
@@ -275,7 +280,7 @@ function updateLocationInformation({ line, column, endLine, endColumn }, languag
  * @param {string} [options.ruleId] the ruleId to report
  * @param {Object} [options.loc] the loc to report
  * @param {string} [options.message] the error message to report
- * @param {string} [options.severity] the error message to report
+ * @param {RuleSeverity} [options.severity] the error message to report
  * @param {Language} [options.language] the language to use to adjust the location information
  * @returns {LintMessage} created problem, returns a missing-rule problem if only provided ruleId.
  * @private
@@ -317,9 +322,10 @@ function createLintingProblem(options) {
  * @param {string} options.justification The justification of the directive
  * @param {ASTNode|token} options.node The Comment node/token.
  * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
+ * @param {Language} language The language to use to adjust the location information.
  * @returns {Object} Directives and problems from the comment
  */
-function createDisableDirectives({ type, value, justification, node }, ruleMapper) {
+function createDisableDirectives({ type, value, justification, node }, ruleMapper, language) {
     const ruleIds = Object.keys(commentParser.parseListConfig(value));
     const directiveRules = ruleIds.length ? ruleIds : [null];
     const result = {
@@ -333,26 +339,36 @@ function createDisableDirectives({ type, value, justification, node }, ruleMappe
         // push to directives, if the rule is defined(including null, e.g. /*eslint enable*/)
         if (ruleId === null || !!ruleMapper(ruleId)) {
             if (type === "disable-next-line") {
+                const { line, column } = updateLocationInformation(
+                    node.loc.end,
+                    language
+                );
+
                 result.directives.push({
                     parentDirective,
                     type,
-                    line: node.loc.end.line,
-                    column: node.loc.end.column + 1,
+                    line,
+                    column,
                     ruleId,
                     justification
                 });
             } else {
+                const { line, column } = updateLocationInformation(
+                    node.loc.start,
+                    language
+                );
+
                 result.directives.push({
                     parentDirective,
                     type,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column + 1,
+                    line,
+                    column,
                     ruleId,
                     justification
                 });
             }
         } else {
-            result.directiveProblems.push(createLintingProblem({ ruleId, loc: node.loc }));
+            result.directiveProblems.push(createLintingProblem({ ruleId, loc: node.loc, language }));
         }
     }
     return result;
@@ -430,7 +446,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                     value: directiveValue,
                     justification: justificationPart,
                     node: comment
-                }, ruleMapper);
+                }, ruleMapper, jslang);
 
                 disableDirectives.push(...directives);
                 problems.push(...directiveProblems);
@@ -470,7 +486,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                 break;
 
             case "eslint": {
-                const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc);
+                const parseResult = commentParser.parseJsonConfig(directiveValue);
 
                 if (parseResult.success) {
                     Object.keys(parseResult.config).forEach(name => {
@@ -557,7 +573,14 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                         configuredRules[name] = ruleOptions;
                     });
                 } else {
-                    problems.push(parseResult.error);
+                    const problem = createLintingProblem({
+                        ruleId: null,
+                        loc: comment.loc,
+                        message: parseResult.error.message
+                    });
+
+                    problem.fatal = true;
+                    problems.push(problem);
                 }
 
                 break;
@@ -588,22 +611,24 @@ function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper, language) {
     const disableDirectives = [];
     const problems = [];
 
-    const {
-        directives: directivesSources,
-        problems: directivesProblems
-    } = sourceCode.getDisableDirectives();
+    if (sourceCode.getDisableDirectives) {
+        const {
+            directives: directivesSources,
+            problems: directivesProblems
+        } = sourceCode.getDisableDirectives();
 
-    problems.push(...directivesProblems.map(directiveProblem => createLintingProblem({
-        ...directiveProblem,
-        language
-    })));
+        problems.push(...directivesProblems.map(directiveProblem => createLintingProblem({
+            ...directiveProblem,
+            language
+        })));
 
-    directivesSources.forEach(directive => {
-        const { directives, directiveProblems } = createDisableDirectives(directive, ruleMapper);
+        directivesSources.forEach(directive => {
+            const { directives, directiveProblems } = createDisableDirectives(directive, ruleMapper, language);
 
-        disableDirectives.push(...directives);
-        problems.push(...directiveProblems);
-    });
+            disableDirectives.push(...directives);
+            problems.push(...directiveProblems);
+        });
+    }
 
     return {
         problems,
@@ -856,7 +881,7 @@ function storeTime(time, timeOpts, slots) {
 
 /**
  * Get the options for a rule (not including severity), if any
- * @param {Array|number} ruleConfig rule configuration
+ * @param {RuleConfig} ruleConfig rule configuration
  * @returns {Array} of rule options, empty Array if none
  */
 function getRuleOptions(ruleConfig) {
@@ -920,7 +945,7 @@ function parse(file, language, languageOptions) {
             nodeType: null,
             fatal: true,
             severity: 2,
-            message: error.message,
+            message: `Parsing error: ${error.message}`,
             line: error.line,
             column: error.column
         }))
@@ -1122,9 +1147,9 @@ function runRules(
     });
 
     const eventGenerator = new NodeEventGenerator(emitter, {
-        visitorKeys: sourceCode.visitorKeys,
+        visitorKeys: sourceCode.visitorKeys ?? language.visitorKeys,
         fallback: Traverser.getKeys,
-        matchClass: language.matchesSelectorClass,
+        matchClass: language.matchesSelectorClass ?? (() => false),
         nodeTypeKey: language.nodeTypeKey
     });
 
@@ -1253,11 +1278,13 @@ class Linter {
      * Initialize the Linter.
      * @param {Object} [config] the config object
      * @param {string} [config.cwd] path to a directory that should be considered as the current working directory, can be undefined.
+     * @param {Array<string>} [config.flags] the feature flags to enable.
      * @param {"flat"|"eslintrc"} [config.configType="flat"] the type of config used.
      */
-    constructor({ cwd, configType = "flat" } = {}) {
+    constructor({ cwd, configType = "flat", flags = [] } = {}) {
         internalSlotsMap.set(this, {
             cwd: normalizeCwd(cwd),
+            flags: flags.filter(flag => activeFlags.has(flag)),
             lastConfigArray: null,
             lastSourceCode: null,
             lastSuppressedMessages: [],
@@ -1278,6 +1305,15 @@ class Linter {
         return pkg.version;
     }
 
+    /**
+     * Indicates if the given feature flag is enabled for this instance.
+     * @param {string} flag The feature flag to check.
+     * @returns {boolean} `true` if the feature flag is enabled, `false` if not.
+     */
+    hasFlag(flag) {
+        return internalSlotsMap.get(this).flags.includes(flag);
+    }
+
     /**
      * Same as linter.verify, except without support for processors.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
@@ -1679,8 +1715,13 @@ class Linter {
             /*
              * If the given source code object as the first argument does not have scopeManager, analyze the scope.
              * This is for backward compatibility (SourceCode is frozen so it cannot rebind).
+             *
+             * We check explicitly for `null` to ensure that this is a JS-flavored language.
+             * For non-JS languages we don't want to do this.
+             *
+             * TODO: Remove this check when we stop exporting the `SourceCode` object.
              */
-            if (!slots.lastSourceCode.scopeManager) {
+            if (slots.lastSourceCode.scopeManager === null) {
                 slots.lastSourceCode = new SourceCode({
                     text: slots.lastSourceCode.text,
                     ast: slots.lastSourceCode.ast,
@@ -1699,7 +1740,7 @@ class Linter {
          * this is primarily about adding variables into the global scope
          * to account for ecmaVersion and configured globals.
          */
-        sourceCode.applyLanguageOptions(languageOptions);
+        sourceCode.applyLanguageOptions?.(languageOptions);
 
         const mergedInlineConfig = {
             rules: {}
@@ -1716,147 +1757,151 @@ class Linter {
 
             // if inline config should warn then add the warnings
             if (options.warnInlineConfig) {
-                sourceCode.getInlineConfigNodes().forEach(node => {
-                    inlineConfigProblems.push(createLintingProblem({
-                        ruleId: null,
-                        message: `'${sourceCode.text.slice(node.range[0], node.range[1])}' has no effect because you have 'noInlineConfig' setting in ${options.warnInlineConfig}.`,
-                        loc: node.loc,
-                        severity: 1,
-                        language: config.language
-                    }));
+                if (sourceCode.getInlineConfigNodes) {
+                    sourceCode.getInlineConfigNodes().forEach(node => {
+                        inlineConfigProblems.push(createLintingProblem({
+                            ruleId: null,
+                            message: `'${sourceCode.text.slice(node.range[0], node.range[1])}' has no effect because you have 'noInlineConfig' setting in ${options.warnInlineConfig}.`,
+                            loc: node.loc,
+                            severity: 1,
+                            language: config.language
+                        }));
 
-                });
+                    });
+                }
             } else {
-                const inlineConfigResult = sourceCode.applyInlineConfig();
-
-                inlineConfigProblems.push(
-                    ...inlineConfigResult.problems
-                        .map(problem => createLintingProblem({ ...problem, language: config.language }))
-                        .map(problem => {
-                            problem.fatal = true;
-                            return problem;
-                        })
-                );
+                const inlineConfigResult = sourceCode.applyInlineConfig?.();
+
+                if (inlineConfigResult) {
+                    inlineConfigProblems.push(
+                        ...inlineConfigResult.problems
+                            .map(problem => createLintingProblem({ ...problem, language: config.language }))
+                            .map(problem => {
+                                problem.fatal = true;
+                                return problem;
+                            })
+                    );
+
+                    // next we need to verify information about the specified rules
+                    const ruleValidator = new RuleValidator();
+
+                    for (const { config: inlineConfig, loc } of inlineConfigResult.configs) {
+
+                        Object.keys(inlineConfig.rules).forEach(ruleId => {
+                            const rule = getRuleFromConfig(ruleId, config);
+                            const ruleValue = inlineConfig.rules[ruleId];
+
+                            if (!rule) {
+                                inlineConfigProblems.push(createLintingProblem({
+                                    ruleId,
+                                    loc,
+                                    language: config.language
+                                }));
+                                return;
+                            }
 
-                // next we need to verify information about the specified rules
-                const ruleValidator = new RuleValidator();
+                            if (Object.hasOwn(mergedInlineConfig.rules, ruleId)) {
+                                inlineConfigProblems.push(createLintingProblem({
+                                    message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
+                                    loc,
+                                    language: config.language
+                                }));
+                                return;
+                            }
 
-                for (const { config: inlineConfig, node } of inlineConfigResult.configs) {
+                            try {
 
-                    Object.keys(inlineConfig.rules).forEach(ruleId => {
-                        const rule = getRuleFromConfig(ruleId, config);
-                        const ruleValue = inlineConfig.rules[ruleId];
+                                let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
 
-                        if (!rule) {
-                            inlineConfigProblems.push(createLintingProblem({
-                                ruleId,
-                                loc: node.loc,
-                                language: config.language
-                            }));
-                            return;
-                        }
+                                assertIsRuleSeverity(ruleId, ruleOptions[0]);
 
-                        if (Object.hasOwn(mergedInlineConfig.rules, ruleId)) {
-                            inlineConfigProblems.push(createLintingProblem({
-                                message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
-                                loc: node.loc,
-                                language: config.language
-                            }));
-                            return;
-                        }
+                                /*
+                                 * If the rule was already configured, inline rule configuration that
+                                 * only has severity should retain options from the config and just override the severity.
+                                 *
+                                 * Example:
+                                 *
+                                 *   {
+                                 *       rules: {
+                                 *           curly: ["error", "multi"]
+                                 *       }
+                                 *   }
+                                 *
+                                 *   /* eslint curly: ["warn"] * /
+                                 *
+                                 *   Results in:
+                                 *
+                                 *   curly: ["warn", "multi"]
+                                 */
 
-                        try {
+                                let shouldValidateOptions = true;
 
-                            let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+                                if (
 
-                            assertIsRuleSeverity(ruleId, ruleOptions[0]);
+                                    /*
+                                     * If inline config for the rule has only severity
+                                     */
+                                    ruleOptions.length === 1 &&
 
-                            /*
-                             * If the rule was already configured, inline rule configuration that
-                             * only has severity should retain options from the config and just override the severity.
-                             *
-                             * Example:
-                             *
-                             *   {
-                             *       rules: {
-                             *           curly: ["error", "multi"]
-                             *       }
-                             *   }
-                             *
-                             *   /* eslint curly: ["warn"] * /
-                             *
-                             *   Results in:
-                             *
-                             *   curly: ["warn", "multi"]
-                             */
+                                    /*
+                                     * And the rule was already configured
+                                     */
+                                    config.rules && Object.hasOwn(config.rules, ruleId)
+                                ) {
 
-                            let shouldValidateOptions = true;
+                                    /*
+                                     * Then use severity from the inline config and options from the provided config
+                                     */
+                                    ruleOptions = [
+                                        ruleOptions[0], // severity from the inline config
+                                        ...config.rules[ruleId].slice(1) // options from the provided config
+                                    ];
 
-                            if (
+                                    // if the rule was enabled, the options have already been validated
+                                    if (config.rules[ruleId][0] > 0) {
+                                        shouldValidateOptions = false;
+                                    }
+                                }
 
-                                /*
-                                 * If inline config for the rule has only severity
-                                 */
-                                ruleOptions.length === 1 &&
+                                if (shouldValidateOptions) {
+                                    ruleValidator.validate({
+                                        plugins: config.plugins,
+                                        rules: {
+                                            [ruleId]: ruleOptions
+                                        }
+                                    });
+                                }
 
-                                /*
-                                 * And the rule was already configured
-                                 */
-                                config.rules && Object.hasOwn(config.rules, ruleId)
-                            ) {
+                                mergedInlineConfig.rules[ruleId] = ruleOptions;
+                            } catch (err) {
 
                                 /*
-                                 * Then use severity from the inline config and options from the provided config
+                                 * If the rule has invalid `meta.schema`, throw the error because
+                                 * this is not an invalid inline configuration but an invalid rule.
                                  */
-                                ruleOptions = [
-                                    ruleOptions[0], // severity from the inline config
-                                    ...config.rules[ruleId].slice(1) // options from the provided config
-                                ];
-
-                                // if the rule was enabled, the options have already been validated
-                                if (config.rules[ruleId][0] > 0) {
-                                    shouldValidateOptions = false;
+                                if (err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA") {
+                                    throw err;
                                 }
-                            }
 
-                            if (shouldValidateOptions) {
-                                ruleValidator.validate({
-                                    plugins: config.plugins,
-                                    rules: {
-                                        [ruleId]: ruleOptions
-                                    }
-                                });
-                            }
+                                let baseMessage = err.message.slice(
+                                    err.message.startsWith("Key \"rules\":")
+                                        ? err.message.indexOf(":", 12) + 1
+                                        : err.message.indexOf(":") + 1
+                                ).trim();
 
-                            mergedInlineConfig.rules[ruleId] = ruleOptions;
-                        } catch (err) {
-
-                            /*
-                             * If the rule has invalid `meta.schema`, throw the error because
-                             * this is not an invalid inline configuration but an invalid rule.
-                             */
-                            if (err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA") {
-                                throw err;
-                            }
-
-                            let baseMessage = err.message.slice(
-                                err.message.startsWith("Key \"rules\":")
-                                    ? err.message.indexOf(":", 12) + 1
-                                    : err.message.indexOf(":") + 1
-                            ).trim();
+                                if (err.messageTemplate) {
+                                    baseMessage += ` You passed "${ruleValue}".`;
+                                }
 
-                            if (err.messageTemplate) {
-                                baseMessage += ` You passed "${ruleValue}".`;
+                                inlineConfigProblems.push(createLintingProblem({
+                                    ruleId,
+                                    message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
+                                    loc,
+                                    language: config.language
+                                }));
                             }
-
-                            inlineConfigProblems.push(createLintingProblem({
-                                ruleId,
-                                message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
-                                loc: node.loc,
-                                language: config.language
-                            }));
-                        }
-                    });
+                        });
+                    }
                 }
             }
         }
@@ -1873,7 +1918,7 @@ class Linter {
 
         let lintingProblems;
 
-        sourceCode.finalize();
+        sourceCode.finalize?.();
 
         try {
             lintingProblems = runRules(

data/node_modules/eslint/lib/linter/node-event-generator.js

@@ -334,10 +334,8 @@ class NodeEventGenerator {
      * @returns {void}
      */
     enterNode(node) {
-        if (node.parent) {
-            this.currentAncestry.unshift(node.parent);
-        }
         this.applySelectors(node, false);
+        this.currentAncestry.unshift(node);
     }
 
     /**
@@ -346,8 +344,8 @@ class NodeEventGenerator {
      * @returns {void}
      */
     leaveNode(node) {
-        this.applySelectors(node, true);
         this.currentAncestry.shift();
+        this.applySelectors(node, true);
     }
 }
 

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

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("@eslint/core").File} File */
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -54,6 +60,7 @@ function stripUnicodeBOM(value) {
 
 /**
  * Represents a virtual file inside of ESLint.
+ * @implements {File}
  */
 class VFile {
 

data/node_modules/eslint/lib/options.js

@@ -30,6 +30,7 @@ const optionator = require("optionator");
  * @property {boolean} errorOnUnmatchedPattern Prevent errors when pattern is unmatched
  * @property {boolean} eslintrc Disable use of configuration from .eslintrc.*
  * @property {string[]} [ext] Specify JavaScript file extensions
+ * @property {string[]} [flag] Feature flags
  * @property {boolean} fix Automatically fix problems
  * @property {boolean} fixDryRun Automatically fix problems without saving the changes to the file system
  * @property {("directive" | "problem" | "suggestion" | "layout")[]} [fixType] Specify the types of fixes to apply (directive, problem, suggestion, layout)
@@ -176,6 +177,16 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let flagFlag;
+
+    if (usingFlatConfig) {
+        flagFlag = {
+            option: "flag",
+            type: "[String]",
+            description: "Enable a feature flag"
+        };
+    }
+
     return optionator({
         prepend: "eslint [options] file.js [file.js] [dir]",
         defaults: {
@@ -424,7 +435,8 @@ module.exports = function(usingFlatConfig) {
                 type: "path::String",
                 description: "Print the configuration for the given file"
             },
-            statsFlag
+            statsFlag,
+            flagFlag
         ].filter(value => !!value)
     });
 };

data/node_modules/eslint/lib/rules/no-restricted-imports.js

@@ -89,6 +89,9 @@ const arrayOfStringsOrObjectPatterns = {
                         minItems: 1,
                         uniqueItems: true
                     },
+                    regex: {
+                        type: "string"
+                    },
                     importNamePattern: {
                         type: "string"
                     },
@@ -104,7 +107,6 @@ const arrayOfStringsOrObjectPatterns = {
                     }
                 },
                 additionalProperties: false,
-                required: ["group"],
                 not: {
                     anyOf: [
                         { required: ["importNames", "allowImportNames"] },
@@ -113,7 +115,11 @@ const arrayOfStringsOrObjectPatterns = {
                         { required: ["importNamePattern", "allowImportNames"] },
                         { required: ["allowImportNames", "allowImportNamePattern"] }
                     ]
-                }
+                },
+                oneOf: [
+                    { required: ["group"] },
+                    { required: ["regex"] }
+                ]
             },
             uniqueItems: true
         }
@@ -235,9 +241,10 @@ module.exports = {
 
         // relative paths are supported for this rule
         const restrictedPatternGroups = restrictedPatterns.map(
-            ({ group, message, caseSensitive, importNames, importNamePattern, allowImportNames, allowImportNamePattern }) => (
+            ({ group, regex, message, caseSensitive, importNames, importNamePattern, allowImportNames, allowImportNamePattern }) => (
                 {
-                    matcher: ignore({ allowRelativePaths: true, ignorecase: !caseSensitive }).add(group),
+                    ...(group ? { matcher: ignore({ allowRelativePaths: true, ignorecase: !caseSensitive }).add(group) } : {}),
+                    ...(typeof regex === "string" ? { regexMatcher: new RegExp(regex, caseSensitive ? "u" : "iu") } : {}),
                     customMessage: message,
                     importNames,
                     importNamePattern,
@@ -493,7 +500,7 @@ module.exports = {
          * @private
          */
         function isRestrictedPattern(importSource, group) {
-            return group.matcher.ignores(importSource);
+            return group.regexMatcher ? group.regexMatcher.test(importSource) : group.matcher.ignores(importSource);
         }
 
         /**