repoburg 1.1.0 → 1.1.2

package/backend/node_modules/eslint/lib/rules/no-mixed-requires.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview Rule to enforce grouped require statements for Node.JS
+ * @author Raphael Pigulla
+ * @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 `require` calls to be mixed with regular variable declarations",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-mixed-requires"
+        },
+
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: "boolean"
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            grouping: {
+                                type: "boolean"
+                            },
+                            allowCall: {
+                                type: "boolean"
+                            }
+                        },
+                        additionalProperties: false
+                    }
+                ]
+            }
+        ],
+
+        messages: {
+            noMixRequire: "Do not mix 'require' and other declarations.",
+            noMixCoreModuleFileComputed: "Do not mix core, module, file and computed requires."
+        }
+    },
+
+    create(context) {
+
+        const options = context.options[0];
+        let grouping = false,
+            allowCall = false;
+
+        if (typeof options === "object") {
+            grouping = options.grouping;
+            allowCall = options.allowCall;
+        } else {
+            grouping = !!options;
+        }
+
+        /**
+         * Returns the list of built-in modules.
+         * @returns {string[]} An array of built-in Node.js modules.
+         */
+        function getBuiltinModules() {
+
+            /*
+             * This list is generated using:
+             * `require("repl")._builtinLibs.concat('repl').sort()`
+             * This particular list is as per nodejs v0.12.2 and iojs v0.7.1
+             */
+            return [
+                "assert", "buffer", "child_process", "cluster", "crypto",
+                "dgram", "dns", "domain", "events", "fs", "http", "https",
+                "net", "os", "path", "punycode", "querystring", "readline",
+                "repl", "smalloc", "stream", "string_decoder", "tls", "tty",
+                "url", "util", "v8", "vm", "zlib"
+            ];
+        }
+
+        const BUILTIN_MODULES = getBuiltinModules();
+
+        const DECL_REQUIRE = "require",
+            DECL_UNINITIALIZED = "uninitialized",
+            DECL_OTHER = "other";
+
+        const REQ_CORE = "core",
+            REQ_FILE = "file",
+            REQ_MODULE = "module",
+            REQ_COMPUTED = "computed";
+
+        /**
+         * Determines the type of a declaration statement.
+         * @param {ASTNode} initExpression The init node of the VariableDeclarator.
+         * @returns {string} The type of declaration represented by the expression.
+         */
+        function getDeclarationType(initExpression) {
+            if (!initExpression) {
+
+                // "var x;"
+                return DECL_UNINITIALIZED;
+            }
+
+            if (initExpression.type === "CallExpression" &&
+                initExpression.callee.type === "Identifier" &&
+                initExpression.callee.name === "require"
+            ) {
+
+                // "var x = require('util');"
+                return DECL_REQUIRE;
+            }
+            if (allowCall &&
+                initExpression.type === "CallExpression" &&
+                initExpression.callee.type === "CallExpression"
+            ) {
+
+                // "var x = require('diagnose')('sub-module');"
+                return getDeclarationType(initExpression.callee);
+            }
+            if (initExpression.type === "MemberExpression") {
+
+                // "var x = require('glob').Glob;"
+                return getDeclarationType(initExpression.object);
+            }
+
+            // "var x = 42;"
+            return DECL_OTHER;
+        }
+
+        /**
+         * Determines the type of module that is loaded via require.
+         * @param {ASTNode} initExpression The init node of the VariableDeclarator.
+         * @returns {string} The module type.
+         */
+        function inferModuleType(initExpression) {
+            if (initExpression.type === "MemberExpression") {
+
+                // "var x = require('glob').Glob;"
+                return inferModuleType(initExpression.object);
+            }
+            if (initExpression.arguments.length === 0) {
+
+                // "var x = require();"
+                return REQ_COMPUTED;
+            }
+
+            const arg = initExpression.arguments[0];
+
+            if (arg.type !== "Literal" || typeof arg.value !== "string") {
+
+                // "var x = require(42);"
+                return REQ_COMPUTED;
+            }
+
+            if (BUILTIN_MODULES.includes(arg.value)) {
+
+                // "var fs = require('fs');"
+                return REQ_CORE;
+            }
+            if (/^\.{0,2}\//u.test(arg.value)) {
+
+                // "var utils = require('./utils');"
+                return REQ_FILE;
+            }
+
+            // "var async = require('async');"
+            return REQ_MODULE;
+
+        }
+
+        /**
+         * Check if the list of variable declarations is mixed, i.e. whether it
+         * contains both require and other declarations.
+         * @param {ASTNode} declarations The list of VariableDeclarators.
+         * @returns {boolean} True if the declarations are mixed, false if not.
+         */
+        function isMixed(declarations) {
+            const contains = {};
+
+            declarations.forEach(declaration => {
+                const type = getDeclarationType(declaration.init);
+
+                contains[type] = true;
+            });
+
+            return !!(
+                contains[DECL_REQUIRE] &&
+                (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
+            );
+        }
+
+        /**
+         * Check if all require declarations in the given list are of the same
+         * type.
+         * @param {ASTNode} declarations The list of VariableDeclarators.
+         * @returns {boolean} True if the declarations are grouped, false if not.
+         */
+        function isGrouped(declarations) {
+            const found = {};
+
+            declarations.forEach(declaration => {
+                if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
+                    found[inferModuleType(declaration.init)] = true;
+                }
+            });
+
+            return Object.keys(found).length <= 1;
+        }
+
+
+        return {
+
+            VariableDeclaration(node) {
+
+                if (isMixed(node.declarations)) {
+                    context.report({
+                        node,
+                        messageId: "noMixRequire"
+                    });
+                } else if (grouping && !isGrouped(node.declarations)) {
+                    context.report({
+                        node,
+                        messageId: "noMixCoreModuleFileComputed"
+                    });
+                }
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview Disallow mixed spaces and tabs for indentation
+ * @author Jary Niebur
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: [],
+        type: "layout",
+
+        docs: {
+            description: "Disallow mixed spaces and tabs for indentation",
+            recommended: true,
+            url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs"
+        },
+
+        schema: [
+            {
+                enum: ["smart-tabs", true, false]
+            }
+        ],
+
+        messages: {
+            mixedSpacesAndTabs: "Mixed spaces and tabs."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        let smartTabs;
+
+        switch (context.options[0]) {
+            case true: // Support old syntax, maybe add deprecation warning here
+            case "smart-tabs":
+                smartTabs = true;
+                break;
+            default:
+                smartTabs = false;
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+
+            "Program:exit"(node) {
+                const lines = sourceCode.lines,
+                    comments = sourceCode.getAllComments(),
+                    ignoredCommentLines = new Set();
+
+                // Add all lines except the first ones.
+                comments.forEach(comment => {
+                    for (let i = comment.loc.start.line + 1; i <= comment.loc.end.line; i++) {
+                        ignoredCommentLines.add(i);
+                    }
+                });
+
+                /*
+                 * At least one space followed by a tab
+                 * or the reverse before non-tab/-space
+                 * characters begin.
+                 */
+                let regex = /^(?=( +|\t+))\1(?:\t| )/u;
+
+                if (smartTabs) {
+
+                    /*
+                     * At least one space followed by a tab
+                     * before non-tab/-space characters begin.
+                     */
+                    regex = /^(?=(\t*))\1(?=( +))\2\t/u;
+                }
+
+                lines.forEach((line, i) => {
+                    const match = regex.exec(line);
+
+                    if (match) {
+                        const lineNumber = i + 1;
+                        const loc = {
+                            start: {
+                                line: lineNumber,
+                                column: match[0].length - 2
+                            },
+                            end: {
+                                line: lineNumber,
+                                column: match[0].length
+                            }
+                        };
+
+                        if (!ignoredCommentLines.has(lineNumber)) {
+                            const containingNode = sourceCode.getNodeByRangeIndex(sourceCode.getIndexFromLoc(loc.start));
+
+                            if (!(containingNode && ["Literal", "TemplateElement"].includes(containingNode.type))) {
+                                context.report({
+                                    node,
+                                    loc,
+                                    messageId: "mixedSpacesAndTabs"
+                                });
+                            }
+                        }
+                    }
+                });
+            }
+        };
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-multi-assign.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Rule to check use of chained assignment expressions
+ * @author Stewart Rand
+ */
+
+"use strict";
+
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow use of chained assignment expressions",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-multi-assign"
+        },
+
+        schema: [{
+            type: "object",
+            properties: {
+                ignoreNonDeclaration: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            unexpectedChain: "Unexpected chained assignment."
+        }
+    },
+
+    create(context) {
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+        const options = context.options[0] || {
+            ignoreNonDeclaration: false
+        };
+        const selectors = [
+            "VariableDeclarator > AssignmentExpression.init",
+            "PropertyDefinition > AssignmentExpression.value"
+        ];
+
+        if (!options.ignoreNonDeclaration) {
+            selectors.push("AssignmentExpression > AssignmentExpression.right");
+        }
+
+        return {
+            [selectors](node) {
+                context.report({
+                    node,
+                    messageId: "unexpectedChain"
+                });
+            }
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-multi-spaces.js

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview Disallow use of multiple spaces.
+ * @author Nicholas C. Zakas
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: [],
+        type: "layout",
+
+        docs: {
+            description: "Disallow multiple spaces",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-multi-spaces"
+        },
+
+        fixable: "whitespace",
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    exceptions: {
+                        type: "object",
+                        patternProperties: {
+                            "^([A-Z][a-z]*)+$": {
+                                type: "boolean"
+                            }
+                        },
+                        additionalProperties: false
+                    },
+                    ignoreEOLComments: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            multipleSpaces: "Multiple spaces found before '{{displayValue}}'."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const options = context.options[0] || {};
+        const ignoreEOLComments = options.ignoreEOLComments;
+        const exceptions = Object.assign({ Property: true }, options.exceptions);
+        const hasExceptions = Object.keys(exceptions).some(key => exceptions[key]);
+
+        /**
+         * Formats value of given comment token for error message by truncating its length.
+         * @param {Token} token comment token
+         * @returns {string} formatted value
+         * @private
+         */
+        function formatReportedCommentValue(token) {
+            const valueLines = token.value.split("\n");
+            const value = valueLines[0];
+            const formattedValue = `${value.slice(0, 12)}...`;
+
+            return valueLines.length === 1 && value.length <= 12 ? value : formattedValue;
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            Program() {
+                sourceCode.tokensAndComments.forEach((leftToken, leftIndex, tokensAndComments) => {
+                    if (leftIndex === tokensAndComments.length - 1) {
+                        return;
+                    }
+                    const rightToken = tokensAndComments[leftIndex + 1];
+
+                    // Ignore tokens that don't have 2 spaces between them or are on different lines
+                    if (
+                        !sourceCode.text.slice(leftToken.range[1], rightToken.range[0]).includes("  ") ||
+                        leftToken.loc.end.line < rightToken.loc.start.line
+                    ) {
+                        return;
+                    }
+
+                    // Ignore comments that are the last token on their line if `ignoreEOLComments` is active.
+                    if (
+                        ignoreEOLComments &&
+                        astUtils.isCommentToken(rightToken) &&
+                        (
+                            leftIndex === tokensAndComments.length - 2 ||
+                            rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line
+                        )
+                    ) {
+                        return;
+                    }
+
+                    // Ignore tokens that are in a node in the "exceptions" object
+                    if (hasExceptions) {
+                        const parentNode = sourceCode.getNodeByRangeIndex(rightToken.range[0] - 1);
+
+                        if (parentNode && exceptions[parentNode.type]) {
+                            return;
+                        }
+                    }
+
+                    let displayValue;
+
+                    if (rightToken.type === "Block") {
+                        displayValue = `/*${formatReportedCommentValue(rightToken)}*/`;
+                    } else if (rightToken.type === "Line") {
+                        displayValue = `//${formatReportedCommentValue(rightToken)}`;
+                    } else {
+                        displayValue = rightToken.value;
+                    }
+
+                    context.report({
+                        node: rightToken,
+                        loc: { start: leftToken.loc.end, end: rightToken.loc.start },
+                        messageId: "multipleSpaces",
+                        data: { displayValue },
+                        fix: fixer => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ")
+                    });
+                });
+            }
+        };
+
+    }
+};

package/backend/node_modules/eslint/lib/rules/no-multi-str.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview Rule to flag when using multiline strings
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow multiline strings",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-multi-str"
+        },
+
+        schema: [],
+
+        messages: {
+            multilineString: "Multiline support is limited to browsers supporting ES5 only."
+        }
+    },
+
+    create(context) {
+
+        /**
+         * Determines if a given node is part of JSX syntax.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} True if the node is a JSX node, false if not.
+         * @private
+         */
+        function isJSXElement(node) {
+            return node.type.indexOf("JSX") === 0;
+        }
+
+        //--------------------------------------------------------------------------
+        // Public API
+        //--------------------------------------------------------------------------
+
+        return {
+
+            Literal(node) {
+                if (astUtils.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent)) {
+                    context.report({
+                        node,
+                        messageId: "multilineString"
+                    });
+                }
+            }
+        };
+
+    }
+};