claude-flow-novice 2.2.0 → 2.2.1

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

@@ -1,486 +0,0 @@
-/**
- * @fileoverview Rule to flag statements without curly braces
- * @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: "Enforce consistent brace style for all control statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/curly"
-        },
-
-        schema: {
-            anyOf: [
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["all"]
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 1
-                },
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["multi", "multi-line", "multi-or-nest"]
-                        },
-                        {
-                            enum: ["consistent"]
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 2
-                }
-            ]
-        },
-
-        fixable: "code",
-
-        messages: {
-            missingCurlyAfter: "Expected { after '{{name}}'.",
-            missingCurlyAfterCondition: "Expected { after '{{name}}' condition.",
-            unexpectedCurlyAfter: "Unnecessary { after '{{name}}'.",
-            unexpectedCurlyAfterCondition: "Unnecessary { after '{{name}}' condition."
-        }
-    },
-
-    create(context) {
-
-        const multiOnly = (context.options[0] === "multi");
-        const multiLine = (context.options[0] === "multi-line");
-        const multiOrNest = (context.options[0] === "multi-or-nest");
-        const consistent = (context.options[1] === "consistent");
-
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Determines if a given node is a one-liner that's on the same line as it's preceding code.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node is a one-liner that's on the same line as it's preceding code.
-         * @private
-         */
-        function isCollapsedOneLiner(node) {
-            const before = sourceCode.getTokenBefore(node);
-            const last = sourceCode.getLastToken(node);
-            const lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
-
-            return before.loc.start.line === lastExcludingSemicolon.loc.end.line;
-        }
-
-        /**
-         * Determines if a given node is a one-liner.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node is a one-liner.
-         * @private
-         */
-        function isOneLiner(node) {
-            if (node.type === "EmptyStatement") {
-                return true;
-            }
-
-            const first = sourceCode.getFirstToken(node);
-            const last = sourceCode.getLastToken(node);
-            const lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
-
-            return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
-        }
-
-        /**
-         * Determines if the given node is a lexical declaration (let, const, function, or class)
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} True if the node is a lexical declaration
-         * @private
-         */
-        function isLexicalDeclaration(node) {
-            if (node.type === "VariableDeclaration") {
-                return node.kind === "const" || node.kind === "let";
-            }
-
-            return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
-        }
-
-        /**
-         * Checks if the given token is an `else` token or not.
-         * @param {Token} token The token to check.
-         * @returns {boolean} `true` if the token is an `else` token.
-         */
-        function isElseKeywordToken(token) {
-            return token.value === "else" && token.type === "Keyword";
-        }
-
-        /**
-         * Determines whether the given node has an `else` keyword token as the first token after.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} `true` if the node is followed by an `else` keyword token.
-         */
-        function isFollowedByElseKeyword(node) {
-            const nextToken = sourceCode.getTokenAfter(node);
-
-            return Boolean(nextToken) && isElseKeywordToken(nextToken);
-        }
-
-        /**
-         * Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.
-         * @param {Token} closingBracket The } token
-         * @returns {boolean} `true` if a semicolon needs to be inserted after the last statement in the block.
-         */
-        function needsSemicolon(closingBracket) {
-            const tokenBefore = sourceCode.getTokenBefore(closingBracket);
-            const tokenAfter = sourceCode.getTokenAfter(closingBracket);
-            const lastBlockNode = sourceCode.getNodeByRangeIndex(tokenBefore.range[0]);
-
-            if (astUtils.isSemicolonToken(tokenBefore)) {
-
-                // If the last statement already has a semicolon, don't add another one.
-                return false;
-            }
-
-            if (!tokenAfter) {
-
-                // If there are no statements after this block, there is no need to add a semicolon.
-                return false;
-            }
-
-            if (lastBlockNode.type === "BlockStatement" && lastBlockNode.parent.type !== "FunctionExpression" && lastBlockNode.parent.type !== "ArrowFunctionExpression") {
-
-                /*
-                 * If the last node surrounded by curly brackets is a BlockStatement (other than a FunctionExpression or an ArrowFunctionExpression),
-                 * don't insert a semicolon. Otherwise, the semicolon would be parsed as a separate statement, which would cause
-                 * a SyntaxError if it was followed by `else`.
-                 */
-                return false;
-            }
-
-            if (tokenBefore.loc.end.line === tokenAfter.loc.start.line) {
-
-                // If the next token is on the same line, insert a semicolon.
-                return true;
-            }
-
-            if (/^[([/`+-]/u.test(tokenAfter.value)) {
-
-                // If the next token starts with a character that would disrupt ASI, insert a semicolon.
-                return true;
-            }
-
-            if (tokenBefore.type === "Punctuator" && (tokenBefore.value === "++" || tokenBefore.value === "--")) {
-
-                // If the last token is ++ or --, insert a semicolon to avoid disrupting ASI.
-                return true;
-            }
-
-            // Otherwise, do not insert a semicolon.
-            return false;
-        }
-
-        /**
-         * Determines whether the code represented by the given node contains an `if` statement
-         * that would become associated with an `else` keyword directly appended to that code.
-         *
-         * Examples where it returns `true`:
-         *
-         *    if (a)
-         *        foo();
-         *
-         *    if (a) {
-         *        foo();
-         *    }
-         *
-         *    if (a)
-         *        foo();
-         *    else if (b)
-         *        bar();
-         *
-         *    while (a)
-         *        if (b)
-         *            if(c)
-         *                foo();
-         *            else
-         *                bar();
-         *
-         * Examples where it returns `false`:
-         *
-         *    if (a)
-         *        foo();
-         *    else
-         *        bar();
-         *
-         *    while (a) {
-         *        if (b)
-         *            if(c)
-         *                foo();
-         *            else
-         *                bar();
-         *    }
-         *
-         *    while (a)
-         *        if (b) {
-         *            if(c)
-         *                foo();
-         *        }
-         *        else
-         *            bar();
-         * @param {ASTNode} node Node representing the code to check.
-         * @returns {boolean} `true` if an `if` statement within the code would become associated with an `else` appended to that code.
-         */
-        function hasUnsafeIf(node) {
-            switch (node.type) {
-                case "IfStatement":
-                    if (!node.alternate) {
-                        return true;
-                    }
-                    return hasUnsafeIf(node.alternate);
-                case "ForStatement":
-                case "ForInStatement":
-                case "ForOfStatement":
-                case "LabeledStatement":
-                case "WithStatement":
-                case "WhileStatement":
-                    return hasUnsafeIf(node.body);
-                default:
-                    return false;
-            }
-        }
-
-        /**
-         * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code.
-         * The braces, which make the given block body, are necessary in either of the following situations:
-         *
-         * 1. The statement is a lexical declaration.
-         * 2. Without the braces, an `if` within the statement would become associated with an `else` after the closing brace:
-         *
-         *     if (a) {
-         *         if (b)
-         *             foo();
-         *     }
-         *     else
-         *         bar();
-         *
-         *     if (a)
-         *         while (b)
-         *             while (c) {
-         *                 while (d)
-         *                     if (e)
-         *                         while(f)
-         *                             foo();
-         *            }
-         *     else
-         *         bar();
-         * @param {ASTNode} node `BlockStatement` body with exactly one statement directly inside. The statement can have its own nested statements.
-         * @returns {boolean} `true` if the braces are necessary - removing them (replacing the given `BlockStatement` body with its single statement content)
-         * would change the semantics of the code or produce a syntax error.
-         */
-        function areBracesNecessary(node) {
-            const statement = node.body[0];
-
-            return isLexicalDeclaration(statement) ||
-                hasUnsafeIf(statement) && isFollowedByElseKeyword(node);
-        }
-
-        /**
-         * Prepares to check the body of a node to see if it's a block statement.
-         * @param {ASTNode} node The node to report if there's a problem.
-         * @param {ASTNode} body The body node to check for blocks.
-         * @param {string} name The name to report if there's a problem.
-         * @param {{ condition: boolean }} opts Options to pass to the report functions
-         * @returns {Object} a prepared check object, with "actual", "expected", "check" properties.
-         *   "actual" will be `true` or `false` whether the body is already a block statement.
-         *   "expected" will be `true` or `false` if the body should be a block statement or not, or
-         *   `null` if it doesn't matter, depending on the rule options. It can be modified to change
-         *   the final behavior of "check".
-         *   "check" will be a function reporting appropriate problems depending on the other
-         *   properties.
-         */
-        function prepareCheck(node, body, name, opts) {
-            const hasBlock = (body.type === "BlockStatement");
-            let expected = null;
-
-            if (hasBlock && (body.body.length !== 1 || areBracesNecessary(body))) {
-                expected = true;
-            } else if (multiOnly) {
-                expected = false;
-            } else if (multiLine) {
-                if (!isCollapsedOneLiner(body)) {
-                    expected = true;
-                }
-
-                // otherwise, the body is allowed to have braces or not to have braces
-
-            } else if (multiOrNest) {
-                if (hasBlock) {
-                    const statement = body.body[0];
-                    const leadingCommentsInBlock = sourceCode.getCommentsBefore(statement);
-
-                    expected = !isOneLiner(statement) || leadingCommentsInBlock.length > 0;
-                } else {
-                    expected = !isOneLiner(body);
-                }
-            } else {
-
-                // default "all"
-                expected = true;
-            }
-
-            return {
-                actual: hasBlock,
-                expected,
-                check() {
-                    if (this.expected !== null && this.expected !== this.actual) {
-                        if (this.expected) {
-                            context.report({
-                                node,
-                                loc: body.loc,
-                                messageId: opts && opts.condition ? "missingCurlyAfterCondition" : "missingCurlyAfter",
-                                data: {
-                                    name
-                                },
-                                fix: fixer => fixer.replaceText(body, `{${sourceCode.getText(body)}}`)
-                            });
-                        } else {
-                            context.report({
-                                node,
-                                loc: body.loc,
-                                messageId: opts && opts.condition ? "unexpectedCurlyAfterCondition" : "unexpectedCurlyAfter",
-                                data: {
-                                    name
-                                },
-                                fix(fixer) {
-
-                                    /*
-                                     * `do while` expressions sometimes need a space to be inserted after `do`.
-                                     * e.g. `do{foo()} while (bar)` should be corrected to `do foo() while (bar)`
-                                     */
-                                    const needsPrecedingSpace = node.type === "DoWhileStatement" &&
-                                        sourceCode.getTokenBefore(body).range[1] === body.range[0] &&
-                                        !astUtils.canTokensBeAdjacent("do", sourceCode.getFirstToken(body, { skip: 1 }));
-
-                                    const openingBracket = sourceCode.getFirstToken(body);
-                                    const closingBracket = sourceCode.getLastToken(body);
-                                    const lastTokenInBlock = sourceCode.getTokenBefore(closingBracket);
-
-                                    if (needsSemicolon(closingBracket)) {
-
-                                        /*
-                                         * If removing braces would cause a SyntaxError due to multiple statements on the same line (or
-                                         * change the semantics of the code due to ASI), don't perform a fix.
-                                         */
-                                        return null;
-                                    }
-
-                                    const resultingBodyText = sourceCode.getText().slice(openingBracket.range[1], lastTokenInBlock.range[0]) +
-                                        sourceCode.getText(lastTokenInBlock) +
-                                        sourceCode.getText().slice(lastTokenInBlock.range[1], closingBracket.range[0]);
-
-                                    return fixer.replaceText(body, (needsPrecedingSpace ? " " : "") + resultingBodyText);
-                                }
-                            });
-                        }
-                    }
-                }
-            };
-        }
-
-        /**
-         * Prepares to check the bodies of a "if", "else if" and "else" chain.
-         * @param {ASTNode} node The first IfStatement node of the chain.
-         * @returns {Object[]} prepared checks for each body of the chain. See `prepareCheck` for more
-         *   information.
-         */
-        function prepareIfChecks(node) {
-            const preparedChecks = [];
-
-            for (let currentNode = node; currentNode; currentNode = currentNode.alternate) {
-                preparedChecks.push(prepareCheck(currentNode, currentNode.consequent, "if", { condition: true }));
-                if (currentNode.alternate && currentNode.alternate.type !== "IfStatement") {
-                    preparedChecks.push(prepareCheck(currentNode, currentNode.alternate, "else"));
-                    break;
-                }
-            }
-
-            if (consistent) {
-
-                /*
-                 * If any node should have or already have braces, make sure they
-                 * all have braces.
-                 * If all nodes shouldn't have braces, make sure they don't.
-                 */
-                const expected = preparedChecks.some(preparedCheck => {
-                    if (preparedCheck.expected !== null) {
-                        return preparedCheck.expected;
-                    }
-                    return preparedCheck.actual;
-                });
-
-                preparedChecks.forEach(preparedCheck => {
-                    preparedCheck.expected = expected;
-                });
-            }
-
-            return preparedChecks;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            IfStatement(node) {
-                const parent = node.parent;
-                const isElseIf = parent.type === "IfStatement" && parent.alternate === node;
-
-                if (!isElseIf) {
-
-                    // This is a top `if`, check the whole `if-else-if` chain
-                    prepareIfChecks(node).forEach(preparedCheck => {
-                        preparedCheck.check();
-                    });
-                }
-
-                // Skip `else if`, it's already checked (when the top `if` was visited)
-            },
-
-            WhileStatement(node) {
-                prepareCheck(node, node.body, "while", { condition: true }).check();
-            },
-
-            DoWhileStatement(node) {
-                prepareCheck(node, node.body, "do").check();
-            },
-
-            ForStatement(node) {
-                prepareCheck(node, node.body, "for", { condition: true }).check();
-            },
-
-            ForInStatement(node) {
-                prepareCheck(node, node.body, "for-in").check();
-            },
-
-            ForOfStatement(node) {
-                prepareCheck(node, node.body, "for-of").check();
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/default-case-last.js

@@ -1,44 +0,0 @@
-/**
- * @fileoverview Rule to enforce default clauses in switch statements to be last
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce default clauses in switch statements to be last",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/default-case-last"
-        },
-
-        schema: [],
-
-        messages: {
-            notLast: "Default clause should be the last clause."
-        }
-    },
-
-    create(context) {
-        return {
-            SwitchStatement(node) {
-                const cases = node.cases,
-                    indexOfDefault = cases.findIndex(c => c.test === null);
-
-                if (indexOfDefault !== -1 && indexOfDefault !== cases.length - 1) {
-                    const defaultClause = cases[indexOfDefault];
-
-                    context.report({ node: defaultClause, messageId: "notLast" });
-                }
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/default-case.js

@@ -1,97 +0,0 @@
-/**
- * @fileoverview require default case in switch statements
- * @author Aliaksei Shytkin
- */
-"use strict";
-
-const DEFAULT_COMMENT_PATTERN = /^no default$/iu;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require `default` cases in `switch` statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/default-case"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                commentPattern: {
-                    type: "string"
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            missingDefaultCase: "Expected a default case."
-        }
-    },
-
-    create(context) {
-        const options = context.options[0] || {};
-        const commentPattern = options.commentPattern
-            ? new RegExp(options.commentPattern, "u")
-            : DEFAULT_COMMENT_PATTERN;
-
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Shortcut to get last element of array
-         * @param {*[]} collection Array
-         * @returns {any} Last element
-         */
-        function last(collection) {
-            return collection[collection.length - 1];
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-
-            SwitchStatement(node) {
-
-                if (!node.cases.length) {
-
-                    /*
-                     * skip check of empty switch because there is no easy way
-                     * to extract comments inside it now
-                     */
-                    return;
-                }
-
-                const hasDefault = node.cases.some(v => v.test === null);
-
-                if (!hasDefault) {
-
-                    let comment;
-
-                    const lastCase = last(node.cases);
-                    const comments = sourceCode.getCommentsAfter(lastCase);
-
-                    if (comments.length) {
-                        comment = last(comments);
-                    }
-
-                    if (!comment || !commentPattern.test(comment.value.trim())) {
-                        context.report({ node, messageId: "missingDefaultCase" });
-                    }
-                }
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/default-param-last.js

@@ -1,62 +0,0 @@
-/**
- * @fileoverview enforce default parameters to be last
- * @author Chiawen Chen
- */
-
-"use strict";
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce default parameters to be last",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/default-param-last"
-        },
-
-        schema: [],
-
-        messages: {
-            shouldBeLast: "Default parameters should be last."
-        }
-    },
-
-    create(context) {
-
-        /**
-         * Handler for function contexts.
-         * @param {ASTNode} node function node
-         * @returns {void}
-         */
-        function handleFunction(node) {
-            let hasSeenPlainParam = false;
-
-            for (let i = node.params.length - 1; i >= 0; i -= 1) {
-                const param = node.params[i];
-
-                if (
-                    param.type !== "AssignmentPattern" &&
-                    param.type !== "RestElement"
-                ) {
-                    hasSeenPlainParam = true;
-                    continue;
-                }
-
-                if (hasSeenPlainParam && param.type === "AssignmentPattern") {
-                    context.report({
-                        node: param,
-                        messageId: "shouldBeLast"
-                    });
-                }
-            }
-        }
-
-        return {
-            FunctionDeclaration: handleFunction,
-            FunctionExpression: handleFunction,
-            ArrowFunctionExpression: handleFunction
-        };
-    }
-};