create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint/lib/rules/comma-spacing.js

@@ -0,0 +1,192 @@
+/**
+ * @fileoverview Comma spacing - validates spacing before and after comma
+ * @author Vignesh Anand aka vegetableman.
+ * @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 consistent spacing before and after commas",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/comma-spacing"
+        },
+
+        fixable: "whitespace",
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    before: {
+                        type: "boolean",
+                        default: false
+                    },
+                    after: {
+                        type: "boolean",
+                        default: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            missing: "A space is required {{loc}} ','.",
+            unexpected: "There should be no space {{loc}} ','."
+        }
+    },
+
+    create(context) {
+
+        const sourceCode = context.sourceCode;
+        const tokensAndComments = sourceCode.tokensAndComments;
+
+        const options = {
+            before: context.options[0] ? context.options[0].before : false,
+            after: context.options[0] ? context.options[0].after : true
+        };
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        // list of comma tokens to ignore for the check of leading whitespace
+        const commaTokensToIgnore = [];
+
+        /**
+         * Reports a spacing error with an appropriate message.
+         * @param {ASTNode} node The binary expression node to report.
+         * @param {string} loc Is the error "before" or "after" the comma?
+         * @param {ASTNode} otherNode The node at the left or right of `node`
+         * @returns {void}
+         * @private
+         */
+        function report(node, loc, otherNode) {
+            context.report({
+                node,
+                fix(fixer) {
+                    if (options[loc]) {
+                        if (loc === "before") {
+                            return fixer.insertTextBefore(node, " ");
+                        }
+                        return fixer.insertTextAfter(node, " ");
+
+                    }
+                    let start, end;
+                    const newText = "";
+
+                    if (loc === "before") {
+                        start = otherNode.range[1];
+                        end = node.range[0];
+                    } else {
+                        start = node.range[1];
+                        end = otherNode.range[0];
+                    }
+
+                    return fixer.replaceTextRange([start, end], newText);
+
+                },
+                messageId: options[loc] ? "missing" : "unexpected",
+                data: {
+                    loc
+                }
+            });
+        }
+
+        /**
+         * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
+         * @param {ASTNode} node An ArrayExpression or ArrayPattern node.
+         * @returns {void}
+         */
+        function addNullElementsToIgnoreList(node) {
+            let previousToken = sourceCode.getFirstToken(node);
+
+            node.elements.forEach(element => {
+                let token;
+
+                if (element === null) {
+                    token = sourceCode.getTokenAfter(previousToken);
+
+                    if (astUtils.isCommaToken(token)) {
+                        commaTokensToIgnore.push(token);
+                    }
+                } else {
+                    token = sourceCode.getTokenAfter(element);
+                }
+
+                previousToken = token;
+            });
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            "Program:exit"() {
+                tokensAndComments.forEach((token, i) => {
+
+                    if (!astUtils.isCommaToken(token)) {
+                        return;
+                    }
+
+                    const previousToken = tokensAndComments[i - 1];
+                    const nextToken = tokensAndComments[i + 1];
+
+                    if (
+                        previousToken &&
+                        !astUtils.isCommaToken(previousToken) && // ignore spacing between two commas
+
+                        /*
+                         * `commaTokensToIgnore` are ending commas of `null` elements (array holes/elisions).
+                         * In addition to spacing between two commas, this can also ignore:
+                         *
+                         *   - Spacing after `[` (controlled by array-bracket-spacing)
+                         *       Example: [ , ]
+                         *                 ^
+                         *   - Spacing after a comment (for backwards compatibility, this was possibly unintentional)
+                         *       Example: [a, /* * / ,]
+                         *                          ^
+                         */
+                        !commaTokensToIgnore.includes(token) &&
+
+                        astUtils.isTokenOnSameLine(previousToken, token) &&
+                        options.before !== sourceCode.isSpaceBetweenTokens(previousToken, token)
+                    ) {
+                        report(token, "before", previousToken);
+                    }
+
+                    if (
+                        nextToken &&
+                        !astUtils.isCommaToken(nextToken) && // ignore spacing between two commas
+                        !astUtils.isClosingParenToken(nextToken) && // controlled by space-in-parens
+                        !astUtils.isClosingBracketToken(nextToken) && // controlled by array-bracket-spacing
+                        !astUtils.isClosingBraceToken(nextToken) && // controlled by object-curly-spacing
+                        !(!options.after && nextToken.type === "Line") && // special case, allow space before line comment
+                        astUtils.isTokenOnSameLine(token, nextToken) &&
+                        options.after !== sourceCode.isSpaceBetweenTokens(token, nextToken)
+                    ) {
+                        report(token, "after", nextToken);
+                    }
+                });
+            },
+            ArrayExpression: addNullElementsToIgnoreList,
+            ArrayPattern: addNullElementsToIgnoreList
+
+        };
+
+    }
+};

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

@@ -0,0 +1,314 @@
+/**
+ * @fileoverview Comma style - enforces comma styles of two types: last and first
+ * @author Vignesh Anand aka vegetableman
+ * @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 consistent comma style",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/comma-style"
+        },
+
+        fixable: "code",
+
+        schema: [
+            {
+                enum: ["first", "last"]
+            },
+            {
+                type: "object",
+                properties: {
+                    exceptions: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "boolean"
+                        }
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            unexpectedLineBeforeAndAfterComma: "Bad line breaking before and after ','.",
+            expectedCommaFirst: "',' should be placed first.",
+            expectedCommaLast: "',' should be placed last."
+        }
+    },
+
+    create(context) {
+        const style = context.options[0] || "last",
+            sourceCode = context.sourceCode;
+        const exceptions = {
+            ArrayPattern: true,
+            ArrowFunctionExpression: true,
+            CallExpression: true,
+            FunctionDeclaration: true,
+            FunctionExpression: true,
+            ImportDeclaration: true,
+            ObjectPattern: true,
+            NewExpression: true
+        };
+
+        if (context.options.length === 2 && Object.prototype.hasOwnProperty.call(context.options[1], "exceptions")) {
+            const keys = Object.keys(context.options[1].exceptions);
+
+            for (let i = 0; i < keys.length; i++) {
+                exceptions[keys[i]] = context.options[1].exceptions[keys[i]];
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        /**
+         * Modified text based on the style
+         * @param {string} styleType Style type
+         * @param {string} text Source code text
+         * @returns {string} modified text
+         * @private
+         */
+        function getReplacedText(styleType, text) {
+            switch (styleType) {
+                case "between":
+                    return `,${text.replace(astUtils.LINEBREAK_MATCHER, "")}`;
+
+                case "first":
+                    return `${text},`;
+
+                case "last":
+                    return `,${text}`;
+
+                default:
+                    return "";
+            }
+        }
+
+        /**
+         * Determines the fixer function for a given style.
+         * @param {string} styleType comma style
+         * @param {ASTNode} previousItemToken The token to check.
+         * @param {ASTNode} commaToken The token to check.
+         * @param {ASTNode} currentItemToken The token to check.
+         * @returns {Function} Fixer function
+         * @private
+         */
+        function getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken) {
+            const text =
+                sourceCode.text.slice(previousItemToken.range[1], commaToken.range[0]) +
+                sourceCode.text.slice(commaToken.range[1], currentItemToken.range[0]);
+            const range = [previousItemToken.range[1], currentItemToken.range[0]];
+
+            return function(fixer) {
+                return fixer.replaceTextRange(range, getReplacedText(styleType, text));
+            };
+        }
+
+        /**
+         * Validates the spacing around single items in lists.
+         * @param {Token} previousItemToken The last token from the previous item.
+         * @param {Token} commaToken The token representing the comma.
+         * @param {Token} currentItemToken The first token of the current item.
+         * @param {Token} reportItem The item to use when reporting an error.
+         * @returns {void}
+         * @private
+         */
+        function validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem) {
+
+            // if single line
+            if (astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
+                    astUtils.isTokenOnSameLine(previousItemToken, commaToken)) {
+
+                // do nothing.
+
+            } else if (!astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
+                    !astUtils.isTokenOnSameLine(previousItemToken, commaToken)) {
+
+                const comment = sourceCode.getCommentsAfter(commaToken)[0];
+                const styleType = comment && comment.type === "Block" && astUtils.isTokenOnSameLine(commaToken, comment)
+                    ? style
+                    : "between";
+
+                // lone comma
+                context.report({
+                    node: reportItem,
+                    loc: commaToken.loc,
+                    messageId: "unexpectedLineBeforeAndAfterComma",
+                    fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken)
+                });
+
+            } else if (style === "first" && !astUtils.isTokenOnSameLine(commaToken, currentItemToken)) {
+
+                context.report({
+                    node: reportItem,
+                    loc: commaToken.loc,
+                    messageId: "expectedCommaFirst",
+                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
+                });
+
+            } else if (style === "last" && astUtils.isTokenOnSameLine(commaToken, currentItemToken)) {
+
+                context.report({
+                    node: reportItem,
+                    loc: commaToken.loc,
+                    messageId: "expectedCommaLast",
+                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
+                });
+            }
+        }
+
+        /**
+         * Checks the comma placement with regards to a declaration/property/element
+         * @param {ASTNode} node The binary expression node to check
+         * @param {string} property The property of the node containing child nodes.
+         * @private
+         * @returns {void}
+         */
+        function validateComma(node, property) {
+            const items = node[property],
+                arrayLiteral = (node.type === "ArrayExpression" || node.type === "ArrayPattern");
+
+            if (items.length > 1 || arrayLiteral) {
+
+                // seed as opening [
+                let previousItemToken = sourceCode.getFirstToken(node);
+
+                items.forEach(item => {
+                    const commaToken = item ? sourceCode.getTokenBefore(item) : previousItemToken,
+                        currentItemToken = item ? sourceCode.getFirstToken(item) : sourceCode.getTokenAfter(commaToken),
+                        reportItem = item || currentItemToken;
+
+                    /*
+                     * This works by comparing three token locations:
+                     * - previousItemToken is the last token of the previous item
+                     * - commaToken is the location of the comma before the current item
+                     * - currentItemToken is the first token of the current item
+                     *
+                     * These values get switched around if item is undefined.
+                     * previousItemToken will refer to the last token not belonging
+                     * to the current item, which could be a comma or an opening
+                     * square bracket. currentItemToken could be a comma.
+                     *
+                     * All comparisons are done based on these tokens directly, so
+                     * they are always valid regardless of an undefined item.
+                     */
+                    if (astUtils.isCommaToken(commaToken)) {
+                        validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem);
+                    }
+
+                    if (item) {
+                        const tokenAfterItem = sourceCode.getTokenAfter(item, astUtils.isNotClosingParenToken);
+
+                        previousItemToken = tokenAfterItem
+                            ? sourceCode.getTokenBefore(tokenAfterItem)
+                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
+                    } else {
+                        previousItemToken = currentItemToken;
+                    }
+                });
+
+                /*
+                 * Special case for array literals that have empty last items, such
+                 * as [ 1, 2, ]. These arrays only have two items show up in the
+                 * AST, so we need to look at the token to verify that there's no
+                 * dangling comma.
+                 */
+                if (arrayLiteral) {
+
+                    const lastToken = sourceCode.getLastToken(node),
+                        nextToLastToken = sourceCode.getTokenBefore(lastToken);
+
+                    if (astUtils.isCommaToken(nextToLastToken)) {
+                        validateCommaItemSpacing(
+                            sourceCode.getTokenBefore(nextToLastToken),
+                            nextToLastToken,
+                            lastToken,
+                            lastToken
+                        );
+                    }
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        const nodes = {};
+
+        if (!exceptions.VariableDeclaration) {
+            nodes.VariableDeclaration = function(node) {
+                validateComma(node, "declarations");
+            };
+        }
+        if (!exceptions.ObjectExpression) {
+            nodes.ObjectExpression = function(node) {
+                validateComma(node, "properties");
+            };
+        }
+        if (!exceptions.ObjectPattern) {
+            nodes.ObjectPattern = function(node) {
+                validateComma(node, "properties");
+            };
+        }
+        if (!exceptions.ArrayExpression) {
+            nodes.ArrayExpression = function(node) {
+                validateComma(node, "elements");
+            };
+        }
+        if (!exceptions.ArrayPattern) {
+            nodes.ArrayPattern = function(node) {
+                validateComma(node, "elements");
+            };
+        }
+        if (!exceptions.FunctionDeclaration) {
+            nodes.FunctionDeclaration = function(node) {
+                validateComma(node, "params");
+            };
+        }
+        if (!exceptions.FunctionExpression) {
+            nodes.FunctionExpression = function(node) {
+                validateComma(node, "params");
+            };
+        }
+        if (!exceptions.ArrowFunctionExpression) {
+            nodes.ArrowFunctionExpression = function(node) {
+                validateComma(node, "params");
+            };
+        }
+        if (!exceptions.CallExpression) {
+            nodes.CallExpression = function(node) {
+                validateComma(node, "arguments");
+            };
+        }
+        if (!exceptions.ImportDeclaration) {
+            nodes.ImportDeclaration = function(node) {
+                validateComma(node, "specifiers");
+            };
+        }
+        if (!exceptions.NewExpression) {
+            nodes.NewExpression = function(node) {
+                validateComma(node, "arguments");
+            };
+        }
+
+        return nodes;
+    }
+};

package/template/lib/react/node_modules/eslint/lib/rules/complexity.js

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Counts the cyclomatic complexity of each function of the script. See http://en.wikipedia.org/wiki/Cyclomatic_complexity.
+ * Counts the number of if, conditional, for, while, try, switch/case,
+ * @author Patrick Brosset
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { upperCaseFirst } = require("../shared/string-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Enforce a maximum cyclomatic complexity allowed in a program",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/complexity"
+        },
+
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: "integer",
+                        minimum: 0
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            maximum: {
+                                type: "integer",
+                                minimum: 0
+                            },
+                            max: {
+                                type: "integer",
+                                minimum: 0
+                            }
+                        },
+                        additionalProperties: false
+                    }
+                ]
+            }
+        ],
+
+        messages: {
+            complex: "{{name}} has a complexity of {{complexity}}. Maximum allowed is {{max}}."
+        }
+    },
+
+    create(context) {
+        const option = context.options[0];
+        let THRESHOLD = 20;
+
+        if (
+            typeof option === "object" &&
+            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+        ) {
+            THRESHOLD = option.maximum || option.max;
+        } else if (typeof option === "number") {
+            THRESHOLD = option;
+        }
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        // Using a stack to store complexity per code path
+        const complexities = [];
+
+        /**
+         * Increase the complexity of the code path in context
+         * @returns {void}
+         * @private
+         */
+        function increaseComplexity() {
+            complexities[complexities.length - 1]++;
+        }
+
+        //--------------------------------------------------------------------------
+        // Public API
+        //--------------------------------------------------------------------------
+
+        return {
+
+            onCodePathStart() {
+
+                // The initial complexity is 1, representing one execution path in the CodePath
+                complexities.push(1);
+            },
+
+            // Each branching in the code adds 1 to the complexity
+            CatchClause: increaseComplexity,
+            ConditionalExpression: increaseComplexity,
+            LogicalExpression: increaseComplexity,
+            ForStatement: increaseComplexity,
+            ForInStatement: increaseComplexity,
+            ForOfStatement: increaseComplexity,
+            IfStatement: increaseComplexity,
+            WhileStatement: increaseComplexity,
+            DoWhileStatement: increaseComplexity,
+
+            // Avoid `default`
+            "SwitchCase[test]": increaseComplexity,
+
+            // Logical assignment operators have short-circuiting behavior
+            AssignmentExpression(node) {
+                if (astUtils.isLogicalAssignmentOperator(node.operator)) {
+                    increaseComplexity();
+                }
+            },
+
+            onCodePathEnd(codePath, node) {
+                const complexity = complexities.pop();
+
+                /*
+                 * This rule only evaluates complexity of functions, so "program" is excluded.
+                 * Class field initializers and class static blocks are implicit functions. Therefore,
+                 * they shouldn't contribute to the enclosing function's complexity, but their
+                 * own complexity should be evaluated.
+                 */
+                if (
+                    codePath.origin !== "function" &&
+                    codePath.origin !== "class-field-initializer" &&
+                    codePath.origin !== "class-static-block"
+                ) {
+                    return;
+                }
+
+                if (complexity > THRESHOLD) {
+                    let name;
+
+                    if (codePath.origin === "class-field-initializer") {
+                        name = "class field initializer";
+                    } else if (codePath.origin === "class-static-block") {
+                        name = "class static block";
+                    } else {
+                        name = astUtils.getFunctionNameWithKind(node);
+                    }
+
+                    context.report({
+                        node,
+                        messageId: "complex",
+                        data: {
+                            name: upperCaseFirst(name),
+                            complexity,
+                            max: THRESHOLD
+                        }
+                    });
+                }
+            }
+        };
+
+    }
+};