immosquare-cleaner 0.1.32 → 0.1.33

data/node_modules/eslint/lib/cli.js

@@ -18,8 +18,8 @@
 const fs = require("fs"),
     path = require("path"),
     { promisify } = require("util"),
-    { ESLint } = require("./eslint"),
-    { FlatESLint, shouldUseFlatConfig } = require("./eslint/flat-eslint"),
+    { LegacyESLint } = require("./eslint"),
+    { ESLint, shouldUseFlatConfig, locateConfigFileToUse } = require("./eslint/eslint"),
     createCLIOptions = require("./options"),
     log = require("./shared/logging"),
     RuntimeInfo = require("./shared/runtime-info"),
@@ -37,6 +37,7 @@ const debug = require("debug")("eslint:cli");
 /** @typedef {import("./eslint/eslint").LintMessage} LintMessage */
 /** @typedef {import("./eslint/eslint").LintResult} LintResult */
 /** @typedef {import("./options").ParsedCLIOptions} ParsedCLIOptions */
+/** @typedef {import("./shared/types").Plugin} Plugin */
 /** @typedef {import("./shared/types").ResultsMeta} ResultsMeta */
 
 //------------------------------------------------------------------------------
@@ -47,6 +48,32 @@ const mkdir = promisify(fs.mkdir);
 const stat = promisify(fs.stat);
 const writeFile = promisify(fs.writeFile);
 
+/**
+ * Loads plugins with the specified names.
+ * @param {{ "import": (name: string) => Promise<any> }} importer An object with an `import` method called once for each plugin.
+ * @param {string[]} pluginNames The names of the plugins to be loaded, with or without the "eslint-plugin-" prefix.
+ * @returns {Promise<Record<string, Plugin>>} A mapping of plugin short names to implementations.
+ */
+async function loadPlugins(importer, pluginNames) {
+    const plugins = {};
+
+    await Promise.all(pluginNames.map(async pluginName => {
+
+        const longName = naming.normalizePackageName(pluginName, "eslint-plugin");
+        const module = await importer.import(longName);
+
+        if (!("default" in module)) {
+            throw new Error(`"${longName}" cannot be used with the \`--plugin\` option because its default module does not provide a \`default\` export`);
+        }
+
+        const shortName = naming.getShorthandName(pluginName, "eslint-plugin");
+
+        plugins[shortName] = module.default;
+    }));
+
+    return plugins;
+}
+
 /**
  * Predicate function for whether or not to apply fixes in quiet mode.
  * If a message is a warning, do not apply a fix.
@@ -58,6 +85,16 @@ function quietFixPredicate(message) {
     return message.severity === 2;
 }
 
+/**
+ * Predicate function for whether or not to run a rule in quiet mode.
+ * If a rule is set to warning, do not run it.
+ * @param {{ ruleId: string; severity: number; }} rule The rule id and severity.
+ * @returns {boolean} True if the lint rule should run, false otherwise.
+ */
+function quietRuleFilter(rule) {
+    return rule.severity === 2;
+}
+
 /**
  * Translates the CLI options into the options expected by the ESLint constructor.
  * @param {ParsedCLIOptions} cliOptions The CLI options to translate.
@@ -94,7 +131,10 @@ async function translateOptions({
     resolvePluginsRelativeTo,
     rule,
     rulesdir,
-    warnIgnored
+    stats,
+    warnIgnored,
+    passOnNoPatterns,
+    maxWarnings
 }, configType) {
 
     let overrideConfig, overrideConfigFile;
@@ -140,17 +180,7 @@ async function translateOptions({
         }
 
         if (plugin) {
-            const plugins = {};
-
-            for (const pluginName of plugin) {
-
-                const shortName = naming.getShorthandName(pluginName, "eslint-plugin");
-                const longName = naming.normalizePackageName(pluginName, "eslint-plugin");
-
-                plugins[shortName] = await importer.import(longName);
-            }
-
-            overrideConfig[0].plugins = plugins;
+            overrideConfig[0].plugins = await loadPlugins(importer, plugin);
         }
 
     } else {
@@ -187,12 +217,20 @@ async function translateOptions({
         fixTypes: fixType,
         ignore,
         overrideConfig,
-        overrideConfigFile
+        overrideConfigFile,
+        passOnNoPatterns
     };
 
     if (configType === "flat") {
         options.ignorePatterns = ignorePattern;
+        options.stats = stats;
         options.warnIgnored = warnIgnored;
+
+        /*
+         * For performance reasons rules not marked as 'error' are filtered out in quiet mode. As maxWarnings
+         * requires rules set to 'warn' to be run, we only filter out 'warn' rules if maxWarnings is not specified.
+         */
+        options.ruleFilter = quiet && maxWarnings === -1 ? quietRuleFilter : () => true;
     } else {
         options.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
         options.rulePaths = rulesdir;
@@ -266,25 +304,23 @@ async function printResults(engine, results, format, outputFile, resultsMeta) {
 
     const output = await formatter.format(results, resultsMeta);
 
-    if (output) {
-        if (outputFile) {
-            const filePath = path.resolve(process.cwd(), outputFile);
+    if (outputFile) {
+        const filePath = path.resolve(process.cwd(), outputFile);
 
-            if (await isDirectory(filePath)) {
-                log.error("Cannot write to output file path, it is a directory: %s", outputFile);
-                return false;
-            }
+        if (await isDirectory(filePath)) {
+            log.error("Cannot write to output file path, it is a directory: %s", outputFile);
+            return false;
+        }
 
-            try {
-                await mkdir(path.dirname(filePath), { recursive: true });
-                await writeFile(filePath, output);
-            } catch (ex) {
-                log.error("There was a problem writing the output file:\n%s", ex);
-                return false;
-            }
-        } else {
-            log.info(output);
+        try {
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, output);
+        } catch (ex) {
+            log.error("There was a problem writing the output file:\n%s", ex);
+            return false;
         }
+    } else if (output) {
+        log.info(output);
     }
 
     return true;
@@ -300,14 +336,35 @@ async function printResults(engine, results, format, outputFile, resultsMeta) {
  */
 const cli = {
 
+    /**
+     * Calculates the command string for the --inspect-config operation.
+     * @param {string} configFile The path to the config file to inspect.
+     * @returns {Promise<string>} The command string to execute.
+     */
+    async calculateInspectConfigFlags(configFile) {
+
+        // find the config file
+        const {
+            configFilePath,
+            basePath,
+            error
+        } = await locateConfigFileToUse({ cwd: process.cwd(), configFile });
+
+        if (error) {
+            throw error;
+        }
+
+        return ["--config", configFilePath, "--basePath", basePath];
+    },
+
     /**
      * Executes the CLI based on an array of arguments that is passed in.
      * @param {string|Array|Object} args The arguments to process.
      * @param {string} [text] The text to lint (used for TTY).
-     * @param {boolean} [allowFlatConfig] Whether or not to allow flat config.
+     * @param {boolean} [allowFlatConfig=true] Whether or not to allow flat config.
      * @returns {Promise<number>} The exit code for the operation.
      */
-    async execute(args, text, allowFlatConfig) {
+    async execute(args, text, allowFlatConfig = true) {
         if (Array.isArray(args)) {
             debug("CLI args: %o", args.slice(2));
         }
@@ -323,6 +380,10 @@ const cli = {
 
         debug("Using flat config?", usingFlatConfig);
 
+        if (allowFlatConfig && !usingFlatConfig) {
+            process.emitWarning("You are using an eslintrc configuration file, which is deprecated and support will be removed in v10.0.0. Please migrate to an eslint.config.js file. See https://eslint.org/docs/latest/use/configure/migration-guide for details.", "ESLintRCWarning");
+        }
+
         const CLIOptions = createCLIOptions(usingFlatConfig);
 
         /** @type {ParsedCLIOptions} */
@@ -376,8 +437,8 @@ const cli = {
             }
 
             const engine = usingFlatConfig
-                ? new FlatESLint(await translateOptions(options, "flat"))
-                : new ESLint(await translateOptions(options));
+                ? new ESLint(await translateOptions(options, "flat"))
+                : new LegacyESLint(await translateOptions(options));
             const fileConfig =
                 await engine.calculateConfigForFile(options.printConfig);
 
@@ -385,6 +446,24 @@ const cli = {
             return 0;
         }
 
+        if (options.inspectConfig) {
+
+            log.info("You can also run this command directly using 'npx @eslint/config-inspector' in the same directory as your configuration file.");
+
+            try {
+                const flatOptions = await translateOptions(options, "flat");
+                const spawn = require("cross-spawn");
+                const flags = await cli.calculateInspectConfigFlags(flatOptions.overrideConfigFile);
+
+                spawn.sync("npx", ["@eslint/config-inspector", ...flags], { encoding: "utf8", stdio: "inherit" });
+            } catch (error) {
+                log.error(error);
+                return 2;
+            }
+
+            return 0;
+        }
+
         debug(`Running on ${useStdin ? "text" : "files"}`);
 
         if (options.fix && options.fixDryRun) {
@@ -405,7 +484,7 @@ const cli = {
             return 2;
         }
 
-        const ActiveESLint = usingFlatConfig ? FlatESLint : ESLint;
+        const ActiveESLint = usingFlatConfig ? ESLint : LegacyESLint;
 
         const engine = new ActiveESLint(await translateOptions(options, usingFlatConfig ? "flat" : "eslintrc"));
         let results;

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

@@ -42,6 +42,9 @@ exports.defaultConfig = [
             ecmaVersion: "latest",
             parser: require("espree"),
             parserOptions: {}
+        },
+        linterOptions: {
+            reportUnusedDisableDirectives: 1
         }
     },
 

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

@@ -13,12 +13,16 @@ const { ConfigArray, ConfigArraySymbol } = require("@humanwhocodes/config-array"
 const { flatConfigSchema } = require("./flat-config-schema");
 const { RuleValidator } = require("./rule-validator");
 const { defaultConfig } = require("./default-config");
-const jsPlugin = require("@eslint/js");
 
 //-----------------------------------------------------------------------------
 // Helpers
 //-----------------------------------------------------------------------------
 
+/**
+ * Fields that are considered metadata and not part of the config object.
+ */
+const META_FIELDS = new Set(["name"]);
+
 const ruleValidator = new RuleValidator();
 
 /**
@@ -75,7 +79,53 @@ function getObjectId(object) {
     return name;
 }
 
+/**
+ * Wraps a config error with details about where the error occurred.
+ * @param {Error} error The original error.
+ * @param {number} originalLength The original length of the config array.
+ * @param {number} baseLength The length of the base config.
+ * @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 }
+    );
+}
+
 const originalBaseConfig = Symbol("originalBaseConfig");
+const originalLength = Symbol("originalLength");
+const baseLength = Symbol("baseLength");
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -102,12 +152,24 @@ class FlatConfigArray extends ConfigArray {
             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>}
@@ -125,45 +187,69 @@ class FlatConfigArray extends ConfigArray {
         Object.defineProperty(this, "shouldIgnore", { writable: false });
     }
 
-    /* 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.
+     * 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.
      */
-    [ConfigArraySymbol.preprocessConfig](config) {
-        if (config === "eslint:recommended") {
+    normalize(context) {
+        return super.normalize(context)
+            .catch(error => {
+                if (error.name === "ConfigError") {
+                    throw wrapConfigErrorWithDetails(error, this[originalLength], this[baseLength]);
+                }
 
-            // if we are in a Node.js environment warn the user
-            if (typeof process !== "undefined" && process.emitWarning) {
-                process.emitWarning("The 'eslint:recommended' string configuration is deprecated and will be replaced by the @eslint/js package's 'recommended' config.");
-            }
+                throw error;
 
-            return jsPlugin.configs.recommended;
-        }
+            });
+    }
+
+    /**
+     * 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 {
 
-        if (config === "eslint:all") {
+            return super.normalizeSync(context);
 
-            // if we are in a Node.js environment warn the user
-            if (typeof process !== "undefined" && process.emitWarning) {
-                process.emitWarning("The 'eslint:all' string configuration is deprecated and will be replaced by the @eslint/js package's 'all' config.");
+        } catch (error) {
+
+            if (error.name === "ConfigError") {
+                throw wrapConfigErrorWithDetails(error, this[originalLength], this[baseLength]);
             }
 
-            return jsPlugin.configs.all;
+            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 `shouldIgnore` is false, we remove any ignore patterns specified
-         * in the config so long as it's not a default config and it doesn't
-         * have a `files` entry.
+         * 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 &&
-            !config.files
+            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;

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

@@ -5,6 +5,23 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../shared/types").Rule} Rule */
+
+//------------------------------------------------------------------------------
+// Private Members
+//------------------------------------------------------------------------------
+
+// JSON schema that disallows passing any options
+const noOptionsSchema = Object.freeze({
+    type: "array",
+    minItems: 0,
+    maxItems: 0
+});
+
 //-----------------------------------------------------------------------------
 // Functions
 //-----------------------------------------------------------------------------
@@ -52,32 +69,39 @@ function getRuleFromConfig(ruleId, config) {
     const { pluginName, ruleName } = parseRuleId(ruleId);
 
     const plugin = config.plugins && config.plugins[pluginName];
-    let rule = plugin && plugin.rules && plugin.rules[ruleName];
-
-
-    // normalize function rules into objects
-    if (rule && typeof rule === "function") {
-        rule = {
-            create: rule
-        };
-    }
+    const rule = plugin && plugin.rules && plugin.rules[ruleName];
 
     return rule;
 }
 
 /**
  * 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 `meta.schema` is `false`.
  */
 function getRuleOptionsSchema(rule) {
 
-    if (!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;
     }
 
-    const schema = rule.schema || rule.meta && rule.meta.schema;
+    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 {
@@ -87,16 +111,13 @@ function getRuleOptionsSchema(rule) {
                 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;
 }
 
 

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

@@ -9,11 +9,6 @@
 // Requirements
 //-----------------------------------------------------------------------------
 
-/*
- * Note: This can be removed in ESLint v9 because structuredClone is available globally
- * starting in Node.js v17.
- */
-const structuredClone = require("@ungap/structured-clone").default;
 const { normalizeSeverityToNumber } = require("../shared/severity");
 
 //-----------------------------------------------------------------------------
@@ -593,6 +588,5 @@ const flatConfigSchema = {
 
 module.exports = {
     flatConfigSchema,
-    assertIsRuleSeverity,
-    assertIsRuleOptions
+    assertIsRuleSeverity
 };

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

@@ -66,6 +66,25 @@ function throwRuleNotFoundError({ pluginName, ruleName }, config) {
     throw new TypeError(errorMessage);
 }
 
+/**
+ * The error type when a rule has an invalid `meta.schema`.
+ */
+class InvalidRuleOptionsSchemaError extends Error {
+
+    /**
+     * Creates a new instance.
+     * @param {string} ruleId Id of the rule that has an invalid `meta.schema`.
+     * @param {Error} processingError Error caught while processing the `meta.schema`.
+     */
+    constructor(ruleId, processingError) {
+        super(
+            `Error while processing options validation schema of rule '${ruleId}': ${processingError.message}`,
+            { cause: processingError }
+        );
+        this.code = "ESLINT_INVALID_RULE_OPTIONS_SCHEMA";
+    }
+}
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -130,10 +149,14 @@ class RuleValidator {
 
             // Precompile and cache validator the first time
             if (!this.validators.has(rule)) {
-                const schema = getRuleOptionsSchema(rule);
-
-                if (schema) {
-                    this.validators.set(rule, ajv.compile(schema));
+                try {
+                    const schema = getRuleOptionsSchema(rule);
+
+                    if (schema) {
+                        this.validators.set(rule, ajv.compile(schema));
+                    }
+                } catch (err) {
+                    throw new InvalidRuleOptionsSchemaError(ruleId, err);
                 }
             }
 
@@ -144,9 +167,22 @@ class RuleValidator {
                 validateRule(ruleOptions.slice(1));
 
                 if (validateRule.errors) {
-                    throw new Error(`Key "rules": Key "${ruleId}": ${
+                    throw new Error(`Key "rules": Key "${ruleId}":\n${
                         validateRule.errors.map(
-                            error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
+                            error => {
+                                if (
+                                    error.keyword === "additionalProperties" &&
+                                    error.schema === false &&
+                                    typeof error.parentSchema?.properties === "object" &&
+                                    typeof error.params?.additionalProperty === "string"
+                                ) {
+                                    const expectedProperties = Object.keys(error.parentSchema.properties).map(property => `"${property}"`);
+
+                                    return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n\t\tUnexpected property "${error.params.additionalProperty}". Expected properties: ${expectedProperties.join(", ")}.\n`;
+                                }
+
+                                return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`;
+                            }
                         ).join("")
                     }`);
                 }