claude-flow-novice 2.2.0 → 2.2.1

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

@@ -1,192 +0,0 @@
-/**
- * @fileoverview Comma spacing - validates spacing before and after comma
- * @author Vignesh Anand aka vegetableman.
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-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 commas",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/comma-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    before: {
-                        type: "boolean",
-                        default: false
-                    },
-                    after: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            missing: "A space is required {{loc}} ','.",
-            unexpected: "There should be no space {{loc}} ','."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-        const tokensAndComments = sourceCode.tokensAndComments;
-
-        const options = {
-            before: context.options[0] ? context.options[0].before : false,
-            after: context.options[0] ? context.options[0].after : true
-        };
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        // list of comma tokens to ignore for the check of leading whitespace
-        const commaTokensToIgnore = [];
-
-        /**
-         * Reports a spacing error with an appropriate message.
-         * @param {ASTNode} node The binary expression node to report.
-         * @param {string} loc Is the error "before" or "after" the comma?
-         * @param {ASTNode} otherNode The node at the left or right of `node`
-         * @returns {void}
-         * @private
-         */
-        function report(node, loc, otherNode) {
-            context.report({
-                node,
-                fix(fixer) {
-                    if (options[loc]) {
-                        if (loc === "before") {
-                            return fixer.insertTextBefore(node, " ");
-                        }
-                        return fixer.insertTextAfter(node, " ");
-
-                    }
-                    let start, end;
-                    const newText = "";
-
-                    if (loc === "before") {
-                        start = otherNode.range[1];
-                        end = node.range[0];
-                    } else {
-                        start = node.range[1];
-                        end = otherNode.range[0];
-                    }
-
-                    return fixer.replaceTextRange([start, end], newText);
-
-                },
-                messageId: options[loc] ? "missing" : "unexpected",
-                data: {
-                    loc
-                }
-            });
-        }
-
-        /**
-         * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
-         * @param {ASTNode} node An ArrayExpression or ArrayPattern node.
-         * @returns {void}
-         */
-        function addNullElementsToIgnoreList(node) {
-            let previousToken = sourceCode.getFirstToken(node);
-
-            node.elements.forEach(element => {
-                let token;
-
-                if (element === null) {
-                    token = sourceCode.getTokenAfter(previousToken);
-
-                    if (astUtils.isCommaToken(token)) {
-                        commaTokensToIgnore.push(token);
-                    }
-                } else {
-                    token = sourceCode.getTokenAfter(element);
-                }
-
-                previousToken = token;
-            });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            "Program:exit"() {
-                tokensAndComments.forEach((token, i) => {
-
-                    if (!astUtils.isCommaToken(token)) {
-                        return;
-                    }
-
-                    const previousToken = tokensAndComments[i - 1];
-                    const nextToken = tokensAndComments[i + 1];
-
-                    if (
-                        previousToken &&
-                        !astUtils.isCommaToken(previousToken) && // ignore spacing between two commas
-
-                        /*
-                         * `commaTokensToIgnore` are ending commas of `null` elements (array holes/elisions).
-                         * In addition to spacing between two commas, this can also ignore:
-                         *
-                         *   - Spacing after `[` (controlled by array-bracket-spacing)
-                         *       Example: [ , ]
-                         *                 ^
-                         *   - Spacing after a comment (for backwards compatibility, this was possibly unintentional)
-                         *       Example: [a, /* * / ,]
-                         *                          ^
-                         */
-                        !commaTokensToIgnore.includes(token) &&
-
-                        astUtils.isTokenOnSameLine(previousToken, token) &&
-                        options.before !== sourceCode.isSpaceBetweenTokens(previousToken, token)
-                    ) {
-                        report(token, "before", previousToken);
-                    }
-
-                    if (
-                        nextToken &&
-                        !astUtils.isCommaToken(nextToken) && // ignore spacing between two commas
-                        !astUtils.isClosingParenToken(nextToken) && // controlled by space-in-parens
-                        !astUtils.isClosingBracketToken(nextToken) && // controlled by array-bracket-spacing
-                        !astUtils.isClosingBraceToken(nextToken) && // controlled by object-curly-spacing
-                        !(!options.after && nextToken.type === "Line") && // special case, allow space before line comment
-                        astUtils.isTokenOnSameLine(token, nextToken) &&
-                        options.after !== sourceCode.isSpaceBetweenTokens(token, nextToken)
-                    ) {
-                        report(token, "after", nextToken);
-                    }
-                });
-            },
-            ArrayExpression: addNullElementsToIgnoreList,
-            ArrayPattern: addNullElementsToIgnoreList
-
-        };
-
-    }
-};

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

@@ -1,314 +0,0 @@
-/**
- * @fileoverview Comma style - enforces comma styles of two types: last and first
- * @author Vignesh Anand aka vegetableman
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-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 comma style",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/comma-style"
-        },
-
-        fixable: "code",
-
-        schema: [
-            {
-                enum: ["first", "last"]
-            },
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "object",
-                        additionalProperties: {
-                            type: "boolean"
-                        }
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedLineBeforeAndAfterComma: "Bad line breaking before and after ','.",
-            expectedCommaFirst: "',' should be placed first.",
-            expectedCommaLast: "',' should be placed last."
-        }
-    },
-
-    create(context) {
-        const style = context.options[0] || "last",
-            sourceCode = context.sourceCode;
-        const exceptions = {
-            ArrayPattern: true,
-            ArrowFunctionExpression: true,
-            CallExpression: true,
-            FunctionDeclaration: true,
-            FunctionExpression: true,
-            ImportDeclaration: true,
-            ObjectPattern: true,
-            NewExpression: true
-        };
-
-        if (context.options.length === 2 && Object.prototype.hasOwnProperty.call(context.options[1], "exceptions")) {
-            const keys = Object.keys(context.options[1].exceptions);
-
-            for (let i = 0; i < keys.length; i++) {
-                exceptions[keys[i]] = context.options[1].exceptions[keys[i]];
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Modified text based on the style
-         * @param {string} styleType Style type
-         * @param {string} text Source code text
-         * @returns {string} modified text
-         * @private
-         */
-        function getReplacedText(styleType, text) {
-            switch (styleType) {
-                case "between":
-                    return `,${text.replace(astUtils.LINEBREAK_MATCHER, "")}`;
-
-                case "first":
-                    return `${text},`;
-
-                case "last":
-                    return `,${text}`;
-
-                default:
-                    return "";
-            }
-        }
-
-        /**
-         * Determines the fixer function for a given style.
-         * @param {string} styleType comma style
-         * @param {ASTNode} previousItemToken The token to check.
-         * @param {ASTNode} commaToken The token to check.
-         * @param {ASTNode} currentItemToken The token to check.
-         * @returns {Function} Fixer function
-         * @private
-         */
-        function getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken) {
-            const text =
-                sourceCode.text.slice(previousItemToken.range[1], commaToken.range[0]) +
-                sourceCode.text.slice(commaToken.range[1], currentItemToken.range[0]);
-            const range = [previousItemToken.range[1], currentItemToken.range[0]];
-
-            return function(fixer) {
-                return fixer.replaceTextRange(range, getReplacedText(styleType, text));
-            };
-        }
-
-        /**
-         * Validates the spacing around single items in lists.
-         * @param {Token} previousItemToken The last token from the previous item.
-         * @param {Token} commaToken The token representing the comma.
-         * @param {Token} currentItemToken The first token of the current item.
-         * @param {Token} reportItem The item to use when reporting an error.
-         * @returns {void}
-         * @private
-         */
-        function validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem) {
-
-            // if single line
-            if (astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
-                    astUtils.isTokenOnSameLine(previousItemToken, commaToken)) {
-
-                // do nothing.
-
-            } else if (!astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
-                    !astUtils.isTokenOnSameLine(previousItemToken, commaToken)) {
-
-                const comment = sourceCode.getCommentsAfter(commaToken)[0];
-                const styleType = comment && comment.type === "Block" && astUtils.isTokenOnSameLine(commaToken, comment)
-                    ? style
-                    : "between";
-
-                // lone comma
-                context.report({
-                    node: reportItem,
-                    loc: commaToken.loc,
-                    messageId: "unexpectedLineBeforeAndAfterComma",
-                    fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken)
-                });
-
-            } else if (style === "first" && !astUtils.isTokenOnSameLine(commaToken, currentItemToken)) {
-
-                context.report({
-                    node: reportItem,
-                    loc: commaToken.loc,
-                    messageId: "expectedCommaFirst",
-                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
-                });
-
-            } else if (style === "last" && astUtils.isTokenOnSameLine(commaToken, currentItemToken)) {
-
-                context.report({
-                    node: reportItem,
-                    loc: commaToken.loc,
-                    messageId: "expectedCommaLast",
-                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
-                });
-            }
-        }
-
-        /**
-         * Checks the comma placement with regards to a declaration/property/element
-         * @param {ASTNode} node The binary expression node to check
-         * @param {string} property The property of the node containing child nodes.
-         * @private
-         * @returns {void}
-         */
-        function validateComma(node, property) {
-            const items = node[property],
-                arrayLiteral = (node.type === "ArrayExpression" || node.type === "ArrayPattern");
-
-            if (items.length > 1 || arrayLiteral) {
-
-                // seed as opening [
-                let previousItemToken = sourceCode.getFirstToken(node);
-
-                items.forEach(item => {
-                    const commaToken = item ? sourceCode.getTokenBefore(item) : previousItemToken,
-                        currentItemToken = item ? sourceCode.getFirstToken(item) : sourceCode.getTokenAfter(commaToken),
-                        reportItem = item || currentItemToken;
-
-                    /*
-                     * This works by comparing three token locations:
-                     * - previousItemToken is the last token of the previous item
-                     * - commaToken is the location of the comma before the current item
-                     * - currentItemToken is the first token of the current item
-                     *
-                     * These values get switched around if item is undefined.
-                     * previousItemToken will refer to the last token not belonging
-                     * to the current item, which could be a comma or an opening
-                     * square bracket. currentItemToken could be a comma.
-                     *
-                     * All comparisons are done based on these tokens directly, so
-                     * they are always valid regardless of an undefined item.
-                     */
-                    if (astUtils.isCommaToken(commaToken)) {
-                        validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem);
-                    }
-
-                    if (item) {
-                        const tokenAfterItem = sourceCode.getTokenAfter(item, astUtils.isNotClosingParenToken);
-
-                        previousItemToken = tokenAfterItem
-                            ? sourceCode.getTokenBefore(tokenAfterItem)
-                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
-                    } else {
-                        previousItemToken = currentItemToken;
-                    }
-                });
-
-                /*
-                 * Special case for array literals that have empty last items, such
-                 * as [ 1, 2, ]. These arrays only have two items show up in the
-                 * AST, so we need to look at the token to verify that there's no
-                 * dangling comma.
-                 */
-                if (arrayLiteral) {
-
-                    const lastToken = sourceCode.getLastToken(node),
-                        nextToLastToken = sourceCode.getTokenBefore(lastToken);
-
-                    if (astUtils.isCommaToken(nextToLastToken)) {
-                        validateCommaItemSpacing(
-                            sourceCode.getTokenBefore(nextToLastToken),
-                            nextToLastToken,
-                            lastToken,
-                            lastToken
-                        );
-                    }
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        const nodes = {};
-
-        if (!exceptions.VariableDeclaration) {
-            nodes.VariableDeclaration = function(node) {
-                validateComma(node, "declarations");
-            };
-        }
-        if (!exceptions.ObjectExpression) {
-            nodes.ObjectExpression = function(node) {
-                validateComma(node, "properties");
-            };
-        }
-        if (!exceptions.ObjectPattern) {
-            nodes.ObjectPattern = function(node) {
-                validateComma(node, "properties");
-            };
-        }
-        if (!exceptions.ArrayExpression) {
-            nodes.ArrayExpression = function(node) {
-                validateComma(node, "elements");
-            };
-        }
-        if (!exceptions.ArrayPattern) {
-            nodes.ArrayPattern = function(node) {
-                validateComma(node, "elements");
-            };
-        }
-        if (!exceptions.FunctionDeclaration) {
-            nodes.FunctionDeclaration = function(node) {
-                validateComma(node, "params");
-            };
-        }
-        if (!exceptions.FunctionExpression) {
-            nodes.FunctionExpression = function(node) {
-                validateComma(node, "params");
-            };
-        }
-        if (!exceptions.ArrowFunctionExpression) {
-            nodes.ArrowFunctionExpression = function(node) {
-                validateComma(node, "params");
-            };
-        }
-        if (!exceptions.CallExpression) {
-            nodes.CallExpression = function(node) {
-                validateComma(node, "arguments");
-            };
-        }
-        if (!exceptions.ImportDeclaration) {
-            nodes.ImportDeclaration = function(node) {
-                validateComma(node, "specifiers");
-            };
-        }
-        if (!exceptions.NewExpression) {
-            nodes.NewExpression = function(node) {
-                validateComma(node, "arguments");
-            };
-        }
-
-        return nodes;
-    }
-};

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

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Counts the cyclomatic complexity of each function of the script. See http://en.wikipedia.org/wiki/Cyclomatic_complexity.
- * Counts the number of if, conditional, for, while, try, switch/case,
- * @author Patrick Brosset
- */
-
-"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 cyclomatic complexity allowed in a program",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/complexity"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            maximum: {
-                                type: "integer",
-                                minimum: 0
-                            },
-                            max: {
-                                type: "integer",
-                                minimum: 0
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            complex: "{{name}} has a complexity of {{complexity}}. Maximum allowed is {{max}}."
-        }
-    },
-
-    create(context) {
-        const option = context.options[0];
-        let THRESHOLD = 20;
-
-        if (
-            typeof option === "object" &&
-            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
-        ) {
-            THRESHOLD = option.maximum || option.max;
-        } else if (typeof option === "number") {
-            THRESHOLD = option;
-        }
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        // Using a stack to store complexity per code path
-        const complexities = [];
-
-        /**
-         * Increase the complexity of the code path in context
-         * @returns {void}
-         * @private
-         */
-        function increaseComplexity() {
-            complexities[complexities.length - 1]++;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-
-            onCodePathStart() {
-
-                // The initial complexity is 1, representing one execution path in the CodePath
-                complexities.push(1);
-            },
-
-            // Each branching in the code adds 1 to the complexity
-            CatchClause: increaseComplexity,
-            ConditionalExpression: increaseComplexity,
-            LogicalExpression: increaseComplexity,
-            ForStatement: increaseComplexity,
-            ForInStatement: increaseComplexity,
-            ForOfStatement: increaseComplexity,
-            IfStatement: increaseComplexity,
-            WhileStatement: increaseComplexity,
-            DoWhileStatement: increaseComplexity,
-
-            // Avoid `default`
-            "SwitchCase[test]": increaseComplexity,
-
-            // Logical assignment operators have short-circuiting behavior
-            AssignmentExpression(node) {
-                if (astUtils.isLogicalAssignmentOperator(node.operator)) {
-                    increaseComplexity();
-                }
-            },
-
-            onCodePathEnd(codePath, node) {
-                const complexity = complexities.pop();
-
-                /*
-                 * This rule only evaluates complexity of functions, so "program" is excluded.
-                 * Class field initializers and class static blocks are implicit functions. Therefore,
-                 * they shouldn't contribute to the enclosing function's complexity, but their
-                 * own complexity should be evaluated.
-                 */
-                if (
-                    codePath.origin !== "function" &&
-                    codePath.origin !== "class-field-initializer" &&
-                    codePath.origin !== "class-static-block"
-                ) {
-                    return;
-                }
-
-                if (complexity > THRESHOLD) {
-                    let name;
-
-                    if (codePath.origin === "class-field-initializer") {
-                        name = "class field initializer";
-                    } else if (codePath.origin === "class-static-block") {
-                        name = "class static block";
-                    } else {
-                        name = astUtils.getFunctionNameWithKind(node);
-                    }
-
-                    context.report({
-                        node,
-                        messageId: "complex",
-                        data: {
-                            name: upperCaseFirst(name),
-                            complexity,
-                            max: THRESHOLD
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};