create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint/lib/rules/no-self-compare.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Rule to flag comparison where left part is the same as the right
+ * part.
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow comparisons where both sides are exactly the same",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-self-compare"
+        },
+
+        schema: [],
+
+        messages: {
+            comparingToSelf: "Comparing to itself is potentially pointless."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Determines whether two nodes are composed of the same tokens.
+         * @param {ASTNode} nodeA The first node
+         * @param {ASTNode} nodeB The second node
+         * @returns {boolean} true if the nodes have identical token representations
+         */
+        function hasSameTokens(nodeA, nodeB) {
+            const tokensA = sourceCode.getTokens(nodeA);
+            const tokensB = sourceCode.getTokens(nodeB);
+
+            return tokensA.length === tokensB.length &&
+                tokensA.every((token, index) => token.type === tokensB[index].type && token.value === tokensB[index].value);
+        }
+
+        return {
+
+            BinaryExpression(node) {
+                const operators = new Set(["===", "==", "!==", "!=", ">", "<", ">=", "<="]);
+
+                if (operators.has(node.operator) && hasSameTokens(node.left, node.right)) {
+                    context.report({ node, messageId: "comparingToSelf" });
+                }
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Rule to flag use of comma operator
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_OPTIONS = {
+    allowInParentheses: true
+};
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow comma operators",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-sequences"
+        },
+
+        schema: [{
+            properties: {
+                allowInParentheses: {
+                    type: "boolean",
+                    default: true
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            unexpectedCommaExpression: "Unexpected use of comma operator."
+        }
+    },
+
+    create(context) {
+        const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0]);
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Parts of the grammar that are required to have parens.
+         */
+        const parenthesized = {
+            DoWhileStatement: "test",
+            IfStatement: "test",
+            SwitchStatement: "discriminant",
+            WhileStatement: "test",
+            WithStatement: "object",
+            ArrowFunctionExpression: "body"
+
+            /*
+             * Omitting CallExpression - commas are parsed as argument separators
+             * Omitting NewExpression - commas are parsed as argument separators
+             * Omitting ForInStatement - parts aren't individually parenthesised
+             * Omitting ForStatement - parts aren't individually parenthesised
+             */
+        };
+
+        /**
+         * Determines whether a node is required by the grammar to be wrapped in
+         * parens, e.g. the test of an if statement.
+         * @param {ASTNode} node The AST node
+         * @returns {boolean} True if parens around node belong to parent node.
+         */
+        function requiresExtraParens(node) {
+            return node.parent && parenthesized[node.parent.type] &&
+                    node === node.parent[parenthesized[node.parent.type]];
+        }
+
+        /**
+         * Check if a node is wrapped in parens.
+         * @param {ASTNode} node The AST node
+         * @returns {boolean} True if the node has a paren on each side.
+         */
+        function isParenthesised(node) {
+            return astUtils.isParenthesised(sourceCode, node);
+        }
+
+        /**
+         * Check if a node is wrapped in two levels of parens.
+         * @param {ASTNode} node The AST node
+         * @returns {boolean} True if two parens surround the node on each side.
+         */
+        function isParenthesisedTwice(node) {
+            const previousToken = sourceCode.getTokenBefore(node, 1),
+                nextToken = sourceCode.getTokenAfter(node, 1);
+
+            return isParenthesised(node) && previousToken && nextToken &&
+                astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&
+                astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
+        }
+
+        return {
+            SequenceExpression(node) {
+
+                // Always allow sequences in for statement update
+                if (node.parent.type === "ForStatement" &&
+                        (node === node.parent.init || node === node.parent.update)) {
+                    return;
+                }
+
+                // Wrapping a sequence in extra parens indicates intent
+                if (options.allowInParentheses) {
+                    if (requiresExtraParens(node)) {
+                        if (isParenthesisedTwice(node)) {
+                            return;
+                        }
+                    } else {
+                        if (isParenthesised(node)) {
+                            return;
+                        }
+                    }
+                }
+
+                const firstCommaToken = sourceCode.getTokenAfter(node.expressions[0], astUtils.isCommaToken);
+
+                context.report({ node, loc: firstCommaToken.loc, messageId: "unexpectedCommaExpression" });
+            }
+        };
+
+    }
+};

package/template/lib/react/node_modules/eslint/lib/rules/no-setter-return.js

@@ -0,0 +1,226 @@
+/**
+ * @fileoverview Rule to disallow returning values from setters
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { findVariable } = require("@eslint-community/eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the given identifier node is a reference to a global variable.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} True if the identifier is a reference to a global variable.
+ */
+function isGlobalReference(node, scope) {
+    const variable = findVariable(scope, node);
+
+    return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
+}
+
+/**
+ * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
+ * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @param {string} objectName Name of the global object.
+ * @param {string} methodName Name of the method.
+ * @param {number} index The given position.
+ * @returns {boolean} `true` if the node is argument at the given position.
+ */
+function isArgumentOfGlobalMethodCall(node, scope, objectName, methodName, index) {
+    const callNode = node.parent;
+
+    return callNode.type === "CallExpression" &&
+        callNode.arguments[index] === node &&
+        astUtils.isSpecificMemberAccess(callNode.callee, objectName, methodName) &&
+        isGlobalReference(astUtils.skipChainExpression(callNode.callee).object, scope);
+}
+
+/**
+ * Determines whether the given node is used as a property descriptor.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} `true` if the node is a property descriptor.
+ */
+function isPropertyDescriptor(node, scope) {
+    if (
+        isArgumentOfGlobalMethodCall(node, scope, "Object", "defineProperty", 2) ||
+        isArgumentOfGlobalMethodCall(node, scope, "Reflect", "defineProperty", 2)
+    ) {
+        return true;
+    }
+
+    const parent = node.parent;
+
+    if (
+        parent.type === "Property" &&
+        parent.value === node
+    ) {
+        const grandparent = parent.parent;
+
+        if (
+            grandparent.type === "ObjectExpression" &&
+            (
+                isArgumentOfGlobalMethodCall(grandparent, scope, "Object", "create", 1) ||
+                isArgumentOfGlobalMethodCall(grandparent, scope, "Object", "defineProperties", 1)
+            )
+        ) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Determines whether the given function node is used as a setter function.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} `true` if the node is a setter.
+ */
+function isSetter(node, scope) {
+    const parent = node.parent;
+
+    if (
+        (parent.type === "Property" || parent.type === "MethodDefinition") &&
+        parent.kind === "set" &&
+        parent.value === node
+    ) {
+
+        // Setter in an object literal or in a class
+        return true;
+    }
+
+    if (
+        parent.type === "Property" &&
+        parent.value === node &&
+        astUtils.getStaticPropertyName(parent) === "set" &&
+        parent.parent.type === "ObjectExpression" &&
+        isPropertyDescriptor(parent.parent, scope)
+    ) {
+
+        // Setter in a property descriptor
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Finds function's outer scope.
+ * @param {Scope} scope Function's own scope.
+ * @returns {Scope} Function's outer scope.
+ */
+function getOuterScope(scope) {
+    const upper = scope.upper;
+
+    if (upper.type === "function-expression-name") {
+        return upper.upper;
+    }
+
+    return upper;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow returning values from setters",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-setter-return"
+        },
+
+        schema: [],
+
+        messages: {
+            returnsValue: "Setter cannot return a value."
+        }
+    },
+
+    create(context) {
+        let funcInfo = null;
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Creates and pushes to the stack a function info object for the given function node.
+         * @param {ASTNode} node The function node.
+         * @returns {void}
+         */
+        function enterFunction(node) {
+            const outerScope = getOuterScope(sourceCode.getScope(node));
+
+            funcInfo = {
+                upper: funcInfo,
+                isSetter: isSetter(node, outerScope)
+            };
+        }
+
+        /**
+         * Pops the current function info object from the stack.
+         * @returns {void}
+         */
+        function exitFunction() {
+            funcInfo = funcInfo.upper;
+        }
+
+        /**
+         * Reports the given node.
+         * @param {ASTNode} node Node to report.
+         * @returns {void}
+         */
+        function report(node) {
+            context.report({ node, messageId: "returnsValue" });
+        }
+
+        return {
+
+            /*
+             * Function declarations cannot be setters, but we still have to track them in the `funcInfo` stack to avoid
+             * false positives, because a ReturnStatement node can belong to a function declaration inside a setter.
+             *
+             * Note: A previously declared function can be referenced and actually used as a setter in a property descriptor,
+             * but that's out of scope for this rule.
+             */
+            FunctionDeclaration: enterFunction,
+            FunctionExpression: enterFunction,
+            ArrowFunctionExpression(node) {
+                enterFunction(node);
+
+                if (funcInfo.isSetter && node.expression) {
+
+                    // { set: foo => bar } property descriptor. Report implicit return 'bar' as the equivalent for a return statement.
+                    report(node.body);
+                }
+            },
+
+            "FunctionDeclaration:exit": exitFunction,
+            "FunctionExpression:exit": exitFunction,
+            "ArrowFunctionExpression:exit": exitFunction,
+
+            ReturnStatement(node) {
+
+                // Global returns (e.g., at the top level of a Node module) don't have `funcInfo`.
+                if (funcInfo && funcInfo.isSetter && node.argument) {
+                    report(node);
+                }
+            }
+        };
+    }
+};

package/template/lib/react/node_modules/eslint/lib/rules/no-shadow-restricted-names.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview Disallow shadowing of NaN, undefined, and Infinity (ES5 section 15.1.1)
+ * @author Michael Ficarra
+ */
+"use strict";
+
+/**
+ * Determines if a variable safely shadows undefined.
+ * This is the case when a variable named `undefined` is never assigned to a value (i.e. it always shares the same value
+ * as the global).
+ * @param {eslintScope.Variable} variable The variable to check
+ * @returns {boolean} true if this variable safely shadows `undefined`
+ */
+function safelyShadowsUndefined(variable) {
+    return variable.name === "undefined" &&
+        variable.references.every(ref => !ref.isWrite()) &&
+        variable.defs.every(def => def.node.type === "VariableDeclarator" && def.node.init === null);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow identifiers from shadowing restricted names",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-shadow-restricted-names"
+        },
+
+        schema: [],
+
+        messages: {
+            shadowingRestrictedName: "Shadowing of global property '{{name}}'."
+        }
+    },
+
+    create(context) {
+
+
+        const RESTRICTED = new Set(["undefined", "NaN", "Infinity", "arguments", "eval"]);
+        const sourceCode = context.sourceCode;
+
+        return {
+            "VariableDeclaration, :function, CatchClause"(node) {
+                for (const variable of sourceCode.getDeclaredVariables(node)) {
+                    if (variable.defs.length > 0 && RESTRICTED.has(variable.name) && !safelyShadowsUndefined(variable)) {
+                        context.report({
+                            node: variable.defs[0].name,
+                            messageId: "shadowingRestrictedName",
+                            data: {
+                                name: variable.name
+                            }
+                        });
+                    }
+                }
+            }
+        };
+
+    }
+};