repoburg 1.0.31 → 1.0.33

package/backend/node_modules/eslint/lib/rules/prefer-numeric-literals.js

@@ -1,148 +0,0 @@
-/**
- * @fileoverview Rule to disallow `parseInt()` in favor of binary, octal, and hexadecimal literals
- * @author Annie Zhang, Henry Zhu
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const radixMap = new Map([
-    [2, { system: "binary", literalPrefix: "0b" }],
-    [8, { system: "octal", literalPrefix: "0o" }],
-    [16, { system: "hexadecimal", literalPrefix: "0x" }]
-]);
-
-/**
- * Checks to see if a CallExpression's callee node is `parseInt` or
- * `Number.parseInt`.
- * @param {ASTNode} calleeNode The callee node to evaluate.
- * @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,
- * false otherwise.
- */
-function isParseInt(calleeNode) {
-    return (
-        astUtils.isSpecificId(calleeNode, "parseInt") ||
-        astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
-    );
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals"
-        },
-
-        schema: [],
-
-        messages: {
-            useLiteral: "Use {{system}} literals instead of {{functionName}}()."
-        },
-
-        fixable: "code"
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-
-            "CallExpression[arguments.length=2]"(node) {
-                const [strNode, radixNode] = node.arguments,
-                    str = astUtils.getStaticStringValue(strNode),
-                    radix = radixNode.value;
-
-                if (
-                    str !== null &&
-                    astUtils.isStringLiteral(strNode) &&
-                    radixNode.type === "Literal" &&
-                    typeof radix === "number" &&
-                    radixMap.has(radix) &&
-                    isParseInt(node.callee)
-                ) {
-
-                    const { system, literalPrefix } = radixMap.get(radix);
-
-                    context.report({
-                        node,
-                        messageId: "useLiteral",
-                        data: {
-                            system,
-                            functionName: sourceCode.getText(node.callee)
-                        },
-                        fix(fixer) {
-                            if (sourceCode.getCommentsInside(node).length) {
-                                return null;
-                            }
-
-                            const replacement = `${literalPrefix}${str}`;
-
-                            if (+replacement !== parseInt(str, radix)) {
-
-                                /*
-                                 * If the newly-produced literal would be invalid, (e.g. 0b1234),
-                                 * or it would yield an incorrect parseInt result for some other reason, don't make a fix.
-                                 *
-                                 * If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+`
-                                 * per the specification doesn't support numeric separators. Thus, the above condition will be `true`
-                                 * (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value.
-                                 * Consequently, no autofixes will be made. This is correct behavior because `parseInt` also
-                                 * doesn't support numeric separators, but it does parse part of the string before the first `_`,
-                                 * so the autofix would be invalid:
-                                 *
-                                 *   parseInt("1_1", 2) // === 1
-                                 *   0b1_1 // === 3
-                                 */
-                                return null;
-                            }
-
-                            const tokenBefore = sourceCode.getTokenBefore(node),
-                                tokenAfter = sourceCode.getTokenAfter(node);
-                            let prefix = "",
-                                suffix = "";
-
-                            if (
-                                tokenBefore &&
-                                tokenBefore.range[1] === node.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
-                            ) {
-                                prefix = " ";
-                            }
-
-                            if (
-                                tokenAfter &&
-                                node.range[1] === tokenAfter.range[0] &&
-                                !astUtils.canTokensBeAdjacent(replacement, tokenAfter)
-                            ) {
-                                suffix = " ";
-                            }
-
-                            return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/prefer-object-has-own.js

@@ -1,114 +0,0 @@
-/**
- * @fileoverview Prefers Object.hasOwn() instead of Object.prototype.hasOwnProperty.call()
- * @author Nitin Kumar
- * @author Gautam Arora
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks if the given node is considered to be an access to a property of `Object.prototype`.
- * @param {ASTNode} node `MemberExpression` node to evaluate.
- * @returns {boolean} `true` if `node.object` is `Object`, `Object.prototype`, or `{}` (empty 'ObjectExpression' node).
- */
-function hasLeftHandObject(node) {
-
-    /*
-     * ({}).hasOwnProperty.call(obj, prop) - `true`
-     * ({ foo }.hasOwnProperty.call(obj, prop)) - `false`, object literal should be empty
-     */
-    if (node.object.type === "ObjectExpression" && node.object.properties.length === 0) {
-        return true;
-    }
-
-    const objectNodeToCheck = node.object.type === "MemberExpression" && astUtils.getStaticPropertyName(node.object) === "prototype" ? node.object.object : node.object;
-
-    if (objectNodeToCheck.type === "Identifier" && objectNodeToCheck.name === "Object") {
-        return true;
-    }
-
-    return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-        docs: {
-            description:
-                "Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-object-has-own"
-        },
-        schema: [],
-        messages: {
-            useHasOwn: "Use 'Object.hasOwn()' instead of 'Object.prototype.hasOwnProperty.call()'."
-        },
-        fixable: "code"
-    },
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        return {
-            CallExpression(node) {
-                if (!(node.callee.type === "MemberExpression" && node.callee.object.type === "MemberExpression")) {
-                    return;
-                }
-
-                const calleePropertyName = astUtils.getStaticPropertyName(node.callee);
-                const objectPropertyName = astUtils.getStaticPropertyName(node.callee.object);
-                const isObject = hasLeftHandObject(node.callee.object);
-
-                // check `Object` scope
-                const scope = sourceCode.getScope(node);
-                const variable = astUtils.getVariableByName(scope, "Object");
-
-                if (
-                    calleePropertyName === "call" &&
-                    objectPropertyName === "hasOwnProperty" &&
-                    isObject &&
-                    variable && variable.scope.type === "global"
-                ) {
-                    context.report({
-                        node,
-                        messageId: "useHasOwn",
-                        fix(fixer) {
-
-                            if (sourceCode.getCommentsInside(node.callee).length > 0) {
-                                return null;
-                            }
-
-                            const tokenJustBeforeNode = sourceCode.getTokenBefore(node.callee, { includeComments: true });
-
-                            // for https://github.com/eslint/eslint/pull/15346#issuecomment-991417335
-                            if (
-                                tokenJustBeforeNode &&
-                                tokenJustBeforeNode.range[1] === node.callee.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenJustBeforeNode, "Object.hasOwn")
-                            ) {
-                                return fixer.replaceText(node.callee, " Object.hasOwn");
-                            }
-
-                            return fixer.replaceText(node.callee, "Object.hasOwn");
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/prefer-object-spread.js

@@ -1,298 +0,0 @@
-/**
- * @fileoverview Prefers object spread property over Object.assign
- * @author Sharmila Jesupaul
- */
-
-"use strict";
-
-const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
-const {
-    isCommaToken,
-    isOpeningParenToken,
-    isClosingParenToken,
-    isParenthesised
-} = require("./utils/ast-utils");
-
-const ANY_SPACE = /\s/u;
-
-/**
- * Helper that checks if the Object.assign call has array spread
- * @param {ASTNode} node The node that the rule warns on
- * @returns {boolean} - Returns true if the Object.assign call has array spread
- */
-function hasArraySpread(node) {
-    return node.arguments.some(arg => arg.type === "SpreadElement");
-}
-
-/**
- * Determines whether the given node is an accessor property (getter/setter).
- * @param {ASTNode} node Node to check.
- * @returns {boolean} `true` if the node is a getter or a setter.
- */
-function isAccessorProperty(node) {
-    return node.type === "Property" &&
-        (node.kind === "get" || node.kind === "set");
-}
-
-/**
- * Determines whether the given object expression node has accessor properties (getters/setters).
- * @param {ASTNode} node `ObjectExpression` node to check.
- * @returns {boolean} `true` if the node has at least one getter/setter.
- */
-function hasAccessors(node) {
-    return node.properties.some(isAccessorProperty);
-}
-
-/**
- * Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters).
- * @param {ASTNode} node `CallExpression` node to check.
- * @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter.
- */
-function hasArgumentsWithAccessors(node) {
-    return node.arguments
-        .filter(arg => arg.type === "ObjectExpression")
-        .some(hasAccessors);
-}
-
-/**
- * Helper that checks if the node needs parentheses to be valid JS.
- * The default is to wrap the node in parentheses to avoid parsing errors.
- * @param {ASTNode} node The node that the rule warns on
- * @param {Object} sourceCode in context sourcecode object
- * @returns {boolean} - Returns true if the node needs parentheses
- */
-function needsParens(node, sourceCode) {
-    const parent = node.parent;
-
-    switch (parent.type) {
-        case "VariableDeclarator":
-        case "ArrayExpression":
-        case "ReturnStatement":
-        case "CallExpression":
-        case "Property":
-            return false;
-        case "AssignmentExpression":
-            return parent.left === node && !isParenthesised(sourceCode, node);
-        default:
-            return !isParenthesised(sourceCode, node);
-    }
-}
-
-/**
- * Determines if an argument needs parentheses. The default is to not add parens.
- * @param {ASTNode} node The node to be checked.
- * @param {Object} sourceCode in context sourcecode object
- * @returns {boolean} True if the node needs parentheses
- */
-function argNeedsParens(node, sourceCode) {
-    switch (node.type) {
-        case "AssignmentExpression":
-        case "ArrowFunctionExpression":
-        case "ConditionalExpression":
-            return !isParenthesised(sourceCode, node);
-        default:
-            return false;
-    }
-}
-
-/**
- * Get the parenthesis tokens of a given ObjectExpression node.
- * This includes the braces of the object literal and enclosing parentheses.
- * @param {ASTNode} node The node to get.
- * @param {Token} leftArgumentListParen The opening paren token of the argument list.
- * @param {SourceCode} sourceCode The source code object to get tokens.
- * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
- */
-function getParenTokens(node, leftArgumentListParen, sourceCode) {
-    const parens = [sourceCode.getFirstToken(node), sourceCode.getLastToken(node)];
-    let leftNext = sourceCode.getTokenBefore(node);
-    let rightNext = sourceCode.getTokenAfter(node);
-
-    // Note: don't include the parens of the argument list.
-    while (
-        leftNext &&
-        rightNext &&
-        leftNext.range[0] > leftArgumentListParen.range[0] &&
-        isOpeningParenToken(leftNext) &&
-        isClosingParenToken(rightNext)
-    ) {
-        parens.push(leftNext, rightNext);
-        leftNext = sourceCode.getTokenBefore(leftNext);
-        rightNext = sourceCode.getTokenAfter(rightNext);
-    }
-
-    return parens.sort((a, b) => a.range[0] - b.range[0]);
-}
-
-/**
- * Get the range of a given token and around whitespaces.
- * @param {Token} token The token to get range.
- * @param {SourceCode} sourceCode The source code object to get tokens.
- * @returns {number} The end of the range of the token and around whitespaces.
- */
-function getStartWithSpaces(token, sourceCode) {
-    const text = sourceCode.text;
-    let start = token.range[0];
-
-    // If the previous token is a line comment then skip this step to avoid commenting this token out.
-    {
-        const prevToken = sourceCode.getTokenBefore(token, { includeComments: true });
-
-        if (prevToken && prevToken.type === "Line") {
-            return start;
-        }
-    }
-
-    // Detect spaces before the token.
-    while (ANY_SPACE.test(text[start - 1] || "")) {
-        start -= 1;
-    }
-
-    return start;
-}
-
-/**
- * Get the range of a given token and around whitespaces.
- * @param {Token} token The token to get range.
- * @param {SourceCode} sourceCode The source code object to get tokens.
- * @returns {number} The start of the range of the token and around whitespaces.
- */
-function getEndWithSpaces(token, sourceCode) {
-    const text = sourceCode.text;
-    let end = token.range[1];
-
-    // Detect spaces after the token.
-    while (ANY_SPACE.test(text[end] || "")) {
-        end += 1;
-    }
-
-    return end;
-}
-
-/**
- * Autofixes the Object.assign call to use an object spread instead.
- * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call
- * @param {string} sourceCode sourceCode of the Object.assign call
- * @returns {Function} autofixer - replaces the Object.assign with a spread object.
- */
-function defineFixer(node, sourceCode) {
-    return function *(fixer) {
-        const leftParen = sourceCode.getTokenAfter(node.callee, isOpeningParenToken);
-        const rightParen = sourceCode.getLastToken(node);
-
-        // Remove everything before the opening paren: callee `Object.assign`, type arguments, and whitespace between the callee and the paren.
-        yield fixer.removeRange([node.range[0], leftParen.range[0]]);
-
-        // Replace the parens of argument list to braces.
-        if (needsParens(node, sourceCode)) {
-            yield fixer.replaceText(leftParen, "({");
-            yield fixer.replaceText(rightParen, "})");
-        } else {
-            yield fixer.replaceText(leftParen, "{");
-            yield fixer.replaceText(rightParen, "}");
-        }
-
-        // Process arguments.
-        for (const argNode of node.arguments) {
-            const innerParens = getParenTokens(argNode, leftParen, sourceCode);
-            const left = innerParens.shift();
-            const right = innerParens.pop();
-
-            if (argNode.type === "ObjectExpression") {
-                const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);
-                const maybeArgumentComma = sourceCode.getTokenAfter(right);
-
-                /*
-                 * Make bare this object literal.
-                 * And remove spaces inside of the braces for better formatting.
-                 */
-                for (const innerParen of innerParens) {
-                    yield fixer.remove(innerParen);
-                }
-                const leftRange = [left.range[0], getEndWithSpaces(left, sourceCode)];
-                const rightRange = [
-                    Math.max(getStartWithSpaces(right, sourceCode), leftRange[1]), // Ensure ranges don't overlap
-                    right.range[1]
-                ];
-
-                yield fixer.removeRange(leftRange);
-                yield fixer.removeRange(rightRange);
-
-                // Remove the comma of this argument if it's duplication.
-                if (
-                    (argNode.properties.length === 0 || isCommaToken(maybeTrailingComma)) &&
-                    isCommaToken(maybeArgumentComma)
-                ) {
-                    yield fixer.remove(maybeArgumentComma);
-                }
-            } else {
-
-                // Make spread.
-                if (argNeedsParens(argNode, sourceCode)) {
-                    yield fixer.insertTextBefore(left, "...(");
-                    yield fixer.insertTextAfter(right, ")");
-                } else {
-                    yield fixer.insertTextBefore(left, "...");
-                }
-            }
-        }
-    };
-}
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description:
-                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-object-spread"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            useSpreadMessage: "Use an object spread instead of `Object.assign` eg: `{ ...foo }`.",
-            useLiteralMessage: "Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-                const trackMap = {
-                    Object: {
-                        assign: { [CALL]: true }
-                    }
-                };
-
-                // Iterate all calls of `Object.assign` (only of the global variable `Object`).
-                for (const { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
-                    if (
-                        refNode.arguments.length >= 1 &&
-                        refNode.arguments[0].type === "ObjectExpression" &&
-                        !hasArraySpread(refNode) &&
-                        !(
-                            refNode.arguments.length > 1 &&
-                            hasArgumentsWithAccessors(refNode)
-                        )
-                    ) {
-                        const messageId = refNode.arguments.length === 1
-                            ? "useLiteralMessage"
-                            : "useSpreadMessage";
-                        const fix = defineFixer(refNode, sourceCode);
-
-                        context.report({ node: refNode, messageId, fix });
-                    }
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/prefer-promise-reject-errors.js

@@ -1,132 +0,0 @@
-/**
- * @fileoverview restrict values that can be used as Promise rejection reasons
- * @author Teddy Katz
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require using Error objects as Promise rejection reasons",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors"
-        },
-
-        fixable: null,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowEmptyReject: { type: "boolean", default: false }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            rejectAnError: "Expected the Promise rejection reason to be an Error."
-        }
-    },
-
-    create(context) {
-
-        const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;
-        const sourceCode = context.sourceCode;
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-
-        /**
-         * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
-         * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
-         * @returns {void}
-         */
-        function checkRejectCall(callExpression) {
-            if (!callExpression.arguments.length && ALLOW_EMPTY_REJECT) {
-                return;
-            }
-            if (
-                !callExpression.arguments.length ||
-                !astUtils.couldBeError(callExpression.arguments[0]) ||
-                callExpression.arguments[0].type === "Identifier" && callExpression.arguments[0].name === "undefined"
-            ) {
-                context.report({
-                    node: callExpression,
-                    messageId: "rejectAnError"
-                });
-            }
-        }
-
-        /**
-         * Determines whether a function call is a Promise.reject() call
-         * @param {ASTNode} node A CallExpression node
-         * @returns {boolean} `true` if the call is a Promise.reject() call
-         */
-        function isPromiseRejectCall(node) {
-            return astUtils.isSpecificMemberAccess(node.callee, "Promise", "reject");
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-
-            // Check `Promise.reject(value)` calls.
-            CallExpression(node) {
-                if (isPromiseRejectCall(node)) {
-                    checkRejectCall(node);
-                }
-            },
-
-            /*
-             * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
-             * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
-             * the nodes in the expression already have the `parent` property.
-             */
-            "NewExpression:exit"(node) {
-                if (
-                    node.callee.type === "Identifier" && node.callee.name === "Promise" &&
-                    node.arguments.length && astUtils.isFunction(node.arguments[0]) &&
-                    node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === "Identifier"
-                ) {
-                    sourceCode.getDeclaredVariables(node.arguments[0])
-
-                        /*
-                         * Find the first variable that matches the second parameter's name.
-                         * If the first parameter has the same name as the second parameter, then the variable will actually
-                         * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
-                         * by the second parameter. It's not possible for an expression with the variable to be evaluated before
-                         * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
-                         * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
-                         * this case.
-                         */
-                        .find(variable => variable.name === node.arguments[0].params[1].name)
-
-                        // Get the references to that variable.
-                        .references
-
-                        // Only check the references that read the parameter's value.
-                        .filter(ref => ref.isRead())
-
-                        // Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
-                        .filter(ref => ref.identifier.parent.type === "CallExpression" && ref.identifier === ref.identifier.parent.callee)
-
-                        // Check the argument of the function call to determine whether it's an Error.
-                        .forEach(ref => checkRejectCall(ref.identifier.parent));
-                }
-            }
-        };
-    }
-};