create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint/lib/rules/array-element-newline.js

@@ -1,311 +0,0 @@
-/**
- * @fileoverview Rule to enforce line breaks after each array element
- * @author Jan Peer Stöcklmair <https://github.com/JPeer264>
- * @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 line breaks after each array element",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/array-element-newline"
-        },
-
-        fixable: "whitespace",
-
-        schema: {
-            definitions: {
-                basicConfig: {
-                    oneOf: [
-                        {
-                            enum: ["always", "never", "consistent"]
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                multiline: {
-                                    type: "boolean"
-                                },
-                                minItems: {
-                                    type: ["integer", "null"],
-                                    minimum: 0
-                                }
-                            },
-                            additionalProperties: false
-                        }
-                    ]
-                }
-            },
-            type: "array",
-            items: [
-                {
-                    oneOf: [
-                        {
-                            $ref: "#/definitions/basicConfig"
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                ArrayExpression: {
-                                    $ref: "#/definitions/basicConfig"
-                                },
-                                ArrayPattern: {
-                                    $ref: "#/definitions/basicConfig"
-                                }
-                            },
-                            additionalProperties: false,
-                            minProperties: 1
-                        }
-                    ]
-                }
-            ]
-        },
-
-        messages: {
-            unexpectedLineBreak: "There should be no linebreak here.",
-            missingLineBreak: "There should be a linebreak after this element."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-
-        /**
-         * Normalizes a given option value.
-         * @param {string|Object|undefined} providedOption An option value to parse.
-         * @returns {{multiline: boolean, minItems: number}} Normalized option object.
-         */
-        function normalizeOptionValue(providedOption) {
-            let consistent = false;
-            let multiline = false;
-            let minItems;
-
-            const option = providedOption || "always";
-
-            if (!option || option === "always" || option.minItems === 0) {
-                minItems = 0;
-            } else if (option === "never") {
-                minItems = Number.POSITIVE_INFINITY;
-            } else if (option === "consistent") {
-                consistent = true;
-                minItems = Number.POSITIVE_INFINITY;
-            } else {
-                multiline = Boolean(option.multiline);
-                minItems = option.minItems || Number.POSITIVE_INFINITY;
-            }
-
-            return { consistent, multiline, minItems };
-        }
-
-        /**
-         * Normalizes a given option value.
-         * @param {string|Object|undefined} options An option value to parse.
-         * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
-         */
-        function normalizeOptions(options) {
-            if (options && (options.ArrayExpression || options.ArrayPattern)) {
-                let expressionOptions, patternOptions;
-
-                if (options.ArrayExpression) {
-                    expressionOptions = normalizeOptionValue(options.ArrayExpression);
-                }
-
-                if (options.ArrayPattern) {
-                    patternOptions = normalizeOptionValue(options.ArrayPattern);
-                }
-
-                return { ArrayExpression: expressionOptions, ArrayPattern: patternOptions };
-            }
-
-            const value = normalizeOptionValue(options);
-
-            return { ArrayExpression: value, ArrayPattern: value };
-        }
-
-        /**
-         * Reports that there shouldn't be a line break after the first token
-         * @param {Token} token The token to use for the report.
-         * @returns {void}
-         */
-        function reportNoLineBreak(token) {
-            const tokenBefore = sourceCode.getTokenBefore(token, { includeComments: true });
-
-            context.report({
-                loc: {
-                    start: tokenBefore.loc.end,
-                    end: token.loc.start
-                },
-                messageId: "unexpectedLineBreak",
-                fix(fixer) {
-                    if (astUtils.isCommentToken(tokenBefore)) {
-                        return null;
-                    }
-
-                    if (!astUtils.isTokenOnSameLine(tokenBefore, token)) {
-                        return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ");
-                    }
-
-                    /*
-                     * This will check if the comma is on the same line as the next element
-                     * Following array:
-                     * [
-                     *     1
-                     *     , 2
-                     *     , 3
-                     * ]
-                     *
-                     * will be fixed to:
-                     * [
-                     *     1, 2, 3
-                     * ]
-                     */
-                    const twoTokensBefore = sourceCode.getTokenBefore(tokenBefore, { includeComments: true });
-
-                    if (astUtils.isCommentToken(twoTokensBefore)) {
-                        return null;
-                    }
-
-                    return fixer.replaceTextRange([twoTokensBefore.range[1], tokenBefore.range[0]], "");
-
-                }
-            });
-        }
-
-        /**
-         * Reports that there should be a line break after the first token
-         * @param {Token} token The token to use for the report.
-         * @returns {void}
-         */
-        function reportRequiredLineBreak(token) {
-            const tokenBefore = sourceCode.getTokenBefore(token, { includeComments: true });
-
-            context.report({
-                loc: {
-                    start: tokenBefore.loc.end,
-                    end: token.loc.start
-                },
-                messageId: "missingLineBreak",
-                fix(fixer) {
-                    return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n");
-                }
-            });
-        }
-
-        /**
-         * Reports a given node if it violated this rule.
-         * @param {ASTNode} node A node to check. This is an ObjectExpression node or an ObjectPattern node.
-         * @returns {void}
-         */
-        function check(node) {
-            const elements = node.elements;
-            const normalizedOptions = normalizeOptions(context.options[0]);
-            const options = normalizedOptions[node.type];
-
-            if (!options) {
-                return;
-            }
-
-            let elementBreak = false;
-
-            /*
-             * MULTILINE: true
-             * loop through every element and check
-             * if at least one element has linebreaks inside
-             * this ensures that following is not valid (due to elements are on the same line):
-             *
-             * [
-             *      1,
-             *      2,
-             *      3
-             * ]
-             */
-            if (options.multiline) {
-                elementBreak = elements
-                    .filter(element => element !== null)
-                    .some(element => element.loc.start.line !== element.loc.end.line);
-            }
-
-            let linebreaksCount = 0;
-
-            for (let i = 0; i < node.elements.length; i++) {
-                const element = node.elements[i];
-
-                const previousElement = elements[i - 1];
-
-                if (i === 0 || element === null || previousElement === null) {
-                    continue;
-                }
-
-                const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils.isCommaToken);
-                const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);
-                const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
-
-                if (!astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) {
-                    linebreaksCount++;
-                }
-            }
-
-            const needsLinebreaks = (
-                elements.length >= options.minItems ||
-                (
-                    options.multiline &&
-                    elementBreak
-                ) ||
-                (
-                    options.consistent &&
-                    linebreaksCount > 0 &&
-                    linebreaksCount < node.elements.length
-                )
-            );
-
-            elements.forEach((element, i) => {
-                const previousElement = elements[i - 1];
-
-                if (i === 0 || element === null || previousElement === null) {
-                    return;
-                }
-
-                const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils.isCommaToken);
-                const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);
-                const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
-
-                if (needsLinebreaks) {
-                    if (astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) {
-                        reportRequiredLineBreak(firstTokenOfCurrentElement);
-                    }
-                } else {
-                    if (!astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) {
-                        reportNoLineBreak(firstTokenOfCurrentElement);
-                    }
-                }
-            });
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-            ArrayPattern: check,
-            ArrayExpression: check
-        };
-    }
-};

package/template/lib/react/node_modules/eslint/lib/rules/arrow-body-style.js

@@ -1,296 +0,0 @@
-/**
- * @fileoverview Rule to require braces in arrow function body.
- * @author Alberto Rodríguez
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require braces around arrow function bodies",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/arrow-body-style"
-        },
-
-        schema: {
-            anyOf: [
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["always", "never"]
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 1
-                },
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["as-needed"]
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                requireReturnForObjectLiteral: { type: "boolean" }
-                            },
-                            additionalProperties: false
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 2
-                }
-            ]
-        },
-
-        fixable: "code",
-
-        messages: {
-            unexpectedOtherBlock: "Unexpected block statement surrounding arrow body.",
-            unexpectedEmptyBlock: "Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.",
-            unexpectedObjectBlock: "Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.",
-            unexpectedSingleBlock: "Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.",
-            expectedBlock: "Expected block statement surrounding arrow body."
-        }
-    },
-
-    create(context) {
-        const options = context.options;
-        const always = options[0] === "always";
-        const asNeeded = !options[0] || options[0] === "as-needed";
-        const never = options[0] === "never";
-        const requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral;
-        const sourceCode = context.sourceCode;
-        let funcInfo = null;
-
-        /**
-         * Checks whether the given node has ASI problem or not.
-         * @param {Token} token The token to check.
-         * @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed.
-         */
-        function hasASIProblem(token) {
-            return token && token.type === "Punctuator" && /^[([/`+-]/u.test(token.value);
-        }
-
-        /**
-         * Gets the closing parenthesis by the given node.
-         * @param {ASTNode} node first node after an opening parenthesis.
-         * @returns {Token} The found closing parenthesis token.
-         */
-        function findClosingParen(node) {
-            let nodeToCheck = node;
-
-            while (!astUtils.isParenthesised(sourceCode, nodeToCheck)) {
-                nodeToCheck = nodeToCheck.parent;
-            }
-            return sourceCode.getTokenAfter(nodeToCheck);
-        }
-
-        /**
-         * Check whether the node is inside of a for loop's init
-         * @param {ASTNode} node node is inside for loop
-         * @returns {boolean} `true` if the node is inside of a for loop, else `false`
-         */
-        function isInsideForLoopInitializer(node) {
-            if (node && node.parent) {
-                if (node.parent.type === "ForStatement" && node.parent.init === node) {
-                    return true;
-                }
-                return isInsideForLoopInitializer(node.parent);
-            }
-            return false;
-        }
-
-        /**
-         * Determines whether a arrow function body needs braces
-         * @param {ASTNode} node The arrow function node.
-         * @returns {void}
-         */
-        function validate(node) {
-            const arrowBody = node.body;
-
-            if (arrowBody.type === "BlockStatement") {
-                const blockBody = arrowBody.body;
-
-                if (blockBody.length !== 1 && !never) {
-                    return;
-                }
-
-                if (asNeeded && requireReturnForObjectLiteral && blockBody[0].type === "ReturnStatement" &&
-                    blockBody[0].argument && blockBody[0].argument.type === "ObjectExpression") {
-                    return;
-                }
-
-                if (never || asNeeded && blockBody[0].type === "ReturnStatement") {
-                    let messageId;
-
-                    if (blockBody.length === 0) {
-                        messageId = "unexpectedEmptyBlock";
-                    } else if (blockBody.length > 1) {
-                        messageId = "unexpectedOtherBlock";
-                    } else if (blockBody[0].argument === null) {
-                        messageId = "unexpectedSingleBlock";
-                    } else if (astUtils.isOpeningBraceToken(sourceCode.getFirstToken(blockBody[0], { skip: 1 }))) {
-                        messageId = "unexpectedObjectBlock";
-                    } else {
-                        messageId = "unexpectedSingleBlock";
-                    }
-
-                    context.report({
-                        node,
-                        loc: arrowBody.loc,
-                        messageId,
-                        fix(fixer) {
-                            const fixes = [];
-
-                            if (blockBody.length !== 1 ||
-                                blockBody[0].type !== "ReturnStatement" ||
-                                !blockBody[0].argument ||
-                                hasASIProblem(sourceCode.getTokenAfter(arrowBody))
-                            ) {
-                                return fixes;
-                            }
-
-                            const openingBrace = sourceCode.getFirstToken(arrowBody);
-                            const closingBrace = sourceCode.getLastToken(arrowBody);
-                            const firstValueToken = sourceCode.getFirstToken(blockBody[0], 1);
-                            const lastValueToken = sourceCode.getLastToken(blockBody[0]);
-                            const commentsExist =
-                                sourceCode.commentsExistBetween(openingBrace, firstValueToken) ||
-                                sourceCode.commentsExistBetween(lastValueToken, closingBrace);
-
-                            /*
-                             * Remove tokens around the return value.
-                             * If comments don't exist, remove extra spaces as well.
-                             */
-                            if (commentsExist) {
-                                fixes.push(
-                                    fixer.remove(openingBrace),
-                                    fixer.remove(closingBrace),
-                                    fixer.remove(sourceCode.getTokenAfter(openingBrace)) // return keyword
-                                );
-                            } else {
-                                fixes.push(
-                                    fixer.removeRange([openingBrace.range[0], firstValueToken.range[0]]),
-                                    fixer.removeRange([lastValueToken.range[1], closingBrace.range[1]])
-                                );
-                            }
-
-                            /*
-                             * If the first token of the return value is `{` or the return value is a sequence expression,
-                             * enclose the return value by parentheses to avoid syntax error.
-                             */
-                            if (astUtils.isOpeningBraceToken(firstValueToken) || blockBody[0].argument.type === "SequenceExpression" || (funcInfo.hasInOperator && isInsideForLoopInitializer(node))) {
-                                if (!astUtils.isParenthesised(sourceCode, blockBody[0].argument)) {
-                                    fixes.push(
-                                        fixer.insertTextBefore(firstValueToken, "("),
-                                        fixer.insertTextAfter(lastValueToken, ")")
-                                    );
-                                }
-                            }
-
-                            /*
-                             * If the last token of the return statement is semicolon, remove it.
-                             * Non-block arrow body is an expression, not a statement.
-                             */
-                            if (astUtils.isSemicolonToken(lastValueToken)) {
-                                fixes.push(fixer.remove(lastValueToken));
-                            }
-
-                            return fixes;
-                        }
-                    });
-                }
-            } else {
-                if (always || (asNeeded && requireReturnForObjectLiteral && arrowBody.type === "ObjectExpression")) {
-                    context.report({
-                        node,
-                        loc: arrowBody.loc,
-                        messageId: "expectedBlock",
-                        fix(fixer) {
-                            const fixes = [];
-                            const arrowToken = sourceCode.getTokenBefore(arrowBody, astUtils.isArrowToken);
-                            const [firstTokenAfterArrow, secondTokenAfterArrow] = sourceCode.getTokensAfter(arrowToken, { count: 2 });
-                            const lastToken = sourceCode.getLastToken(node);
-
-                            let parenthesisedObjectLiteral = null;
-
-                            if (
-                                astUtils.isOpeningParenToken(firstTokenAfterArrow) &&
-                                astUtils.isOpeningBraceToken(secondTokenAfterArrow)
-                            ) {
-                                const braceNode = sourceCode.getNodeByRangeIndex(secondTokenAfterArrow.range[0]);
-
-                                if (braceNode.type === "ObjectExpression") {
-                                    parenthesisedObjectLiteral = braceNode;
-                                }
-                            }
-
-                            // If the value is object literal, remove parentheses which were forced by syntax.
-                            if (parenthesisedObjectLiteral) {
-                                const openingParenToken = firstTokenAfterArrow;
-                                const openingBraceToken = secondTokenAfterArrow;
-
-                                if (astUtils.isTokenOnSameLine(openingParenToken, openingBraceToken)) {
-                                    fixes.push(fixer.replaceText(openingParenToken, "{return "));
-                                } else {
-
-                                    // Avoid ASI
-                                    fixes.push(
-                                        fixer.replaceText(openingParenToken, "{"),
-                                        fixer.insertTextBefore(openingBraceToken, "return ")
-                                    );
-                                }
-
-                                // Closing paren for the object doesn't have to be lastToken, e.g.: () => ({}).foo()
-                                fixes.push(fixer.remove(findClosingParen(parenthesisedObjectLiteral)));
-                                fixes.push(fixer.insertTextAfter(lastToken, "}"));
-
-                            } else {
-                                fixes.push(fixer.insertTextBefore(firstTokenAfterArrow, "{return "));
-                                fixes.push(fixer.insertTextAfter(lastToken, "}"));
-                            }
-
-                            return fixes;
-                        }
-                    });
-                }
-            }
-        }
-
-        return {
-            "BinaryExpression[operator='in']"() {
-                let info = funcInfo;
-
-                while (info) {
-                    info.hasInOperator = true;
-                    info = info.upper;
-                }
-            },
-            ArrowFunctionExpression() {
-                funcInfo = {
-                    upper: funcInfo,
-                    hasInOperator: false
-                };
-            },
-            "ArrowFunctionExpression:exit"(node) {
-                validate(node);
-                funcInfo = funcInfo.upper;
-            }
-        };
-    }
-};