immosquare-cleaner 0.1.38 → 0.1.40

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

@@ -33,12 +33,6 @@ const ruleSeverities = new Map([
     [2, 2], ["error", 2]
 ]);
 
-const globalVariablesValues = new Set([
-    true, "true", "writable", "writeable",
-    false, "false", "readonly", "readable", null,
-    "off"
-]);
-
 /**
  * Check if a value is a non-null object.
  * @param {any} value The value to check.
@@ -143,6 +137,23 @@ function normalizeRuleOptions(ruleOptions) {
     return structuredClone(finalOptions);
 }
 
+/**
+ * Determines if an object has any methods.
+ * @param {Object} object The object to check.
+ * @returns {boolean} `true` if the object has any methods.
+ */
+function hasMethod(object) {
+
+    for (const key of Object.keys(object)) {
+
+        if (typeof object[key] === "function") {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 //-----------------------------------------------------------------------------
 // Assertions
 //-----------------------------------------------------------------------------
@@ -301,47 +312,48 @@ const deepObjectAssignSchema = {
     validate: "object"
 };
 
+
 //-----------------------------------------------------------------------------
 // High-Level Schemas
 //-----------------------------------------------------------------------------
 
 /** @type {ObjectPropertySchema} */
-const globalsSchema = {
-    merge: "assign",
-    validate(value) {
+const languageOptionsSchema = {
+    merge(first = {}, second = {}) {
 
-        assertIsObject(value);
+        const result = deepMerge(first, second);
 
-        for (const key of Object.keys(value)) {
+        for (const [key, value] of Object.entries(result)) {
 
-            // avoid hairy edge case
-            if (key === "__proto__") {
-                continue;
-            }
+            /*
+             * Special case: Because the `parser` property is an object, it should
+             * not be deep merged. Instead, it should be replaced if it exists in
+             * the second object. To make this more generic, we just check for
+             * objects with methods and replace them if they exist in the second
+             * object.
+             */
+            if (isNonArrayObject(value)) {
+                if (hasMethod(value)) {
+                    result[key] = second[key] ?? first[key];
+                    continue;
+                }
 
-            if (key !== key.trim()) {
-                throw new TypeError(`Global "${key}" has leading or trailing whitespace.`);
+                // for other objects, make sure we aren't reusing the same object
+                result[key] = { ...result[key] };
+                continue;
             }
 
-            if (!globalVariablesValues.has(value[key])) {
-                throw new TypeError(`Key "${key}": Expected "readonly", "writable", or "off".`);
-            }
         }
-    }
+
+        return result;
+    },
+    validate: "object"
 };
 
 /** @type {ObjectPropertySchema} */
-const parserSchema = {
+const languageSchema = {
     merge: "replace",
-    validate(value) {
-
-        if (!value || typeof value !== "object" ||
-            (typeof value.parse !== "function" && typeof value.parseForESLint !== "function")
-        ) {
-            throw new TypeError("Expected object with parse() or parseForESLint() method.");
-        }
-
-    }
+    validate: assertIsPluginMemberName
 };
 
 /** @type {ObjectPropertySchema} */
@@ -501,28 +513,6 @@ const rulesSchema = {
     }
 };
 
-/** @type {ObjectPropertySchema} */
-const ecmaVersionSchema = {
-    merge: "replace",
-    validate(value) {
-        if (typeof value === "number" || value === "latest") {
-            return;
-        }
-
-        throw new TypeError("Expected a number or \"latest\".");
-    }
-};
-
-/** @type {ObjectPropertySchema} */
-const sourceTypeSchema = {
-    merge: "replace",
-    validate(value) {
-        if (typeof value !== "string" || !/^(?:script|module|commonjs)$/u.test(value)) {
-            throw new TypeError("Expected \"script\", \"module\", or \"commonjs\".");
-        }
-    }
-};
-
 /**
  * Creates a schema that always throws an error. Useful for warning
  * about eslintrc-style keys.
@@ -568,15 +558,8 @@ const flatConfigSchema = {
             reportUnusedDisableDirectives: disableDirectiveSeveritySchema
         }
     },
-    languageOptions: {
-        schema: {
-            ecmaVersion: ecmaVersionSchema,
-            sourceType: sourceTypeSchema,
-            globals: globalsSchema,
-            parser: parserSchema,
-            parserOptions: deepObjectAssignSchema
-        }
-    },
+    language: languageSchema,
+    languageOptions: languageOptionsSchema,
     processor: processorSchema,
     plugins: pluginsSchema,
     rules: rulesSchema
@@ -588,5 +571,6 @@ const flatConfigSchema = {
 
 module.exports = {
     flatConfigSchema,
+    hasMethod,
     assertIsRuleSeverity
 };

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

@@ -91,7 +91,7 @@ class AllFilesIgnoredError extends Error {
      */
     constructor(pattern) {
         super(`All files matched by '${pattern}' are ignored.`);
-        this.messageTemplate = "all-files-ignored";
+        this.messageTemplate = "all-matched-files-ignored";
         this.messageData = { pattern };
     }
 }
@@ -335,15 +335,15 @@ async function globSearch({
 
                             /*
                              * We updated the unmatched patterns set only if the path
-                             * matches and the file isn't ignored. If the file is
-                             * ignored, that means there wasn't a match for the
+                             * matches and the file has a config. If the file has no
+                             * config, that means there wasn't a match for the
                              * pattern so it should not be removed.
                              *
-                             * Performance note: isFileIgnored() aggressively caches
+                             * Performance note: `getConfig()` aggressively caches
                              * results so there is no performance penalty for calling
-                             * it twice with the same argument.
+                             * it multiple times with the same argument.
                              */
-                            if (pathMatches && !configs.isFileIgnored(entry.path)) {
+                            if (pathMatches && configs.getConfig(entry.path)) {
                                 unmatchedPatterns.delete(matcher.pattern);
                             }
 
@@ -351,7 +351,7 @@ async function globSearch({
                         }, false)
                         : matchers.some(matcher => matcher.match(relativePath));
 
-                    return matchesPattern && !configs.isFileIgnored(entry.path);
+                    return matchesPattern && configs.getConfig(entry.path) !== void 0;
                 })
             },
             (error, entries) => {
@@ -494,7 +494,7 @@ async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
 
     }
 
-    return [...new Set(filePaths)];
+    return filePaths;
 
 }
 
@@ -543,10 +543,7 @@ async function findFiles({
 
             // files are added directly to the list
             if (stat.isFile()) {
-                results.push({
-                    filePath,
-                    ignored: configs.isFileIgnored(filePath)
-                });
+                results.push(filePath);
             }
 
             // directories need extensions attached
@@ -604,11 +601,10 @@ async function findFiles({
     });
 
     return [
-        ...results,
-        ...globbyResults.map(filePath => ({
-            filePath: path.resolve(filePath),
-            ignored: false
-        }))
+        ...new Set([
+            ...results,
+            ...globbyResults.map(filePath => path.resolve(filePath))
+        ])
     ];
 }
 
@@ -630,17 +626,31 @@ function isErrorMessage(message) {
  * Returns result with warning by ignore settings
  * @param {string} filePath File path of checked code
  * @param {string} baseDir Absolute path of base directory
+ * @param {"ignored"|"external"|"unconfigured"} configStatus A status that determines why the file is ignored
  * @returns {LintResult} Result with single warning
  * @private
  */
-function createIgnoreResult(filePath, baseDir) {
+function createIgnoreResult(filePath, baseDir, configStatus) {
     let message;
-    const isInNodeModules = baseDir && path.dirname(path.relative(baseDir, filePath)).split(path.sep).includes("node_modules");
 
-    if (isInNodeModules) {
-        message = "File ignored by default because it is located under the node_modules directory. Use ignore pattern \"!**/node_modules/\" to disable file ignore settings or use \"--no-warn-ignored\" to suppress this warning.";
-    } else {
-        message = "File ignored because of a matching ignore pattern. Use \"--no-ignore\" to disable file ignore settings or use \"--no-warn-ignored\" to suppress this warning.";
+    switch (configStatus) {
+        case "external":
+            message = "File ignored because outside of base path.";
+            break;
+        case "unconfigured":
+            message = "File ignored because no matching configuration was supplied.";
+            break;
+        default:
+            {
+                const isInNodeModules = baseDir && path.dirname(path.relative(baseDir, filePath)).split(path.sep).includes("node_modules");
+
+                if (isInNodeModules) {
+                    message = "File ignored by default because it is located under the node_modules directory. Use ignore pattern \"!**/node_modules/\" to disable file ignore settings or use \"--no-warn-ignored\" to suppress this warning.";
+                } else {
+                    message = "File ignored because of a matching ignore pattern. Use \"--no-ignore\" to disable file ignore settings or use \"--no-warn-ignored\" to suppress this warning.";
+                }
+            }
+            break;
     }
 
     return {

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

@@ -68,7 +68,7 @@ const { Retrier } = require("@humanwhocodes/retry");
  * The options with which to configure the ESLint instance.
  * @typedef {Object} ESLintOptions
  * @property {boolean} [allowInlineConfig] Enable or disable inline configuration comments.
- * @property {ConfigData} [baseConfig] Base config object, extended by all configs used with this instance
+ * @property {ConfigData|Array<ConfigData>} [baseConfig] Base config, extended by all configs used with this instance
  * @property {boolean} [cache] Enable result caching.
  * @property {string} [cacheLocation] The cache file to use instead of .eslintcache.
  * @property {"metadata" | "content"} [cacheStrategy] The strategy used to detect changed files.
@@ -79,7 +79,7 @@ const { Retrier } = require("@humanwhocodes/retry");
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} [ignore] False disables all ignore patterns except for the default ones.
  * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores. These patterns are relative to `cwd`.
- * @property {ConfigData} [overrideConfig] Override config object, overrides all configs used with this instance
+ * @property {ConfigData|Array<ConfigData>} [overrideConfig] Override config, overrides all configs used with this instance
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
  *      when a string.
@@ -509,7 +509,7 @@ function verifyText({
              * @returns {boolean} `true` if the linter should adopt the code block.
              */
             filterCodeBlock(blockFilename) {
-                return configs.isExplicitMatch(blockFilename);
+                return configs.getConfig(blockFilename) !== void 0;
             }
         }
     );
@@ -865,28 +865,21 @@ class ESLint {
          */
         const results = await Promise.all(
 
-            filePaths.map(({ filePath, ignored }) => {
-
-                /*
-                 * If a filename was entered that matches an ignore
-                 * pattern, then notify the user.
-                 */
-                if (ignored) {
-                    if (warnIgnored) {
-                        return createIgnoreResult(filePath, cwd);
-                    }
-
-                    return void 0;
-                }
+            filePaths.map(filePath => {
 
                 const config = configs.getConfig(filePath);
 
                 /*
-                 * Sometimes a file found through a glob pattern will
-                 * be ignored. In this case, `config` will be undefined
-                 * and we just silently ignore the file.
+                 * If a filename was entered that cannot be matched
+                 * to a config, then notify the user.
                  */
                 if (!config) {
+                    if (warnIgnored) {
+                        const configStatus = configs.getConfigStatus(filePath);
+
+                        return createIgnoreResult(filePath, cwd, configStatus);
+                    }
+
                     return void 0;
                 }
 
@@ -1038,7 +1031,9 @@ class ESLint {
             const shouldWarnIgnored = typeof warnIgnored === "boolean" ? warnIgnored : constructorWarnIgnored;
 
             if (shouldWarnIgnored) {
-                results.push(createIgnoreResult(resolvedFilename, cwd));
+                const configStatus = configs.getConfigStatus(resolvedFilename);
+
+                results.push(createIgnoreResult(resolvedFilename, cwd, configStatus));
             }
         } else {
 

data/node_modules/eslint/lib/languages/js/index.js

@@ -0,0 +1,247 @@
+/**
+ * @fileoverview JavaScript Language Object
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const { SourceCode } = require("./source-code");
+const createDebug = require("debug");
+const astUtils = require("../../shared/ast-utils");
+const eslintScope = require("eslint-scope");
+const evk = require("eslint-visitor-keys");
+const { validateLanguageOptions } = require("./validate-language-options");
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("../../linter/vfile").VFile} VFile */
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+const debug = createDebug("eslint:languages:js");
+const DEFAULT_ECMA_VERSION = 5;
+
+/**
+ * Analyze scope of the given AST.
+ * @param {ASTNode} ast The `Program` node to analyze.
+ * @param {LanguageOptions} languageOptions The parser options.
+ * @param {Record<string, string[]>} visitorKeys The visitor keys.
+ * @returns {ScopeManager} The analysis result.
+ */
+function analyzeScope(ast, languageOptions, visitorKeys) {
+    const parserOptions = languageOptions.parserOptions;
+    const ecmaFeatures = parserOptions.ecmaFeatures || {};
+    const ecmaVersion = languageOptions.ecmaVersion || DEFAULT_ECMA_VERSION;
+
+    return eslintScope.analyze(ast, {
+        ignoreEval: true,
+        nodejsScope: ecmaFeatures.globalReturn,
+        impliedStrict: ecmaFeatures.impliedStrict,
+        ecmaVersion: typeof ecmaVersion === "number" ? ecmaVersion : 6,
+        sourceType: languageOptions.sourceType || "script",
+        childVisitorKeys: visitorKeys || evk.KEYS,
+        fallback: evk.getKeys
+    });
+}
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+module.exports = {
+
+    fileType: "text",
+    lineStart: 1,
+    columnStart: 0,
+    nodeTypeKey: "type",
+    visitorKeys: evk.KEYS,
+
+    validateLanguageOptions,
+
+    /**
+     * Determines if a given node matches a given selector class.
+     * @param {string} className The class name to check.
+     * @param {ASTNode} node The node to check.
+     * @param {Array<ASTNode>} ancestry The ancestry of the node.
+     * @returns {boolean} True if there's a match, false if not.
+     * @throws {Error} When an unknown class name is passed.
+     */
+    matchesSelectorClass(className, node, ancestry) {
+
+        /*
+         * Copyright (c) 2013, Joel Feenstra
+         * All rights reserved.
+         *
+         * Redistribution and use in source and binary forms, with or without
+         * modification, are permitted provided that the following conditions are met:
+         *    * Redistributions of source code must retain the above copyright
+         *      notice, this list of conditions and the following disclaimer.
+         *    * Redistributions in binary form must reproduce the above copyright
+         *      notice, this list of conditions and the following disclaimer in the
+         *      documentation and/or other materials provided with the distribution.
+         *    * Neither the name of the ESQuery nor the names of its contributors may
+         *      be used to endorse or promote products derived from this software without
+         *      specific prior written permission.
+         *
+         * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+         * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+         * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+         * DISCLAIMED. IN NO EVENT SHALL JOEL FEENSTRA BE LIABLE FOR ANY
+         * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+         * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+         * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+         * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+         * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+         * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+         */
+
+        switch (className.toLowerCase()) {
+
+            case "statement":
+                if (node.type.slice(-9) === "Statement") {
+                    return true;
+                }
+
+                // fallthrough: interface Declaration <: Statement { }
+
+            case "declaration":
+                return node.type.slice(-11) === "Declaration";
+
+            case "pattern":
+                if (node.type.slice(-7) === "Pattern") {
+                    return true;
+                }
+
+                // fallthrough: interface Expression <: Node, Pattern { }
+
+            case "expression":
+                return node.type.slice(-10) === "Expression" ||
+                    node.type.slice(-7) === "Literal" ||
+                    (
+                        node.type === "Identifier" &&
+                        (ancestry.length === 0 || ancestry[0].type !== "MetaProperty")
+                    ) ||
+                    node.type === "MetaProperty";
+
+            case "function":
+                return node.type === "FunctionDeclaration" ||
+                    node.type === "FunctionExpression" ||
+                    node.type === "ArrowFunctionExpression";
+
+            default:
+                throw new Error(`Unknown class name: ${className}`);
+        }
+    },
+
+    /**
+     * Parses the given file into an AST.
+     * @param {VFile} file The virtual file to parse.
+     * @param {Object} options Additional options passed from ESLint.
+     * @param {LanguageOptions} options.languageOptions The language options.
+     * @returns {Object} The result of parsing.
+     */
+    parse(file, { languageOptions }) {
+
+        // Note: BOM already removed
+        const { body: text, path: filePath } = file;
+        const textToParse = text.replace(astUtils.shebangPattern, (match, captured) => `//${captured}`);
+        const { ecmaVersion, sourceType, parser } = languageOptions;
+        const parserOptions = Object.assign(
+            { ecmaVersion, sourceType },
+            languageOptions.parserOptions,
+            {
+                loc: true,
+                range: true,
+                raw: true,
+                tokens: true,
+                comment: true,
+                eslintVisitorKeys: true,
+                eslintScopeManager: true,
+                filePath
+            }
+        );
+
+        /*
+         * Check for parsing errors first. If there's a parsing error, nothing
+         * else can happen. However, a parsing error does not throw an error
+         * from this method - it's just considered a fatal error message, a
+         * problem that ESLint identified just like any other.
+         */
+        try {
+            debug("Parsing:", filePath);
+            const parseResult = (typeof parser.parseForESLint === "function")
+                ? parser.parseForESLint(textToParse, parserOptions)
+                : { ast: parser.parse(textToParse, parserOptions) };
+
+            debug("Parsing successful:", filePath);
+
+            const {
+                ast,
+                services: parserServices = {},
+                visitorKeys = evk.KEYS,
+                scopeManager
+            } = parseResult;
+
+            return {
+                ok: true,
+                ast,
+                parserServices,
+                visitorKeys,
+                scopeManager
+            };
+        } catch (ex) {
+
+            // If the message includes a leading line number, strip it:
+            const message = `Parsing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
+
+            debug("%s\n%s", message, ex.stack);
+
+            return {
+                ok: false,
+                errors: [{
+                    message,
+                    line: ex.lineNumber,
+                    column: ex.column
+                }]
+            };
+        }
+
+    },
+
+    /**
+     * Creates a new `SourceCode` object from the given information.
+     * @param {VFile} file The virtual file to create a `SourceCode` object from.
+     * @param {Object} parseResult The result returned from `parse()`.
+     * @param {Object} options Additional options passed from ESLint.
+     * @param {LanguageOptions} options.languageOptions The language options.
+     * @returns {SourceCode} The new `SourceCode` object.
+     */
+    createSourceCode(file, parseResult, { languageOptions }) {
+
+        const { body: text, path: filePath, bom: hasBOM } = file;
+        const { ast, parserServices, visitorKeys } = parseResult;
+
+        debug("Scope analysis:", filePath);
+        const scopeManager = parseResult.scopeManager || analyzeScope(ast, languageOptions, visitorKeys);
+
+        debug("Scope analysis successful:", filePath);
+
+        return new SourceCode({
+            text,
+            ast,
+            hasBOM,
+            parserServices,
+            scopeManager,
+            visitorKeys
+        });
+    }
+
+};