@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/require-unicode-regexp.js

@@ -1,129 +0,0 @@
-/**
- * @fileoverview Rule to enforce the use of `u` flag on RegExp.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-    CALL,
-    CONSTRUCT,
-    ReferenceTracker,
-    getStringIfConstant
-} = require("@eslint-community/eslint-utils");
-const astUtils = require("./utils/ast-utils.js");
-const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce the use of `u` or `v` flag on RegExp",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/require-unicode-regexp"
-        },
-
-        hasSuggestions: true,
-
-        messages: {
-            addUFlag: "Add the 'u' flag.",
-            requireUFlag: "Use the 'u' flag."
-        },
-
-        schema: []
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            "Literal[regex]"(node) {
-                const flags = node.regex.flags || "";
-
-                if (!flags.includes("u") && !flags.includes("v")) {
-                    context.report({
-                        messageId: "requireUFlag",
-                        node,
-                        suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)
-                            ? [
-                                {
-                                    fix(fixer) {
-                                        return fixer.insertTextAfter(node, "u");
-                                    },
-                                    messageId: "addUFlag"
-                                }
-                            ]
-                            : null
-                    });
-                }
-            },
-
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-                const trackMap = {
-                    RegExp: { [CALL]: true, [CONSTRUCT]: true }
-                };
-
-                for (const { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
-                    const [patternNode, flagsNode] = refNode.arguments;
-
-                    if (patternNode && patternNode.type === "SpreadElement") {
-                        continue;
-                    }
-                    const pattern = getStringIfConstant(patternNode, scope);
-                    const flags = getStringIfConstant(flagsNode, scope);
-
-                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u") && !flags.includes("v"))) {
-                        context.report({
-                            messageId: "requireUFlag",
-                            node: refNode,
-                            suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)
-                                ? [
-                                    {
-                                        fix(fixer) {
-                                            if (flagsNode) {
-                                                if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
-                                                    const flagsNodeText = sourceCode.getText(flagsNode);
-
-                                                    return fixer.replaceText(flagsNode, [
-                                                        flagsNodeText.slice(0, flagsNodeText.length - 1),
-                                                        flagsNodeText.slice(flagsNodeText.length - 1)
-                                                    ].join("u"));
-                                                }
-
-                                                // We intentionally don't suggest concatenating + "u" to non-literals
-                                                return null;
-                                            }
-
-                                            const penultimateToken = sourceCode.getLastToken(refNode, { skip: 1 }); // skip closing parenthesis
-
-                                            return fixer.insertTextAfter(
-                                                penultimateToken,
-                                                astUtils.isCommaToken(penultimateToken)
-                                                    ? ' "u",'
-                                                    : ', "u"'
-                                            );
-                                        },
-                                        messageId: "addUFlag"
-                                    }
-                                ]
-                                : null
-                        });
-                    }
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/require-yield.js

@@ -1,77 +0,0 @@
-/**
- * @fileoverview Rule to flag the generator functions that does not have yield.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require generator functions to contain `yield`",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/require-yield"
-        },
-
-        schema: [],
-
-        messages: {
-            missingYield: "This generator function does not have 'yield'."
-        }
-    },
-
-    create(context) {
-        const stack = [];
-
-        /**
-         * If the node is a generator function, start counting `yield` keywords.
-         * @param {Node} node A function node to check.
-         * @returns {void}
-         */
-        function beginChecking(node) {
-            if (node.generator) {
-                stack.push(0);
-            }
-        }
-
-        /**
-         * If the node is a generator function, end counting `yield` keywords, then
-         * reports result.
-         * @param {Node} node A function node to check.
-         * @returns {void}
-         */
-        function endChecking(node) {
-            if (!node.generator) {
-                return;
-            }
-
-            const countYield = stack.pop();
-
-            if (countYield === 0 && node.body.body.length > 0) {
-                context.report({ node, messageId: "missingYield" });
-            }
-        }
-
-        return {
-            FunctionDeclaration: beginChecking,
-            "FunctionDeclaration:exit": endChecking,
-            FunctionExpression: beginChecking,
-            "FunctionExpression:exit": endChecking,
-
-            // Increases the count of `yield` keyword.
-            YieldExpression() {
-
-                if (stack.length > 0) {
-                    stack[stack.length - 1] += 1;
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/rest-spread-spacing.js

@@ -1,123 +0,0 @@
-/**
- * @fileoverview Enforce spacing between rest and spread operators and their expressions.
- * @author Kai Cataldo
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce spacing between rest and spread operators and their expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/rest-spread-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                enum: ["always", "never"]
-            }
-        ],
-
-        messages: {
-            unexpectedWhitespace: "Unexpected whitespace after {{type}} operator.",
-            expectedWhitespace: "Expected whitespace after {{type}} operator."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode,
-            alwaysSpace = context.options[0] === "always";
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Checks whitespace between rest/spread operators and their expressions
-         * @param {ASTNode} node The node to check
-         * @returns {void}
-         */
-        function checkWhiteSpace(node) {
-            const operator = sourceCode.getFirstToken(node),
-                nextToken = sourceCode.getTokenAfter(operator),
-                hasWhitespace = sourceCode.isSpaceBetweenTokens(operator, nextToken);
-            let type;
-
-            switch (node.type) {
-                case "SpreadElement":
-                    type = "spread";
-                    if (node.parent.type === "ObjectExpression") {
-                        type += " property";
-                    }
-                    break;
-                case "RestElement":
-                    type = "rest";
-                    if (node.parent.type === "ObjectPattern") {
-                        type += " property";
-                    }
-                    break;
-                case "ExperimentalSpreadProperty":
-                    type = "spread property";
-                    break;
-                case "ExperimentalRestProperty":
-                    type = "rest property";
-                    break;
-                default:
-                    return;
-            }
-
-            if (alwaysSpace && !hasWhitespace) {
-                context.report({
-                    node,
-                    loc: operator.loc,
-                    messageId: "expectedWhitespace",
-                    data: {
-                        type
-                    },
-                    fix(fixer) {
-                        return fixer.replaceTextRange([operator.range[1], nextToken.range[0]], " ");
-                    }
-                });
-            } else if (!alwaysSpace && hasWhitespace) {
-                context.report({
-                    node,
-                    loc: {
-                        start: operator.loc.end,
-                        end: nextToken.loc.start
-                    },
-                    messageId: "unexpectedWhitespace",
-                    data: {
-                        type
-                    },
-                    fix(fixer) {
-                        return fixer.removeRange([operator.range[1], nextToken.range[0]]);
-                    }
-                });
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            SpreadElement: checkWhiteSpace,
-            RestElement: checkWhiteSpace,
-            ExperimentalSpreadProperty: checkWhiteSpace,
-            ExperimentalRestProperty: checkWhiteSpace
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/semi-spacing.js

@@ -1,248 +0,0 @@
-/**
- * @fileoverview Validates spacing before and after semicolon
- * @author Mathias Schreck
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce consistent spacing before and after semicolons",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/semi-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    before: {
-                        type: "boolean",
-                        default: false
-                    },
-                    after: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedWhitespaceBefore: "Unexpected whitespace before semicolon.",
-            unexpectedWhitespaceAfter: "Unexpected whitespace after semicolon.",
-            missingWhitespaceBefore: "Missing whitespace before semicolon.",
-            missingWhitespaceAfter: "Missing whitespace after semicolon."
-        }
-    },
-
-    create(context) {
-
-        const config = context.options[0],
-            sourceCode = context.sourceCode;
-        let requireSpaceBefore = false,
-            requireSpaceAfter = true;
-
-        if (typeof config === "object") {
-            requireSpaceBefore = config.before;
-            requireSpaceAfter = config.after;
-        }
-
-        /**
-         * Checks if a given token has leading whitespace.
-         * @param {Object} token The token to check.
-         * @returns {boolean} True if the given token has leading space, false if not.
-         */
-        function hasLeadingSpace(token) {
-            const tokenBefore = sourceCode.getTokenBefore(token);
-
-            return tokenBefore && astUtils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetweenTokens(tokenBefore, token);
-        }
-
-        /**
-         * Checks if a given token has trailing whitespace.
-         * @param {Object} token The token to check.
-         * @returns {boolean} True if the given token has trailing space, false if not.
-         */
-        function hasTrailingSpace(token) {
-            const tokenAfter = sourceCode.getTokenAfter(token);
-
-            return tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetweenTokens(token, tokenAfter);
-        }
-
-        /**
-         * Checks if the given token is the last token in its line.
-         * @param {Token} token The token to check.
-         * @returns {boolean} Whether or not the token is the last in its line.
-         */
-        function isLastTokenInCurrentLine(token) {
-            const tokenAfter = sourceCode.getTokenAfter(token);
-
-            return !(tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter));
-        }
-
-        /**
-         * Checks if the given token is the first token in its line
-         * @param {Token} token The token to check.
-         * @returns {boolean} Whether or not the token is the first in its line.
-         */
-        function isFirstTokenInCurrentLine(token) {
-            const tokenBefore = sourceCode.getTokenBefore(token);
-
-            return !(tokenBefore && astUtils.isTokenOnSameLine(token, tokenBefore));
-        }
-
-        /**
-         * Checks if the next token of a given token is a closing parenthesis.
-         * @param {Token} token The token to check.
-         * @returns {boolean} Whether or not the next token of a given token is a closing parenthesis.
-         */
-        function isBeforeClosingParen(token) {
-            const nextToken = sourceCode.getTokenAfter(token);
-
-            return (nextToken && astUtils.isClosingBraceToken(nextToken) || astUtils.isClosingParenToken(nextToken));
-        }
-
-        /**
-         * Report location example :
-         *
-         * for unexpected space `before`
-         *
-         * var a = 'b'   ;
-         *            ^^^
-         *
-         * for unexpected space `after`
-         *
-         * var a = 'b';  c = 10;
-         *             ^^
-         *
-         * Reports if the given token has invalid spacing.
-         * @param {Token} token The semicolon token to check.
-         * @param {ASTNode} node The corresponding node of the token.
-         * @returns {void}
-         */
-        function checkSemicolonSpacing(token, node) {
-            if (astUtils.isSemicolonToken(token)) {
-                if (hasLeadingSpace(token)) {
-                    if (!requireSpaceBefore) {
-                        const tokenBefore = sourceCode.getTokenBefore(token);
-                        const loc = {
-                            start: tokenBefore.loc.end,
-                            end: token.loc.start
-                        };
-
-                        context.report({
-                            node,
-                            loc,
-                            messageId: "unexpectedWhitespaceBefore",
-                            fix(fixer) {
-
-                                return fixer.removeRange([tokenBefore.range[1], token.range[0]]);
-                            }
-                        });
-                    }
-                } else {
-                    if (requireSpaceBefore) {
-                        const loc = token.loc;
-
-                        context.report({
-                            node,
-                            loc,
-                            messageId: "missingWhitespaceBefore",
-                            fix(fixer) {
-                                return fixer.insertTextBefore(token, " ");
-                            }
-                        });
-                    }
-                }
-
-                if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {
-                    if (hasTrailingSpace(token)) {
-                        if (!requireSpaceAfter) {
-                            const tokenAfter = sourceCode.getTokenAfter(token);
-                            const loc = {
-                                start: token.loc.end,
-                                end: tokenAfter.loc.start
-                            };
-
-                            context.report({
-                                node,
-                                loc,
-                                messageId: "unexpectedWhitespaceAfter",
-                                fix(fixer) {
-
-                                    return fixer.removeRange([token.range[1], tokenAfter.range[0]]);
-                                }
-                            });
-                        }
-                    } else {
-                        if (requireSpaceAfter) {
-                            const loc = token.loc;
-
-                            context.report({
-                                node,
-                                loc,
-                                messageId: "missingWhitespaceAfter",
-                                fix(fixer) {
-                                    return fixer.insertTextAfter(token, " ");
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-        }
-
-        /**
-         * Checks the spacing of the semicolon with the assumption that the last token is the semicolon.
-         * @param {ASTNode} node The node to check.
-         * @returns {void}
-         */
-        function checkNode(node) {
-            const token = sourceCode.getLastToken(node);
-
-            checkSemicolonSpacing(token, node);
-        }
-
-        return {
-            VariableDeclaration: checkNode,
-            ExpressionStatement: checkNode,
-            BreakStatement: checkNode,
-            ContinueStatement: checkNode,
-            DebuggerStatement: checkNode,
-            DoWhileStatement: checkNode,
-            ReturnStatement: checkNode,
-            ThrowStatement: checkNode,
-            ImportDeclaration: checkNode,
-            ExportNamedDeclaration: checkNode,
-            ExportAllDeclaration: checkNode,
-            ExportDefaultDeclaration: checkNode,
-            ForStatement(node) {
-                if (node.init) {
-                    checkSemicolonSpacing(sourceCode.getTokenAfter(node.init), node);
-                }
-
-                if (node.test) {
-                    checkSemicolonSpacing(sourceCode.getTokenAfter(node.test), node);
-                }
-            },
-            PropertyDefinition: checkNode
-        };
-    }
-};