repoburg 1.0.32 → 1.0.34

package/backend/node_modules/eslint/lib/rules/quote-props.js

@@ -1,310 +0,0 @@
-/**
- * @fileoverview Rule to flag non-quoted property names in object literals.
- * @author Mathias Bynens <http://mathiasbynens.be/>
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const espree = require("espree");
-const astUtils = require("./utils/ast-utils");
-const keywords = require("./utils/keywords");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "suggestion",
-
-        docs: {
-            description: "Require quotes around object literal property names",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/quote-props"
-        },
-
-        schema: {
-            anyOf: [
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"]
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 1
-                },
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"]
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                keywords: {
-                                    type: "boolean"
-                                },
-                                unnecessary: {
-                                    type: "boolean"
-                                },
-                                numbers: {
-                                    type: "boolean"
-                                }
-                            },
-                            additionalProperties: false
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 2
-                }
-            ]
-        },
-
-        fixable: "code",
-        messages: {
-            requireQuotesDueToReservedWord: "Properties should be quoted as '{{property}}' is a reserved word.",
-            inconsistentlyQuotedProperty: "Inconsistently quoted property '{{key}}' found.",
-            unnecessarilyQuotedProperty: "Unnecessarily quoted property '{{property}}' found.",
-            unquotedReservedProperty: "Unquoted reserved word '{{property}}' used as key.",
-            unquotedNumericProperty: "Unquoted number literal '{{property}}' used as key.",
-            unquotedPropertyFound: "Unquoted property '{{property}}' found.",
-            redundantQuoting: "Properties shouldn't be quoted as all quotes are redundant."
-        }
-    },
-
-    create(context) {
-
-        const MODE = context.options[0],
-            KEYWORDS = context.options[1] && context.options[1].keywords,
-            CHECK_UNNECESSARY = !context.options[1] || context.options[1].unnecessary !== false,
-            NUMBERS = context.options[1] && context.options[1].numbers,
-
-            sourceCode = context.sourceCode;
-
-
-        /**
-         * Checks whether a certain string constitutes an ES3 token
-         * @param {string} tokenStr The string to be checked.
-         * @returns {boolean} `true` if it is an ES3 token.
-         */
-        function isKeyword(tokenStr) {
-            return keywords.includes(tokenStr);
-        }
-
-        /**
-         * Checks if an espree-tokenized key has redundant quotes (i.e. whether quotes are unnecessary)
-         * @param {string} rawKey The raw key value from the source
-         * @param {espreeTokens} tokens The espree-tokenized node key
-         * @param {boolean} [skipNumberLiterals=false] Indicates whether number literals should be checked
-         * @returns {boolean} Whether or not a key has redundant quotes.
-         * @private
-         */
-        function areQuotesRedundant(rawKey, tokens, skipNumberLiterals) {
-            return tokens.length === 1 && tokens[0].start === 0 && tokens[0].end === rawKey.length &&
-                (["Identifier", "Keyword", "Null", "Boolean"].includes(tokens[0].type) ||
-                (tokens[0].type === "Numeric" && !skipNumberLiterals && String(+tokens[0].value) === tokens[0].value));
-        }
-
-        /**
-         * Returns a string representation of a property node with quotes removed
-         * @param {ASTNode} key Key AST Node, which may or may not be quoted
-         * @returns {string} A replacement string for this property
-         */
-        function getUnquotedKey(key) {
-            return key.type === "Identifier" ? key.name : key.value;
-        }
-
-        /**
-         * Returns a string representation of a property node with quotes added
-         * @param {ASTNode} key Key AST Node, which may or may not be quoted
-         * @returns {string} A replacement string for this property
-         */
-        function getQuotedKey(key) {
-            if (key.type === "Literal" && typeof key.value === "string") {
-
-                // If the key is already a string literal, don't replace the quotes with double quotes.
-                return sourceCode.getText(key);
-            }
-
-            // Otherwise, the key is either an identifier or a number literal.
-            return `"${key.type === "Identifier" ? key.name : key.value}"`;
-        }
-
-        /**
-         * Ensures that a property's key is quoted only when necessary
-         * @param {ASTNode} node Property AST node
-         * @returns {void}
-         */
-        function checkUnnecessaryQuotes(node) {
-            const key = node.key;
-
-            if (node.method || node.computed || node.shorthand) {
-                return;
-            }
-
-            if (key.type === "Literal" && typeof key.value === "string") {
-                let tokens;
-
-                try {
-                    tokens = espree.tokenize(key.value);
-                } catch {
-                    return;
-                }
-
-                if (tokens.length !== 1) {
-                    return;
-                }
-
-                const isKeywordToken = isKeyword(tokens[0].value);
-
-                if (isKeywordToken && KEYWORDS) {
-                    return;
-                }
-
-                if (CHECK_UNNECESSARY && areQuotesRedundant(key.value, tokens, NUMBERS)) {
-                    context.report({
-                        node,
-                        messageId: "unnecessarilyQuotedProperty",
-                        data: { property: key.value },
-                        fix: fixer => fixer.replaceText(key, getUnquotedKey(key))
-                    });
-                }
-            } else if (KEYWORDS && key.type === "Identifier" && isKeyword(key.name)) {
-                context.report({
-                    node,
-                    messageId: "unquotedReservedProperty",
-                    data: { property: key.name },
-                    fix: fixer => fixer.replaceText(key, getQuotedKey(key))
-                });
-            } else if (NUMBERS && key.type === "Literal" && astUtils.isNumericLiteral(key)) {
-                context.report({
-                    node,
-                    messageId: "unquotedNumericProperty",
-                    data: { property: key.value },
-                    fix: fixer => fixer.replaceText(key, getQuotedKey(key))
-                });
-            }
-        }
-
-        /**
-         * Ensures that a property's key is quoted
-         * @param {ASTNode} node Property AST node
-         * @returns {void}
-         */
-        function checkOmittedQuotes(node) {
-            const key = node.key;
-
-            if (!node.method && !node.computed && !node.shorthand && !(key.type === "Literal" && typeof key.value === "string")) {
-                context.report({
-                    node,
-                    messageId: "unquotedPropertyFound",
-                    data: { property: key.name || key.value },
-                    fix: fixer => fixer.replaceText(key, getQuotedKey(key))
-                });
-            }
-        }
-
-        /**
-         * Ensures that an object's keys are consistently quoted, optionally checks for redundancy of quotes
-         * @param {ASTNode} node Property AST node
-         * @param {boolean} checkQuotesRedundancy Whether to check quotes' redundancy
-         * @returns {void}
-         */
-        function checkConsistency(node, checkQuotesRedundancy) {
-            const quotedProps = [],
-                unquotedProps = [];
-            let keywordKeyName = null,
-                necessaryQuotes = false;
-
-            node.properties.forEach(property => {
-                const key = property.key;
-
-                if (!key || property.method || property.computed || property.shorthand) {
-                    return;
-                }
-
-                if (key.type === "Literal" && typeof key.value === "string") {
-
-                    quotedProps.push(property);
-
-                    if (checkQuotesRedundancy) {
-                        let tokens;
-
-                        try {
-                            tokens = espree.tokenize(key.value);
-                        } catch {
-                            necessaryQuotes = true;
-                            return;
-                        }
-
-                        necessaryQuotes = necessaryQuotes || !areQuotesRedundant(key.value, tokens) || KEYWORDS && isKeyword(tokens[0].value);
-                    }
-                } else if (KEYWORDS && checkQuotesRedundancy && key.type === "Identifier" && isKeyword(key.name)) {
-                    unquotedProps.push(property);
-                    necessaryQuotes = true;
-                    keywordKeyName = key.name;
-                } else {
-                    unquotedProps.push(property);
-                }
-            });
-
-            if (checkQuotesRedundancy && quotedProps.length && !necessaryQuotes) {
-                quotedProps.forEach(property => {
-                    context.report({
-                        node: property,
-                        messageId: "redundantQuoting",
-                        fix: fixer => fixer.replaceText(property.key, getUnquotedKey(property.key))
-                    });
-                });
-            } else if (unquotedProps.length && keywordKeyName) {
-                unquotedProps.forEach(property => {
-                    context.report({
-                        node: property,
-                        messageId: "requireQuotesDueToReservedWord",
-                        data: { property: keywordKeyName },
-                        fix: fixer => fixer.replaceText(property.key, getQuotedKey(property.key))
-                    });
-                });
-            } else if (quotedProps.length && unquotedProps.length) {
-                unquotedProps.forEach(property => {
-                    context.report({
-                        node: property,
-                        messageId: "inconsistentlyQuotedProperty",
-                        data: { key: property.key.name || property.key.value },
-                        fix: fixer => fixer.replaceText(property.key, getQuotedKey(property.key))
-                    });
-                });
-            }
-        }
-
-        return {
-            Property(node) {
-                if (MODE === "always" || !MODE) {
-                    checkOmittedQuotes(node);
-                }
-                if (MODE === "as-needed") {
-                    checkUnnecessaryQuotes(node);
-                }
-            },
-            ObjectExpression(node) {
-                if (MODE === "consistent") {
-                    checkConsistency(node, false);
-                }
-                if (MODE === "consistent-as-needed") {
-                    checkConsistency(node, true);
-                }
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/quotes.js

@@ -1,350 +0,0 @@
-/**
- * @fileoverview A rule to choose between single and double quote marks
- * @author Matt DuVall <http://www.mattduvall.com/>, Brandon Payton
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-
-const QUOTE_SETTINGS = {
-    double: {
-        quote: "\"",
-        alternateQuote: "'",
-        description: "doublequote"
-    },
-    single: {
-        quote: "'",
-        alternateQuote: "\"",
-        description: "singlequote"
-    },
-    backtick: {
-        quote: "`",
-        alternateQuote: "\"",
-        description: "backtick"
-    }
-};
-
-// An unescaped newline is a newline preceded by an even number of backslashes.
-const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`, "u");
-
-/**
- * Switches quoting of javascript string between ' " and `
- * escaping and unescaping as necessary.
- * Only escaping of the minimal set of characters is changed.
- * Note: escaping of newlines when switching from backtick to other quotes is not handled.
- * @param {string} str A string to convert.
- * @returns {string} The string with changed quotes.
- * @private
- */
-QUOTE_SETTINGS.double.convert =
-QUOTE_SETTINGS.single.convert =
-QUOTE_SETTINGS.backtick.convert = function(str) {
-    const newQuote = this.quote;
-    const oldQuote = str[0];
-
-    if (newQuote === oldQuote) {
-        return str;
-    }
-    return newQuote + str.slice(1, -1).replace(/\\(\$\{|\r\n?|\n|.)|["'`]|\$\{|(\r\n?|\n)/gu, (match, escaped, newline) => {
-        if (escaped === oldQuote || oldQuote === "`" && escaped === "${") {
-            return escaped; // unescape
-        }
-        if (match === newQuote || newQuote === "`" && match === "${") {
-            return `\\${match}`; // escape
-        }
-        if (newline && oldQuote === "`") {
-            return "\\n"; // escape newlines
-        }
-        return match;
-    }) + newQuote;
-};
-
-const AVOID_ESCAPE = "avoid-escape";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce the consistent use of either backticks, double, or single quotes",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/quotes"
-        },
-
-        fixable: "code",
-
-        schema: [
-            {
-                enum: ["single", "double", "backtick"]
-            },
-            {
-                anyOf: [
-                    {
-                        enum: ["avoid-escape"]
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            avoidEscape: {
-                                type: "boolean"
-                            },
-                            allowTemplateLiterals: {
-                                type: "boolean"
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            wrongQuotes: "Strings must use {{description}}."
-        }
-    },
-
-    create(context) {
-
-        const quoteOption = context.options[0],
-            settings = QUOTE_SETTINGS[quoteOption || "double"],
-            options = context.options[1],
-            allowTemplateLiterals = options && options.allowTemplateLiterals === true,
-            sourceCode = context.sourceCode;
-        let avoidEscape = options && options.avoidEscape === true;
-
-        // deprecated
-        if (options === AVOID_ESCAPE) {
-            avoidEscape = true;
-        }
-
-        /**
-         * Determines if a given node is part of JSX syntax.
-         *
-         * This function returns `true` in the following cases:
-         *
-         * - `<div className="foo"></div>` ... If the literal is an attribute value, the parent of the literal is `JSXAttribute`.
-         * - `<div>foo</div>` ... If the literal is a text content, the parent of the literal is `JSXElement`.
-         * - `<>foo</>` ... If the literal is a text content, the parent of the literal is `JSXFragment`.
-         *
-         * In particular, this function returns `false` in the following cases:
-         *
-         * - `<div className={"foo"}></div>`
-         * - `<div>{"foo"}</div>`
-         *
-         * In both cases, inside of the braces is handled as normal JavaScript.
-         * The braces are `JSXExpressionContainer` nodes.
-         * @param {ASTNode} node The Literal node to check.
-         * @returns {boolean} True if the node is a part of JSX, false if not.
-         * @private
-         */
-        function isJSXLiteral(node) {
-            return node.parent.type === "JSXAttribute" || node.parent.type === "JSXElement" || node.parent.type === "JSXFragment";
-        }
-
-        /**
-         * Checks whether or not a given node is a directive.
-         * The directive is a `ExpressionStatement` which has only a string literal not surrounded by
-         * parentheses.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} Whether or not the node is a directive.
-         * @private
-         */
-        function isDirective(node) {
-            return (
-                node.type === "ExpressionStatement" &&
-                node.expression.type === "Literal" &&
-                typeof node.expression.value === "string" &&
-                !astUtils.isParenthesised(sourceCode, node.expression)
-            );
-        }
-
-        /**
-         * Checks whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
-         * @see {@link http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive}
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} Whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
-         * @private
-         */
-        function isExpressionInOrJustAfterDirectivePrologue(node) {
-            if (!astUtils.isTopLevelExpressionStatement(node.parent)) {
-                return false;
-            }
-            const block = node.parent.parent;
-
-            // Check the node is at a prologue.
-            for (let i = 0; i < block.body.length; ++i) {
-                const statement = block.body[i];
-
-                if (statement === node.parent) {
-                    return true;
-                }
-                if (!isDirective(statement)) {
-                    break;
-                }
-            }
-
-            return false;
-        }
-
-        /**
-         * Checks whether or not a given node is allowed as non backtick.
-         * @param {ASTNode} node A node to check.
-         * @returns {boolean} Whether or not the node is allowed as non backtick.
-         * @private
-         */
-        function isAllowedAsNonBacktick(node) {
-            const parent = node.parent;
-
-            switch (parent.type) {
-
-                // Directive Prologues.
-                case "ExpressionStatement":
-                    return !astUtils.isParenthesised(sourceCode, node) && isExpressionInOrJustAfterDirectivePrologue(node);
-
-                // LiteralPropertyName.
-                case "Property":
-                case "PropertyDefinition":
-                case "MethodDefinition":
-                    return parent.key === node && !parent.computed;
-
-                // ModuleSpecifier.
-                case "ImportDeclaration":
-                case "ExportNamedDeclaration":
-                    return parent.source === node;
-
-                // ModuleExportName or ModuleSpecifier.
-                case "ExportAllDeclaration":
-                    return parent.exported === node || parent.source === node;
-
-                // ModuleExportName.
-                case "ImportSpecifier":
-                    return parent.imported === node;
-
-                // ModuleExportName.
-                case "ExportSpecifier":
-                    return parent.local === node || parent.exported === node;
-
-                // Others don't allow.
-                default:
-                    return false;
-            }
-        }
-
-        /**
-         * Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings.
-         * @param {ASTNode} node A TemplateLiteral node to check.
-         * @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings.
-         * @private
-         */
-        function isUsingFeatureOfTemplateLiteral(node) {
-            const hasTag = node.parent.type === "TaggedTemplateExpression" && node === node.parent.quasi;
-
-            if (hasTag) {
-                return true;
-            }
-
-            const hasStringInterpolation = node.expressions.length > 0;
-
-            if (hasStringInterpolation) {
-                return true;
-            }
-
-            const isMultilineString = node.quasis.length >= 1 && UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw);
-
-            if (isMultilineString) {
-                return true;
-            }
-
-            return false;
-        }
-
-        return {
-
-            Literal(node) {
-                const val = node.value,
-                    rawVal = node.raw;
-
-                if (settings && typeof val === "string") {
-                    let isValid = (quoteOption === "backtick" && isAllowedAsNonBacktick(node)) ||
-                        isJSXLiteral(node) ||
-                        astUtils.isSurroundedBy(rawVal, settings.quote);
-
-                    if (!isValid && avoidEscape) {
-                        isValid = astUtils.isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.includes(settings.quote);
-                    }
-
-                    if (!isValid) {
-                        context.report({
-                            node,
-                            messageId: "wrongQuotes",
-                            data: {
-                                description: settings.description
-                            },
-                            fix(fixer) {
-                                if (quoteOption === "backtick" && astUtils.hasOctalOrNonOctalDecimalEscapeSequence(rawVal)) {
-
-                                    /*
-                                     * An octal or non-octal decimal escape sequence in a template literal would
-                                     * produce syntax error, even in non-strict mode.
-                                     */
-                                    return null;
-                                }
-
-                                return fixer.replaceText(node, settings.convert(node.raw));
-                            }
-                        });
-                    }
-                }
-            },
-
-            TemplateLiteral(node) {
-
-                // Don't throw an error if backticks are expected or a template literal feature is in use.
-                if (
-                    allowTemplateLiterals ||
-                    quoteOption === "backtick" ||
-                    isUsingFeatureOfTemplateLiteral(node)
-                ) {
-                    return;
-                }
-
-                context.report({
-                    node,
-                    messageId: "wrongQuotes",
-                    data: {
-                        description: settings.description
-                    },
-                    fix(fixer) {
-                        if (astUtils.isTopLevelExpressionStatement(node.parent) && !astUtils.isParenthesised(sourceCode, node)) {
-
-                            /*
-                             * TemplateLiterals aren't actually directives, but fixing them might turn
-                             * them into directives and change the behavior of the code.
-                             */
-                            return null;
-                        }
-                        return fixer.replaceText(node, settings.convert(sourceCode.getText(node)));
-                    }
-                });
-            }
-        };
-
-    }
-};