repoburg 1.0.31 → 1.0.33

package/backend/node_modules/eslint/lib/rules/new-cap.js

@@ -1,276 +0,0 @@
-/**
- * @fileoverview Rule to flag use of constructors without capital letters
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const CAPS_ALLOWED = [
-    "Array",
-    "Boolean",
-    "Date",
-    "Error",
-    "Function",
-    "Number",
-    "Object",
-    "RegExp",
-    "String",
-    "Symbol",
-    "BigInt"
-];
-
-/**
- * Ensure that if the key is provided, it must be an array.
- * @param {Object} obj Object to check with `key`.
- * @param {string} key Object key to check on `obj`.
- * @param {any} fallback If obj[key] is not present, this will be returned.
- * @throws {TypeError} If key is not an own array type property of `obj`.
- * @returns {string[]} Returns obj[key] if it's an Array, otherwise `fallback`
- */
-function checkArray(obj, key, fallback) {
-
-    /* c8 ignore start */
-    if (Object.prototype.hasOwnProperty.call(obj, key) && !Array.isArray(obj[key])) {
-        throw new TypeError(`${key}, if provided, must be an Array`);
-    }/* c8 ignore stop */
-    return obj[key] || fallback;
-}
-
-/**
- * A reducer function to invert an array to an Object mapping the string form of the key, to `true`.
- * @param {Object} map Accumulator object for the reduce.
- * @param {string} key Object key to set to `true`.
- * @returns {Object} Returns the updated Object for further reduction.
- */
-function invert(map, key) {
-    map[key] = true;
-    return map;
-}
-
-/**
- * Creates an object with the cap is new exceptions as its keys and true as their values.
- * @param {Object} config Rule configuration
- * @returns {Object} Object with cap is new exceptions.
- */
-function calculateCapIsNewExceptions(config) {
-    let capIsNewExceptions = checkArray(config, "capIsNewExceptions", CAPS_ALLOWED);
-
-    if (capIsNewExceptions !== CAPS_ALLOWED) {
-        capIsNewExceptions = capIsNewExceptions.concat(CAPS_ALLOWED);
-    }
-
-    return capIsNewExceptions.reduce(invert, {});
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require constructor names to begin with a capital letter",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/new-cap"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    newIsCap: {
-                        type: "boolean",
-                        default: true
-                    },
-                    capIsNew: {
-                        type: "boolean",
-                        default: true
-                    },
-                    newIsCapExceptions: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        }
-                    },
-                    newIsCapExceptionPattern: {
-                        type: "string"
-                    },
-                    capIsNewExceptions: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        }
-                    },
-                    capIsNewExceptionPattern: {
-                        type: "string"
-                    },
-                    properties: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-        messages: {
-            upper: "A function with a name starting with an uppercase letter should only be used as a constructor.",
-            lower: "A constructor name should not start with a lowercase letter."
-        }
-    },
-
-    create(context) {
-
-        const config = Object.assign({}, context.options[0]);
-
-        config.newIsCap = config.newIsCap !== false;
-        config.capIsNew = config.capIsNew !== false;
-        const skipProperties = config.properties === false;
-
-        const newIsCapExceptions = checkArray(config, "newIsCapExceptions", []).reduce(invert, {});
-        const newIsCapExceptionPattern = config.newIsCapExceptionPattern ? new RegExp(config.newIsCapExceptionPattern, "u") : null;
-
-        const capIsNewExceptions = calculateCapIsNewExceptions(config);
-        const capIsNewExceptionPattern = config.capIsNewExceptionPattern ? new RegExp(config.capIsNewExceptionPattern, "u") : null;
-
-        const listeners = {};
-
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Get exact callee name from expression
-         * @param {ASTNode} node CallExpression or NewExpression node
-         * @returns {string} name
-         */
-        function extractNameFromExpression(node) {
-            return node.callee.type === "Identifier"
-                ? node.callee.name
-                : astUtils.getStaticPropertyName(node.callee) || "";
-        }
-
-        /**
-         * Returns the capitalization state of the string -
-         * Whether the first character is uppercase, lowercase, or non-alphabetic
-         * @param {string} str String
-         * @returns {string} capitalization state: "non-alpha", "lower", or "upper"
-         */
-        function getCap(str) {
-            const firstChar = str.charAt(0);
-
-            const firstCharLower = firstChar.toLowerCase();
-            const firstCharUpper = firstChar.toUpperCase();
-
-            if (firstCharLower === firstCharUpper) {
-
-                // char has no uppercase variant, so it's non-alphabetic
-                return "non-alpha";
-            }
-            if (firstChar === firstCharLower) {
-                return "lower";
-            }
-            return "upper";
-
-        }
-
-        /**
-         * Check if capitalization is allowed for a CallExpression
-         * @param {Object} allowedMap Object mapping calleeName to a Boolean
-         * @param {ASTNode} node CallExpression node
-         * @param {string} calleeName Capitalized callee name from a CallExpression
-         * @param {Object} pattern RegExp object from options pattern
-         * @returns {boolean} Returns true if the callee may be capitalized
-         */
-        function isCapAllowed(allowedMap, node, calleeName, pattern) {
-            const sourceText = sourceCode.getText(node.callee);
-
-            if (allowedMap[calleeName] || allowedMap[sourceText]) {
-                return true;
-            }
-
-            if (pattern && pattern.test(sourceText)) {
-                return true;
-            }
-
-            const callee = astUtils.skipChainExpression(node.callee);
-
-            if (calleeName === "UTC" && callee.type === "MemberExpression") {
-
-                // allow if callee is Date.UTC
-                return callee.object.type === "Identifier" &&
-                    callee.object.name === "Date";
-            }
-
-            return skipProperties && callee.type === "MemberExpression";
-        }
-
-        /**
-         * Reports the given messageId for the given node. The location will be the start of the property or the callee.
-         * @param {ASTNode} node CallExpression or NewExpression node.
-         * @param {string} messageId The messageId to report.
-         * @returns {void}
-         */
-        function report(node, messageId) {
-            let callee = astUtils.skipChainExpression(node.callee);
-
-            if (callee.type === "MemberExpression") {
-                callee = callee.property;
-            }
-
-            context.report({ node, loc: callee.loc, messageId });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        if (config.newIsCap) {
-            listeners.NewExpression = function(node) {
-
-                const constructorName = extractNameFromExpression(node);
-
-                if (constructorName) {
-                    const capitalization = getCap(constructorName);
-                    const isAllowed = capitalization !== "lower" || isCapAllowed(newIsCapExceptions, node, constructorName, newIsCapExceptionPattern);
-
-                    if (!isAllowed) {
-                        report(node, "lower");
-                    }
-                }
-            };
-        }
-
-        if (config.capIsNew) {
-            listeners.CallExpression = function(node) {
-
-                const calleeName = extractNameFromExpression(node);
-
-                if (calleeName) {
-                    const capitalization = getCap(calleeName);
-                    const isAllowed = capitalization !== "upper" || isCapAllowed(capIsNewExceptions, node, calleeName, capIsNewExceptionPattern);
-
-                    if (!isAllowed) {
-                        report(node, "upper");
-                    }
-                }
-            };
-        }
-
-        return listeners;
-    }
-};

package/backend/node_modules/eslint/lib/rules/new-parens.js

@@ -1,93 +0,0 @@
-/**
- * @fileoverview Rule to flag when using constructor without parentheses
- * @author Ilya Volodin
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce or disallow parentheses when invoking a constructor with no arguments",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/new-parens"
-        },
-
-        fixable: "code",
-        schema: [
-            {
-                enum: ["always", "never"]
-            }
-        ],
-        messages: {
-            missing: "Missing '()' invoking a constructor.",
-            unnecessary: "Unnecessary '()' invoking a constructor with no arguments."
-        }
-    },
-
-    create(context) {
-        const options = context.options;
-        const always = options[0] !== "never"; // Default is always
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            NewExpression(node) {
-                if (node.arguments.length !== 0) {
-                    return; // if there are arguments, there have to be parens
-                }
-
-                const lastToken = sourceCode.getLastToken(node);
-                const hasLastParen = lastToken && astUtils.isClosingParenToken(lastToken);
-
-                // `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens
-                const hasParens = hasLastParen &&
-                    astUtils.isOpeningParenToken(sourceCode.getTokenBefore(lastToken)) &&
-                    node.callee.range[1] < node.range[1];
-
-                if (always) {
-                    if (!hasParens) {
-                        context.report({
-                            node,
-                            messageId: "missing",
-                            fix: fixer => fixer.insertTextAfter(node, "()")
-                        });
-                    }
-                } else {
-                    if (hasParens) {
-                        context.report({
-                            node,
-                            messageId: "unnecessary",
-                            fix: fixer => [
-                                fixer.remove(sourceCode.getTokenBefore(lastToken)),
-                                fixer.remove(lastToken),
-                                fixer.insertTextBefore(node, "("),
-                                fixer.insertTextAfter(node, ")")
-                            ]
-                        });
-                    }
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/newline-after-var.js

@@ -1,253 +0,0 @@
-/**
- * @fileoverview Rule to check empty newline after "var" statement
- * @author Gopal Venkatesan
- * @deprecated in ESLint v4.0.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow an empty line after variable declarations",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/newline-after-var"
-        },
-        schema: [
-            {
-                enum: ["never", "always"]
-            }
-        ],
-        fixable: "whitespace",
-        messages: {
-            expected: "Expected blank line after variable declarations.",
-            unexpected: "Unexpected blank line after variable declarations."
-        },
-
-        deprecated: true,
-
-        replacedBy: ["padding-line-between-statements"]
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        // Default `mode` to "always".
-        const mode = context.options[0] === "never" ? "never" : "always";
-
-        // Cache starting and ending line numbers of comments for faster lookup
-        const commentEndLine = sourceCode.getAllComments().reduce((result, token) => {
-            result[token.loc.start.line] = token.loc.end.line;
-            return result;
-        }, {});
-
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Gets a token from the given node to compare line to the next statement.
-         *
-         * In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy.
-         *
-         * - The last token is semicolon.
-         * - The semicolon is on a different line from the previous token of the semicolon.
-         *
-         * This behavior would address semicolon-less style code. e.g.:
-         *
-         *     var foo = 1
-         *
-         *     ;(a || b).doSomething()
-         * @param {ASTNode} node The node to get.
-         * @returns {Token} The token to compare line to the next statement.
-         */
-        function getLastToken(node) {
-            const lastToken = sourceCode.getLastToken(node);
-
-            if (lastToken.type === "Punctuator" && lastToken.value === ";") {
-                const prevToken = sourceCode.getTokenBefore(lastToken);
-
-                if (prevToken.loc.end.line !== lastToken.loc.start.line) {
-                    return prevToken;
-                }
-            }
-
-            return lastToken;
-        }
-
-        /**
-         * Determine if provided keyword is a variable declaration
-         * @private
-         * @param {string} keyword keyword to test
-         * @returns {boolean} True if `keyword` is a type of var
-         */
-        function isVar(keyword) {
-            return keyword === "var" || keyword === "let" || keyword === "const";
-        }
-
-        /**
-         * Determine if provided keyword is a variant of for specifiers
-         * @private
-         * @param {string} keyword keyword to test
-         * @returns {boolean} True if `keyword` is a variant of for specifier
-         */
-        function isForTypeSpecifier(keyword) {
-            return keyword === "ForStatement" || keyword === "ForInStatement" || keyword === "ForOfStatement";
-        }
-
-        /**
-         * Determine if provided keyword is an export specifiers
-         * @private
-         * @param {string} nodeType nodeType to test
-         * @returns {boolean} True if `nodeType` is an export specifier
-         */
-        function isExportSpecifier(nodeType) {
-            return nodeType === "ExportNamedDeclaration" || nodeType === "ExportSpecifier" ||
-                nodeType === "ExportDefaultDeclaration" || nodeType === "ExportAllDeclaration";
-        }
-
-        /**
-         * Determine if provided node is the last of their parent block.
-         * @private
-         * @param {ASTNode} node node to test
-         * @returns {boolean} True if `node` is last of their parent block.
-         */
-        function isLastNode(node) {
-            const token = sourceCode.getTokenAfter(node);
-
-            return !token || (token.type === "Punctuator" && token.value === "}");
-        }
-
-        /**
-         * Gets the last line of a group of consecutive comments
-         * @param {number} commentStartLine The starting line of the group
-         * @returns {number} The number of the last comment line of the group
-         */
-        function getLastCommentLineOfBlock(commentStartLine) {
-            const currentCommentEnd = commentEndLine[commentStartLine];
-
-            return commentEndLine[currentCommentEnd + 1] ? getLastCommentLineOfBlock(currentCommentEnd + 1) : currentCommentEnd;
-        }
-
-        /**
-         * Determine if a token starts more than one line after a comment ends
-         * @param {token} token The token being checked
-         * @param {integer} commentStartLine The line number on which the comment starts
-         * @returns {boolean} True if `token` does not start immediately after a comment
-         */
-        function hasBlankLineAfterComment(token, commentStartLine) {
-            return token.loc.start.line > getLastCommentLineOfBlock(commentStartLine) + 1;
-        }
-
-        /**
-         * Checks that a blank line exists after a variable declaration when mode is
-         * set to "always", or checks that there is no blank line when mode is set
-         * to "never"
-         * @private
-         * @param {ASTNode} node `VariableDeclaration` node to test
-         * @returns {void}
-         */
-        function checkForBlankLine(node) {
-
-            /*
-             * lastToken is the last token on the node's line. It will usually also be the last token of the node, but it will
-             * sometimes be second-last if there is a semicolon on a different line.
-             */
-            const lastToken = getLastToken(node),
-
-                /*
-                 * If lastToken is the last token of the node, nextToken should be the token after the node. Otherwise, nextToken
-                 * is the last token of the node.
-                 */
-                nextToken = lastToken === sourceCode.getLastToken(node) ? sourceCode.getTokenAfter(node) : sourceCode.getLastToken(node),
-                nextLineNum = lastToken.loc.end.line + 1;
-
-            // Ignore if there is no following statement
-            if (!nextToken) {
-                return;
-            }
-
-            // Ignore if parent of node is a for variant
-            if (isForTypeSpecifier(node.parent.type)) {
-                return;
-            }
-
-            // Ignore if parent of node is an export specifier
-            if (isExportSpecifier(node.parent.type)) {
-                return;
-            }
-
-            /*
-             * Some coding styles use multiple `var` statements, so do nothing if
-             * the next token is a `var` statement.
-             */
-            if (nextToken.type === "Keyword" && isVar(nextToken.value)) {
-                return;
-            }
-
-            // Ignore if it is last statement in a block
-            if (isLastNode(node)) {
-                return;
-            }
-
-            // Next statement is not a `var`...
-            const noNextLineToken = nextToken.loc.start.line > nextLineNum;
-            const hasNextLineComment = (typeof commentEndLine[nextLineNum] !== "undefined");
-
-            if (mode === "never" && noNextLineToken && !hasNextLineComment) {
-                context.report({
-                    node,
-                    messageId: "unexpected",
-                    fix(fixer) {
-                        const linesBetween = sourceCode.getText().slice(lastToken.range[1], nextToken.range[0]).split(astUtils.LINEBREAK_MATCHER);
-
-                        return fixer.replaceTextRange([lastToken.range[1], nextToken.range[0]], `${linesBetween.slice(0, -1).join("")}\n${linesBetween[linesBetween.length - 1]}`);
-                    }
-                });
-            }
-
-            // Token on the next line, or comment without blank line
-            if (
-                mode === "always" && (
-                    !noNextLineToken ||
-                    hasNextLineComment && !hasBlankLineAfterComment(nextToken, nextLineNum)
-                )
-            ) {
-                context.report({
-                    node,
-                    messageId: "expected",
-                    fix(fixer) {
-                        if ((noNextLineToken ? getLastCommentLineOfBlock(nextLineNum) : lastToken.loc.end.line) === nextToken.loc.start.line) {
-                            return fixer.insertTextBefore(nextToken, "\n\n");
-                        }
-
-                        return fixer.insertTextBeforeRange([nextToken.range[0] - nextToken.loc.start.column, nextToken.range[1]], "\n");
-                    }
-                });
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            VariableDeclaration: checkForBlankLine
-        };
-
-    }
-};