@alexlit/lint-kit 127.0.0 → 127.2.0

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

@@ -1,149 +0,0 @@
-/**
- * @fileoverview Disallow Labeled Statements
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow labeled statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-labels"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowLoop: {
-                        type: "boolean",
-                        default: false
-                    },
-                    allowSwitch: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedLabel: "Unexpected labeled statement.",
-            unexpectedLabelInBreak: "Unexpected label in break statement.",
-            unexpectedLabelInContinue: "Unexpected label in continue statement."
-        }
-    },
-
-    create(context) {
-        const options = context.options[0];
-        const allowLoop = options && options.allowLoop;
-        const allowSwitch = options && options.allowSwitch;
-        let scopeInfo = null;
-
-        /**
-         * Gets the kind of a given node.
-         * @param {ASTNode} node A node to get.
-         * @returns {string} The kind of the node.
-         */
-        function getBodyKind(node) {
-            if (astUtils.isLoop(node)) {
-                return "loop";
-            }
-            if (node.type === "SwitchStatement") {
-                return "switch";
-            }
-            return "other";
-        }
-
-        /**
-         * Checks whether the label of a given kind is allowed or not.
-         * @param {string} kind A kind to check.
-         * @returns {boolean} `true` if the kind is allowed.
-         */
-        function isAllowed(kind) {
-            switch (kind) {
-                case "loop": return allowLoop;
-                case "switch": return allowSwitch;
-                default: return false;
-            }
-        }
-
-        /**
-         * Checks whether a given name is a label of a loop or not.
-         * @param {string} label A name of a label to check.
-         * @returns {boolean} `true` if the name is a label of a loop.
-         */
-        function getKind(label) {
-            let info = scopeInfo;
-
-            while (info) {
-                if (info.label === label) {
-                    return info.kind;
-                }
-                info = info.upper;
-            }
-
-            /* c8 ignore next */
-            return "other";
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            LabeledStatement(node) {
-                scopeInfo = {
-                    label: node.label.name,
-                    kind: getBodyKind(node.body),
-                    upper: scopeInfo
-                };
-            },
-
-            "LabeledStatement:exit"(node) {
-                if (!isAllowed(scopeInfo.kind)) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedLabel"
-                    });
-                }
-
-                scopeInfo = scopeInfo.upper;
-            },
-
-            BreakStatement(node) {
-                if (node.label && !isAllowed(getKind(node.label.name))) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedLabelInBreak"
-                    });
-                }
-            },
-
-            ContinueStatement(node) {
-                if (node.label && !isAllowed(getKind(node.label.name))) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedLabelInContinue"
-                    });
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-lone-blocks.js

@@ -1,136 +0,0 @@
-/**
- * @fileoverview Rule to flag blocks with no reason to exist
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary nested blocks",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-lone-blocks"
-        },
-
-        schema: [],
-
-        messages: {
-            redundantBlock: "Block is redundant.",
-            redundantNestedBlock: "Nested block is redundant."
-        }
-    },
-
-    create(context) {
-
-        // A stack of lone blocks to be checked for block-level bindings
-        const loneBlocks = [];
-        let ruleDef;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports a node as invalid.
-         * @param {ASTNode} node The node to be reported.
-         * @returns {void}
-         */
-        function report(node) {
-            const messageId = node.parent.type === "BlockStatement" || node.parent.type === "StaticBlock"
-                ? "redundantNestedBlock"
-                : "redundantBlock";
-
-            context.report({
-                node,
-                messageId
-            });
-        }
-
-        /**
-         * Checks for any occurrence of a BlockStatement in a place where lists of statements can appear
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} True if the node is a lone block.
-         */
-        function isLoneBlock(node) {
-            return node.parent.type === "BlockStatement" ||
-                node.parent.type === "StaticBlock" ||
-                node.parent.type === "Program" ||
-
-                // Don't report blocks in switch cases if the block is the only statement of the case.
-                node.parent.type === "SwitchCase" && !(node.parent.consequent[0] === node && node.parent.consequent.length === 1);
-        }
-
-        /**
-         * Checks the enclosing block of the current node for block-level bindings,
-         * and "marks it" as valid if any.
-         * @param {ASTNode} node The current node to check.
-         * @returns {void}
-         */
-        function markLoneBlock(node) {
-            if (loneBlocks.length === 0) {
-                return;
-            }
-
-            const block = node.parent;
-
-            if (loneBlocks.at(-1) === block) {
-                loneBlocks.pop();
-            }
-        }
-
-        // Default rule definition: report all lone blocks
-        ruleDef = {
-            BlockStatement(node) {
-                if (isLoneBlock(node)) {
-                    report(node);
-                }
-            }
-        };
-
-        // ES6: report blocks without block-level bindings, or that's only child of another block
-        if (context.languageOptions.ecmaVersion >= 2015) {
-            ruleDef = {
-                BlockStatement(node) {
-                    if (isLoneBlock(node)) {
-                        loneBlocks.push(node);
-                    }
-                },
-                "BlockStatement:exit"(node) {
-                    if (loneBlocks.length > 0 && loneBlocks.at(-1) === node) {
-                        loneBlocks.pop();
-                        report(node);
-                    } else if (
-                        (
-                            node.parent.type === "BlockStatement" ||
-                            node.parent.type === "StaticBlock"
-                        ) &&
-                        node.parent.body.length === 1
-                    ) {
-                        report(node);
-                    }
-                }
-            };
-
-            ruleDef.VariableDeclaration = function(node) {
-                if (node.kind !== "var") {
-                    markLoneBlock(node);
-                }
-            };
-
-            ruleDef.FunctionDeclaration = function(node) {
-                if (sourceCode.getScope(node).isStrict) {
-                    markLoneBlock(node);
-                }
-            };
-
-            ruleDef.ClassDeclaration = markLoneBlock;
-        }
-
-        return ruleDef;
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-lonely-if.js

@@ -1,88 +0,0 @@
-/**
- * @fileoverview Rule to disallow if as the only statement in an else block
- * @author Brandon Mills
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `if` statements as the only statement in `else` blocks",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-lonely-if"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            unexpectedLonelyIf: "Unexpected if as the only statement in an else block."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            IfStatement(node) {
-                const parent = node.parent,
-                    grandparent = parent.parent;
-
-                if (parent && parent.type === "BlockStatement" &&
-                        parent.body.length === 1 && grandparent &&
-                        grandparent.type === "IfStatement" &&
-                        parent === grandparent.alternate) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedLonelyIf",
-                        fix(fixer) {
-                            const openingElseCurly = sourceCode.getFirstToken(parent);
-                            const closingElseCurly = sourceCode.getLastToken(parent);
-                            const elseKeyword = sourceCode.getTokenBefore(openingElseCurly);
-                            const tokenAfterElseBlock = sourceCode.getTokenAfter(closingElseCurly);
-                            const lastIfToken = sourceCode.getLastToken(node.consequent);
-                            const sourceText = sourceCode.getText();
-
-                            if (sourceText.slice(openingElseCurly.range[1],
-                                node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim()) {
-
-                                // Don't fix if there are any non-whitespace characters interfering (e.g. comments)
-                                return null;
-                            }
-
-                            if (
-                                node.consequent.type !== "BlockStatement" && lastIfToken.value !== ";" && tokenAfterElseBlock &&
-                                (
-                                    node.consequent.loc.end.line === tokenAfterElseBlock.loc.start.line ||
-                                    /^[([/+`-]/u.test(tokenAfterElseBlock.value) ||
-                                    lastIfToken.value === "++" ||
-                                    lastIfToken.value === "--"
-                                )
-                            ) {
-
-                                /*
-                                 * If the `if` statement has no block, and is not followed by a semicolon, make sure that fixing
-                                 * the issue would not change semantics due to ASI. If this would happen, don't do a fix.
-                                 */
-                                return null;
-                            }
-
-                            return fixer.replaceTextRange(
-                                [openingElseCurly.range[0], closingElseCurly.range[1]],
-                                (elseKeyword.range[1] === openingElseCurly.range[0] ? " " : "") + sourceCode.getText(node)
-                            );
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-loop-func.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Rule to flag creation of function inside a loop
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-
-/**
- * Identifies is a node is a FunctionExpression which is part of an IIFE
- * @param {ASTNode} node Node to test
- * @returns {boolean} True if it's an IIFE
- */
-function isIIFE(node) {
-    return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
-}
-
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow function declarations that contain unsafe references inside loop statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-loop-func"
-        },
-
-        schema: [],
-
-        messages: {
-            unsafeRefs: "Function declared in a loop contains unsafe references to variable(s) {{ varNames }}."
-        }
-    },
-
-    create(context) {
-
-        const SKIPPED_IIFE_NODES = new Set();
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Gets the containing loop node of a specified node.
-         *
-         * We don't need to check nested functions, so this ignores those, with the exception of IIFE.
-         * `Scope.through` contains references of nested functions.
-         * @param {ASTNode} node An AST node to get.
-         * @returns {ASTNode|null} The containing loop node of the specified node, or
-         *      `null`.
-         */
-        function getContainingLoopNode(node) {
-            for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {
-                const parent = currentNode.parent;
-
-                switch (parent.type) {
-                    case "WhileStatement":
-                    case "DoWhileStatement":
-                        return parent;
-
-                    case "ForStatement":
-
-                        // `init` is outside of the loop.
-                        if (parent.init !== currentNode) {
-                            return parent;
-                        }
-                        break;
-
-                    case "ForInStatement":
-                    case "ForOfStatement":
-
-                        // `right` is outside of the loop.
-                        if (parent.right !== currentNode) {
-                            return parent;
-                        }
-                        break;
-
-                    case "ArrowFunctionExpression":
-                    case "FunctionExpression":
-                    case "FunctionDeclaration":
-
-                        // We need to check nested functions only in case of IIFE.
-                        if (SKIPPED_IIFE_NODES.has(parent)) {
-                            break;
-                        }
-
-                        return null;
-                    default:
-                        break;
-                }
-            }
-
-            return null;
-        }
-
-        /**
-         * Gets the containing loop node of a given node.
-         * If the loop was nested, this returns the most outer loop.
-         * @param {ASTNode} node A node to get. This is a loop node.
-         * @param {ASTNode|null} excludedNode A node that the result node should not
-         *      include.
-         * @returns {ASTNode} The most outer loop node.
-         */
-        function getTopLoopNode(node, excludedNode) {
-            const border = excludedNode ? excludedNode.range[1] : 0;
-            let retv = node;
-            let containingLoopNode = node;
-
-            while (containingLoopNode && containingLoopNode.range[0] >= border) {
-                retv = containingLoopNode;
-                containingLoopNode = getContainingLoopNode(containingLoopNode);
-            }
-
-            return retv;
-        }
-
-        /**
-         * Checks whether a given reference which refers to an upper scope's variable is
-         * safe or not.
-         * @param {ASTNode} loopNode A containing loop node.
-         * @param {eslint-scope.Reference} reference A reference to check.
-         * @returns {boolean} `true` if the reference is safe or not.
-         */
-        function isSafe(loopNode, reference) {
-            const variable = reference.resolved;
-            const definition = variable && variable.defs[0];
-            const declaration = definition && definition.parent;
-            const kind = (declaration && declaration.type === "VariableDeclaration")
-                ? declaration.kind
-                : "";
-
-            // Variables which are declared by `const` is safe.
-            if (kind === "const") {
-                return true;
-            }
-
-            /*
-             * Variables which are declared by `let` in the loop is safe.
-             * It's a different instance from the next loop step's.
-             */
-            if (kind === "let" &&
-                declaration.range[0] > loopNode.range[0] &&
-                declaration.range[1] < loopNode.range[1]
-            ) {
-                return true;
-            }
-
-            /*
-             * WriteReferences which exist after this border are unsafe because those
-             * can modify the variable.
-             */
-            const border = getTopLoopNode(
-                loopNode,
-                (kind === "let") ? declaration : null
-            ).range[0];
-
-            /**
-             * Checks whether a given reference is safe or not.
-             * The reference is every reference of the upper scope's variable we are
-             * looking now.
-             *
-             * It's safe if the reference matches one of the following condition.
-             * - is readonly.
-             * - doesn't exist inside a local function and after the border.
-             * @param {eslint-scope.Reference} upperRef A reference to check.
-             * @returns {boolean} `true` if the reference is safe.
-             */
-            function isSafeReference(upperRef) {
-                const id = upperRef.identifier;
-
-                return (
-                    !upperRef.isWrite() ||
-                    variable.scope.variableScope === upperRef.from.variableScope &&
-                    id.range[0] < border
-                );
-            }
-
-            return Boolean(variable) && variable.references.every(isSafeReference);
-        }
-
-        /**
-         * Reports functions which match the following condition:
-         *
-         * - has a loop node in ancestors.
-         * - has any references which refers to an unsafe variable.
-         * @param {ASTNode} node The AST node to check.
-         * @returns {void}
-         */
-        function checkForLoops(node) {
-            const loopNode = getContainingLoopNode(node);
-
-            if (!loopNode) {
-                return;
-            }
-
-            const references = sourceCode.getScope(node).through;
-
-            // Check if the function is not asynchronous or a generator function
-            if (!(node.async || node.generator)) {
-                if (isIIFE(node)) {
-
-                    const isFunctionExpression = node.type === "FunctionExpression";
-
-                    // Check if the function is referenced elsewhere in the code
-                    const isFunctionReferenced = isFunctionExpression && node.id ? references.some(r => r.identifier.name === node.id.name) : false;
-
-                    if (!isFunctionReferenced) {
-                        SKIPPED_IIFE_NODES.add(node);
-                        return;
-                    }
-                }
-            }
-
-            const unsafeRefs = references.filter(r => r.resolved && !isSafe(loopNode, r)).map(r => r.identifier.name);
-
-            if (unsafeRefs.length > 0) {
-                context.report({
-                    node,
-                    messageId: "unsafeRefs",
-                    data: { varNames: `'${unsafeRefs.join("', '")}'` }
-                });
-            }
-        }
-
-        return {
-            ArrowFunctionExpression: checkForLoops,
-            FunctionExpression: checkForLoops,
-            FunctionDeclaration: checkForLoops
-        };
-    }
-};