@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-backreference.js

@@ -1,244 +0,0 @@
-/**
- * @fileoverview Rule to disallow useless backreferences in regular expressions
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
-const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const parser = new RegExpParser();
-
-/**
- * Finds the path from the given `regexpp` AST node to the root node.
- * @param {regexpp.Node} node Node.
- * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node.
- */
-function getPathToRoot(node) {
-    const path = [];
-    let current = node;
-
-    do {
-        path.push(current);
-        current = current.parent;
-    } while (current);
-
-    return path;
-}
-
-/**
- * Determines whether the given `regexpp` AST node is a lookaround node.
- * @param {regexpp.Node} node Node.
- * @returns {boolean} `true` if it is a lookaround node.
- */
-function isLookaround(node) {
-    return node.type === "Assertion" &&
-        (node.kind === "lookahead" || node.kind === "lookbehind");
-}
-
-/**
- * Determines whether the given `regexpp` AST node is a negative lookaround node.
- * @param {regexpp.Node} node Node.
- * @returns {boolean} `true` if it is a negative lookaround node.
- */
-function isNegativeLookaround(node) {
-    return isLookaround(node) && node.negate;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow useless backreferences in regular expressions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-useless-backreference"
-        },
-
-        schema: [],
-
-        messages: {
-            nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.",
-            forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.",
-            backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.",
-            disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.",
-            intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks and reports useless backreferences in the given regular expression.
-         * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
-         * @param {string} pattern Regular expression pattern.
-         * @param {string} flags Regular expression flags.
-         * @returns {void}
-         */
-        function checkRegex(node, pattern, flags) {
-            let regExpAST;
-
-            try {
-                regExpAST = parser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
-            } catch {
-
-                // Ignore regular expressions with syntax errors
-                return;
-            }
-
-            visitRegExpAST(regExpAST, {
-                onBackreferenceEnter(bref) {
-                    const groups = [bref.resolved].flat(),
-                        brefPath = getPathToRoot(bref);
-
-                    const problems = groups.map(group => {
-                        const groupPath = getPathToRoot(group);
-
-                        if (brefPath.includes(group)) {
-
-                            // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
-                            return {
-                                messageId: "nested",
-                                group
-                            };
-                        }
-
-
-                        // Start from the root to find the lowest common ancestor.
-                        let i = brefPath.length - 1,
-                            j = groupPath.length - 1;
-
-                        do {
-                            i--;
-                            j--;
-                        } while (brefPath[i] === groupPath[j]);
-
-                        const indexOfLowestCommonAncestor = j + 1,
-                            groupCut = groupPath.slice(0, indexOfLowestCommonAncestor),
-                            commonPath = groupPath.slice(indexOfLowestCommonAncestor),
-                            lowestCommonLookaround = commonPath.find(isLookaround),
-                            isMatchingBackward = lowestCommonLookaround && lowestCommonLookaround.kind === "lookbehind";
-
-                        if (groupCut.at(-1).type === "Alternative") {
-
-                            // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
-                            return {
-                                messageId: "disjunctive",
-                                group
-                            };
-                        }
-                        if (!isMatchingBackward && bref.end <= group.start) {
-
-                            // bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match.
-                            return {
-                                messageId: "forward",
-                                group
-                            };
-                        }
-                        if (isMatchingBackward && group.end <= bref.start) {
-
-                            // the opposite of the previous when the regex is matching backward in a lookbehind context.
-                            return {
-                                messageId: "backward",
-                                group
-                            };
-                        }
-                        if (groupCut.some(isNegativeLookaround)) {
-
-                            // group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match.
-                            return {
-                                messageId: "intoNegativeLookaround",
-                                group
-                            };
-                        }
-
-                        return null;
-                    });
-
-                    if (problems.length === 0 || problems.some(problem => !problem)) {
-
-                        // If there are no problems or no problems with any group then do not report it.
-                        return;
-                    }
-
-                    let problemsToReport;
-
-                    // Gets problems that appear in the same disjunction.
-                    const problemsInSameDisjunction = problems.filter(problem => problem.messageId !== "disjunctive");
-
-                    if (problemsInSameDisjunction.length) {
-
-                        // Only report problems that appear in the same disjunction.
-                        problemsToReport = problemsInSameDisjunction;
-                    } else {
-
-                        // If all groups appear in different disjunctions, report it.
-                        problemsToReport = problems;
-                    }
-
-                    const [{ messageId, group }, ...other] = problemsToReport;
-                    let otherGroups = "";
-
-                    if (other.length === 1) {
-                        otherGroups = " and another group";
-                    } else if (other.length > 1) {
-                        otherGroups = ` and other ${other.length} groups`;
-                    }
-                    context.report({
-                        node,
-                        messageId,
-                        data: {
-                            bref: bref.raw,
-                            group: group.raw,
-                            otherGroups
-                        }
-                    });
-                }
-            });
-        }
-
-        return {
-            "Literal[regex]"(node) {
-                const { pattern, flags } = node.regex;
-
-                checkRegex(node, pattern, flags);
-            },
-            Program(node) {
-                const scope = sourceCode.getScope(node),
-                    tracker = new ReferenceTracker(scope),
-                    traceMap = {
-                        RegExp: {
-                            [CALL]: true,
-                            [CONSTRUCT]: true
-                        }
-                    };
-
-                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
-                    const [patternNode, flagsNode] = refNode.arguments,
-                        pattern = getStringIfConstant(patternNode, scope),
-                        flags = getStringIfConstant(flagsNode, scope);
-
-                    if (typeof pattern === "string") {
-                        checkRegex(refNode, pattern, flags || "");
-                    }
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-call.js

@@ -1,90 +0,0 @@
-/**
- * @fileoverview A rule to disallow unnecessary `.call()` and `.apply()`.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a node is a `.call()`/`.apply()`.
- * @param {ASTNode} node A CallExpression node to check.
- * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
- */
-function isCallOrNonVariadicApply(node) {
-    const callee = astUtils.skipChainExpression(node.callee);
-
-    return (
-        callee.type === "MemberExpression" &&
-        callee.property.type === "Identifier" &&
-        callee.computed === false &&
-        (
-            (callee.property.name === "call" && node.arguments.length >= 1) ||
-            (callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
-        )
-    );
-}
-
-
-/**
- * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
- * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.
- * @param {SourceCode} sourceCode The ESLint source code object.
- * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- */
-function isValidThisArg(expectedThis, thisArg, sourceCode) {
-    if (!expectedThis) {
-        return astUtils.isNullOrUndefined(thisArg);
-    }
-    return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary calls to `.call()` and `.apply()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-useless-call"
-        },
-
-        schema: [],
-
-        messages: {
-            unnecessaryCall: "Unnecessary '.{{name}}()'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            CallExpression(node) {
-                if (!isCallOrNonVariadicApply(node)) {
-                    return;
-                }
-
-                const callee = astUtils.skipChainExpression(node.callee);
-                const applied = astUtils.skipChainExpression(callee.object);
-                const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
-                const thisArg = node.arguments[0];
-
-                if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
-                    context.report({ node, messageId: "unnecessaryCall", data: { name: callee.property.name } });
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-catch.js

@@ -1,57 +0,0 @@
-/**
- * @fileoverview Reports useless `catch` clauses that just rethrow their error.
- * @author Teddy Katz
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary `catch` clauses",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-useless-catch"
-        },
-
-        schema: [],
-
-        messages: {
-            unnecessaryCatchClause: "Unnecessary catch clause.",
-            unnecessaryCatch: "Unnecessary try/catch wrapper."
-        }
-    },
-
-    create(context) {
-        return {
-            CatchClause(node) {
-                if (
-                    node.param &&
-                    node.param.type === "Identifier" &&
-                    node.body.body.length &&
-                    node.body.body[0].type === "ThrowStatement" &&
-                    node.body.body[0].argument.type === "Identifier" &&
-                    node.body.body[0].argument.name === node.param.name
-                ) {
-                    if (node.parent.finalizer) {
-                        context.report({
-                            node,
-                            messageId: "unnecessaryCatchClause"
-                        });
-                    } else {
-                        context.report({
-                            node: node.parent,
-                            messageId: "unnecessaryCatch"
-                        });
-                    }
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-computed-key.js

@@ -1,168 +0,0 @@
-/**
- * @fileoverview Rule to disallow unnecessary computed property keys in object literals
- * @author Burak Yigit Kaya
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the computed key syntax is unnecessarily used for the given node.
- * In particular, it determines whether removing the square brackets and using the content between them
- * directly as the key (e.g. ['foo'] -> 'foo') would produce valid syntax and preserve the same behavior.
- * Valid non-computed keys are only: identifiers, number literals and string literals.
- * Only literals can preserve the same behavior, with a few exceptions for specific node types:
- * Property
- *   - { ["__proto__"]: foo } defines a property named "__proto__"
- *     { "__proto__": foo } defines object's prototype
- * PropertyDefinition
- *   - class C { ["constructor"]; } defines an instance field named "constructor"
- *     class C { "constructor"; } produces a parsing error
- *   - class C { static ["constructor"]; } defines a static field named "constructor"
- *     class C { static "constructor"; } produces a parsing error
- *   - class C { static ["prototype"]; } produces a runtime error (doesn't break the whole script)
- *     class C { static "prototype"; } produces a parsing error (breaks the whole script)
- * MethodDefinition
- *   - class C { ["constructor"]() {} } defines a prototype method named "constructor"
- *     class C { "constructor"() {} } defines the constructor
- *   - class C { static ["prototype"]() {} } produces a runtime error (doesn't break the whole script)
- *     class C { static "prototype"() {} } produces a parsing error (breaks the whole script)
- * @param {ASTNode} node The node to check. It can be `Property`, `PropertyDefinition` or `MethodDefinition`.
- * @throws {Error} (Unreachable.)
- * @returns {void} `true` if the node has useless computed key.
- */
-function hasUselessComputedKey(node) {
-    if (!node.computed) {
-        return false;
-    }
-
-    const { key } = node;
-
-    if (key.type !== "Literal") {
-        return false;
-    }
-
-    const { value } = key;
-
-    if (typeof value !== "number" && typeof value !== "string") {
-        return false;
-    }
-
-    switch (node.type) {
-        case "Property":
-            return value !== "__proto__";
-
-        case "PropertyDefinition":
-            if (node.static) {
-                return value !== "constructor" && value !== "prototype";
-            }
-
-            return value !== "constructor";
-
-        case "MethodDefinition":
-            if (node.static) {
-                return value !== "prototype";
-            }
-
-            return value !== "constructor";
-
-        /* c8 ignore next */
-        default:
-            throw new Error(`Unexpected node type: ${node.type}`);
-    }
-
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary computed property keys in objects and classes",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-useless-computed-key"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                enforceForClassMembers: {
-                    type: "boolean",
-                    default: true
-                }
-            },
-            additionalProperties: false
-        }],
-        fixable: "code",
-
-        messages: {
-            unnecessarilyComputedProperty: "Unnecessarily computed property [{{property}}] found."
-        }
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const enforceForClassMembers = context.options[0]?.enforceForClassMembers ?? true;
-
-        /**
-         * Reports a given node if it violated this rule.
-         * @param {ASTNode} node The node to check.
-         * @returns {void}
-         */
-        function check(node) {
-            if (hasUselessComputedKey(node)) {
-                const { key } = node;
-
-                context.report({
-                    node,
-                    messageId: "unnecessarilyComputedProperty",
-                    data: { property: sourceCode.getText(key) },
-                    fix(fixer) {
-                        const leftSquareBracket = sourceCode.getTokenBefore(key, astUtils.isOpeningBracketToken);
-                        const rightSquareBracket = sourceCode.getTokenAfter(key, astUtils.isClosingBracketToken);
-
-                        // If there are comments between the brackets and the property name, don't do a fix.
-                        if (sourceCode.commentsExistBetween(leftSquareBracket, rightSquareBracket)) {
-                            return null;
-                        }
-
-                        const tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket);
-
-                        // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
-                        const needsSpaceBeforeKey = tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] &&
-                            !astUtils.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key));
-
-                        const replacementKey = (needsSpaceBeforeKey ? " " : "") + key.raw;
-
-                        return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);
-                    }
-                });
-            }
-        }
-
-        /**
-         * A no-op function to act as placeholder for checking a node when the `enforceForClassMembers` option is `false`.
-         * @returns {void}
-         * @private
-         */
-        function noop() {}
-
-        return {
-            Property: check,
-            MethodDefinition: enforceForClassMembers ? check : noop,
-            PropertyDefinition: enforceForClassMembers ? check : noop
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-useless-concat.js

@@ -1,115 +0,0 @@
-/**
- * @fileoverview disallow unnecessary concatenation of template strings
- * @author Henry Zhu
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a given node is a concatenation.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node is a concatenation.
- */
-function isConcatenation(node) {
-    return node.type === "BinaryExpression" && node.operator === "+";
-}
-
-/**
- * Checks if the given token is a `+` token or not.
- * @param {Token} token The token to check.
- * @returns {boolean} `true` if the token is a `+` token.
- */
-function isConcatOperatorToken(token) {
-    return token.value === "+" && token.type === "Punctuator";
-}
-
-/**
- * Get's the right most node on the left side of a BinaryExpression with + operator.
- * @param {ASTNode} node A BinaryExpression node to check.
- * @returns {ASTNode} node
- */
-function getLeft(node) {
-    let left = node.left;
-
-    while (isConcatenation(left)) {
-        left = left.right;
-    }
-    return left;
-}
-
-/**
- * Get's the left most node on the right side of a BinaryExpression with + operator.
- * @param {ASTNode} node A BinaryExpression node to check.
- * @returns {ASTNode} node
- */
-function getRight(node) {
-    let right = node.right;
-
-    while (isConcatenation(right)) {
-        right = right.left;
-    }
-    return right;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary concatenation of literals or template literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-useless-concat"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpectedConcat: "Unexpected string concatenation of literals."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            BinaryExpression(node) {
-
-                // check if not concatenation
-                if (node.operator !== "+") {
-                    return;
-                }
-
-                // account for the `foo + "a" + "b"` case
-                const left = getLeft(node);
-                const right = getRight(node);
-
-                if (astUtils.isStringLiteral(left) &&
-                    astUtils.isStringLiteral(right) &&
-                    astUtils.isTokenOnSameLine(left, right)
-                ) {
-                    const operatorToken = sourceCode.getFirstTokenBetween(left, right, isConcatOperatorToken);
-
-                    context.report({
-                        node,
-                        loc: operatorToken.loc,
-                        messageId: "unexpectedConcat"
-                    });
-                }
-            }
-        };
-    }
-};