repoburg 1.1.0 → 1.1.1

package/backend/node_modules/eslint/lib/rules/no-shadow.js

@@ -0,0 +1,336 @@
+/**
+ * @fileoverview Rule to flag on declaring variables already declared in the outer scope
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const FUNC_EXPR_NODE_TYPES = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+const CALL_EXPR_NODE_TYPE = new Set(["CallExpression"]);
+const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
+const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow variable declarations from shadowing variables declared in the outer scope",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-shadow"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    builtinGlobals: { type: "boolean", default: false },
+                    hoist: { enum: ["all", "functions", "never"], default: "functions" },
+                    allow: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        }
+                    },
+                    ignoreOnInitialization: { type: "boolean", default: false }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            noShadow: "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
+            noShadowGlobal: "'{{name}}' is already a global variable."
+        }
+    },
+
+    create(context) {
+
+        const options = {
+            builtinGlobals: context.options[0] && context.options[0].builtinGlobals,
+            hoist: (context.options[0] && context.options[0].hoist) || "functions",
+            allow: (context.options[0] && context.options[0].allow) || [],
+            ignoreOnInitialization: context.options[0] && context.options[0].ignoreOnInitialization
+        };
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Checks whether or not a given location is inside of the range of a given node.
+         * @param {ASTNode} node An node to check.
+         * @param {number} location A location to check.
+         * @returns {boolean} `true` if the location is inside of the range of the node.
+         */
+        function isInRange(node, location) {
+            return node && node.range[0] <= location && location <= node.range[1];
+        }
+
+        /**
+         * Searches from the current node through its ancestry to find a matching node.
+         * @param {ASTNode} node a node to get.
+         * @param {(node: ASTNode) => boolean} match a callback that checks whether or not the node verifies its condition or not.
+         * @returns {ASTNode|null} the matching node.
+         */
+        function findSelfOrAncestor(node, match) {
+            let currentNode = node;
+
+            while (currentNode && !match(currentNode)) {
+                currentNode = currentNode.parent;
+            }
+            return currentNode;
+        }
+
+        /**
+         * Finds function's outer scope.
+         * @param {Scope} scope Function's own scope.
+         * @returns {Scope} Function's outer scope.
+         */
+        function getOuterScope(scope) {
+            const upper = scope.upper;
+
+            if (upper.type === "function-expression-name") {
+                return upper.upper;
+            }
+            return upper;
+        }
+
+        /**
+         * Checks if a variable and a shadowedVariable have the same init pattern ancestor.
+         * @param {Object} variable a variable to check.
+         * @param {Object} shadowedVariable a shadowedVariable to check.
+         * @returns {boolean} Whether or not the variable and the shadowedVariable have the same init pattern ancestor.
+         */
+        function isInitPatternNode(variable, shadowedVariable) {
+            const outerDef = shadowedVariable.defs[0];
+
+            if (!outerDef) {
+                return false;
+            }
+
+            const { variableScope } = variable.scope;
+
+
+            if (!(FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) && getOuterScope(variableScope) === shadowedVariable.scope)) {
+                return false;
+            }
+
+            const fun = variableScope.block;
+            const { parent } = fun;
+
+            const callExpression = findSelfOrAncestor(
+                parent,
+                node => CALL_EXPR_NODE_TYPE.has(node.type)
+            );
+
+            if (!callExpression) {
+                return false;
+            }
+
+            let node = outerDef.name;
+            const location = callExpression.range[1];
+
+            while (node) {
+                if (node.type === "VariableDeclarator") {
+                    if (isInRange(node.init, location)) {
+                        return true;
+                    }
+                    if (FOR_IN_OF_TYPE.test(node.parent.parent.type) &&
+                        isInRange(node.parent.parent.right, location)
+                    ) {
+                        return true;
+                    }
+                    break;
+                } else if (node.type === "AssignmentPattern") {
+                    if (isInRange(node.right, location)) {
+                        return true;
+                    }
+                } else if (SENTINEL_TYPE.test(node.type)) {
+                    break;
+                }
+
+                node = node.parent;
+            }
+
+            return false;
+        }
+
+        /**
+         * Check if variable name is allowed.
+         * @param {ASTNode} variable The variable to check.
+         * @returns {boolean} Whether or not the variable name is allowed.
+         */
+        function isAllowed(variable) {
+            return options.allow.includes(variable.name);
+        }
+
+        /**
+         * Checks if a variable of the class name in the class scope of ClassDeclaration.
+         *
+         * ClassDeclaration creates two variables of its name into its outer scope and its class scope.
+         * So we should ignore the variable in the class scope.
+         * @param {Object} variable The variable to check.
+         * @returns {boolean} Whether or not the variable of the class name in the class scope of ClassDeclaration.
+         */
+        function isDuplicatedClassNameVariable(variable) {
+            const block = variable.scope.block;
+
+            return block.type === "ClassDeclaration" && block.id === variable.identifiers[0];
+        }
+
+        /**
+         * Checks if a variable is inside the initializer of scopeVar.
+         *
+         * To avoid reporting at declarations such as `var a = function a() {};`.
+         * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.
+         * @param {Object} variable The variable to check.
+         * @param {Object} scopeVar The scope variable to look for.
+         * @returns {boolean} Whether or not the variable is inside initializer of scopeVar.
+         */
+        function isOnInitializer(variable, scopeVar) {
+            const outerScope = scopeVar.scope;
+            const outerDef = scopeVar.defs[0];
+            const outer = outerDef && outerDef.parent && outerDef.parent.range;
+            const innerScope = variable.scope;
+            const innerDef = variable.defs[0];
+            const inner = innerDef && innerDef.name.range;
+
+            return (
+                outer &&
+                 inner &&
+                 outer[0] < inner[0] &&
+                 inner[1] < outer[1] &&
+                 ((innerDef.type === "FunctionName" && innerDef.node.type === "FunctionExpression") || innerDef.node.type === "ClassExpression") &&
+                 outerScope === innerScope.upper
+            );
+        }
+
+        /**
+         * Get a range of a variable's identifier node.
+         * @param {Object} variable The variable to get.
+         * @returns {Array|undefined} The range of the variable's identifier node.
+         */
+        function getNameRange(variable) {
+            const def = variable.defs[0];
+
+            return def && def.name.range;
+        }
+
+        /**
+         * Get declared line and column of a variable.
+         * @param {eslint-scope.Variable} variable The variable to get.
+         * @returns {Object} The declared line and column of the variable.
+         */
+        function getDeclaredLocation(variable) {
+            const identifier = variable.identifiers[0];
+            let obj;
+
+            if (identifier) {
+                obj = {
+                    global: false,
+                    line: identifier.loc.start.line,
+                    column: identifier.loc.start.column + 1
+                };
+            } else {
+                obj = {
+                    global: true
+                };
+            }
+            return obj;
+        }
+
+        /**
+         * Checks if a variable is in TDZ of scopeVar.
+         * @param {Object} variable The variable to check.
+         * @param {Object} scopeVar The variable of TDZ.
+         * @returns {boolean} Whether or not the variable is in TDZ of scopeVar.
+         */
+        function isInTdz(variable, scopeVar) {
+            const outerDef = scopeVar.defs[0];
+            const inner = getNameRange(variable);
+            const outer = getNameRange(scopeVar);
+
+            return (
+                inner &&
+                 outer &&
+                 inner[1] < outer[0] &&
+
+                 // Excepts FunctionDeclaration if is {"hoist":"function"}.
+                 (options.hoist !== "functions" || !outerDef || outerDef.node.type !== "FunctionDeclaration")
+            );
+        }
+
+        /**
+         * Checks the current context for shadowed variables.
+         * @param {Scope} scope Fixme
+         * @returns {void}
+         */
+        function checkForShadows(scope) {
+            const variables = scope.variables;
+
+            for (let i = 0; i < variables.length; ++i) {
+                const variable = variables[i];
+
+                // Skips "arguments" or variables of a class name in the class scope of ClassDeclaration.
+                if (variable.identifiers.length === 0 ||
+                     isDuplicatedClassNameVariable(variable) ||
+                     isAllowed(variable)
+                ) {
+                    continue;
+                }
+
+                // Gets shadowed variable.
+                const shadowed = astUtils.getVariableByName(scope.upper, variable.name);
+
+                if (shadowed &&
+                      (shadowed.identifiers.length > 0 || (options.builtinGlobals && "writeable" in shadowed)) &&
+                      !isOnInitializer(variable, shadowed) &&
+                      !(options.ignoreOnInitialization && isInitPatternNode(variable, shadowed)) &&
+                      !(options.hoist !== "all" && isInTdz(variable, shadowed))
+                ) {
+                    const location = getDeclaredLocation(shadowed);
+                    const messageId = location.global ? "noShadowGlobal" : "noShadow";
+                    const data = { name: variable.name };
+
+                    if (!location.global) {
+                        data.shadowedLine = location.line;
+                        data.shadowedColumn = location.column;
+                    }
+                    context.report({
+                        node: variable.identifiers[0],
+                        messageId,
+                        data
+                    });
+                }
+            }
+        }
+
+        return {
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
+                const stack = globalScope.childScopes.slice();
+
+                while (stack.length) {
+                    const scope = stack.pop();
+
+                    stack.push(...scope.childScopes);
+                    checkForShadows(scope);
+                }
+            }
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-spaced-func.js

@@ -0,0 +1,83 @@
+/**
+ * @fileoverview Rule to check that spaced function application
+ * @author Matt DuVall <http://www.mattduvall.com>
+ * @deprecated in ESLint v3.3.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "layout",
+
+        docs: {
+            description: "Disallow spacing between function identifiers and their applications (deprecated)",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-spaced-func"
+        },
+
+        deprecated: true,
+
+        replacedBy: ["func-call-spacing"],
+
+        fixable: "whitespace",
+        schema: [],
+
+        messages: {
+            noSpacedFunction: "Unexpected space between function name and paren."
+        }
+    },
+
+    create(context) {
+
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Check if open space is present in a function name
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function detectOpenSpaces(node) {
+            const lastCalleeToken = sourceCode.getLastToken(node.callee);
+            let prevToken = lastCalleeToken,
+                parenToken = sourceCode.getTokenAfter(lastCalleeToken);
+
+            // advances to an open parenthesis.
+            while (
+                parenToken &&
+                parenToken.range[1] < node.range[1] &&
+                parenToken.value !== "("
+            ) {
+                prevToken = parenToken;
+                parenToken = sourceCode.getTokenAfter(parenToken);
+            }
+
+            // look for a space between the callee and the open paren
+            if (parenToken &&
+                parenToken.range[1] < node.range[1] &&
+                sourceCode.isSpaceBetweenTokens(prevToken, parenToken)
+            ) {
+                context.report({
+                    node,
+                    loc: lastCalleeToken.loc.start,
+                    messageId: "noSpacedFunction",
+                    fix(fixer) {
+                        return fixer.removeRange([prevToken.range[1], parenToken.range[0]]);
+                    }
+                });
+            }
+        }
+
+        return {
+            CallExpression: detectOpenSpaces,
+            NewExpression: detectOpenSpaces
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-sparse-arrays.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Disallow sparse arrays
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow sparse arrays",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-sparse-arrays"
+        },
+
+        schema: [],
+
+        messages: {
+            unexpectedSparseArray: "Unexpected comma in middle of array."
+        }
+    },
+
+    create(context) {
+
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+
+            ArrayExpression(node) {
+
+                const emptySpot = node.elements.includes(null);
+
+                if (emptySpot) {
+                    context.report({ node, messageId: "unexpectedSparseArray" });
+                }
+            }
+
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-sync.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Rule to check for properties whose identifier ends with the string Sync
+ * @author Matt DuVall<http://mattduvall.com/>
+ * @deprecated in ESLint v7.0.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow synchronous methods",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-sync"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowAtRootLevel: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            noSync: "Unexpected sync method: '{{propertyName}}'."
+        }
+    },
+
+    create(context) {
+        const selector = context.options[0] && context.options[0].allowAtRootLevel
+            ? ":function MemberExpression[property.name=/.*Sync$/]"
+            : "MemberExpression[property.name=/.*Sync$/]";
+
+        return {
+            [selector](node) {
+                context.report({
+                    node,
+                    messageId: "noSync",
+                    data: {
+                        propertyName: node.property.name
+                    }
+                });
+            }
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-tabs.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Rule to check for tabs inside a file
+ * @author Gyandeep Singh
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const tabRegex = /\t+/gu;
+const anyNonWhitespaceRegex = /\S/u;
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: [],
+        type: "layout",
+
+        docs: {
+            description: "Disallow all tabs",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-tabs"
+        },
+        schema: [{
+            type: "object",
+            properties: {
+                allowIndentationTabs: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            unexpectedTab: "Unexpected tab character."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const allowIndentationTabs = context.options && context.options[0] && context.options[0].allowIndentationTabs;
+
+        return {
+            Program(node) {
+                sourceCode.getLines().forEach((line, index) => {
+                    let match;
+
+                    while ((match = tabRegex.exec(line)) !== null) {
+                        if (allowIndentationTabs && !anyNonWhitespaceRegex.test(line.slice(0, match.index))) {
+                            continue;
+                        }
+
+                        context.report({
+                            node,
+                            loc: {
+                                start: {
+                                    line: index + 1,
+                                    column: match.index
+                                },
+                                end: {
+                                    line: index + 1,
+                                    column: match.index + match[0].length
+                                }
+                            },
+                            messageId: "unexpectedTab"
+                        });
+                    }
+                });
+            }
+        };
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-template-curly-in-string.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Warn when using template string syntax in regular strings
+ * @author Jeroen Engels
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow template literal placeholder syntax in regular strings",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-template-curly-in-string"
+        },
+
+        schema: [],
+
+        messages: {
+            unexpectedTemplateExpression: "Unexpected template string expression."
+        }
+    },
+
+    create(context) {
+        const regex = /\$\{[^}]+\}/u;
+
+        return {
+            Literal(node) {
+                if (typeof node.value === "string" && regex.test(node.value)) {
+                    context.report({
+                        node,
+                        messageId: "unexpectedTemplateExpression"
+                    });
+                }
+            }
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-ternary.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Rule to flag use of ternary operators.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow ternary operators",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-ternary"
+        },
+
+        schema: [],
+
+        messages: {
+            noTernaryOperator: "Ternary operator used."
+        }
+    },
+
+    create(context) {
+
+        return {
+
+            ConditionalExpression(node) {
+                context.report({ node, messageId: "noTernaryOperator" });
+            }
+
+        };
+
+    }
+};