create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint/lib/rules/no-unsafe-negation.js

@@ -1,128 +0,0 @@
-/**
- * @fileoverview Rule to disallow negating the left operand of relational operators
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether the given operator is `in` or `instanceof`
- * @param {string} op The operator type to check.
- * @returns {boolean} `true` if the operator is `in` or `instanceof`
- */
-function isInOrInstanceOfOperator(op) {
-    return op === "in" || op === "instanceof";
-}
-
-/**
- * Checks whether the given operator is an ordering relational operator or not.
- * @param {string} op The operator type to check.
- * @returns {boolean} `true` if the operator is an ordering relational operator.
- */
-function isOrderingRelationalOperator(op) {
-    return op === "<" || op === ">" || op === ">=" || op === "<=";
-}
-
-/**
- * Checks whether the given node is a logical negation expression or not.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is a logical negation expression.
- */
-function isNegation(node) {
-    return node.type === "UnaryExpression" && node.operator === "!";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow negating the left operand of relational operators",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-unsafe-negation"
-        },
-
-        hasSuggestions: true,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    enforceForOrderingRelations: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: null,
-
-        messages: {
-            unexpected: "Unexpected negating the left operand of '{{operator}}' operator.",
-            suggestNegatedExpression: "Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.",
-            suggestParenthesisedNegation: "Wrap negation in '()' to make the intention explicit. This preserves the current behavior."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = context.options[0] || {};
-        const enforceForOrderingRelations = options.enforceForOrderingRelations === true;
-
-        return {
-            BinaryExpression(node) {
-                const operator = node.operator;
-                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(operator);
-
-                if (
-                    (isInOrInstanceOfOperator(operator) || orderingRelationRuleApplies) &&
-                    isNegation(node.left) &&
-                    !astUtils.isParenthesised(sourceCode, node.left)
-                ) {
-                    context.report({
-                        node,
-                        loc: node.left.loc,
-                        messageId: "unexpected",
-                        data: { operator },
-                        suggest: [
-                            {
-                                messageId: "suggestNegatedExpression",
-                                data: { operator },
-                                fix(fixer) {
-                                    const negationToken = sourceCode.getFirstToken(node.left);
-                                    const fixRange = [negationToken.range[1], node.range[1]];
-                                    const text = sourceCode.text.slice(fixRange[0], fixRange[1]);
-
-                                    return fixer.replaceTextRange(fixRange, `(${text})`);
-                                }
-                            },
-                            {
-                                messageId: "suggestParenthesisedNegation",
-                                fix(fixer) {
-                                    return fixer.replaceText(node.left, `(${sourceCode.getText(node.left)})`);
-                                }
-                            }
-                        ]
-                    });
-                }
-            }
-        };
-    }
-};

package/template/lib/react/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js

@@ -1,205 +0,0 @@
-/**
- * @fileoverview Rule to disallow unsafe optional chaining
- * @author Yeon JuAn
- */
-
-"use strict";
-
-const UNSAFE_ARITHMETIC_OPERATORS = new Set(["+", "-", "/", "*", "%", "**"]);
-const UNSAFE_ASSIGNMENT_OPERATORS = new Set(["+=", "-=", "/=", "*=", "%=", "**="]);
-const UNSAFE_RELATIONAL_OPERATORS = new Set(["in", "instanceof"]);
-
-/**
- * Checks whether a node is a destructuring pattern or not
- * @param {ASTNode} node node to check
- * @returns {boolean} `true` if a node is a destructuring pattern, otherwise `false`
- */
-function isDestructuringPattern(node) {
-    return node.type === "ObjectPattern" || node.type === "ArrayPattern";
-}
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow use of optional chaining in contexts where the `undefined` value is not allowed",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining"
-        },
-        schema: [{
-            type: "object",
-            properties: {
-                disallowArithmeticOperators: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-        fixable: null,
-        messages: {
-            unsafeOptionalChain: "Unsafe usage of optional chaining. If it short-circuits with 'undefined' the evaluation will throw TypeError.",
-            unsafeArithmetic: "Unsafe arithmetic operation on optional chaining. It can result in NaN."
-        }
-    },
-
-    create(context) {
-        const options = context.options[0] || {};
-        const disallowArithmeticOperators = (options.disallowArithmeticOperators) || false;
-
-        /**
-         * Reports unsafe usage of optional chaining
-         * @param {ASTNode} node node to report
-         * @returns {void}
-         */
-        function reportUnsafeUsage(node) {
-            context.report({
-                messageId: "unsafeOptionalChain",
-                node
-            });
-        }
-
-        /**
-         * Reports unsafe arithmetic operation on optional chaining
-         * @param {ASTNode} node node to report
-         * @returns {void}
-         */
-        function reportUnsafeArithmetic(node) {
-            context.report({
-                messageId: "unsafeArithmetic",
-                node
-            });
-        }
-
-        /**
-         * Checks and reports if a node can short-circuit with `undefined` by optional chaining.
-         * @param {ASTNode} [node] node to check
-         * @param {Function} reportFunc report function
-         * @returns {void}
-         */
-        function checkUndefinedShortCircuit(node, reportFunc) {
-            if (!node) {
-                return;
-            }
-            switch (node.type) {
-                case "LogicalExpression":
-                    if (node.operator === "||" || node.operator === "??") {
-                        checkUndefinedShortCircuit(node.right, reportFunc);
-                    } else if (node.operator === "&&") {
-                        checkUndefinedShortCircuit(node.left, reportFunc);
-                        checkUndefinedShortCircuit(node.right, reportFunc);
-                    }
-                    break;
-                case "SequenceExpression":
-                    checkUndefinedShortCircuit(
-                        node.expressions[node.expressions.length - 1],
-                        reportFunc
-                    );
-                    break;
-                case "ConditionalExpression":
-                    checkUndefinedShortCircuit(node.consequent, reportFunc);
-                    checkUndefinedShortCircuit(node.alternate, reportFunc);
-                    break;
-                case "AwaitExpression":
-                    checkUndefinedShortCircuit(node.argument, reportFunc);
-                    break;
-                case "ChainExpression":
-                    reportFunc(node);
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        /**
-         * Checks unsafe usage of optional chaining
-         * @param {ASTNode} node node to check
-         * @returns {void}
-         */
-        function checkUnsafeUsage(node) {
-            checkUndefinedShortCircuit(node, reportUnsafeUsage);
-        }
-
-        /**
-         * Checks unsafe arithmetic operations on optional chaining
-         * @param {ASTNode} node node to check
-         * @returns {void}
-         */
-        function checkUnsafeArithmetic(node) {
-            checkUndefinedShortCircuit(node, reportUnsafeArithmetic);
-        }
-
-        return {
-            "AssignmentExpression, AssignmentPattern"(node) {
-                if (isDestructuringPattern(node.left)) {
-                    checkUnsafeUsage(node.right);
-                }
-            },
-            "ClassDeclaration, ClassExpression"(node) {
-                checkUnsafeUsage(node.superClass);
-            },
-            CallExpression(node) {
-                if (!node.optional) {
-                    checkUnsafeUsage(node.callee);
-                }
-            },
-            NewExpression(node) {
-                checkUnsafeUsage(node.callee);
-            },
-            VariableDeclarator(node) {
-                if (isDestructuringPattern(node.id)) {
-                    checkUnsafeUsage(node.init);
-                }
-            },
-            MemberExpression(node) {
-                if (!node.optional) {
-                    checkUnsafeUsage(node.object);
-                }
-            },
-            TaggedTemplateExpression(node) {
-                checkUnsafeUsage(node.tag);
-            },
-            ForOfStatement(node) {
-                checkUnsafeUsage(node.right);
-            },
-            SpreadElement(node) {
-                if (node.parent && node.parent.type !== "ObjectExpression") {
-                    checkUnsafeUsage(node.argument);
-                }
-            },
-            BinaryExpression(node) {
-                if (UNSAFE_RELATIONAL_OPERATORS.has(node.operator)) {
-                    checkUnsafeUsage(node.right);
-                }
-                if (
-                    disallowArithmeticOperators &&
-                    UNSAFE_ARITHMETIC_OPERATORS.has(node.operator)
-                ) {
-                    checkUnsafeArithmetic(node.right);
-                    checkUnsafeArithmetic(node.left);
-                }
-            },
-            WithStatement(node) {
-                checkUnsafeUsage(node.object);
-            },
-            UnaryExpression(node) {
-                if (
-                    disallowArithmeticOperators &&
-                    UNSAFE_ARITHMETIC_OPERATORS.has(node.operator)
-                ) {
-                    checkUnsafeArithmetic(node.argument);
-                }
-            },
-            AssignmentExpression(node) {
-                if (
-                    disallowArithmeticOperators &&
-                    UNSAFE_ASSIGNMENT_OPERATORS.has(node.operator)
-                ) {
-                    checkUnsafeArithmetic(node.right);
-                }
-            }
-        };
-    }
-};

package/template/lib/react/node_modules/eslint/lib/rules/no-unused-expressions.js

@@ -1,186 +0,0 @@
-/**
- * @fileoverview Flag expressions in statement position that do not side effect
- * @author Michael Ficarra
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * Returns `true`.
- * @returns {boolean} `true`.
- */
-function alwaysTrue() {
-    return true;
-}
-
-/**
- * Returns `false`.
- * @returns {boolean} `false`.
- */
-function alwaysFalse() {
-    return false;
-}
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unused expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-unused-expressions"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowShortCircuit: {
-                        type: "boolean",
-                        default: false
-                    },
-                    allowTernary: {
-                        type: "boolean",
-                        default: false
-                    },
-                    allowTaggedTemplates: {
-                        type: "boolean",
-                        default: false
-                    },
-                    enforceForJSX: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unusedExpression: "Expected an assignment or function call and instead saw an expression."
-        }
-    },
-
-    create(context) {
-        const config = context.options[0] || {},
-            allowShortCircuit = config.allowShortCircuit || false,
-            allowTernary = config.allowTernary || false,
-            allowTaggedTemplates = config.allowTaggedTemplates || false,
-            enforceForJSX = config.enforceForJSX || false;
-
-        /**
-         * Has AST suggesting a directive.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node structurally represents a directive
-         */
-        function looksLikeDirective(node) {
-            return node.type === "ExpressionStatement" &&
-                node.expression.type === "Literal" && typeof node.expression.value === "string";
-        }
-
-        /**
-         * Gets the leading sequence of members in a list that pass the predicate.
-         * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
-         * @param {a[]} list the input list
-         * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
-         */
-        function takeWhile(predicate, list) {
-            for (let i = 0; i < list.length; ++i) {
-                if (!predicate(list[i])) {
-                    return list.slice(0, i);
-                }
-            }
-            return list.slice();
-        }
-
-        /**
-         * Gets leading directives nodes in a Node body.
-         * @param {ASTNode} node a Program or BlockStatement node
-         * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
-         */
-        function directives(node) {
-            return takeWhile(looksLikeDirective, node.body);
-        }
-
-        /**
-         * Detect if a Node is a directive.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node is considered a directive in its current position
-         */
-        function isDirective(node) {
-
-            /**
-             * https://tc39.es/ecma262/#directive-prologue
-             *
-             * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
-             * Class static blocks do not have directive prologue.
-             */
-            return astUtils.isTopLevelExpressionStatement(node) && directives(node.parent).includes(node);
-        }
-
-        /**
-         * The member functions return `true` if the type has no side-effects.
-         * Unknown nodes are handled as `false`, then this rule ignores those.
-         */
-        const Checker = Object.assign(Object.create(null), {
-            isDisallowed(node) {
-                return (Checker[node.type] || alwaysFalse)(node);
-            },
-
-            ArrayExpression: alwaysTrue,
-            ArrowFunctionExpression: alwaysTrue,
-            BinaryExpression: alwaysTrue,
-            ChainExpression(node) {
-                return Checker.isDisallowed(node.expression);
-            },
-            ClassExpression: alwaysTrue,
-            ConditionalExpression(node) {
-                if (allowTernary) {
-                    return Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate);
-                }
-                return true;
-            },
-            FunctionExpression: alwaysTrue,
-            Identifier: alwaysTrue,
-            JSXElement() {
-                return enforceForJSX;
-            },
-            JSXFragment() {
-                return enforceForJSX;
-            },
-            Literal: alwaysTrue,
-            LogicalExpression(node) {
-                if (allowShortCircuit) {
-                    return Checker.isDisallowed(node.right);
-                }
-                return true;
-            },
-            MemberExpression: alwaysTrue,
-            MetaProperty: alwaysTrue,
-            ObjectExpression: alwaysTrue,
-            SequenceExpression: alwaysTrue,
-            TaggedTemplateExpression() {
-                return !allowTaggedTemplates;
-            },
-            TemplateLiteral: alwaysTrue,
-            ThisExpression: alwaysTrue,
-            UnaryExpression(node) {
-                return node.operator !== "void" && node.operator !== "delete";
-            }
-        });
-
-        return {
-            ExpressionStatement(node) {
-                if (Checker.isDisallowed(node.expression) && !isDirective(node)) {
-                    context.report({ node, messageId: "unusedExpression" });
-                }
-            }
-        };
-    }
-};

package/template/lib/react/node_modules/eslint/lib/rules/no-unused-labels.js

@@ -1,143 +0,0 @@
-/**
- * @fileoverview Rule to disallow unused 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 unused labels",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-unused-labels"
-        },
-
-        schema: [],
-
-        fixable: "code",
-
-        messages: {
-            unused: "'{{name}}:' is defined but never used."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        let scopeInfo = null;
-
-        /**
-         * Adds a scope info to the stack.
-         * @param {ASTNode} node A node to add. This is a LabeledStatement.
-         * @returns {void}
-         */
-        function enterLabeledScope(node) {
-            scopeInfo = {
-                label: node.label.name,
-                used: false,
-                upper: scopeInfo
-            };
-        }
-
-        /**
-         * Checks if a `LabeledStatement` node is fixable.
-         * For a node to be fixable, there must be no comments between the label and the body.
-         * Furthermore, is must be possible to remove the label without turning the body statement into a
-         * directive after other fixes are applied.
-         * @param {ASTNode} node The node to evaluate.
-         * @returns {boolean} Whether or not the node is fixable.
-         */
-        function isFixable(node) {
-
-            /*
-             * Only perform a fix if there are no comments between the label and the body. This will be the case
-             * when there is exactly one token/comment (the ":") between the label and the body.
-             */
-            if (sourceCode.getTokenAfter(node.label, { includeComments: true }) !==
-                sourceCode.getTokenBefore(node.body, { includeComments: true })) {
-                return false;
-            }
-
-            // Looking for the node's deepest ancestor which is not a `LabeledStatement`.
-            let ancestor = node.parent;
-
-            while (ancestor.type === "LabeledStatement") {
-                ancestor = ancestor.parent;
-            }
-
-            if (ancestor.type === "Program" ||
-                (ancestor.type === "BlockStatement" && astUtils.isFunction(ancestor.parent))) {
-                const { body } = node;
-
-                if (body.type === "ExpressionStatement" &&
-                    ((body.expression.type === "Literal" && typeof body.expression.value === "string") ||
-                    astUtils.isStaticTemplateLiteral(body.expression))) {
-                    return false; // potential directive
-                }
-            }
-            return true;
-        }
-
-        /**
-         * Removes the top of the stack.
-         * At the same time, this reports the label if it's never used.
-         * @param {ASTNode} node A node to report. This is a LabeledStatement.
-         * @returns {void}
-         */
-        function exitLabeledScope(node) {
-            if (!scopeInfo.used) {
-                context.report({
-                    node: node.label,
-                    messageId: "unused",
-                    data: node.label,
-                    fix: isFixable(node) ? fixer => fixer.removeRange([node.range[0], node.body.range[0]]) : null
-                });
-            }
-
-            scopeInfo = scopeInfo.upper;
-        }
-
-        /**
-         * Marks the label of a given node as used.
-         * @param {ASTNode} node A node to mark. This is a BreakStatement or
-         *      ContinueStatement.
-         * @returns {void}
-         */
-        function markAsUsed(node) {
-            if (!node.label) {
-                return;
-            }
-
-            const label = node.label.name;
-            let info = scopeInfo;
-
-            while (info) {
-                if (info.label === label) {
-                    info.used = true;
-                    break;
-                }
-                info = info.upper;
-            }
-        }
-
-        return {
-            LabeledStatement: enterLabeledScope,
-            "LabeledStatement:exit": exitLabeledScope,
-            BreakStatement: markAsUsed,
-            ContinueStatement: markAsUsed
-        };
-    }
-};