@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/valid-typeof.js

@@ -1,127 +0,0 @@
-/**
- * @fileoverview Ensures that the results of typeof are compared against a valid string
- * @author Ian Christian Myers
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Enforce comparing `typeof` expressions against valid strings",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/valid-typeof"
-        },
-
-        hasSuggestions: true,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    requireStringLiterals: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-        messages: {
-            invalidValue: "Invalid typeof comparison value.",
-            notString: "Typeof comparisons should be to string literals.",
-            suggestString: 'Use `"{{type}}"` instead of `{{type}}`.'
-        }
-    },
-
-    create(context) {
-
-        const VALID_TYPES = new Set(["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"]),
-            OPERATORS = new Set(["==", "===", "!=", "!=="]);
-        const sourceCode = context.sourceCode;
-        const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;
-
-        let globalScope;
-
-        /**
-         * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
-         * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
-         * @param {ASTNode} node `Identifier` node to check.
-         * @returns {boolean} `true` if the node is a reference to a global variable.
-         */
-        function isReferenceToGlobalVariable(node) {
-            const variable = globalScope.set.get(node.name);
-
-            return variable && variable.defs.length === 0 &&
-                variable.references.some(ref => ref.identifier === node);
-        }
-
-        /**
-         * Determines whether a node is a typeof expression.
-         * @param {ASTNode} node The node
-         * @returns {boolean} `true` if the node is a typeof expression
-         */
-        function isTypeofExpression(node) {
-            return node.type === "UnaryExpression" && node.operator === "typeof";
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-
-            Program(node) {
-                globalScope = sourceCode.getScope(node);
-            },
-
-            UnaryExpression(node) {
-                if (isTypeofExpression(node)) {
-                    const { parent } = node;
-
-                    if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
-                        const sibling = parent.left === node ? parent.right : parent.left;
-
-                        if (sibling.type === "Literal" || astUtils.isStaticTemplateLiteral(sibling)) {
-                            const value = sibling.type === "Literal" ? sibling.value : sibling.quasis[0].value.cooked;
-
-                            if (!VALID_TYPES.has(value)) {
-                                context.report({ node: sibling, messageId: "invalidValue" });
-                            }
-                        } else if (sibling.type === "Identifier" && sibling.name === "undefined" && isReferenceToGlobalVariable(sibling)) {
-                            context.report({
-                                node: sibling,
-                                messageId: requireStringLiterals ? "notString" : "invalidValue",
-                                suggest: [
-                                    {
-                                        messageId: "suggestString",
-                                        data: { type: "undefined" },
-                                        fix(fixer) {
-                                            return fixer.replaceText(sibling, '"undefined"');
-                                        }
-                                    }
-                                ]
-                            });
-                        } else if (requireStringLiterals && !isTypeofExpression(sibling)) {
-                            context.report({ node: sibling, messageId: "notString" });
-                        }
-                    }
-                }
-            }
-
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/vars-on-top.js

@@ -1,157 +0,0 @@
-/**
- * @fileoverview Rule to enforce var declarations are only at the top of a function.
- * @author Danny Fritz
- * @author Gyandeep Singh
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require `var` declarations be placed at the top of their containing scope",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/vars-on-top"
-        },
-
-        schema: [],
-        messages: {
-            top: "All 'var' declarations must be at the top of the function scope."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Has AST suggesting a directive.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node structurally represents a directive
-         */
-        function looksLikeDirective(node) {
-            return node.type === "ExpressionStatement" &&
-                node.expression.type === "Literal" && typeof node.expression.value === "string";
-        }
-
-        /**
-         * Check to see if its a ES6 import declaration
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node represents a import declaration
-         */
-        function looksLikeImport(node) {
-            return node.type === "ImportDeclaration" || node.type === "ImportSpecifier" ||
-                node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier";
-        }
-
-        /**
-         * Checks whether a given node is a variable declaration or not.
-         * @param {ASTNode} node any node
-         * @returns {boolean} `true` if the node is a variable declaration.
-         */
-        function isVariableDeclaration(node) {
-            return (
-                node.type === "VariableDeclaration" ||
-                (
-                    node.type === "ExportNamedDeclaration" &&
-                    node.declaration &&
-                    node.declaration.type === "VariableDeclaration"
-                )
-            );
-        }
-
-        /**
-         * Checks whether this variable is on top of the block body
-         * @param {ASTNode} node The node to check
-         * @param {ASTNode[]} statements collection of ASTNodes for the parent node block
-         * @returns {boolean} True if var is on top otherwise false
-         */
-        function isVarOnTop(node, statements) {
-            const l = statements.length;
-            let i = 0;
-
-            // Skip over directives and imports. Static blocks don't have either.
-            if (node.parent.type !== "StaticBlock") {
-                for (; i < l; ++i) {
-                    if (!looksLikeDirective(statements[i]) && !looksLikeImport(statements[i])) {
-                        break;
-                    }
-                }
-            }
-
-            for (; i < l; ++i) {
-                if (!isVariableDeclaration(statements[i])) {
-                    return false;
-                }
-                if (statements[i] === node) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        /**
-         * Checks whether variable is on top at the global level
-         * @param {ASTNode} node The node to check
-         * @param {ASTNode} parent Parent of the node
-         * @returns {void}
-         */
-        function globalVarCheck(node, parent) {
-            if (!isVarOnTop(node, parent.body)) {
-                context.report({ node, messageId: "top" });
-            }
-        }
-
-        /**
-         * Checks whether variable is on top at functional block scope level
-         * @param {ASTNode} node The node to check
-         * @returns {void}
-         */
-        function blockScopeVarCheck(node) {
-            const { parent } = node;
-
-            if (
-                parent.type === "BlockStatement" &&
-                /Function/u.test(parent.parent.type) &&
-                isVarOnTop(node, parent.body)
-            ) {
-                return;
-            }
-
-            if (
-                parent.type === "StaticBlock" &&
-                isVarOnTop(node, parent.body)
-            ) {
-                return;
-            }
-
-            context.report({ node, messageId: "top" });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            "VariableDeclaration[kind='var']"(node) {
-                if (node.parent.type === "ExportNamedDeclaration") {
-                    globalVarCheck(node.parent, node.parent.parent);
-                } else if (node.parent.type === "Program") {
-                    globalVarCheck(node, node.parent);
-                } else {
-                    blockScopeVarCheck(node);
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/wrap-iife.js

@@ -1,207 +0,0 @@
-/**
- * @fileoverview Rule to flag when IIFE is not wrapped in parens
- * @author Ilya Volodin
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const eslintUtils = require("@eslint-community/eslint-utils");
-
-//----------------------------------------------------------------------
-// Helpers
-//----------------------------------------------------------------------
-
-/**
- * Check if the given node is callee of a `NewExpression` node
- * @param {ASTNode} node node to check
- * @returns {boolean} True if the node is callee of a `NewExpression` node
- * @private
- */
-function isCalleeOfNewExpression(node) {
-    const maybeCallee = node.parent.type === "ChainExpression"
-        ? node.parent
-        : node;
-
-    return (
-        maybeCallee.parent.type === "NewExpression" &&
-        maybeCallee.parent.callee === maybeCallee
-    );
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Require parentheses around immediate `function` invocations",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/wrap-iife"
-        },
-
-        schema: [
-            {
-                enum: ["outside", "inside", "any"]
-            },
-            {
-                type: "object",
-                properties: {
-                    functionPrototypeMethods: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: "code",
-        messages: {
-            wrapInvocation: "Wrap an immediate function invocation in parentheses.",
-            wrapExpression: "Wrap only the function expression in parens.",
-            moveInvocation: "Move the invocation into the parens that contain the function."
-        }
-    },
-
-    create(context) {
-
-        const style = context.options[0] || "outside";
-        const includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
-         * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if it is wrapped in any parens
-         * @private
-         */
-        function isWrappedInAnyParens(node) {
-            return astUtils.isParenthesised(sourceCode, node);
-        }
-
-        /**
-         * Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
-         * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if it is wrapped in grouping parens
-         * @private
-         */
-        function isWrappedInGroupingParens(node) {
-            return eslintUtils.isParenthesized(1, node, sourceCode);
-        }
-
-        /**
-         * Get the function node from an IIFE
-         * @param {ASTNode} node node to evaluate
-         * @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist
-         */
-        function getFunctionNodeFromIIFE(node) {
-            const callee = astUtils.skipChainExpression(node.callee);
-
-            if (callee.type === "FunctionExpression") {
-                return callee;
-            }
-
-            if (includeFunctionPrototypeMethods &&
-                callee.type === "MemberExpression" &&
-                callee.object.type === "FunctionExpression" &&
-                (astUtils.getStaticPropertyName(callee) === "call" || astUtils.getStaticPropertyName(callee) === "apply")
-            ) {
-                return callee.object;
-            }
-
-            return null;
-        }
-
-
-        return {
-            CallExpression(node) {
-                const innerNode = getFunctionNodeFromIIFE(node);
-
-                if (!innerNode) {
-                    return;
-                }
-
-                const isCallExpressionWrapped = isWrappedInAnyParens(node),
-                    isFunctionExpressionWrapped = isWrappedInAnyParens(innerNode);
-
-                if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) {
-                    context.report({
-                        node,
-                        messageId: "wrapInvocation",
-                        fix(fixer) {
-                            const nodeToSurround = style === "inside" ? innerNode : node;
-
-                            return fixer.replaceText(nodeToSurround, `(${sourceCode.getText(nodeToSurround)})`);
-                        }
-                    });
-                } else if (style === "inside" && !isFunctionExpressionWrapped) {
-                    context.report({
-                        node,
-                        messageId: "wrapExpression",
-                        fix(fixer) {
-
-                            // The outer call expression will always be wrapped at this point.
-
-                            if (isWrappedInGroupingParens(node) && !isCalleeOfNewExpression(node)) {
-
-                                /*
-                                 * Parenthesize the function expression and remove unnecessary grouping parens around the call expression.
-                                 * Replace the range between the end of the function expression and the end of the call expression.
-                                 * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
-                                 */
-
-                                const parenAfter = sourceCode.getTokenAfter(node);
-
-                                return fixer.replaceTextRange(
-                                    [innerNode.range[1], parenAfter.range[1]],
-                                    `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`
-                                );
-                            }
-
-                            /*
-                             * Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens.
-                             * These parens cannot be removed, so just parenthesize the function expression.
-                             */
-
-                            return fixer.replaceText(innerNode, `(${sourceCode.getText(innerNode)})`);
-                        }
-                    });
-                } else if (style === "outside" && !isCallExpressionWrapped) {
-                    context.report({
-                        node,
-                        messageId: "moveInvocation",
-                        fix(fixer) {
-
-                            /*
-                             * The inner function expression will always be wrapped at this point.
-                             * It's only necessary to replace the range between the end of the function expression
-                             * and the call expression. For example, in `(function(foo) {})(bar)`, the range `)(bar)`
-                             * should get replaced with `(bar))`.
-                             */
-                            const parenAfter = sourceCode.getTokenAfter(innerNode);
-
-                            return fixer.replaceTextRange(
-                                [parenAfter.range[0], node.range[1]],
-                                `${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`
-                            );
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/wrap-regex.js

@@ -1,61 +0,0 @@
-/**
- * @fileoverview Rule to flag when regex literals are not wrapped in parens
- * @author Matt DuVall <http://www.mattduvall.com>
- * @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: "Require parenthesis around regex literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/wrap-regex"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            requireParens: "Wrap the regexp literal in parens to disambiguate the slash."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-
-            Literal(node) {
-                const token = sourceCode.getFirstToken(node),
-                    nodeType = token.type;
-
-                if (nodeType === "RegularExpression") {
-                    const beforeToken = sourceCode.getTokenBefore(node);
-                    const afterToken = sourceCode.getTokenAfter(node);
-                    const { parent } = node;
-
-                    if (parent.type === "MemberExpression" && parent.object === node &&
-                        !(beforeToken && beforeToken.value === "(" && afterToken && afterToken.value === ")")) {
-                        context.report({
-                            node,
-                            messageId: "requireParens",
-                            fix: fixer => fixer.replaceText(node, `(${sourceCode.getText(node)})`)
-                        });
-                    }
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,130 +0,0 @@
-/**
- * @fileoverview Rule to check the spacing around the * in yield* expressions.
- * @author Bryan Smith
- * @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: "Require or disallow spacing around the `*` in `yield*` expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/yield-star-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        enum: ["before", "after", "both", "neither"]
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            before: { type: "boolean" },
-                            after: { type: "boolean" }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-        messages: {
-            missingBefore: "Missing space before *.",
-            missingAfter: "Missing space after *.",
-            unexpectedBefore: "Unexpected space before *.",
-            unexpectedAfter: "Unexpected space after *."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        const mode = (function(option) {
-            if (!option || typeof option === "string") {
-                return {
-                    before: { before: true, after: false },
-                    after: { before: false, after: true },
-                    both: { before: true, after: true },
-                    neither: { before: false, after: false }
-                }[option || "after"];
-            }
-            return option;
-        }(context.options[0]));
-
-        /**
-         * Checks the spacing between two tokens before or after the star token.
-         * @param {string} side Either "before" or "after".
-         * @param {Token} leftToken `function` keyword token if side is "before", or
-         *     star token if side is "after".
-         * @param {Token} rightToken Star token if side is "before", or identifier
-         *     token if side is "after".
-         * @returns {void}
-         */
-        function checkSpacing(side, leftToken, rightToken) {
-            if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken) !== mode[side]) {
-                const after = leftToken.value === "*";
-                const spaceRequired = mode[side];
-                const node = after ? leftToken : rightToken;
-                let messageId;
-
-                if (spaceRequired) {
-                    messageId = side === "before" ? "missingBefore" : "missingAfter";
-                } else {
-                    messageId = side === "before" ? "unexpectedBefore" : "unexpectedAfter";
-                }
-
-                context.report({
-                    node,
-                    messageId,
-                    fix(fixer) {
-                        if (spaceRequired) {
-                            if (after) {
-                                return fixer.insertTextAfter(node, " ");
-                            }
-                            return fixer.insertTextBefore(node, " ");
-                        }
-                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
-                    }
-                });
-            }
-        }
-
-        /**
-         * Enforces the spacing around the star if node is a yield* expression.
-         * @param {ASTNode} node A yield expression node.
-         * @returns {void}
-         */
-        function checkExpression(node) {
-            if (!node.delegate) {
-                return;
-            }
-
-            const tokens = sourceCode.getFirstTokens(node, 3);
-            const yieldToken = tokens[0];
-            const starToken = tokens[1];
-            const nextToken = tokens[2];
-
-            checkSpacing("before", yieldToken, starToken);
-            checkSpacing("after", starToken, nextToken);
-        }
-
-        return {
-            YieldExpression: checkExpression
-        };
-
-    }
-};