create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint/lib/rules/prefer-reflect.js

@@ -1,127 +0,0 @@
-/**
- * @fileoverview Rule to suggest using "Reflect" api over Function/Object methods
- * @author Keith Cirkel <http://keithcirkel.co.uk>
- * @deprecated in ESLint v3.9.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require `Reflect` methods where applicable",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-reflect"
-        },
-
-        deprecated: true,
-
-        replacedBy: [],
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "array",
-                        items: {
-                            enum: [
-                                "apply",
-                                "call",
-                                "delete",
-                                "defineProperty",
-                                "getOwnPropertyDescriptor",
-                                "getPrototypeOf",
-                                "setPrototypeOf",
-                                "isExtensible",
-                                "getOwnPropertyNames",
-                                "preventExtensions"
-                            ]
-                        },
-                        uniqueItems: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            preferReflect: "Avoid using {{existing}}, instead use {{substitute}}."
-        }
-    },
-
-    create(context) {
-        const existingNames = {
-            apply: "Function.prototype.apply",
-            call: "Function.prototype.call",
-            defineProperty: "Object.defineProperty",
-            getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
-            getPrototypeOf: "Object.getPrototypeOf",
-            setPrototypeOf: "Object.setPrototypeOf",
-            isExtensible: "Object.isExtensible",
-            getOwnPropertyNames: "Object.getOwnPropertyNames",
-            preventExtensions: "Object.preventExtensions"
-        };
-
-        const reflectSubstitutes = {
-            apply: "Reflect.apply",
-            call: "Reflect.apply",
-            defineProperty: "Reflect.defineProperty",
-            getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
-            getPrototypeOf: "Reflect.getPrototypeOf",
-            setPrototypeOf: "Reflect.setPrototypeOf",
-            isExtensible: "Reflect.isExtensible",
-            getOwnPropertyNames: "Reflect.getOwnPropertyNames",
-            preventExtensions: "Reflect.preventExtensions"
-        };
-
-        const exceptions = (context.options[0] || {}).exceptions || [];
-
-        /**
-         * Reports the Reflect violation based on the `existing` and `substitute`
-         * @param {Object} node The node that violates the rule.
-         * @param {string} existing The existing method name that has been used.
-         * @param {string} substitute The Reflect substitute that should be used.
-         * @returns {void}
-         */
-        function report(node, existing, substitute) {
-            context.report({
-                node,
-                messageId: "preferReflect",
-                data: {
-                    existing,
-                    substitute
-                }
-            });
-        }
-
-        return {
-            CallExpression(node) {
-                const methodName = (node.callee.property || {}).name;
-                const isReflectCall = (node.callee.object || {}).name === "Reflect";
-                const hasReflectSubstitute = Object.prototype.hasOwnProperty.call(reflectSubstitutes, methodName);
-                const userConfiguredException = exceptions.includes(methodName);
-
-                if (hasReflectSubstitute && !isReflectCall && !userConfiguredException) {
-                    report(node, existingNames[methodName], reflectSubstitutes[methodName]);
-                }
-            },
-            UnaryExpression(node) {
-                const isDeleteOperator = node.operator === "delete";
-                const targetsIdentifier = node.argument.type === "Identifier";
-                const userConfiguredException = exceptions.includes("delete");
-
-                if (isDeleteOperator && !targetsIdentifier && !userConfiguredException) {
-                    report(node, "the delete keyword", "Reflect.deleteProperty");
-                }
-            }
-        };
-
-    }
-};

package/template/lib/react/node_modules/eslint/lib/rules/prefer-regex-literals.js

@@ -1,507 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of the `RegExp` constructor in favor of regular expression literals
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { CALL, CONSTRUCT, ReferenceTracker, findVariable } = require("@eslint-community/eslint-utils");
-const { RegExpValidator, visitRegExpAST, RegExpParser } = require("@eslint-community/regexpp");
-const { canTokensBeAdjacent } = require("./utils/ast-utils");
-const { REGEXPP_LATEST_ECMA_VERSION } = require("./utils/regular-expressions");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the given node is a string literal.
- * @param {ASTNode} node Node to check.
- * @returns {boolean} True if the node is a string literal.
- */
-function isStringLiteral(node) {
-    return node.type === "Literal" && typeof node.value === "string";
-}
-
-/**
- * Determines whether the given node is a regex literal.
- * @param {ASTNode} node Node to check.
- * @returns {boolean} True if the node is a regex literal.
- */
-function isRegexLiteral(node) {
-    return node.type === "Literal" && Object.prototype.hasOwnProperty.call(node, "regex");
-}
-
-const validPrecedingTokens = new Set([
-    "(",
-    ";",
-    "[",
-    ",",
-    "=",
-    "+",
-    "*",
-    "-",
-    "?",
-    "~",
-    "%",
-    "**",
-    "!",
-    "typeof",
-    "instanceof",
-    "&&",
-    "||",
-    "??",
-    "return",
-    "...",
-    "delete",
-    "void",
-    "in",
-    "<",
-    ">",
-    "<=",
-    ">=",
-    "==",
-    "===",
-    "!=",
-    "!==",
-    "<<",
-    ">>",
-    ">>>",
-    "&",
-    "|",
-    "^",
-    ":",
-    "{",
-    "=>",
-    "*=",
-    "<<=",
-    ">>=",
-    ">>>=",
-    "^=",
-    "|=",
-    "&=",
-    "??=",
-    "||=",
-    "&&=",
-    "**=",
-    "+=",
-    "-=",
-    "/=",
-    "%=",
-    "/",
-    "do",
-    "break",
-    "continue",
-    "debugger",
-    "case",
-    "throw"
-]);
-
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow use of the `RegExp` constructor in favor of regular expression literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-regex-literals"
-        },
-
-        hasSuggestions: true,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    disallowRedundantWrapping: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedRegExp: "Use a regular expression literal instead of the 'RegExp' constructor.",
-            replaceWithLiteral: "Replace with an equivalent regular expression literal.",
-            replaceWithLiteralAndFlags: "Replace with an equivalent regular expression literal with flags '{{ flags }}'.",
-            replaceWithIntendedLiteralAndFlags: "Replace with a regular expression literal with flags '{{ flags }}'.",
-            unexpectedRedundantRegExp: "Regular expression literal is unnecessarily wrapped within a 'RegExp' constructor.",
-            unexpectedRedundantRegExpWithFlags: "Use regular expression literal with flags instead of the 'RegExp' constructor."
-        }
-    },
-
-    create(context) {
-        const [{ disallowRedundantWrapping = false } = {}] = context.options;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether the given identifier node is a reference to a global variable.
-         * @param {ASTNode} node `Identifier` node to check.
-         * @returns {boolean} True if the identifier is a reference to a global variable.
-         */
-        function isGlobalReference(node) {
-            const scope = sourceCode.getScope(node);
-            const variable = findVariable(scope, node);
-
-            return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
-        }
-
-        /**
-         * Determines whether the given node is a String.raw`` tagged template expression
-         * with a static template literal.
-         * @param {ASTNode} node Node to check.
-         * @returns {boolean} True if the node is String.raw`` with a static template.
-         */
-        function isStringRawTaggedStaticTemplateLiteral(node) {
-            return node.type === "TaggedTemplateExpression" &&
-                astUtils.isSpecificMemberAccess(node.tag, "String", "raw") &&
-                isGlobalReference(astUtils.skipChainExpression(node.tag).object) &&
-                astUtils.isStaticTemplateLiteral(node.quasi);
-        }
-
-        /**
-         * Gets the value of a string
-         * @param {ASTNode} node The node to get the string of.
-         * @returns {string|null} The value of the node.
-         */
-        function getStringValue(node) {
-            if (isStringLiteral(node)) {
-                return node.value;
-            }
-
-            if (astUtils.isStaticTemplateLiteral(node)) {
-                return node.quasis[0].value.cooked;
-            }
-
-            if (isStringRawTaggedStaticTemplateLiteral(node)) {
-                return node.quasi.quasis[0].value.raw;
-            }
-
-            return null;
-        }
-
-        /**
-         * Determines whether the given node is considered to be a static string by the logic of this rule.
-         * @param {ASTNode} node Node to check.
-         * @returns {boolean} True if the node is a static string.
-         */
-        function isStaticString(node) {
-            return isStringLiteral(node) ||
-                astUtils.isStaticTemplateLiteral(node) ||
-                isStringRawTaggedStaticTemplateLiteral(node);
-        }
-
-        /**
-         * Determines whether the relevant arguments of the given are all static string literals.
-         * @param {ASTNode} node Node to check.
-         * @returns {boolean} True if all arguments are static strings.
-         */
-        function hasOnlyStaticStringArguments(node) {
-            const args = node.arguments;
-
-            if ((args.length === 1 || args.length === 2) && args.every(isStaticString)) {
-                return true;
-            }
-
-            return false;
-        }
-
-        /**
-         * Determines whether the arguments of the given node indicate that a regex literal is unnecessarily wrapped.
-         * @param {ASTNode} node Node to check.
-         * @returns {boolean} True if the node already contains a regex literal argument.
-         */
-        function isUnnecessarilyWrappedRegexLiteral(node) {
-            const args = node.arguments;
-
-            if (args.length === 1 && isRegexLiteral(args[0])) {
-                return true;
-            }
-
-            if (args.length === 2 && isRegexLiteral(args[0]) && isStaticString(args[1])) {
-                return true;
-            }
-
-            return false;
-        }
-
-        /**
-         * Returns a ecmaVersion compatible for regexpp.
-         * @param {number} ecmaVersion The ecmaVersion to convert.
-         * @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
-         */
-        function getRegexppEcmaVersion(ecmaVersion) {
-            if (ecmaVersion <= 5) {
-                return 5;
-            }
-            return Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION);
-        }
-
-        const regexppEcmaVersion = getRegexppEcmaVersion(context.languageOptions.ecmaVersion);
-
-        /**
-         * Makes a character escaped or else returns null.
-         * @param {string} character The character to escape.
-         * @returns {string} The resulting escaped character.
-         */
-        function resolveEscapes(character) {
-            switch (character) {
-                case "\n":
-                case "\\\n":
-                    return "\\n";
-
-                case "\r":
-                case "\\\r":
-                    return "\\r";
-
-                case "\t":
-                case "\\\t":
-                    return "\\t";
-
-                case "\v":
-                case "\\\v":
-                    return "\\v";
-
-                case "\f":
-                case "\\\f":
-                    return "\\f";
-
-                case "/":
-                    return "\\/";
-
-                default:
-                    return null;
-            }
-        }
-
-        /**
-         * Checks whether the given regex and flags are valid for the ecma version or not.
-         * @param {string} pattern The regex pattern to check.
-         * @param {string | undefined} flags The regex flags to check.
-         * @returns {boolean} True if the given regex pattern and flags are valid for the ecma version.
-         */
-        function isValidRegexForEcmaVersion(pattern, flags) {
-            const validator = new RegExpValidator({ ecmaVersion: regexppEcmaVersion });
-
-            try {
-                validator.validatePattern(pattern, 0, pattern.length, {
-                    unicode: flags ? flags.includes("u") : false,
-                    unicodeSets: flags ? flags.includes("v") : false
-                });
-                if (flags) {
-                    validator.validateFlags(flags);
-                }
-                return true;
-            } catch {
-                return false;
-            }
-        }
-
-        /**
-         * Checks whether two given regex flags contain the same flags or not.
-         * @param {string} flagsA The regex flags.
-         * @param {string} flagsB The regex flags.
-         * @returns {boolean} True if two regex flags contain same flags.
-         */
-        function areFlagsEqual(flagsA, flagsB) {
-            return [...flagsA].sort().join("") === [...flagsB].sort().join("");
-        }
-
-
-        /**
-         * Merges two regex flags.
-         * @param {string} flagsA The regex flags.
-         * @param {string} flagsB The regex flags.
-         * @returns {string} The merged regex flags.
-         */
-        function mergeRegexFlags(flagsA, flagsB) {
-            const flagsSet = new Set([
-                ...flagsA,
-                ...flagsB
-            ]);
-
-            return [...flagsSet].join("");
-        }
-
-        /**
-         * Checks whether a give node can be fixed to the given regex pattern and flags.
-         * @param {ASTNode} node The node to check.
-         * @param {string} pattern The regex pattern to check.
-         * @param {string} flags The regex flags
-         * @returns {boolean} True if a node can be fixed to the given regex pattern and flags.
-         */
-        function canFixTo(node, pattern, flags) {
-            const tokenBefore = sourceCode.getTokenBefore(node);
-
-            return sourceCode.getCommentsInside(node).length === 0 &&
-                (!tokenBefore || validPrecedingTokens.has(tokenBefore.value)) &&
-                isValidRegexForEcmaVersion(pattern, flags);
-        }
-
-        /**
-         * Returns a safe output code considering the before and after tokens.
-         * @param {ASTNode} node The regex node.
-         * @param {string} newRegExpValue The new regex expression value.
-         * @returns {string} The output code.
-         */
-        function getSafeOutput(node, newRegExpValue) {
-            const tokenBefore = sourceCode.getTokenBefore(node);
-            const tokenAfter = sourceCode.getTokenAfter(node);
-
-            return (tokenBefore && !canTokensBeAdjacent(tokenBefore, newRegExpValue) && tokenBefore.range[1] === node.range[0] ? " " : "") +
-                newRegExpValue +
-            (tokenAfter && !canTokensBeAdjacent(newRegExpValue, tokenAfter) && node.range[1] === tokenAfter.range[0] ? " " : "");
-
-        }
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-                const traceMap = {
-                    RegExp: {
-                        [CALL]: true,
-                        [CONSTRUCT]: true
-                    }
-                };
-
-                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
-                    if (disallowRedundantWrapping && isUnnecessarilyWrappedRegexLiteral(refNode)) {
-                        const regexNode = refNode.arguments[0];
-
-                        if (refNode.arguments.length === 2) {
-                            const suggests = [];
-
-                            const argFlags = getStringValue(refNode.arguments[1]) || "";
-
-                            if (canFixTo(refNode, regexNode.regex.pattern, argFlags)) {
-                                suggests.push({
-                                    messageId: "replaceWithLiteralAndFlags",
-                                    pattern: regexNode.regex.pattern,
-                                    flags: argFlags
-                                });
-                            }
-
-                            const literalFlags = regexNode.regex.flags || "";
-                            const mergedFlags = mergeRegexFlags(literalFlags, argFlags);
-
-                            if (
-                                !areFlagsEqual(mergedFlags, argFlags) &&
-                                canFixTo(refNode, regexNode.regex.pattern, mergedFlags)
-                            ) {
-                                suggests.push({
-                                    messageId: "replaceWithIntendedLiteralAndFlags",
-                                    pattern: regexNode.regex.pattern,
-                                    flags: mergedFlags
-                                });
-                            }
-
-                            context.report({
-                                node: refNode,
-                                messageId: "unexpectedRedundantRegExpWithFlags",
-                                suggest: suggests.map(({ flags, pattern, messageId }) => ({
-                                    messageId,
-                                    data: {
-                                        flags
-                                    },
-                                    fix(fixer) {
-                                        return fixer.replaceText(refNode, getSafeOutput(refNode, `/${pattern}/${flags}`));
-                                    }
-                                }))
-                            });
-                        } else {
-                            const outputs = [];
-
-                            if (canFixTo(refNode, regexNode.regex.pattern, regexNode.regex.flags)) {
-                                outputs.push(sourceCode.getText(regexNode));
-                            }
-
-
-                            context.report({
-                                node: refNode,
-                                messageId: "unexpectedRedundantRegExp",
-                                suggest: outputs.map(output => ({
-                                    messageId: "replaceWithLiteral",
-                                    fix(fixer) {
-                                        return fixer.replaceText(
-                                            refNode,
-                                            getSafeOutput(refNode, output)
-                                        );
-                                    }
-                                }))
-                            });
-                        }
-                    } else if (hasOnlyStaticStringArguments(refNode)) {
-                        let regexContent = getStringValue(refNode.arguments[0]);
-                        let noFix = false;
-                        let flags;
-
-                        if (refNode.arguments[1]) {
-                            flags = getStringValue(refNode.arguments[1]);
-                        }
-
-                        if (!canFixTo(refNode, regexContent, flags)) {
-                            noFix = true;
-                        }
-
-                        if (!/^[-a-zA-Z0-9\\[\](){} \t\r\n\v\f!@#$%^&*+^_=/~`.><?,'"|:;]*$/u.test(regexContent)) {
-                            noFix = true;
-                        }
-
-                        if (regexContent && !noFix) {
-                            let charIncrease = 0;
-
-                            const ast = new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, {
-                                unicode: flags ? flags.includes("u") : false,
-                                unicodeSets: flags ? flags.includes("v") : false
-                            });
-
-                            visitRegExpAST(ast, {
-                                onCharacterEnter(characterNode) {
-                                    const escaped = resolveEscapes(characterNode.raw);
-
-                                    if (escaped) {
-                                        regexContent =
-                                            regexContent.slice(0, characterNode.start + charIncrease) +
-                                            escaped +
-                                            regexContent.slice(characterNode.end + charIncrease);
-
-                                        if (characterNode.raw.length === 1) {
-                                            charIncrease += 1;
-                                        }
-                                    }
-                                }
-                            });
-                        }
-
-                        const newRegExpValue = `/${regexContent || "(?:)"}/${flags || ""}`;
-
-                        context.report({
-                            node: refNode,
-                            messageId: "unexpectedRegExp",
-                            suggest: noFix ? [] : [{
-                                messageId: "replaceWithLiteral",
-                                fix(fixer) {
-                                    return fixer.replaceText(refNode, getSafeOutput(refNode, newRegExpValue));
-                                }
-                            }]
-                        });
-                    }
-                }
-            }
-        };
-    }
-};