repoburg 1.0.67 → 1.0.68

package/backend/node_modules/eslint/lib/rules/getter-return.js

@@ -1,204 +0,0 @@
-/**
- * @fileoverview Enforces that a return statement is present in property getters.
- * @author Aladdin-ADD(hh_2013@foxmail.com)
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
-
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-
-    for (const segment of segments) {
-        if (segment.reachable) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Enforce `return` statements in getters",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/getter-return"
-        },
-
-        fixable: null,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowImplicit: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            expected: "Expected to return a value in {{name}}.",
-            expectedAlways: "Expected {{name}} to always return a value."
-        }
-    },
-
-    create(context) {
-
-        const options = context.options[0] || { allowImplicit: false };
-        const sourceCode = context.sourceCode;
-
-        let funcInfo = {
-            upper: null,
-            codePath: null,
-            hasReturn: false,
-            shouldCheck: false,
-            node: null,
-            currentSegments: []
-        };
-
-        /**
-         * Checks whether or not the last code path segment is reachable.
-         * Then reports this function if the segment is reachable.
-         *
-         * If the last code path segment is reachable, there are paths which are not
-         * returned or thrown.
-         * @param {ASTNode} node A node to check.
-         * @returns {void}
-         */
-        function checkLastSegment(node) {
-            if (funcInfo.shouldCheck &&
-                isAnySegmentReachable(funcInfo.currentSegments)
-            ) {
-                context.report({
-                    node,
-                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
-                    messageId: funcInfo.hasReturn ? "expectedAlways" : "expected",
-                    data: {
-                        name: astUtils.getFunctionNameWithKind(funcInfo.node)
-                    }
-                });
-            }
-        }
-
-        /**
-         * Checks whether a node means a getter function.
-         * @param {ASTNode} node a node to check.
-         * @returns {boolean} if node means a getter, return true; else return false.
-         */
-        function isGetter(node) {
-            const parent = node.parent;
-
-            if (TARGET_NODE_TYPE.test(node.type) && node.body.type === "BlockStatement") {
-                if (parent.kind === "get") {
-                    return true;
-                }
-                if (parent.type === "Property" && astUtils.getStaticPropertyName(parent) === "get" && parent.parent.type === "ObjectExpression") {
-
-                    // Object.defineProperty() or Reflect.defineProperty()
-                    if (parent.parent.parent.type === "CallExpression") {
-                        const callNode = parent.parent.parent.callee;
-
-                        if (astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperty") ||
-                            astUtils.isSpecificMemberAccess(callNode, "Reflect", "defineProperty")) {
-                            return true;
-                        }
-                    }
-
-                    // Object.defineProperties() or Object.create()
-                    if (parent.parent.parent.type === "Property" &&
-                        parent.parent.parent.parent.type === "ObjectExpression" &&
-                        parent.parent.parent.parent.parent.type === "CallExpression") {
-                        const callNode = parent.parent.parent.parent.parent.callee;
-
-                        return astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperties") ||
-                               astUtils.isSpecificMemberAccess(callNode, "Object", "create");
-                    }
-                }
-            }
-            return false;
-        }
-        return {
-
-            // Stacks this function's information.
-            onCodePathStart(codePath, node) {
-                funcInfo = {
-                    upper: funcInfo,
-                    codePath,
-                    hasReturn: false,
-                    shouldCheck: isGetter(node),
-                    node,
-                    currentSegments: new Set()
-                };
-            },
-
-            // Pops this function's information.
-            onCodePathEnd() {
-                funcInfo = funcInfo.upper;
-            },
-            onUnreachableCodePathSegmentStart(segment) {
-                funcInfo.currentSegments.add(segment);
-            },
-
-            onUnreachableCodePathSegmentEnd(segment) {
-                funcInfo.currentSegments.delete(segment);
-            },
-
-            onCodePathSegmentStart(segment) {
-                funcInfo.currentSegments.add(segment);
-            },
-
-            onCodePathSegmentEnd(segment) {
-                funcInfo.currentSegments.delete(segment);
-            },
-
-            // Checks the return statement is valid.
-            ReturnStatement(node) {
-                if (funcInfo.shouldCheck) {
-                    funcInfo.hasReturn = true;
-
-                    // if allowImplicit: false, should also check node.argument
-                    if (!options.allowImplicit && !node.argument) {
-                        context.report({
-                            node,
-                            messageId: "expected",
-                            data: {
-                                name: astUtils.getFunctionNameWithKind(funcInfo.node)
-                            }
-                        });
-                    }
-                }
-            },
-
-            // Reports a given function if the last path is reachable.
-            "FunctionExpression:exit": checkLastSegment,
-            "ArrowFunctionExpression:exit": checkLastSegment
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/global-require.js

@@ -1,90 +0,0 @@
-/**
- * @fileoverview Rule for disallowing require() outside of the top-level module context
- * @author Jamund Ferguson
- * @deprecated in ESLint v7.0.0
- */
-
-"use strict";
-
-const ACCEPTABLE_PARENTS = new Set([
-    "AssignmentExpression",
-    "VariableDeclarator",
-    "MemberExpression",
-    "ExpressionStatement",
-    "CallExpression",
-    "ConditionalExpression",
-    "Program",
-    "VariableDeclaration",
-    "ChainExpression"
-]);
-
-/**
- * Finds the eslint-scope reference in the given scope.
- * @param {Object} scope The scope to search.
- * @param {ASTNode} node The identifier node.
- * @returns {Reference|null} Returns the found reference or null if none were found.
- */
-function findReference(scope, node) {
-    const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&
-            reference.identifier.range[1] === node.range[1]);
-
-    if (references.length === 1) {
-        return references[0];
-    }
-
-    /* c8 ignore next */
-    return null;
-
-}
-
-/**
- * Checks if the given identifier node is shadowed in the given scope.
- * @param {Object} scope The current scope.
- * @param {ASTNode} node The identifier node to check.
- * @returns {boolean} Whether or not the name is shadowed.
- */
-function isShadowed(scope, node) {
-    const reference = findReference(scope, node);
-
-    return reference && reference.resolved && reference.resolved.defs.length > 0;
-}
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-
-        replacedBy: [],
-
-        type: "suggestion",
-
-        docs: {
-            description: "Require `require()` calls to be placed at top-level module scope",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/global-require"
-        },
-
-        schema: [],
-        messages: {
-            unexpected: "Unexpected require()."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            CallExpression(node) {
-                const currentScope = sourceCode.getScope(node);
-
-                if (node.callee.name === "require" && !isShadowed(currentScope, node.callee)) {
-                    const isGoodRequire = sourceCode.getAncestors(node).every(parent => ACCEPTABLE_PARENTS.has(parent.type));
-
-                    if (!isGoodRequire) {
-                        context.report({ node, messageId: "unexpected" });
-                    }
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/grouped-accessor-pairs.js

@@ -1,215 +0,0 @@
-/**
- * @fileoverview Rule to require grouped accessor pairs in object literals and classes
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/**
- * Property name if it can be computed statically, otherwise the list of the tokens of the key node.
- * @typedef {string|Token[]} Key
- */
-
-/**
- * Accessor nodes with the same key.
- * @typedef {Object} AccessorData
- * @property {Key} key Accessor's key
- * @property {ASTNode[]} getters List of getter nodes.
- * @property {ASTNode[]} setters List of setter nodes.
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not the given lists represent the equal tokens in the same order.
- * Tokens are compared by their properties, not by instance.
- * @param {Token[]} left First list of tokens.
- * @param {Token[]} right Second list of tokens.
- * @returns {boolean} `true` if the lists have same tokens.
- */
-function areEqualTokenLists(left, right) {
-    if (left.length !== right.length) {
-        return false;
-    }
-
-    for (let i = 0; i < left.length; i++) {
-        const leftToken = left[i],
-            rightToken = right[i];
-
-        if (leftToken.type !== rightToken.type || leftToken.value !== rightToken.value) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Checks whether or not the given keys are equal.
- * @param {Key} left First key.
- * @param {Key} right Second key.
- * @returns {boolean} `true` if the keys are equal.
- */
-function areEqualKeys(left, right) {
-    if (typeof left === "string" && typeof right === "string") {
-
-        // Statically computed names.
-        return left === right;
-    }
-    if (Array.isArray(left) && Array.isArray(right)) {
-
-        // Token lists.
-        return areEqualTokenLists(left, right);
-    }
-
-    return false;
-}
-
-/**
- * Checks whether or not a given node is of an accessor kind ('get' or 'set').
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node is of an accessor kind.
- */
-function isAccessorKind(node) {
-    return node.kind === "get" || node.kind === "set";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require grouped accessor pairs in object literals and classes",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/grouped-accessor-pairs"
-        },
-
-        schema: [
-            {
-                enum: ["anyOrder", "getBeforeSet", "setBeforeGet"]
-            }
-        ],
-
-        messages: {
-            notGrouped: "Accessor pair {{ formerName }} and {{ latterName }} should be grouped.",
-            invalidOrder: "Expected {{ latterName }} to be before {{ formerName }}."
-        }
-    },
-
-    create(context) {
-        const order = context.options[0] || "anyOrder";
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports the given accessor pair.
-         * @param {string} messageId messageId to report.
-         * @param {ASTNode} formerNode getter/setter node that is defined before `latterNode`.
-         * @param {ASTNode} latterNode getter/setter node that is defined after `formerNode`.
-         * @returns {void}
-         * @private
-         */
-        function report(messageId, formerNode, latterNode) {
-            context.report({
-                node: latterNode,
-                messageId,
-                loc: astUtils.getFunctionHeadLoc(latterNode.value, sourceCode),
-                data: {
-                    formerName: astUtils.getFunctionNameWithKind(formerNode.value),
-                    latterName: astUtils.getFunctionNameWithKind(latterNode.value)
-                }
-            });
-        }
-
-        /**
-         * Checks accessor pairs in the given list of nodes.
-         * @param {ASTNode[]} nodes The list to check.
-         * @param {Function} shouldCheck – Predicate that returns `true` if the node should be checked.
-         * @returns {void}
-         * @private
-         */
-        function checkList(nodes, shouldCheck) {
-            const accessors = [];
-            let found = false;
-
-            for (let i = 0; i < nodes.length; i++) {
-                const node = nodes[i];
-
-                if (shouldCheck(node) && isAccessorKind(node)) {
-
-                    // Creates a new `AccessorData` object for the given getter or setter node.
-                    const name = astUtils.getStaticPropertyName(node);
-                    const key = (name !== null) ? name : sourceCode.getTokens(node.key);
-
-                    // Merges the given `AccessorData` object into the given accessors list.
-                    for (let j = 0; j < accessors.length; j++) {
-                        const accessor = accessors[j];
-
-                        if (areEqualKeys(accessor.key, key)) {
-                            accessor.getters.push(...node.kind === "get" ? [node] : []);
-                            accessor.setters.push(...node.kind === "set" ? [node] : []);
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (!found) {
-                        accessors.push({
-                            key,
-                            getters: node.kind === "get" ? [node] : [],
-                            setters: node.kind === "set" ? [node] : []
-                        });
-                    }
-                    found = false;
-                }
-            }
-
-            for (const { getters, setters } of accessors) {
-
-                // Don't report accessor properties that have duplicate getters or setters.
-                if (getters.length === 1 && setters.length === 1) {
-                    const [getter] = getters,
-                        [setter] = setters,
-                        getterIndex = nodes.indexOf(getter),
-                        setterIndex = nodes.indexOf(setter),
-                        formerNode = getterIndex < setterIndex ? getter : setter,
-                        latterNode = getterIndex < setterIndex ? setter : getter;
-
-                    if (Math.abs(getterIndex - setterIndex) > 1) {
-                        report("notGrouped", formerNode, latterNode);
-                    } else if (
-                        (order === "getBeforeSet" && getterIndex > setterIndex) ||
-                        (order === "setBeforeGet" && getterIndex < setterIndex)
-                    ) {
-                        report("invalidOrder", formerNode, latterNode);
-                    }
-                }
-            }
-        }
-
-        return {
-            ObjectExpression(node) {
-                checkList(node.properties, n => n.type === "Property");
-            },
-            ClassBody(node) {
-                checkList(node.body, n => n.type === "MethodDefinition" && !n.static);
-                checkList(node.body, n => n.type === "MethodDefinition" && n.static);
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/guard-for-in.js

@@ -1,76 +0,0 @@
-/**
- * @fileoverview Rule to flag for-in loops without if statements inside
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require `for-in` loops to include an `if` statement",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/guard-for-in"
-        },
-
-        schema: [],
-        messages: {
-            wrap: "The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            ForInStatement(node) {
-                const body = node.body;
-
-                // empty statement
-                if (body.type === "EmptyStatement") {
-                    return;
-                }
-
-                // if statement
-                if (body.type === "IfStatement") {
-                    return;
-                }
-
-                // empty block
-                if (body.type === "BlockStatement" && body.body.length === 0) {
-                    return;
-                }
-
-                // block with just if statement
-                if (body.type === "BlockStatement" && body.body.length === 1 && body.body[0].type === "IfStatement") {
-                    return;
-                }
-
-                // block that starts with if statement
-                if (body.type === "BlockStatement" && body.body.length >= 1 && body.body[0].type === "IfStatement") {
-                    const i = body.body[0];
-
-                    // ... whose consequent is a continue
-                    if (i.consequent.type === "ContinueStatement") {
-                        return;
-                    }
-
-                    // ... whose consequent is a block that contains only a continue
-                    if (i.consequent.type === "BlockStatement" && i.consequent.body.length === 1 && i.consequent.body[0].type === "ContinueStatement") {
-                        return;
-                    }
-                }
-
-                context.report({ node, messageId: "wrap" });
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/handle-callback-err.js

@@ -1,101 +0,0 @@
-/**
- * @fileoverview Ensure handling of errors when we know they exist.
- * @author Jamund Ferguson
- * @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: "Require error handling in callbacks",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/handle-callback-err"
-        },
-
-        schema: [
-            {
-                type: "string"
-            }
-        ],
-        messages: {
-            expected: "Expected error to be handled."
-        }
-    },
-
-    create(context) {
-
-        const errorArgument = context.options[0] || "err";
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks if the given argument should be interpreted as a regexp pattern.
-         * @param {string} stringToCheck The string which should be checked.
-         * @returns {boolean} Whether or not the string should be interpreted as a pattern.
-         */
-        function isPattern(stringToCheck) {
-            const firstChar = stringToCheck[0];
-
-            return firstChar === "^";
-        }
-
-        /**
-         * Checks if the given name matches the configured error argument.
-         * @param {string} name The name which should be compared.
-         * @returns {boolean} Whether or not the given name matches the configured error variable name.
-         */
-        function matchesConfiguredErrorName(name) {
-            if (isPattern(errorArgument)) {
-                const regexp = new RegExp(errorArgument, "u");
-
-                return regexp.test(name);
-            }
-            return name === errorArgument;
-        }
-
-        /**
-         * Get the parameters of a given function scope.
-         * @param {Object} scope The function scope.
-         * @returns {Array} All parameters of the given scope.
-         */
-        function getParameters(scope) {
-            return scope.variables.filter(variable => variable.defs[0] && variable.defs[0].type === "Parameter");
-        }
-
-        /**
-         * Check to see if we're handling the error object properly.
-         * @param {ASTNode} node The AST node to check.
-         * @returns {void}
-         */
-        function checkForError(node) {
-            const scope = sourceCode.getScope(node),
-                parameters = getParameters(scope),
-                firstParameter = parameters[0];
-
-            if (firstParameter && matchesConfiguredErrorName(firstParameter.name)) {
-                if (firstParameter.references.length === 0) {
-                    context.report({ node, messageId: "expected" });
-                }
-            }
-        }
-
-        return {
-            FunctionDeclaration: checkForError,
-            FunctionExpression: checkForError,
-            ArrowFunctionExpression: checkForError
-        };
-
-    }
-};