@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/yoda.js

@@ -1,353 +0,0 @@
-/**
- * @fileoverview Rule to require or disallow yoda comparisons
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//--------------------------------------------------------------------------
-// Requirements
-//--------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//--------------------------------------------------------------------------
-// Helpers
-//--------------------------------------------------------------------------
-
-/**
- * Determines whether an operator is a comparison operator.
- * @param {string} operator The operator to check.
- * @returns {boolean} Whether or not it is a comparison operator.
- */
-function isComparisonOperator(operator) {
-    return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
-}
-
-/**
- * Determines whether an operator is an equality operator.
- * @param {string} operator The operator to check.
- * @returns {boolean} Whether or not it is an equality operator.
- */
-function isEqualityOperator(operator) {
-    return /^(==|===)$/u.test(operator);
-}
-
-/**
- * Determines whether an operator is one used in a range test.
- * Allowed operators are `<` and `<=`.
- * @param {string} operator The operator to check.
- * @returns {boolean} Whether the operator is used in range tests.
- */
-function isRangeTestOperator(operator) {
-    return ["<", "<="].includes(operator);
-}
-
-/**
- * Determines whether a non-Literal node is a negative number that should be
- * treated as if it were a single Literal node.
- * @param {ASTNode} node Node to test.
- * @returns {boolean} True if the node is a negative number that looks like a
- *                    real literal and should be treated as such.
- */
-function isNegativeNumericLiteral(node) {
-    return (
-        node.type === "UnaryExpression" &&
-        node.operator === "-" &&
-        node.prefix &&
-        astUtils.isNumericLiteral(node.argument)
-    );
-}
-
-/**
- * Determines whether a non-Literal node should be treated as a single Literal node.
- * @param {ASTNode} node Node to test
- * @returns {boolean} True if the node should be treated as a single Literal node.
- */
-function looksLikeLiteral(node) {
-    return isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node);
-}
-
-/**
- * Attempts to derive a Literal node from nodes that are treated like literals.
- * @param {ASTNode} node Node to normalize.
- * @returns {ASTNode} One of the following options.
- *  1. The original node if the node is already a Literal
- *  2. A normalized Literal node with the negative number as the value if the
- *     node represents a negative number literal.
- *  3. A normalized Literal node with the string as the value if the node is
- *     a Template Literal without expression.
- *  4. Otherwise `null`.
- */
-function getNormalizedLiteral(node) {
-    if (node.type === "Literal") {
-        return node;
-    }
-
-    if (isNegativeNumericLiteral(node)) {
-        return {
-            type: "Literal",
-            value: -node.argument.value,
-            raw: `-${node.argument.value}`
-        };
-    }
-
-    if (astUtils.isStaticTemplateLiteral(node)) {
-        return {
-            type: "Literal",
-            value: node.quasis[0].value.cooked,
-            raw: node.quasis[0].value.raw
-        };
-    }
-
-    return null;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: 'Require or disallow "Yoda" conditions',
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/yoda"
-        },
-
-        schema: [
-            {
-                enum: ["always", "never"]
-            },
-            {
-                type: "object",
-                properties: {
-                    exceptRange: {
-                        type: "boolean",
-                        default: false
-                    },
-                    onlyEquality: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: "code",
-        messages: {
-            expected:
-                "Expected literal to be on the {{expectedSide}} side of {{operator}}."
-        }
-    },
-
-    create(context) {
-
-        // Default to "never" (!always) if no option
-        const always = context.options[0] === "always";
-        const exceptRange =
-            context.options[1] && context.options[1].exceptRange;
-        const onlyEquality =
-            context.options[1] && context.options[1].onlyEquality;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether node represents a range test.
-         * A range test is a "between" test like `(0 <= x && x < 1)` or an "outside"
-         * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and
-         * both operators must be `<` or `<=`. Finally, the literal on the left side
-         * must be less than or equal to the literal on the right side so that the
-         * test makes any sense.
-         * @param {ASTNode} node LogicalExpression node to test.
-         * @returns {boolean} Whether node is a range test.
-         */
-        function isRangeTest(node) {
-            const left = node.left,
-                right = node.right;
-
-            /**
-             * Determines whether node is of the form `0 <= x && x < 1`.
-             * @returns {boolean} Whether node is a "between" range test.
-             */
-            function isBetweenTest() {
-                if (node.operator === "&&" && astUtils.isSameReference(left.right, right.left)) {
-                    const leftLiteral = getNormalizedLiteral(left.left);
-                    const rightLiteral = getNormalizedLiteral(right.right);
-
-                    if (leftLiteral === null && rightLiteral === null) {
-                        return false;
-                    }
-
-                    if (rightLiteral === null || leftLiteral === null) {
-                        return true;
-                    }
-
-                    if (leftLiteral.value <= rightLiteral.value) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            /**
-             * Determines whether node is of the form `x < 0 || 1 <= x`.
-             * @returns {boolean} Whether node is an "outside" range test.
-             */
-            function isOutsideTest() {
-                if (node.operator === "||" && astUtils.isSameReference(left.left, right.right)) {
-                    const leftLiteral = getNormalizedLiteral(left.right);
-                    const rightLiteral = getNormalizedLiteral(right.left);
-
-                    if (leftLiteral === null && rightLiteral === null) {
-                        return false;
-                    }
-
-                    if (rightLiteral === null || leftLiteral === null) {
-                        return true;
-                    }
-
-                    if (leftLiteral.value <= rightLiteral.value) {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            /**
-             * Determines whether node is wrapped in parentheses.
-             * @returns {boolean} Whether node is preceded immediately by an open
-             *                    paren token and followed immediately by a close
-             *                    paren token.
-             */
-            function isParenWrapped() {
-                return astUtils.isParenthesised(sourceCode, node);
-            }
-
-            return (
-                node.type === "LogicalExpression" &&
-                left.type === "BinaryExpression" &&
-                right.type === "BinaryExpression" &&
-                isRangeTestOperator(left.operator) &&
-                isRangeTestOperator(right.operator) &&
-                (isBetweenTest() || isOutsideTest()) &&
-                isParenWrapped()
-            );
-        }
-
-        const OPERATOR_FLIP_MAP = {
-            "===": "===",
-            "!==": "!==",
-            "==": "==",
-            "!=": "!=",
-            "<": ">",
-            ">": "<",
-            "<=": ">=",
-            ">=": "<="
-        };
-
-        /**
-         * Returns a string representation of a BinaryExpression node with its sides/operator flipped around.
-         * @param {ASTNode} node The BinaryExpression node
-         * @returns {string} A string representation of the node with the sides and operator flipped
-         */
-        function getFlippedString(node) {
-            const operatorToken = sourceCode.getFirstTokenBetween(
-                node.left,
-                node.right,
-                token => token.value === node.operator
-            );
-            const lastLeftToken = sourceCode.getTokenBefore(operatorToken);
-            const firstRightToken = sourceCode.getTokenAfter(operatorToken);
-
-            const source = sourceCode.getText();
-
-            const leftText = source.slice(
-                node.range[0],
-                lastLeftToken.range[1]
-            );
-            const textBeforeOperator = source.slice(
-                lastLeftToken.range[1],
-                operatorToken.range[0]
-            );
-            const textAfterOperator = source.slice(
-                operatorToken.range[1],
-                firstRightToken.range[0]
-            );
-            const rightText = source.slice(
-                firstRightToken.range[0],
-                node.range[1]
-            );
-
-            const tokenBefore = sourceCode.getTokenBefore(node);
-            const tokenAfter = sourceCode.getTokenAfter(node);
-            let prefix = "";
-            let suffix = "";
-
-            if (
-                tokenBefore &&
-                tokenBefore.range[1] === node.range[0] &&
-                !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken)
-            ) {
-                prefix = " ";
-            }
-
-            if (
-                tokenAfter &&
-                node.range[1] === tokenAfter.range[0] &&
-                !astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter)
-            ) {
-                suffix = " ";
-            }
-
-            return (
-                prefix +
-                rightText +
-                textBeforeOperator +
-                OPERATOR_FLIP_MAP[operatorToken.value] +
-                textAfterOperator +
-                leftText +
-                suffix
-            );
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            BinaryExpression(node) {
-                const expectedLiteral = always ? node.left : node.right;
-                const expectedNonLiteral = always ? node.right : node.left;
-
-                // If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error.
-                if (
-                    (expectedNonLiteral.type === "Literal" ||
-                        looksLikeLiteral(expectedNonLiteral)) &&
-                    !(
-                        expectedLiteral.type === "Literal" ||
-                        looksLikeLiteral(expectedLiteral)
-                    ) &&
-                    !(!isEqualityOperator(node.operator) && onlyEquality) &&
-                    isComparisonOperator(node.operator) &&
-                    !(exceptRange && isRangeTest(node.parent))
-                ) {
-                    context.report({
-                        node,
-                        messageId: "expected",
-                        data: {
-                            operator: node.operator,
-                            expectedSide: always ? "left" : "right"
-                        },
-                        fix: fixer =>
-                            fixer.replaceText(node, getFlippedString(node))
-                    });
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/ajv.js

@@ -1,34 +0,0 @@
-/**
- * @fileoverview The instance of Ajv validator.
- * @author Evgeny Poberezkin
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const Ajv = require("ajv"),
-    metaSchema = require("ajv/lib/refs/json-schema-draft-04.json");
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = (additionalOptions = {}) => {
-    const ajv = new Ajv({
-        meta: false,
-        useDefaults: true,
-        validateSchema: false,
-        missingRefs: "ignore",
-        verbose: true,
-        schemaId: "auto",
-        ...additionalOptions
-    });
-
-    ajv.addMetaSchema(metaSchema);
-    // eslint-disable-next-line no-underscore-dangle -- Ajv's API
-    ajv._opts.defaultMeta = metaSchema.id;
-
-    return ajv;
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/ast-utils.js

@@ -1,29 +0,0 @@
-/**
- * @fileoverview Common utils for AST.
- *
- * This file contains only shared items for core and rules.
- * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-"use strict";
-
-const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
-const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
-const shebangPattern = /^#!([^\r\n]+)/u;
-
-/**
- * Creates a version of the `lineBreakPattern` regex with the global flag.
- * Global regexes are mutable, so this needs to be a function instead of a constant.
- * @returns {RegExp} A global regular expression that matches line terminators
- */
-function createGlobalLinebreakMatcher() {
-    return new RegExp(lineBreakPattern.source, "gu");
-}
-
-module.exports = {
-    breakableTypePattern,
-    lineBreakPattern,
-    createGlobalLinebreakMatcher,
-    shebangPattern
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/directives.js

@@ -1,15 +0,0 @@
-/**
- * @fileoverview Common utils for directives.
- *
- * This file contains only shared items for directives.
- * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
- *
- * @author gfyoung <https://github.com/gfyoung>
- */
-"use strict";
-
-const directivesPattern = /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u;
-
-module.exports = {
-    directivesPattern
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/flags.js

@@ -1,27 +0,0 @@
-/**
- * @fileoverview Shared flags for ESLint.
- */
-
-"use strict";
-
-/**
- * The set of flags that change ESLint behavior with a description.
- * @type {Map<string, string>}
- */
-const activeFlags = new Map([
-    ["test_only", "Used only for testing."],
-    ["unstable_ts_config", "Enable TypeScript configuration files."]
-]);
-
-/**
- * The set of flags that used to be active but no longer have an effect.
- * @type {Map<string, string>}
- */
-const inactiveFlags = new Map([
-    ["test_only_old", "Used only for testing."]
-]);
-
-module.exports = {
-    activeFlags,
-    inactiveFlags
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/logging.js

@@ -1,39 +0,0 @@
-/**
- * @fileoverview Handle logging for ESLint
- * @author Gyandeep Singh
- */
-
-"use strict";
-
-/* eslint no-console: "off" -- Logging util */
-
-/* c8 ignore next */
-module.exports = {
-
-    /**
-     * Cover for console.info
-     * @param {...any} args The elements to log.
-     * @returns {void}
-     */
-    info(...args) {
-        console.log(...args);
-    },
-
-    /**
-     * Cover for console.warn
-     * @param {...any} args The elements to log.
-     * @returns {void}
-     */
-    warn(...args) {
-        console.warn(...args);
-    },
-
-    /**
-     * Cover for console.error
-     * @param {...any} args The elements to log.
-     * @returns {void}
-     */
-    error(...args) {
-        console.error(...args);
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/runtime-info.js

@@ -1,168 +0,0 @@
-/**
- * @fileoverview Utility to get information about the execution environment.
- * @author Kai Cataldo
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const path = require("node:path");
-const spawn = require("cross-spawn");
-const os = require("node:os");
-const log = require("../shared/logging");
-const packageJson = require("../../package.json");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Generates and returns execution environment information.
- * @returns {string} A string that contains execution environment information.
- */
-function environment() {
-    const cache = new Map();
-
-    /**
-     * Checks if a path is a child of a directory.
-     * @param {string} parentPath The parent path to check.
-     * @param {string} childPath The path to check.
-     * @returns {boolean} Whether or not the given path is a child of a directory.
-     */
-    function isChildOfDirectory(parentPath, childPath) {
-        return !path.relative(parentPath, childPath).startsWith("..");
-    }
-
-    /**
-     * Synchronously executes a shell command and formats the result.
-     * @param {string} cmd The command to execute.
-     * @param {Array} args The arguments to be executed with the command.
-     * @throws {Error} As may be collected by `cross-spawn.sync`.
-     * @returns {string} The version returned by the command.
-     */
-    function execCommand(cmd, args) {
-        const key = [cmd, ...args].join(" ");
-
-        if (cache.has(key)) {
-            return cache.get(key);
-        }
-
-        const process = spawn.sync(cmd, args, { encoding: "utf8" });
-
-        if (process.error) {
-            throw process.error;
-        }
-
-        const result = process.stdout.trim();
-
-        cache.set(key, result);
-        return result;
-    }
-
-    /**
-     * Normalizes a version number.
-     * @param {string} versionStr The string to normalize.
-     * @returns {string} The normalized version number.
-     */
-    function normalizeVersionStr(versionStr) {
-        return versionStr.startsWith("v") ? versionStr : `v${versionStr}`;
-    }
-
-    /**
-     * Gets bin version.
-     * @param {string} bin The bin to check.
-     * @throws {Error} As may be collected by `cross-spawn.sync`.
-     * @returns {string} The normalized version returned by the command.
-     */
-    function getBinVersion(bin) {
-        const binArgs = ["--version"];
-
-        try {
-            return normalizeVersionStr(execCommand(bin, binArgs));
-        } catch (e) {
-            log.error(`Error finding ${bin} version running the command \`${bin} ${binArgs.join(" ")}\``);
-            throw e;
-        }
-    }
-
-    /**
-     * Gets installed npm package version.
-     * @param {string} pkg The package to check.
-     * @param {boolean} global Whether to check globally or not.
-     * @throws {Error} As may be collected by `cross-spawn.sync`.
-     * @returns {string} The normalized version returned by the command.
-     */
-    function getNpmPackageVersion(pkg, { global = false } = {}) {
-        const npmBinArgs = ["bin", "-g"];
-        const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
-
-        if (global) {
-            npmLsArgs.push("-g");
-        }
-
-        try {
-            const parsedStdout = JSON.parse(execCommand("npm", npmLsArgs));
-
-            /*
-             * Checking globally returns an empty JSON object, while local checks
-             * include the name and version of the local project.
-             */
-            if (Object.keys(parsedStdout).length === 0 || !(parsedStdout.dependencies && parsedStdout.dependencies.eslint)) {
-                return "Not found";
-            }
-
-            const [, processBinPath] = process.argv;
-            let npmBinPath;
-
-            try {
-                npmBinPath = execCommand("npm", npmBinArgs);
-            } catch (e) {
-                log.error(`Error finding npm binary path when running command \`npm ${npmBinArgs.join(" ")}\``);
-                throw e;
-            }
-
-            const isGlobal = isChildOfDirectory(npmBinPath, processBinPath);
-            let pkgVersion = parsedStdout.dependencies.eslint.version;
-
-            if ((global && isGlobal) || (!global && !isGlobal)) {
-                pkgVersion += " (Currently used)";
-            }
-
-            return normalizeVersionStr(pkgVersion);
-        } catch (e) {
-            log.error(`Error finding ${pkg} version running the command \`npm ${npmLsArgs.join(" ")}\``);
-            throw e;
-        }
-    }
-
-    return [
-        "Environment Info:",
-        "",
-        `Node version: ${getBinVersion("node")}`,
-        `npm version: ${getBinVersion("npm")}`,
-        `Local ESLint version: ${getNpmPackageVersion("eslint", { global: false })}`,
-        `Global ESLint version: ${getNpmPackageVersion("eslint", { global: true })}`,
-        `Operating System: ${os.platform()} ${os.release()}`
-    ].join("\n");
-}
-
-/**
- * Returns version of currently executing ESLint.
- * @returns {string} The version from the currently executing ESLint's package.json.
- */
-function version() {
-    return `v${packageJson.version}`;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = {
-    __esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
-    environment,
-    version
-};