claude-flow-novice 2.2.0 → 2.2.1

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/arrow-parens.js

@@ -1,186 +0,0 @@
-/**
- * @fileoverview Rule to require parens in arrow function arguments.
- * @author Jxck
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines if the given arrow function has block body.
- * @param {ASTNode} node `ArrowFunctionExpression` node.
- * @returns {boolean} `true` if the function has block body.
- */
-function hasBlockBody(node) {
-    return node.body.type === "BlockStatement";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Require parentheses around arrow function arguments",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/arrow-parens"
-        },
-
-        fixable: "code",
-
-        schema: [
-            {
-                enum: ["always", "as-needed"]
-            },
-            {
-                type: "object",
-                properties: {
-                    requireForBlockBody: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedParens: "Unexpected parentheses around single function argument.",
-            expectedParens: "Expected parentheses around arrow function argument.",
-
-            unexpectedParensInline: "Unexpected parentheses around single function argument having a body with no curly braces.",
-            expectedParensBlock: "Expected parentheses around arrow function argument having a body with curly braces."
-        }
-    },
-
-    create(context) {
-        const asNeeded = context.options[0] === "as-needed";
-        const requireForBlockBody = asNeeded && context.options[1] && context.options[1].requireForBlockBody === true;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Finds opening paren of parameters for the given arrow function, if it exists.
-         * It is assumed that the given arrow function has exactly one parameter.
-         * @param {ASTNode} node `ArrowFunctionExpression` node.
-         * @returns {Token|null} the opening paren, or `null` if the given arrow function doesn't have parens of parameters.
-         */
-        function findOpeningParenOfParams(node) {
-            const tokenBeforeParams = sourceCode.getTokenBefore(node.params[0]);
-
-            if (
-                tokenBeforeParams &&
-                astUtils.isOpeningParenToken(tokenBeforeParams) &&
-                node.range[0] <= tokenBeforeParams.range[0]
-            ) {
-                return tokenBeforeParams;
-            }
-
-            return null;
-        }
-
-        /**
-         * Finds closing paren of parameters for the given arrow function.
-         * It is assumed that the given arrow function has parens of parameters and that it has exactly one parameter.
-         * @param {ASTNode} node `ArrowFunctionExpression` node.
-         * @returns {Token} the closing paren of parameters.
-         */
-        function getClosingParenOfParams(node) {
-            return sourceCode.getTokenAfter(node.params[0], astUtils.isClosingParenToken);
-        }
-
-        /**
-         * Determines whether the given arrow function has comments inside parens of parameters.
-         * It is assumed that the given arrow function has parens of parameters.
-         * @param {ASTNode} node `ArrowFunctionExpression` node.
-         * @param {Token} openingParen Opening paren of parameters.
-         * @returns {boolean} `true` if the function has at least one comment inside of parens of parameters.
-         */
-        function hasCommentsInParensOfParams(node, openingParen) {
-            return sourceCode.commentsExistBetween(openingParen, getClosingParenOfParams(node));
-        }
-
-        /**
-         * Determines whether the given arrow function has unexpected tokens before opening paren of parameters,
-         * in which case it will be assumed that the existing parens of parameters are necessary.
-         * Only tokens within the range of the arrow function (tokens that are part of the arrow function) are taken into account.
-         * Example: <T>(a) => b
-         * @param {ASTNode} node `ArrowFunctionExpression` node.
-         * @param {Token} openingParen Opening paren of parameters.
-         * @returns {boolean} `true` if the function has at least one unexpected token.
-         */
-        function hasUnexpectedTokensBeforeOpeningParen(node, openingParen) {
-            const expectedCount = node.async ? 1 : 0;
-
-            return sourceCode.getFirstToken(node, { skip: expectedCount }) !== openingParen;
-        }
-
-        return {
-            "ArrowFunctionExpression[params.length=1]"(node) {
-                const shouldHaveParens = !asNeeded || requireForBlockBody && hasBlockBody(node);
-                const openingParen = findOpeningParenOfParams(node);
-                const hasParens = openingParen !== null;
-                const [param] = node.params;
-
-                if (shouldHaveParens && !hasParens) {
-                    context.report({
-                        node,
-                        messageId: requireForBlockBody ? "expectedParensBlock" : "expectedParens",
-                        loc: param.loc,
-                        *fix(fixer) {
-                            yield fixer.insertTextBefore(param, "(");
-                            yield fixer.insertTextAfter(param, ")");
-                        }
-                    });
-                }
-
-                if (
-                    !shouldHaveParens &&
-                    hasParens &&
-                    param.type === "Identifier" &&
-                    !param.typeAnnotation &&
-                    !node.returnType &&
-                    !hasCommentsInParensOfParams(node, openingParen) &&
-                    !hasUnexpectedTokensBeforeOpeningParen(node, openingParen)
-                ) {
-                    context.report({
-                        node,
-                        messageId: requireForBlockBody ? "unexpectedParensInline" : "unexpectedParens",
-                        loc: param.loc,
-                        *fix(fixer) {
-                            const tokenBeforeOpeningParen = sourceCode.getTokenBefore(openingParen);
-                            const closingParen = getClosingParenOfParams(node);
-
-                            if (
-                                tokenBeforeOpeningParen &&
-                                tokenBeforeOpeningParen.range[1] === openingParen.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBeforeOpeningParen, sourceCode.getFirstToken(param))
-                            ) {
-                                yield fixer.insertTextBefore(openingParen, " ");
-                            }
-
-                            // remove parens, whitespace inside parens, and possible trailing comma
-                            yield fixer.removeRange([openingParen.range[0], param.range[0]]);
-                            yield fixer.removeRange([param.range[1], closingParen.range[1]]);
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/arrow-spacing.js

@@ -1,164 +0,0 @@
-/**
- * @fileoverview Rule to define spacing before/after arrow function's arrow.
- * @author Jxck
- * @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 consistent spacing before and after the arrow in arrow functions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/arrow-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    before: {
-                        type: "boolean",
-                        default: true
-                    },
-                    after: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            expectedBefore: "Missing space before =>.",
-            unexpectedBefore: "Unexpected space before =>.",
-
-            expectedAfter: "Missing space after =>.",
-            unexpectedAfter: "Unexpected space after =>."
-        }
-    },
-
-    create(context) {
-
-        // merge rules with default
-        const rule = Object.assign({}, context.options[0]);
-
-        rule.before = rule.before !== false;
-        rule.after = rule.after !== false;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Get tokens of arrow(`=>`) and before/after arrow.
-         * @param {ASTNode} node The arrow function node.
-         * @returns {Object} Tokens of arrow and before/after arrow.
-         */
-        function getTokens(node) {
-            const arrow = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
-
-            return {
-                before: sourceCode.getTokenBefore(arrow),
-                arrow,
-                after: sourceCode.getTokenAfter(arrow)
-            };
-        }
-
-        /**
-         * Count spaces before/after arrow(`=>`) token.
-         * @param {Object} tokens Tokens before/after arrow.
-         * @returns {Object} count of space before/after arrow.
-         */
-        function countSpaces(tokens) {
-            const before = tokens.arrow.range[0] - tokens.before.range[1];
-            const after = tokens.after.range[0] - tokens.arrow.range[1];
-
-            return { before, after };
-        }
-
-        /**
-         * Determines whether space(s) before after arrow(`=>`) is satisfy rule.
-         * if before/after value is `true`, there should be space(s).
-         * if before/after value is `false`, there should be no space.
-         * @param {ASTNode} node The arrow function node.
-         * @returns {void}
-         */
-        function spaces(node) {
-            const tokens = getTokens(node);
-            const countSpace = countSpaces(tokens);
-
-            if (rule.before) {
-
-                // should be space(s) before arrow
-                if (countSpace.before === 0) {
-                    context.report({
-                        node: tokens.before,
-                        messageId: "expectedBefore",
-                        fix(fixer) {
-                            return fixer.insertTextBefore(tokens.arrow, " ");
-                        }
-                    });
-                }
-            } else {
-
-                // should be no space before arrow
-                if (countSpace.before > 0) {
-                    context.report({
-                        node: tokens.before,
-                        messageId: "unexpectedBefore",
-                        fix(fixer) {
-                            return fixer.removeRange([tokens.before.range[1], tokens.arrow.range[0]]);
-                        }
-                    });
-                }
-            }
-
-            if (rule.after) {
-
-                // should be space(s) after arrow
-                if (countSpace.after === 0) {
-                    context.report({
-                        node: tokens.after,
-                        messageId: "expectedAfter",
-                        fix(fixer) {
-                            return fixer.insertTextAfter(tokens.arrow, " ");
-                        }
-                    });
-                }
-            } else {
-
-                // should be no space after arrow
-                if (countSpace.after > 0) {
-                    context.report({
-                        node: tokens.after,
-                        messageId: "unexpectedAfter",
-                        fix(fixer) {
-                            return fixer.removeRange([tokens.arrow.range[1], tokens.after.range[0]]);
-                        }
-                    });
-                }
-            }
-        }
-
-        return {
-            ArrowFunctionExpression: spaces
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/block-scoped-var.js

@@ -1,135 +0,0 @@
-/**
- * @fileoverview Rule to check for "block scoped" variables by binding context
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce the use of variables within the scope they are defined",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/block-scoped-var"
-        },
-
-        schema: [],
-
-        messages: {
-            outOfScope: "'{{name}}' declared on line {{definitionLine}} column {{definitionColumn}} is used outside of binding context."
-        }
-    },
-
-    create(context) {
-        let stack = [];
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Makes a block scope.
-         * @param {ASTNode} node A node of a scope.
-         * @returns {void}
-         */
-        function enterScope(node) {
-            stack.push(node.range);
-        }
-
-        /**
-         * Pops the last block scope.
-         * @returns {void}
-         */
-        function exitScope() {
-            stack.pop();
-        }
-
-        /**
-         * Reports a given reference.
-         * @param {eslint-scope.Reference} reference A reference to report.
-         * @param {eslint-scope.Definition} definition A definition for which to report reference.
-         * @returns {void}
-         */
-        function report(reference, definition) {
-            const identifier = reference.identifier;
-            const definitionPosition = definition.name.loc.start;
-
-            context.report({
-                node: identifier,
-                messageId: "outOfScope",
-                data: {
-                    name: identifier.name,
-                    definitionLine: definitionPosition.line,
-                    definitionColumn: definitionPosition.column + 1
-                }
-            });
-        }
-
-        /**
-         * Finds and reports references which are outside of valid scopes.
-         * @param {ASTNode} node A node to get variables.
-         * @returns {void}
-         */
-        function checkForVariables(node) {
-            if (node.kind !== "var") {
-                return;
-            }
-
-            // Defines a predicate to check whether or not a given reference is outside of valid scope.
-            const scopeRange = stack[stack.length - 1];
-
-            /**
-             * Check if a reference is out of scope
-             * @param {ASTNode} reference node to examine
-             * @returns {boolean} True is its outside the scope
-             * @private
-             */
-            function isOutsideOfScope(reference) {
-                const idRange = reference.identifier.range;
-
-                return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1];
-            }
-
-            // Gets declared variables, and checks its references.
-            const variables = sourceCode.getDeclaredVariables(node);
-
-            for (let i = 0; i < variables.length; ++i) {
-
-                // Reports.
-                variables[i]
-                    .references
-                    .filter(isOutsideOfScope)
-                    .forEach(ref => report(ref, variables[i].defs.find(def => def.parent === node)));
-            }
-        }
-
-        return {
-            Program(node) {
-                stack = [node.range];
-            },
-
-            // Manages scopes.
-            BlockStatement: enterScope,
-            "BlockStatement:exit": exitScope,
-            ForStatement: enterScope,
-            "ForStatement:exit": exitScope,
-            ForInStatement: enterScope,
-            "ForInStatement:exit": exitScope,
-            ForOfStatement: enterScope,
-            "ForOfStatement:exit": exitScope,
-            SwitchStatement: enterScope,
-            "SwitchStatement:exit": exitScope,
-            CatchClause: enterScope,
-            "CatchClause:exit": exitScope,
-            StaticBlock: enterScope,
-            "StaticBlock:exit": exitScope,
-
-            // Finds and reports references which are outside of valid scope.
-            VariableDeclaration: checkForVariables
-        };
-
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/block-spacing.js

@@ -1,174 +0,0 @@
-/**
- * @fileoverview A rule to disallow or enforce spaces inside of single line blocks.
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const util = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow or enforce spaces inside of blocks after opening block and before closing block",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/block-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            { enum: ["always", "never"] }
-        ],
-
-        messages: {
-            missing: "Requires a space {{location}} '{{token}}'.",
-            extra: "Unexpected space(s) {{location}} '{{token}}'."
-        }
-    },
-
-    create(context) {
-        const always = (context.options[0] !== "never"),
-            messageId = always ? "missing" : "extra",
-            sourceCode = context.sourceCode;
-
-        /**
-         * Gets the open brace token from a given node.
-         * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to get.
-         * @returns {Token} The token of the open brace.
-         */
-        function getOpenBrace(node) {
-            if (node.type === "SwitchStatement") {
-                if (node.cases.length > 0) {
-                    return sourceCode.getTokenBefore(node.cases[0]);
-                }
-                return sourceCode.getLastToken(node, 1);
-            }
-
-            if (node.type === "StaticBlock") {
-                return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
-            }
-
-            // "BlockStatement"
-            return sourceCode.getFirstToken(node);
-        }
-
-        /**
-         * Checks whether or not:
-         *   - given tokens are on same line.
-         *   - there is/isn't a space between given tokens.
-         * @param {Token} left A token to check.
-         * @param {Token} right The token which is next to `left`.
-         * @returns {boolean}
-         *    When the option is `"always"`, `true` if there are one or more spaces between given tokens.
-         *    When the option is `"never"`, `true` if there are not any spaces between given tokens.
-         *    If given tokens are not on same line, it's always `true`.
-         */
-        function isValid(left, right) {
-            return (
-                !util.isTokenOnSameLine(left, right) ||
-                sourceCode.isSpaceBetweenTokens(left, right) === always
-            );
-        }
-
-        /**
-         * Checks and reports invalid spacing style inside braces.
-         * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to check.
-         * @returns {void}
-         */
-        function checkSpacingInsideBraces(node) {
-
-            // Gets braces and the first/last token of content.
-            const openBrace = getOpenBrace(node);
-            const closeBrace = sourceCode.getLastToken(node);
-            const firstToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });
-            const lastToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
-
-            // Skip if the node is invalid or empty.
-            if (openBrace.type !== "Punctuator" ||
-                openBrace.value !== "{" ||
-                closeBrace.type !== "Punctuator" ||
-                closeBrace.value !== "}" ||
-                firstToken === closeBrace
-            ) {
-                return;
-            }
-
-            // Skip line comments for option never
-            if (!always && firstToken.type === "Line") {
-                return;
-            }
-
-            // Check.
-            if (!isValid(openBrace, firstToken)) {
-                let loc = openBrace.loc;
-
-                if (messageId === "extra") {
-                    loc = {
-                        start: openBrace.loc.end,
-                        end: firstToken.loc.start
-                    };
-                }
-
-                context.report({
-                    node,
-                    loc,
-                    messageId,
-                    data: {
-                        location: "after",
-                        token: openBrace.value
-                    },
-                    fix(fixer) {
-                        if (always) {
-                            return fixer.insertTextBefore(firstToken, " ");
-                        }
-
-                        return fixer.removeRange([openBrace.range[1], firstToken.range[0]]);
-                    }
-                });
-            }
-            if (!isValid(lastToken, closeBrace)) {
-                let loc = closeBrace.loc;
-
-                if (messageId === "extra") {
-                    loc = {
-                        start: lastToken.loc.end,
-                        end: closeBrace.loc.start
-                    };
-                }
-                context.report({
-                    node,
-                    loc,
-                    messageId,
-                    data: {
-                        location: "before",
-                        token: closeBrace.value
-                    },
-                    fix(fixer) {
-                        if (always) {
-                            return fixer.insertTextAfter(lastToken, " ");
-                        }
-
-                        return fixer.removeRange([lastToken.range[1], closeBrace.range[0]]);
-                    }
-                });
-            }
-        }
-
-        return {
-            BlockStatement: checkSpacingInsideBraces,
-            StaticBlock: checkSpacingInsideBraces,
-            SwitchStatement: checkSpacingInsideBraces
-        };
-    }
-};