claude-flow-novice 2.2.0 → 2.2.1

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-extra-boolean-cast.js

@@ -1,317 +0,0 @@
-/**
- * @fileoverview Rule to flag unnecessary double negation in Boolean contexts
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const eslintUtils = require("@eslint-community/eslint-utils");
-
-const precedence = astUtils.getPrecedence;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary boolean casts",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-extra-boolean-cast"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                enforceForLogicalOperands: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-        fixable: "code",
-
-        messages: {
-            unexpectedCall: "Redundant Boolean call.",
-            unexpectedNegation: "Redundant double negation."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        // Node types which have a test which will coerce values to booleans.
-        const BOOLEAN_NODE_TYPES = new Set([
-            "IfStatement",
-            "DoWhileStatement",
-            "WhileStatement",
-            "ConditionalExpression",
-            "ForStatement"
-        ]);
-
-        /**
-         * Check if a node is a Boolean function or constructor.
-         * @param {ASTNode} node the node
-         * @returns {boolean} If the node is Boolean function or constructor
-         */
-        function isBooleanFunctionOrConstructorCall(node) {
-
-            // Boolean(<bool>) and new Boolean(<bool>)
-            return (node.type === "CallExpression" || node.type === "NewExpression") &&
-                    node.callee.type === "Identifier" &&
-                        node.callee.name === "Boolean";
-        }
-
-        /**
-         * Checks whether the node is a logical expression and that the option is enabled
-         * @param {ASTNode} node the node
-         * @returns {boolean} if the node is a logical expression and option is enabled
-         */
-        function isLogicalContext(node) {
-            return node.type === "LogicalExpression" &&
-            (node.operator === "||" || node.operator === "&&") &&
-            (context.options.length && context.options[0].enforceForLogicalOperands === true);
-
-        }
-
-
-        /**
-         * Check if a node is in a context where its value would be coerced to a boolean at runtime.
-         * @param {ASTNode} node The node
-         * @returns {boolean} If it is in a boolean context
-         */
-        function isInBooleanContext(node) {
-            return (
-                (isBooleanFunctionOrConstructorCall(node.parent) &&
-                node === node.parent.arguments[0]) ||
-
-                (BOOLEAN_NODE_TYPES.has(node.parent.type) &&
-                    node === node.parent.test) ||
-
-                // !<bool>
-                (node.parent.type === "UnaryExpression" &&
-                    node.parent.operator === "!")
-            );
-        }
-
-        /**
-         * Checks whether the node is a context that should report an error
-         * Acts recursively if it is in a logical context
-         * @param {ASTNode} node the node
-         * @returns {boolean} If the node is in one of the flagged contexts
-         */
-        function isInFlaggedContext(node) {
-            if (node.parent.type === "ChainExpression") {
-                return isInFlaggedContext(node.parent);
-            }
-
-            return isInBooleanContext(node) ||
-            (isLogicalContext(node.parent) &&
-
-            // For nested logical statements
-            isInFlaggedContext(node.parent)
-            );
-        }
-
-
-        /**
-         * Check if a node has comments inside.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} `true` if it has comments inside.
-         */
-        function hasCommentsInside(node) {
-            return Boolean(sourceCode.getCommentsInside(node).length);
-        }
-
-        /**
-         * Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} `true` if the node is parenthesized.
-         * @private
-         */
-        function isParenthesized(node) {
-            return eslintUtils.isParenthesized(1, node, sourceCode);
-        }
-
-        /**
-         * Determines whether the given node needs to be parenthesized when replacing the previous node.
-         * It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
-         * of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
-         * For example, if the parent is `ConditionalExpression`, `previousNode` must be its `test` child.
-         * @param {ASTNode} previousNode Previous node.
-         * @param {ASTNode} node The node to check.
-         * @throws {Error} (Unreachable.)
-         * @returns {boolean} `true` if the node needs to be parenthesized.
-         */
-        function needsParens(previousNode, node) {
-            if (previousNode.parent.type === "ChainExpression") {
-                return needsParens(previousNode.parent, node);
-            }
-            if (isParenthesized(previousNode)) {
-
-                // parentheses around the previous node will stay, so there is no need for an additional pair
-                return false;
-            }
-
-            // parent of the previous node will become parent of the replacement node
-            const parent = previousNode.parent;
-
-            switch (parent.type) {
-                case "CallExpression":
-                case "NewExpression":
-                    return node.type === "SequenceExpression";
-                case "IfStatement":
-                case "DoWhileStatement":
-                case "WhileStatement":
-                case "ForStatement":
-                    return false;
-                case "ConditionalExpression":
-                    return precedence(node) <= precedence(parent);
-                case "UnaryExpression":
-                    return precedence(node) < precedence(parent);
-                case "LogicalExpression":
-                    if (astUtils.isMixedLogicalAndCoalesceExpressions(node, parent)) {
-                        return true;
-                    }
-                    if (previousNode === parent.left) {
-                        return precedence(node) < precedence(parent);
-                    }
-                    return precedence(node) <= precedence(parent);
-
-                /* c8 ignore next */
-                default:
-                    throw new Error(`Unexpected parent type: ${parent.type}`);
-            }
-        }
-
-        return {
-            UnaryExpression(node) {
-                const parent = node.parent;
-
-
-                // Exit early if it's guaranteed not to match
-                if (node.operator !== "!" ||
-                          parent.type !== "UnaryExpression" ||
-                          parent.operator !== "!") {
-                    return;
-                }
-
-
-                if (isInFlaggedContext(parent)) {
-                    context.report({
-                        node: parent,
-                        messageId: "unexpectedNegation",
-                        fix(fixer) {
-                            if (hasCommentsInside(parent)) {
-                                return null;
-                            }
-
-                            if (needsParens(parent, node.argument)) {
-                                return fixer.replaceText(parent, `(${sourceCode.getText(node.argument)})`);
-                            }
-
-                            let prefix = "";
-                            const tokenBefore = sourceCode.getTokenBefore(parent);
-                            const firstReplacementToken = sourceCode.getFirstToken(node.argument);
-
-                            if (
-                                tokenBefore &&
-                                tokenBefore.range[1] === parent.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)
-                            ) {
-                                prefix = " ";
-                            }
-
-                            return fixer.replaceText(parent, prefix + sourceCode.getText(node.argument));
-                        }
-                    });
-                }
-            },
-
-            CallExpression(node) {
-                if (node.callee.type !== "Identifier" || node.callee.name !== "Boolean") {
-                    return;
-                }
-
-                if (isInFlaggedContext(node)) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedCall",
-                        fix(fixer) {
-                            const parent = node.parent;
-
-                            if (node.arguments.length === 0) {
-                                if (parent.type === "UnaryExpression" && parent.operator === "!") {
-
-                                    /*
-                                     * !Boolean() -> true
-                                     */
-
-                                    if (hasCommentsInside(parent)) {
-                                        return null;
-                                    }
-
-                                    const replacement = "true";
-                                    let prefix = "";
-                                    const tokenBefore = sourceCode.getTokenBefore(parent);
-
-                                    if (
-                                        tokenBefore &&
-                                        tokenBefore.range[1] === parent.range[0] &&
-                                        !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
-                                    ) {
-                                        prefix = " ";
-                                    }
-
-                                    return fixer.replaceText(parent, prefix + replacement);
-                                }
-
-                                /*
-                                 * Boolean() -> false
-                                 */
-
-                                if (hasCommentsInside(node)) {
-                                    return null;
-                                }
-
-                                return fixer.replaceText(node, "false");
-                            }
-
-                            if (node.arguments.length === 1) {
-                                const argument = node.arguments[0];
-
-                                if (argument.type === "SpreadElement" || hasCommentsInside(node)) {
-                                    return null;
-                                }
-
-                                /*
-                                 * Boolean(expression) -> expression
-                                 */
-
-                                if (needsParens(node, argument)) {
-                                    return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);
-                                }
-
-                                return fixer.replaceText(node, sourceCode.getText(argument));
-                            }
-
-                            // two or more arguments
-                            return null;
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,149 +0,0 @@
-/**
- * @fileoverview Rule to disallow unnecessary labels
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary labels",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-extra-label"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            unexpected: "This label '{{name}}' is unnecessary."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        let scopeInfo = null;
-
-        /**
-         * Creates a new scope with a breakable statement.
-         * @param {ASTNode} node A node to create. This is a BreakableStatement.
-         * @returns {void}
-         */
-        function enterBreakableStatement(node) {
-            scopeInfo = {
-                label: node.parent.type === "LabeledStatement" ? node.parent.label : null,
-                breakable: true,
-                upper: scopeInfo
-            };
-        }
-
-        /**
-         * Removes the top scope of the stack.
-         * @returns {void}
-         */
-        function exitBreakableStatement() {
-            scopeInfo = scopeInfo.upper;
-        }
-
-        /**
-         * Creates a new scope with a labeled statement.
-         *
-         * This ignores it if the body is a breakable statement.
-         * In this case it's handled in the `enterBreakableStatement` function.
-         * @param {ASTNode} node A node to create. This is a LabeledStatement.
-         * @returns {void}
-         */
-        function enterLabeledStatement(node) {
-            if (!astUtils.isBreakableStatement(node.body)) {
-                scopeInfo = {
-                    label: node.label,
-                    breakable: false,
-                    upper: scopeInfo
-                };
-            }
-        }
-
-        /**
-         * Removes the top scope of the stack.
-         *
-         * This ignores it if the body is a breakable statement.
-         * In this case it's handled in the `exitBreakableStatement` function.
-         * @param {ASTNode} node A node. This is a LabeledStatement.
-         * @returns {void}
-         */
-        function exitLabeledStatement(node) {
-            if (!astUtils.isBreakableStatement(node.body)) {
-                scopeInfo = scopeInfo.upper;
-            }
-        }
-
-        /**
-         * Reports a given control node if it's unnecessary.
-         * @param {ASTNode} node A node. This is a BreakStatement or a
-         *      ContinueStatement.
-         * @returns {void}
-         */
-        function reportIfUnnecessary(node) {
-            if (!node.label) {
-                return;
-            }
-
-            const labelNode = node.label;
-
-            for (let info = scopeInfo; info !== null; info = info.upper) {
-                if (info.breakable || info.label && info.label.name === labelNode.name) {
-                    if (info.breakable && info.label && info.label.name === labelNode.name) {
-                        context.report({
-                            node: labelNode,
-                            messageId: "unexpected",
-                            data: labelNode,
-                            fix(fixer) {
-                                const breakOrContinueToken = sourceCode.getFirstToken(node);
-
-                                if (sourceCode.commentsExistBetween(breakOrContinueToken, labelNode)) {
-                                    return null;
-                                }
-
-                                return fixer.removeRange([breakOrContinueToken.range[1], labelNode.range[1]]);
-                            }
-                        });
-                    }
-                    return;
-                }
-            }
-        }
-
-        return {
-            WhileStatement: enterBreakableStatement,
-            "WhileStatement:exit": exitBreakableStatement,
-            DoWhileStatement: enterBreakableStatement,
-            "DoWhileStatement:exit": exitBreakableStatement,
-            ForStatement: enterBreakableStatement,
-            "ForStatement:exit": exitBreakableStatement,
-            ForInStatement: enterBreakableStatement,
-            "ForInStatement:exit": exitBreakableStatement,
-            ForOfStatement: enterBreakableStatement,
-            "ForOfStatement:exit": exitBreakableStatement,
-            SwitchStatement: enterBreakableStatement,
-            "SwitchStatement:exit": exitBreakableStatement,
-            LabeledStatement: enterLabeledStatement,
-            "LabeledStatement:exit": exitLabeledStatement,
-            BreakStatement: reportIfUnnecessary,
-            ContinueStatement: reportIfUnnecessary
-        };
-    }
-};