claude-flow-novice 2.2.0 → 2.2.1

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

@@ -1,156 +0,0 @@
-/**
- * @fileoverview A rule to set the maximum depth block can be nested in a function.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce a maximum depth that blocks can be nested",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/max-depth"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            maximum: {
-                                type: "integer",
-                                minimum: 0
-                            },
-                            max: {
-                                type: "integer",
-                                minimum: 0
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-        messages: {
-            tooDeeply: "Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}}."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        const functionStack = [],
-            option = context.options[0];
-        let maxDepth = 4;
-
-        if (
-            typeof option === "object" &&
-            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
-        ) {
-            maxDepth = option.maximum || option.max;
-        }
-        if (typeof option === "number") {
-            maxDepth = option;
-        }
-
-        /**
-         * When parsing a new function, store it in our function stack
-         * @returns {void}
-         * @private
-         */
-        function startFunction() {
-            functionStack.push(0);
-        }
-
-        /**
-         * When parsing is done then pop out the reference
-         * @returns {void}
-         * @private
-         */
-        function endFunction() {
-            functionStack.pop();
-        }
-
-        /**
-         * Save the block and Evaluate the node
-         * @param {ASTNode} node node to evaluate
-         * @returns {void}
-         * @private
-         */
-        function pushBlock(node) {
-            const len = ++functionStack[functionStack.length - 1];
-
-            if (len > maxDepth) {
-                context.report({ node, messageId: "tooDeeply", data: { depth: len, maxDepth } });
-            }
-        }
-
-        /**
-         * Pop the saved block
-         * @returns {void}
-         * @private
-         */
-        function popBlock() {
-            functionStack[functionStack.length - 1]--;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            Program: startFunction,
-            FunctionDeclaration: startFunction,
-            FunctionExpression: startFunction,
-            ArrowFunctionExpression: startFunction,
-            StaticBlock: startFunction,
-
-            IfStatement(node) {
-                if (node.parent.type !== "IfStatement") {
-                    pushBlock(node);
-                }
-            },
-            SwitchStatement: pushBlock,
-            TryStatement: pushBlock,
-            DoWhileStatement: pushBlock,
-            WhileStatement: pushBlock,
-            WithStatement: pushBlock,
-            ForStatement: pushBlock,
-            ForInStatement: pushBlock,
-            ForOfStatement: pushBlock,
-
-            "IfStatement:exit": popBlock,
-            "SwitchStatement:exit": popBlock,
-            "TryStatement:exit": popBlock,
-            "DoWhileStatement:exit": popBlock,
-            "WhileStatement:exit": popBlock,
-            "WithStatement:exit": popBlock,
-            "ForStatement:exit": popBlock,
-            "ForInStatement:exit": popBlock,
-            "ForOfStatement:exit": popBlock,
-
-            "FunctionDeclaration:exit": endFunction,
-            "FunctionExpression:exit": endFunction,
-            "ArrowFunctionExpression:exit": endFunction,
-            "StaticBlock:exit": endFunction,
-            "Program:exit": endFunction
-        };
-
-    }
-};

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

@@ -1,440 +0,0 @@
-/**
- * @fileoverview Rule to check for max length on a line.
- * @author Matt DuVall <http://www.mattduvall.com>
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-
-const OPTIONS_SCHEMA = {
-    type: "object",
-    properties: {
-        code: {
-            type: "integer",
-            minimum: 0
-        },
-        comments: {
-            type: "integer",
-            minimum: 0
-        },
-        tabWidth: {
-            type: "integer",
-            minimum: 0
-        },
-        ignorePattern: {
-            type: "string"
-        },
-        ignoreComments: {
-            type: "boolean"
-        },
-        ignoreStrings: {
-            type: "boolean"
-        },
-        ignoreUrls: {
-            type: "boolean"
-        },
-        ignoreTemplateLiterals: {
-            type: "boolean"
-        },
-        ignoreRegExpLiterals: {
-            type: "boolean"
-        },
-        ignoreTrailingComments: {
-            type: "boolean"
-        }
-    },
-    additionalProperties: false
-};
-
-const OPTIONS_OR_INTEGER_SCHEMA = {
-    anyOf: [
-        OPTIONS_SCHEMA,
-        {
-            type: "integer",
-            minimum: 0
-        }
-    ]
-};
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce a maximum line length",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/max-len"
-        },
-
-        schema: [
-            OPTIONS_OR_INTEGER_SCHEMA,
-            OPTIONS_OR_INTEGER_SCHEMA,
-            OPTIONS_SCHEMA
-        ],
-        messages: {
-            max: "This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.",
-            maxComment: "This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}."
-        }
-    },
-
-    create(context) {
-
-        /*
-         * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:
-         * - They're matching an entire string that we know is a URI
-         * - We're matching part of a string where we think there *might* be a URL
-         * - We're only concerned about URLs, as picking out any URI would cause
-         *   too many false positives
-         * - We don't care about matching the entire URL, any small segment is fine
-         */
-        const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Computes the length of a line that may contain tabs. The width of each
-         * tab will be the number of spaces to the next tab stop.
-         * @param {string} line The line.
-         * @param {int} tabWidth The width of each tab stop in spaces.
-         * @returns {int} The computed line length.
-         * @private
-         */
-        function computeLineLength(line, tabWidth) {
-            let extraCharacterCount = 0;
-
-            line.replace(/\t/gu, (match, offset) => {
-                const totalOffset = offset + extraCharacterCount,
-                    previousTabStopOffset = tabWidth ? totalOffset % tabWidth : 0,
-                    spaceCount = tabWidth - previousTabStopOffset;
-
-                extraCharacterCount += spaceCount - 1; // -1 for the replaced tab
-            });
-            return Array.from(line).length + extraCharacterCount;
-        }
-
-        // The options object must be the last option specified…
-        const options = Object.assign({}, context.options[context.options.length - 1]);
-
-        // …but max code length…
-        if (typeof context.options[0] === "number") {
-            options.code = context.options[0];
-        }
-
-        // …and tabWidth can be optionally specified directly as integers.
-        if (typeof context.options[1] === "number") {
-            options.tabWidth = context.options[1];
-        }
-
-        const maxLength = typeof options.code === "number" ? options.code : 80,
-            tabWidth = typeof options.tabWidth === "number" ? options.tabWidth : 4,
-            ignoreComments = !!options.ignoreComments,
-            ignoreStrings = !!options.ignoreStrings,
-            ignoreTemplateLiterals = !!options.ignoreTemplateLiterals,
-            ignoreRegExpLiterals = !!options.ignoreRegExpLiterals,
-            ignoreTrailingComments = !!options.ignoreTrailingComments || !!options.ignoreComments,
-            ignoreUrls = !!options.ignoreUrls,
-            maxCommentLength = options.comments;
-        let ignorePattern = options.ignorePattern || null;
-
-        if (ignorePattern) {
-            ignorePattern = new RegExp(ignorePattern, "u");
-        }
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Tells if a given comment is trailing: it starts on the current line and
-         * extends to or past the end of the current line.
-         * @param {string} line The source line we want to check for a trailing comment on
-         * @param {number} lineNumber The one-indexed line number for line
-         * @param {ASTNode} comment The comment to inspect
-         * @returns {boolean} If the comment is trailing on the given line
-         */
-        function isTrailingComment(line, lineNumber, comment) {
-            return comment &&
-                (comment.loc.start.line === lineNumber && lineNumber <= comment.loc.end.line) &&
-                (comment.loc.end.line > lineNumber || comment.loc.end.column === line.length);
-        }
-
-        /**
-         * Tells if a comment encompasses the entire line.
-         * @param {string} line The source line with a trailing comment
-         * @param {number} lineNumber The one-indexed line number this is on
-         * @param {ASTNode} comment The comment to remove
-         * @returns {boolean} If the comment covers the entire line
-         */
-        function isFullLineComment(line, lineNumber, comment) {
-            const start = comment.loc.start,
-                end = comment.loc.end,
-                isFirstTokenOnLine = !line.slice(0, comment.loc.start.column).trim();
-
-            return comment &&
-                (start.line < lineNumber || (start.line === lineNumber && isFirstTokenOnLine)) &&
-                (end.line > lineNumber || (end.line === lineNumber && end.column === line.length));
-        }
-
-        /**
-         * Check if a node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} True if the node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
-         */
-        function isJSXEmptyExpressionInSingleLineContainer(node) {
-            if (!node || !node.parent || node.type !== "JSXEmptyExpression" || node.parent.type !== "JSXExpressionContainer") {
-                return false;
-            }
-
-            const parent = node.parent;
-
-            return parent.loc.start.line === parent.loc.end.line;
-        }
-
-        /**
-         * Gets the line after the comment and any remaining trailing whitespace is
-         * stripped.
-         * @param {string} line The source line with a trailing comment
-         * @param {ASTNode} comment The comment to remove
-         * @returns {string} Line without comment and trailing whitespace
-         */
-        function stripTrailingComment(line, comment) {
-
-            // loc.column is zero-indexed
-            return line.slice(0, comment.loc.start.column).replace(/\s+$/u, "");
-        }
-
-        /**
-         * Ensure that an array exists at [key] on `object`, and add `value` to it.
-         * @param {Object} object the object to mutate
-         * @param {string} key the object's key
-         * @param {any} value the value to add
-         * @returns {void}
-         * @private
-         */
-        function ensureArrayAndPush(object, key, value) {
-            if (!Array.isArray(object[key])) {
-                object[key] = [];
-            }
-            object[key].push(value);
-        }
-
-        /**
-         * Retrieves an array containing all strings (" or ') in the source code.
-         * @returns {ASTNode[]} An array of string nodes.
-         */
-        function getAllStrings() {
-            return sourceCode.ast.tokens.filter(token => (token.type === "String" ||
-                (token.type === "JSXText" && sourceCode.getNodeByRangeIndex(token.range[0] - 1).type === "JSXAttribute")));
-        }
-
-        /**
-         * Retrieves an array containing all template literals in the source code.
-         * @returns {ASTNode[]} An array of template literal nodes.
-         */
-        function getAllTemplateLiterals() {
-            return sourceCode.ast.tokens.filter(token => token.type === "Template");
-        }
-
-
-        /**
-         * Retrieves an array containing all RegExp literals in the source code.
-         * @returns {ASTNode[]} An array of RegExp literal nodes.
-         */
-        function getAllRegExpLiterals() {
-            return sourceCode.ast.tokens.filter(token => token.type === "RegularExpression");
-        }
-
-        /**
-         *
-         * reduce an array of AST nodes by line number, both start and end.
-         * @param {ASTNode[]} arr array of AST nodes
-         * @returns {Object} accululated AST nodes
-         */
-        function groupArrayByLineNumber(arr) {
-            const obj = {};
-
-            for (let i = 0; i < arr.length; i++) {
-                const node = arr[i];
-
-                for (let j = node.loc.start.line; j <= node.loc.end.line; ++j) {
-                    ensureArrayAndPush(obj, j, node);
-                }
-            }
-            return obj;
-        }
-
-        /**
-         * Returns an array of all comments in the source code.
-         * If the element in the array is a JSXEmptyExpression contained with a single line JSXExpressionContainer,
-         * the element is changed with JSXExpressionContainer node.
-         * @returns {ASTNode[]} An array of comment nodes
-         */
-        function getAllComments() {
-            const comments = [];
-
-            sourceCode.getAllComments()
-                .forEach(commentNode => {
-                    const containingNode = sourceCode.getNodeByRangeIndex(commentNode.range[0]);
-
-                    if (isJSXEmptyExpressionInSingleLineContainer(containingNode)) {
-
-                        // push a unique node only
-                        if (comments[comments.length - 1] !== containingNode.parent) {
-                            comments.push(containingNode.parent);
-                        }
-                    } else {
-                        comments.push(commentNode);
-                    }
-                });
-
-            return comments;
-        }
-
-        /**
-         * Check the program for max length
-         * @param {ASTNode} node Node to examine
-         * @returns {void}
-         * @private
-         */
-        function checkProgramForMaxLength(node) {
-
-            // split (honors line-ending)
-            const lines = sourceCode.lines,
-
-                // list of comments to ignore
-                comments = ignoreComments || maxCommentLength || ignoreTrailingComments ? getAllComments() : [];
-
-            // we iterate over comments in parallel with the lines
-            let commentsIndex = 0;
-
-            const strings = getAllStrings();
-            const stringsByLine = groupArrayByLineNumber(strings);
-
-            const templateLiterals = getAllTemplateLiterals();
-            const templateLiteralsByLine = groupArrayByLineNumber(templateLiterals);
-
-            const regExpLiterals = getAllRegExpLiterals();
-            const regExpLiteralsByLine = groupArrayByLineNumber(regExpLiterals);
-
-            lines.forEach((line, i) => {
-
-                // i is zero-indexed, line numbers are one-indexed
-                const lineNumber = i + 1;
-
-                /*
-                 * if we're checking comment length; we need to know whether this
-                 * line is a comment
-                 */
-                let lineIsComment = false;
-                let textToMeasure;
-
-                /*
-                 * We can short-circuit the comment checks if we're already out of
-                 * comments to check.
-                 */
-                if (commentsIndex < comments.length) {
-                    let comment = null;
-
-                    // iterate over comments until we find one past the current line
-                    do {
-                        comment = comments[++commentsIndex];
-                    } while (comment && comment.loc.start.line <= lineNumber);
-
-                    // and step back by one
-                    comment = comments[--commentsIndex];
-
-                    if (isFullLineComment(line, lineNumber, comment)) {
-                        lineIsComment = true;
-                        textToMeasure = line;
-                    } else if (ignoreTrailingComments && isTrailingComment(line, lineNumber, comment)) {
-                        textToMeasure = stripTrailingComment(line, comment);
-
-                        // ignore multiple trailing comments in the same line
-                        let lastIndex = commentsIndex;
-
-                        while (isTrailingComment(textToMeasure, lineNumber, comments[--lastIndex])) {
-                            textToMeasure = stripTrailingComment(textToMeasure, comments[lastIndex]);
-                        }
-                    } else {
-                        textToMeasure = line;
-                    }
-                } else {
-                    textToMeasure = line;
-                }
-                if (ignorePattern && ignorePattern.test(textToMeasure) ||
-                    ignoreUrls && URL_REGEXP.test(textToMeasure) ||
-                    ignoreStrings && stringsByLine[lineNumber] ||
-                    ignoreTemplateLiterals && templateLiteralsByLine[lineNumber] ||
-                    ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber]
-                ) {
-
-                    // ignore this line
-                    return;
-                }
-
-                const lineLength = computeLineLength(textToMeasure, tabWidth);
-                const commentLengthApplies = lineIsComment && maxCommentLength;
-
-                if (lineIsComment && ignoreComments) {
-                    return;
-                }
-
-                const loc = {
-                    start: {
-                        line: lineNumber,
-                        column: 0
-                    },
-                    end: {
-                        line: lineNumber,
-                        column: textToMeasure.length
-                    }
-                };
-
-                if (commentLengthApplies) {
-                    if (lineLength > maxCommentLength) {
-                        context.report({
-                            node,
-                            loc,
-                            messageId: "maxComment",
-                            data: {
-                                lineLength,
-                                maxCommentLength
-                            }
-                        });
-                    }
-                } else if (lineLength > maxLength) {
-                    context.report({
-                        node,
-                        loc,
-                        messageId: "max",
-                        data: {
-                            lineLength,
-                            maxLength
-                        }
-                    });
-                }
-            });
-        }
-
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            Program: checkProgramForMaxLength
-        };
-
-    }
-};