claude-flow-novice 2.2.0 → 2.2.1

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-implicit-coercion.js

@@ -1,380 +0,0 @@
-/**
- * @fileoverview A rule to disallow the type conversions with shorter notations.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;
-const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
-
-/**
- * Parses and normalizes an option object.
- * @param {Object} options An option object to parse.
- * @returns {Object} The parsed and normalized option object.
- */
-function parseOptions(options) {
-    return {
-        boolean: "boolean" in options ? options.boolean : true,
-        number: "number" in options ? options.number : true,
-        string: "string" in options ? options.string : true,
-        disallowTemplateShorthand: "disallowTemplateShorthand" in options ? options.disallowTemplateShorthand : false,
-        allow: options.allow || []
-    };
-}
-
-/**
- * Checks whether or not a node is a double logical negating.
- * @param {ASTNode} node An UnaryExpression node to check.
- * @returns {boolean} Whether or not the node is a double logical negating.
- */
-function isDoubleLogicalNegating(node) {
-    return (
-        node.operator === "!" &&
-        node.argument.type === "UnaryExpression" &&
-        node.argument.operator === "!"
-    );
-}
-
-/**
- * Checks whether or not a node is a binary negating of `.indexOf()` method calling.
- * @param {ASTNode} node An UnaryExpression node to check.
- * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
- */
-function isBinaryNegatingOfIndexOf(node) {
-    if (node.operator !== "~") {
-        return false;
-    }
-    const callNode = astUtils.skipChainExpression(node.argument);
-
-    return (
-        callNode.type === "CallExpression" &&
-        astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN)
-    );
-}
-
-/**
- * Checks whether or not a node is a multiplying by one.
- * @param {BinaryExpression} node A BinaryExpression node to check.
- * @returns {boolean} Whether or not the node is a multiplying by one.
- */
-function isMultiplyByOne(node) {
-    return node.operator === "*" && (
-        node.left.type === "Literal" && node.left.value === 1 ||
-        node.right.type === "Literal" && node.right.value === 1
-    );
-}
-
-/**
- * Checks whether the given node logically represents multiplication by a fraction of `1`.
- * For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the
- * whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`.
- * @param {BinaryExpression} node A BinaryExpression node to check.
- * @param {SourceCode} sourceCode The source code object.
- * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
- */
-function isMultiplyByFractionOfOne(node, sourceCode) {
-    return node.type === "BinaryExpression" &&
-        node.operator === "*" &&
-        (node.right.type === "Literal" && node.right.value === 1) &&
-        node.parent.type === "BinaryExpression" &&
-        node.parent.operator === "/" &&
-        node.parent.left === node &&
-        !astUtils.isParenthesised(sourceCode, node);
-}
-
-/**
- * Checks whether the result of a node is numeric or not
- * @param {ASTNode} node The node to test
- * @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call
- */
-function isNumeric(node) {
-    return (
-        node.type === "Literal" && typeof node.value === "number" ||
-        node.type === "CallExpression" && (
-            node.callee.name === "Number" ||
-            node.callee.name === "parseInt" ||
-            node.callee.name === "parseFloat"
-        )
-    );
-}
-
-/**
- * Returns the first non-numeric operand in a BinaryExpression. Designed to be
- * used from bottom to up since it walks up the BinaryExpression trees using
- * node.parent to find the result.
- * @param {BinaryExpression} node The BinaryExpression node to be walked up on
- * @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null
- */
-function getNonNumericOperand(node) {
-    const left = node.left,
-        right = node.right;
-
-    if (right.type !== "BinaryExpression" && !isNumeric(right)) {
-        return right;
-    }
-
-    if (left.type !== "BinaryExpression" && !isNumeric(left)) {
-        return left;
-    }
-
-    return null;
-}
-
-/**
- * Checks whether an expression evaluates to a string.
- * @param {ASTNode} node node that represents the expression to check.
- * @returns {boolean} Whether or not the expression evaluates to a string.
- */
-function isStringType(node) {
-    return astUtils.isStringLiteral(node) ||
-        (
-            node.type === "CallExpression" &&
-            node.callee.type === "Identifier" &&
-            node.callee.name === "String"
-        );
-}
-
-/**
- * Checks whether a node is an empty string literal or not.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} Whether or not the passed in node is an
- * empty string literal or not.
- */
-function isEmptyString(node) {
-    return astUtils.isStringLiteral(node) && (node.value === "" || (node.type === "TemplateLiteral" && node.quasis.length === 1 && node.quasis[0].value.cooked === ""));
-}
-
-/**
- * Checks whether or not a node is a concatenating with an empty string.
- * @param {ASTNode} node A BinaryExpression node to check.
- * @returns {boolean} Whether or not the node is a concatenating with an empty string.
- */
-function isConcatWithEmptyString(node) {
-    return node.operator === "+" && (
-        (isEmptyString(node.left) && !isStringType(node.right)) ||
-        (isEmptyString(node.right) && !isStringType(node.left))
-    );
-}
-
-/**
- * Checks whether or not a node is appended with an empty string.
- * @param {ASTNode} node An AssignmentExpression node to check.
- * @returns {boolean} Whether or not the node is appended with an empty string.
- */
-function isAppendEmptyString(node) {
-    return node.operator === "+=" && isEmptyString(node.right);
-}
-
-/**
- * Returns the operand that is not an empty string from a flagged BinaryExpression.
- * @param {ASTNode} node The flagged BinaryExpression node to check.
- * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
- */
-function getNonEmptyOperand(node) {
-    return isEmptyString(node.left) ? node.right : node.left;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow shorthand type conversions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-implicit-coercion"
-        },
-
-        fixable: "code",
-
-        schema: [{
-            type: "object",
-            properties: {
-                boolean: {
-                    type: "boolean",
-                    default: true
-                },
-                number: {
-                    type: "boolean",
-                    default: true
-                },
-                string: {
-                    type: "boolean",
-                    default: true
-                },
-                disallowTemplateShorthand: {
-                    type: "boolean",
-                    default: false
-                },
-                allow: {
-                    type: "array",
-                    items: {
-                        enum: ALLOWABLE_OPERATORS
-                    },
-                    uniqueItems: true
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            useRecommendation: "use `{{recommendation}}` instead."
-        }
-    },
-
-    create(context) {
-        const options = parseOptions(context.options[0] || {});
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports an error and autofixes the node
-         * @param {ASTNode} node An ast node to report the error on.
-         * @param {string} recommendation The recommended code for the issue
-         * @param {bool} shouldFix Whether this report should fix the node
-         * @returns {void}
-         */
-        function report(node, recommendation, shouldFix) {
-            context.report({
-                node,
-                messageId: "useRecommendation",
-                data: {
-                    recommendation
-                },
-                fix(fixer) {
-                    if (!shouldFix) {
-                        return null;
-                    }
-
-                    const tokenBefore = sourceCode.getTokenBefore(node);
-
-                    if (
-                        tokenBefore &&
-                        tokenBefore.range[1] === node.range[0] &&
-                        !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
-                    ) {
-                        return fixer.replaceText(node, ` ${recommendation}`);
-                    }
-                    return fixer.replaceText(node, recommendation);
-                }
-            });
-        }
-
-        return {
-            UnaryExpression(node) {
-                let operatorAllowed;
-
-                // !!foo
-                operatorAllowed = options.allow.includes("!!");
-                if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
-                    const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
-
-                    report(node, recommendation, true);
-                }
-
-                // ~foo.indexOf(bar)
-                operatorAllowed = options.allow.includes("~");
-                if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
-
-                    // `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case.
-                    const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
-                    const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
-
-                    report(node, recommendation, false);
-                }
-
-                // +foo
-                operatorAllowed = options.allow.includes("+");
-                if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
-                    const recommendation = `Number(${sourceCode.getText(node.argument)})`;
-
-                    report(node, recommendation, true);
-                }
-            },
-
-            // Use `:exit` to prevent double reporting
-            "BinaryExpression:exit"(node) {
-                let operatorAllowed;
-
-                // 1 * foo
-                operatorAllowed = options.allow.includes("*");
-                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) &&
-                    getNonNumericOperand(node);
-
-                if (nonNumericOperand) {
-                    const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
-
-                    report(node, recommendation, true);
-                }
-
-                // "" + foo
-                operatorAllowed = options.allow.includes("+");
-                if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
-                    const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
-
-                    report(node, recommendation, true);
-                }
-            },
-
-            AssignmentExpression(node) {
-
-                // foo += ""
-                const operatorAllowed = options.allow.includes("+");
-
-                if (!operatorAllowed && options.string && isAppendEmptyString(node)) {
-                    const code = sourceCode.getText(getNonEmptyOperand(node));
-                    const recommendation = `${code} = String(${code})`;
-
-                    report(node, recommendation, true);
-                }
-            },
-
-            TemplateLiteral(node) {
-                if (!options.disallowTemplateShorthand) {
-                    return;
-                }
-
-                // tag`${foo}`
-                if (node.parent.type === "TaggedTemplateExpression") {
-                    return;
-                }
-
-                // `` or `${foo}${bar}`
-                if (node.expressions.length !== 1) {
-                    return;
-                }
-
-
-                //  `prefix${foo}`
-                if (node.quasis[0].value.cooked !== "") {
-                    return;
-                }
-
-                //  `${foo}postfix`
-                if (node.quasis[1].value.cooked !== "") {
-                    return;
-                }
-
-                // if the expression is already a string, then this isn't a coercion
-                if (isStringType(node.expressions[0])) {
-                    return;
-                }
-
-                const code = sourceCode.getText(node.expressions[0]);
-                const recommendation = `String(${code})`;
-
-                report(node, recommendation, true);
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-implicit-globals.js

@@ -1,146 +0,0 @@
-/**
- * @fileoverview Rule to check for implicit global variables, functions and classes.
- * @author Joshua Peek
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow declarations in the global scope",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-implicit-globals"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                lexicalBindings: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            globalNonLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
-            globalLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
-            globalVariableLeak: "Global variable leak, declare the variable if it is intended to be local.",
-            assignmentToReadonlyGlobal: "Unexpected assignment to read-only global variable.",
-            redeclarationOfReadonlyGlobal: "Unexpected redeclaration of read-only global variable."
-        }
-    },
-
-    create(context) {
-
-        const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports the node.
-         * @param {ASTNode} node Node to report.
-         * @param {string} messageId Id of the message to report.
-         * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
-         * @returns {void}
-         */
-        function report(node, messageId, kind) {
-            context.report({
-                node,
-                messageId,
-                data: {
-                    kind
-                }
-            });
-        }
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-
-                scope.variables.forEach(variable => {
-
-                    // Only ESLint global variables have the `writable` key.
-                    const isReadonlyEslintGlobalVariable = variable.writeable === false;
-                    const isWritableEslintGlobalVariable = variable.writeable === true;
-
-                    if (isWritableEslintGlobalVariable) {
-
-                        // Everything is allowed with writable ESLint global variables.
-                        return;
-                    }
-
-                    // Variables exported by "exported" block comments
-                    if (variable.eslintExported) {
-                        return;
-                    }
-
-                    variable.defs.forEach(def => {
-                        const defNode = def.node;
-
-                        if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
-                            if (isReadonlyEslintGlobalVariable) {
-                                report(defNode, "redeclarationOfReadonlyGlobal");
-                            } else {
-                                report(
-                                    defNode,
-                                    "globalNonLexicalBinding",
-                                    def.type === "FunctionName" ? "function" : `'${def.parent.kind}'`
-                                );
-                            }
-                        }
-
-                        if (checkLexicalBindings) {
-                            if (def.type === "ClassName" ||
-                                    (def.type === "Variable" && (def.parent.kind === "let" || def.parent.kind === "const"))) {
-                                if (isReadonlyEslintGlobalVariable) {
-                                    report(defNode, "redeclarationOfReadonlyGlobal");
-                                } else {
-                                    report(
-                                        defNode,
-                                        "globalLexicalBinding",
-                                        def.type === "ClassName" ? "class" : `'${def.parent.kind}'`
-                                    );
-                                }
-                            }
-                        }
-                    });
-                });
-
-                // Undeclared assigned variables.
-                scope.implicit.variables.forEach(variable => {
-                    const scopeVariable = scope.set.get(variable.name);
-                    let messageId;
-
-                    if (scopeVariable) {
-
-                        // ESLint global variable
-                        if (scopeVariable.writeable) {
-                            return;
-                        }
-                        messageId = "assignmentToReadonlyGlobal";
-
-                    } else {
-
-                        // Reference to an unknown variable, possible global leak.
-                        messageId = "globalVariableLeak";
-                    }
-
-                    // def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
-                    variable.defs.forEach(def => {
-                        report(def.node, messageId);
-                    });
-                });
-            }
-        };
-
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-implied-eval.js

@@ -1,132 +0,0 @@
-/**
- * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { getStaticValue } = require("@eslint-community/eslint-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of `eval()`-like methods",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-implied-eval"
-        },
-
-        schema: [],
-
-        messages: {
-            impliedEval: "Implied eval. Consider passing a function instead of a string."
-        }
-    },
-
-    create(context) {
-        const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
-        const EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks whether a node is evaluated as a string or not.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} True if the node is evaluated as a string.
-         */
-        function isEvaluatedString(node) {
-            if (
-                (node.type === "Literal" && typeof node.value === "string") ||
-                node.type === "TemplateLiteral"
-            ) {
-                return true;
-            }
-            if (node.type === "BinaryExpression" && node.operator === "+") {
-                return isEvaluatedString(node.left) || isEvaluatedString(node.right);
-            }
-            return false;
-        }
-
-        /**
-         * Reports if the `CallExpression` node has evaluated argument.
-         * @param {ASTNode} node A CallExpression to check.
-         * @returns {void}
-         */
-        function reportImpliedEvalCallExpression(node) {
-            const [firstArgument] = node.arguments;
-
-            if (firstArgument) {
-
-                const staticValue = getStaticValue(firstArgument, sourceCode.getScope(node));
-                const isStaticString = staticValue && typeof staticValue.value === "string";
-                const isString = isStaticString || isEvaluatedString(firstArgument);
-
-                if (isString) {
-                    context.report({
-                        node,
-                        messageId: "impliedEval"
-                    });
-                }
-            }
-
-        }
-
-        /**
-         * Reports calls of `implied eval` via the global references.
-         * @param {Variable} globalVar A global variable to check.
-         * @returns {void}
-         */
-        function reportImpliedEvalViaGlobal(globalVar) {
-            const { references, name } = globalVar;
-
-            references.forEach(ref => {
-                const identifier = ref.identifier;
-                let node = identifier.parent;
-
-                while (astUtils.isSpecificMemberAccess(node, null, name)) {
-                    node = node.parent;
-                }
-
-                if (astUtils.isSpecificMemberAccess(node, null, EVAL_LIKE_FUNC_PATTERN)) {
-                    const calleeNode = node.parent.type === "ChainExpression" ? node.parent : node;
-                    const parent = calleeNode.parent;
-
-                    if (parent.type === "CallExpression" && parent.callee === calleeNode) {
-                        reportImpliedEvalCallExpression(parent);
-                    }
-                }
-            });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            CallExpression(node) {
-                if (astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)) {
-                    reportImpliedEvalCallExpression(node);
-                }
-            },
-            "Program:exit"(node) {
-                const globalScope = sourceCode.getScope(node);
-
-                GLOBAL_CANDIDATES
-                    .map(candidate => astUtils.getVariableByName(globalScope, candidate))
-                    .filter(globalVar => !!globalVar && globalVar.defs.length === 0)
-                    .forEach(reportImpliedEvalViaGlobal);
-            }
-        };
-
-    }
-};