claude-flow-novice 2.2.0 → 2.2.1

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/max-statements-per-line.js

@@ -1,199 +0,0 @@
-/**
- * @fileoverview Specify the maximum number of statements allowed per line.
- * @author Kenneth Williams
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce a maximum number of statements allowed per line",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/max-statements-per-line"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    max: {
-                        type: "integer",
-                        minimum: 1,
-                        default: 1
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-        messages: {
-            exceed: "This line has {{numberOfStatementsOnThisLine}} {{statements}}. Maximum allowed is {{maxStatementsPerLine}}."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode,
-            options = context.options[0] || {},
-            maxStatementsPerLine = typeof options.max !== "undefined" ? options.max : 1;
-
-        let lastStatementLine = 0,
-            numberOfStatementsOnThisLine = 0,
-            firstExtraStatement;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        const SINGLE_CHILD_ALLOWED = /^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/u;
-
-        /**
-         * Reports with the first extra statement, and clears it.
-         * @returns {void}
-         */
-        function reportFirstExtraStatementAndClear() {
-            if (firstExtraStatement) {
-                context.report({
-                    node: firstExtraStatement,
-                    messageId: "exceed",
-                    data: {
-                        numberOfStatementsOnThisLine,
-                        maxStatementsPerLine,
-                        statements: numberOfStatementsOnThisLine === 1 ? "statement" : "statements"
-                    }
-                });
-            }
-            firstExtraStatement = null;
-        }
-
-        /**
-         * Gets the actual last token of a given node.
-         * @param {ASTNode} node A node to get. This is a node except EmptyStatement.
-         * @returns {Token} The actual last token.
-         */
-        function getActualLastToken(node) {
-            return sourceCode.getLastToken(node, astUtils.isNotSemicolonToken);
-        }
-
-        /**
-         * Addresses a given node.
-         * It updates the state of this rule, then reports the node if the node violated this rule.
-         * @param {ASTNode} node A node to check.
-         * @returns {void}
-         */
-        function enterStatement(node) {
-            const line = node.loc.start.line;
-
-            /*
-             * Skip to allow non-block statements if this is direct child of control statements.
-             * `if (a) foo();` is counted as 1.
-             * But `if (a) foo(); else foo();` should be counted as 2.
-             */
-            if (SINGLE_CHILD_ALLOWED.test(node.parent.type) &&
-                node.parent.alternate !== node
-            ) {
-                return;
-            }
-
-            // Update state.
-            if (line === lastStatementLine) {
-                numberOfStatementsOnThisLine += 1;
-            } else {
-                reportFirstExtraStatementAndClear();
-                numberOfStatementsOnThisLine = 1;
-                lastStatementLine = line;
-            }
-
-            // Reports if the node violated this rule.
-            if (numberOfStatementsOnThisLine === maxStatementsPerLine + 1) {
-                firstExtraStatement = firstExtraStatement || node;
-            }
-        }
-
-        /**
-         * Updates the state of this rule with the end line of leaving node to check with the next statement.
-         * @param {ASTNode} node A node to check.
-         * @returns {void}
-         */
-        function leaveStatement(node) {
-            const line = getActualLastToken(node).loc.end.line;
-
-            // Update state.
-            if (line !== lastStatementLine) {
-                reportFirstExtraStatementAndClear();
-                numberOfStatementsOnThisLine = 1;
-                lastStatementLine = line;
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            BreakStatement: enterStatement,
-            ClassDeclaration: enterStatement,
-            ContinueStatement: enterStatement,
-            DebuggerStatement: enterStatement,
-            DoWhileStatement: enterStatement,
-            ExpressionStatement: enterStatement,
-            ForInStatement: enterStatement,
-            ForOfStatement: enterStatement,
-            ForStatement: enterStatement,
-            FunctionDeclaration: enterStatement,
-            IfStatement: enterStatement,
-            ImportDeclaration: enterStatement,
-            LabeledStatement: enterStatement,
-            ReturnStatement: enterStatement,
-            SwitchStatement: enterStatement,
-            ThrowStatement: enterStatement,
-            TryStatement: enterStatement,
-            VariableDeclaration: enterStatement,
-            WhileStatement: enterStatement,
-            WithStatement: enterStatement,
-            ExportNamedDeclaration: enterStatement,
-            ExportDefaultDeclaration: enterStatement,
-            ExportAllDeclaration: enterStatement,
-
-            "BreakStatement:exit": leaveStatement,
-            "ClassDeclaration:exit": leaveStatement,
-            "ContinueStatement:exit": leaveStatement,
-            "DebuggerStatement:exit": leaveStatement,
-            "DoWhileStatement:exit": leaveStatement,
-            "ExpressionStatement:exit": leaveStatement,
-            "ForInStatement:exit": leaveStatement,
-            "ForOfStatement:exit": leaveStatement,
-            "ForStatement:exit": leaveStatement,
-            "FunctionDeclaration:exit": leaveStatement,
-            "IfStatement:exit": leaveStatement,
-            "ImportDeclaration:exit": leaveStatement,
-            "LabeledStatement:exit": leaveStatement,
-            "ReturnStatement:exit": leaveStatement,
-            "SwitchStatement:exit": leaveStatement,
-            "ThrowStatement:exit": leaveStatement,
-            "TryStatement:exit": leaveStatement,
-            "VariableDeclaration:exit": leaveStatement,
-            "WhileStatement:exit": leaveStatement,
-            "WithStatement:exit": leaveStatement,
-            "ExportNamedDeclaration:exit": leaveStatement,
-            "ExportDefaultDeclaration:exit": leaveStatement,
-            "ExportAllDeclaration:exit": leaveStatement,
-            "Program:exit": reportFirstExtraStatementAndClear
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/max-statements.js

@@ -1,184 +0,0 @@
-/**
- * @fileoverview A rule to set the maximum number of statements in a function.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { upperCaseFirst } = require("../shared/string-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce a maximum number of statements allowed in function blocks",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/max-statements"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            maximum: {
-                                type: "integer",
-                                minimum: 0
-                            },
-                            max: {
-                                type: "integer",
-                                minimum: 0
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            },
-            {
-                type: "object",
-                properties: {
-                    ignoreTopLevelFunctions: {
-                        type: "boolean"
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-        messages: {
-            exceed: "{{name}} has too many statements ({{count}}). Maximum allowed is {{max}}."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        const functionStack = [],
-            option = context.options[0],
-            ignoreTopLevelFunctions = context.options[1] && context.options[1].ignoreTopLevelFunctions || false,
-            topLevelFunctions = [];
-        let maxStatements = 10;
-
-        if (
-            typeof option === "object" &&
-            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
-        ) {
-            maxStatements = option.maximum || option.max;
-        } else if (typeof option === "number") {
-            maxStatements = option;
-        }
-
-        /**
-         * Reports a node if it has too many statements
-         * @param {ASTNode} node node to evaluate
-         * @param {int} count Number of statements in node
-         * @param {int} max Maximum number of statements allowed
-         * @returns {void}
-         * @private
-         */
-        function reportIfTooManyStatements(node, count, max) {
-            if (count > max) {
-                const name = upperCaseFirst(astUtils.getFunctionNameWithKind(node));
-
-                context.report({
-                    node,
-                    messageId: "exceed",
-                    data: { name, count, max }
-                });
-            }
-        }
-
-        /**
-         * When parsing a new function, store it in our function stack
-         * @returns {void}
-         * @private
-         */
-        function startFunction() {
-            functionStack.push(0);
-        }
-
-        /**
-         * Evaluate the node at the end of function
-         * @param {ASTNode} node node to evaluate
-         * @returns {void}
-         * @private
-         */
-        function endFunction(node) {
-            const count = functionStack.pop();
-
-            /*
-             * This rule does not apply to class static blocks, but we have to track them so
-             * that statements in them do not count as statements in the enclosing function.
-             */
-            if (node.type === "StaticBlock") {
-                return;
-            }
-
-            if (ignoreTopLevelFunctions && functionStack.length === 0) {
-                topLevelFunctions.push({ node, count });
-            } else {
-                reportIfTooManyStatements(node, count, maxStatements);
-            }
-        }
-
-        /**
-         * Increment the count of the functions
-         * @param {ASTNode} node node to evaluate
-         * @returns {void}
-         * @private
-         */
-        function countStatements(node) {
-            functionStack[functionStack.length - 1] += node.body.length;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            FunctionDeclaration: startFunction,
-            FunctionExpression: startFunction,
-            ArrowFunctionExpression: startFunction,
-            StaticBlock: startFunction,
-
-            BlockStatement: countStatements,
-
-            "FunctionDeclaration:exit": endFunction,
-            "FunctionExpression:exit": endFunction,
-            "ArrowFunctionExpression:exit": endFunction,
-            "StaticBlock:exit": endFunction,
-
-            "Program:exit"() {
-                if (topLevelFunctions.length === 1) {
-                    return;
-                }
-
-                topLevelFunctions.forEach(element => {
-                    const count = element.count;
-                    const node = element.node;
-
-                    reportIfTooManyStatements(node, count, maxStatements);
-                });
-            }
-        };
-
-    }
-};