repoburg 1.1.0 → 1.1.2

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'explicit-member-accessibility',
+    meta: {
+        hasSuggestions: true,
+        type: 'problem',
+        docs: {
+            description: 'Require explicit accessibility modifiers on class properties and methods',
+            // too opinionated to be recommended
+        },
+        fixable: 'code',
+        messages: {
+            missingAccessibility: 'Missing accessibility modifier on {{type}} {{name}}.',
+            unwantedPublicAccessibility: 'Public accessibility modifier on {{type}} {{name}}.',
+            addExplicitAccessibility: "Add '{{ type }}' accessibility modifier",
+        },
+        schema: [
+            {
+                $defs: {
+                    accessibilityLevel: {
+                        oneOf: [
+                            {
+                                type: 'string',
+                                enum: ['explicit'],
+                                description: 'Always require an accessor.',
+                            },
+                            {
+                                type: 'string',
+                                enum: ['no-public'],
+                                description: 'Require an accessor except when public.',
+                            },
+                            {
+                                type: 'string',
+                                enum: ['off'],
+                                description: 'Never check whether there is an accessor.',
+                            },
+                        ],
+                    },
+                },
+                type: 'object',
+                properties: {
+                    accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
+                    overrides: {
+                        type: 'object',
+                        properties: {
+                            accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
+                            constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
+                            methods: { $ref: '#/items/0/$defs/accessibilityLevel' },
+                            properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
+                            parameterProperties: {
+                                $ref: '#/items/0/$defs/accessibilityLevel',
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                    ignoredMethodNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ accessibility: 'explicit' }],
+    create(context, [option]) {
+        const sourceCode = (0, eslint_utils_1.getSourceCode)(context);
+        const baseCheck = option.accessibility ?? 'explicit';
+        const overrides = option.overrides ?? {};
+        const ctorCheck = overrides.constructors ?? baseCheck;
+        const accessorCheck = overrides.accessors ?? baseCheck;
+        const methodCheck = overrides.methods ?? baseCheck;
+        const propCheck = overrides.properties ?? baseCheck;
+        const paramPropCheck = overrides.parameterProperties ?? baseCheck;
+        const ignoredMethodNames = new Set(option.ignoredMethodNames ?? []);
+        /**
+         * Checks if a method declaration has an accessibility modifier.
+         * @param methodDefinition The node representing a MethodDefinition.
+         */
+        function checkMethodAccessibilityModifier(methodDefinition) {
+            if (methodDefinition.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                return;
+            }
+            let nodeType = 'method definition';
+            let check = baseCheck;
+            switch (methodDefinition.kind) {
+                case 'method':
+                    check = methodCheck;
+                    break;
+                case 'constructor':
+                    check = ctorCheck;
+                    break;
+                case 'get':
+                case 'set':
+                    check = accessorCheck;
+                    nodeType = `${methodDefinition.kind} property accessor`;
+                    break;
+            }
+            const { name: methodName } = (0, util_1.getNameFromMember)(methodDefinition, sourceCode);
+            if (check === 'off' || ignoredMethodNames.has(methodName)) {
+                return;
+            }
+            if (check === 'no-public' &&
+                methodDefinition.accessibility === 'public') {
+                context.report({
+                    node: methodDefinition,
+                    messageId: 'unwantedPublicAccessibility',
+                    data: {
+                        type: nodeType,
+                        name: methodName,
+                    },
+                    fix: getUnwantedPublicAccessibilityFixer(methodDefinition),
+                });
+            }
+            else if (check === 'explicit' && !methodDefinition.accessibility) {
+                context.report({
+                    node: methodDefinition,
+                    messageId: 'missingAccessibility',
+                    data: {
+                        type: nodeType,
+                        name: methodName,
+                    },
+                    suggest: getMissingAccessibilitySuggestions(methodDefinition),
+                });
+            }
+        }
+        /**
+         * Creates a fixer that removes a "public" keyword with following spaces
+         */
+        function getUnwantedPublicAccessibilityFixer(node) {
+            return function (fixer) {
+                const tokens = sourceCode.getTokens(node);
+                let rangeToRemove;
+                for (let i = 0; i < tokens.length; i++) {
+                    const token = tokens[i];
+                    if (token.type === utils_1.AST_TOKEN_TYPES.Keyword &&
+                        token.value === 'public') {
+                        const commensAfterPublicKeyword = sourceCode.getCommentsAfter(token);
+                        if (commensAfterPublicKeyword.length) {
+                            // public /* Hi there! */ static foo()
+                            // ^^^^^^^
+                            rangeToRemove = [
+                                token.range[0],
+                                commensAfterPublicKeyword[0].range[0],
+                            ];
+                            break;
+                        }
+                        else {
+                            // public static foo()
+                            // ^^^^^^^
+                            rangeToRemove = [token.range[0], tokens[i + 1].range[0]];
+                            break;
+                        }
+                    }
+                }
+                return fixer.removeRange(rangeToRemove);
+            };
+        }
+        /**
+         * Creates a fixer that adds a "public" keyword with following spaces
+         */
+        function getMissingAccessibilitySuggestions(node) {
+            function fix(accessibility, fixer) {
+                if (node.decorators.length) {
+                    const lastDecorator = node.decorators[node.decorators.length - 1];
+                    const nextToken = sourceCode.getTokenAfter(lastDecorator);
+                    return fixer.insertTextBefore(nextToken, `${accessibility} `);
+                }
+                return fixer.insertTextBefore(node, `${accessibility} `);
+            }
+            return [
+                {
+                    messageId: 'addExplicitAccessibility',
+                    data: { type: 'public' },
+                    fix: fixer => fix('public', fixer),
+                },
+                {
+                    messageId: 'addExplicitAccessibility',
+                    data: { type: 'private' },
+                    fix: fixer => fix('private', fixer),
+                },
+                {
+                    messageId: 'addExplicitAccessibility',
+                    data: { type: 'protected' },
+                    fix: fixer => fix('protected', fixer),
+                },
+            ];
+        }
+        /**
+         * Checks if property has an accessibility modifier.
+         * @param propertyDefinition The node representing a PropertyDefinition.
+         */
+        function checkPropertyAccessibilityModifier(propertyDefinition) {
+            if (propertyDefinition.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                return;
+            }
+            const nodeType = 'class property';
+            const { name: propertyName } = (0, util_1.getNameFromMember)(propertyDefinition, sourceCode);
+            if (propCheck === 'no-public' &&
+                propertyDefinition.accessibility === 'public') {
+                context.report({
+                    node: propertyDefinition,
+                    messageId: 'unwantedPublicAccessibility',
+                    data: {
+                        type: nodeType,
+                        name: propertyName,
+                    },
+                    fix: getUnwantedPublicAccessibilityFixer(propertyDefinition),
+                });
+            }
+            else if (propCheck === 'explicit' &&
+                !propertyDefinition.accessibility) {
+                context.report({
+                    node: propertyDefinition,
+                    messageId: 'missingAccessibility',
+                    data: {
+                        type: nodeType,
+                        name: propertyName,
+                    },
+                    suggest: getMissingAccessibilitySuggestions(propertyDefinition),
+                });
+            }
+        }
+        /**
+         * Checks that the parameter property has the desired accessibility modifiers set.
+         * @param node The node representing a Parameter Property
+         */
+        function checkParameterPropertyAccessibilityModifier(node) {
+            const nodeType = 'parameter property';
+            // HAS to be an identifier or assignment or TSC will throw
+            if (node.parameter.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                node.parameter.type !== utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                return;
+            }
+            const nodeName = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier
+                ? node.parameter.name
+                : // has to be an Identifier or TSC will throw an error
+                    node.parameter.left.name;
+            switch (paramPropCheck) {
+                case 'explicit': {
+                    if (!node.accessibility) {
+                        context.report({
+                            node,
+                            messageId: 'missingAccessibility',
+                            data: {
+                                type: nodeType,
+                                name: nodeName,
+                            },
+                            suggest: getMissingAccessibilitySuggestions(node),
+                        });
+                    }
+                    break;
+                }
+                case 'no-public': {
+                    if (node.accessibility === 'public' && node.readonly) {
+                        context.report({
+                            node,
+                            messageId: 'unwantedPublicAccessibility',
+                            data: {
+                                type: nodeType,
+                                name: nodeName,
+                            },
+                            fix: getUnwantedPublicAccessibilityFixer(node),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+        return {
+            'MethodDefinition, TSAbstractMethodDefinition': checkMethodAccessibilityModifier,
+            'PropertyDefinition, TSAbstractPropertyDefinition': checkPropertyAccessibilityModifier,
+            TSParameterProperty: checkParameterPropertyAccessibilityModifier,
+        };
+    },
+});
+//# sourceMappingURL=explicit-member-accessibility.js.map

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-member-accessibility.js","sourceRoot":"","sources":["../../src/rules/explicit-member-accessibility.ts"],"names":[],"mappings":"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"}

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const utils_1 = require("@typescript-eslint/utils");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const util_1 = require("../util");
+const explicitReturnTypeUtils_1 = require("../util/explicitReturnTypeUtils");
+exports.default = (0, util_1.createRule)({
+    name: 'explicit-module-boundary-types',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: "Require explicit return and argument types on exported functions' and classes' public class methods",
+        },
+        messages: {
+            missingReturnType: 'Missing return type on function.',
+            missingArgType: "Argument '{{name}}' should be typed.",
+            missingArgTypeUnnamed: '{{type}} argument should be typed.',
+            anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.",
+            anyTypedArgUnnamed: '{{type}} argument should be typed with a non-any type.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowArgumentsExplicitlyTypedAsAny: {
+                        description: 'Whether to ignore arguments that are explicitly typed as `any`.',
+                        type: 'boolean',
+                    },
+                    allowDirectConstAssertionInArrowFunctions: {
+                        description: [
+                            'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
+                            'You must still type the parameters of the function.',
+                        ].join('\n'),
+                        type: 'boolean',
+                    },
+                    allowedNames: {
+                        description: 'An array of function/method names that will not have their arguments or return values checked.',
+                        items: {
+                            type: 'string',
+                        },
+                        type: 'array',
+                    },
+                    allowHigherOrderFunctions: {
+                        description: [
+                            'Whether to ignore return type annotations on functions immediately returning another function expression.',
+                            'You must still type the parameters of the function.',
+                        ].join('\n'),
+                        type: 'boolean',
+                    },
+                    allowTypedFunctionExpressions: {
+                        description: 'Whether to ignore type annotations on the variable of a function expression.',
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowArgumentsExplicitlyTypedAsAny: false,
+            allowDirectConstAssertionInArrowFunctions: true,
+            allowedNames: [],
+            allowHigherOrderFunctions: true,
+            allowTypedFunctionExpressions: true,
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = (0, eslint_utils_1.getSourceCode)(context);
+        // tracks all of the functions we've already checked
+        const checkedFunctions = new Set();
+        // tracks functions that were found whilst traversing
+        const foundFunctions = [];
+        // all nodes visited, avoids infinite recursion for cyclic references
+        // (such as class member referring to itself)
+        const alreadyVisited = new Set();
+        /*
+        # How the rule works:
+    
+        As the rule traverses the AST, it immediately checks every single function that it finds is exported.
+        "exported" means that it is either directly exported, or that its name is exported.
+    
+        It also collects a list of every single function it finds on the way, but does not check them.
+        After it's finished traversing the AST, it then iterates through the list of found functions, and checks to see if
+        any of them are part of a higher-order function
+        */
+        return {
+            ExportDefaultDeclaration(node) {
+                checkNode(node.declaration);
+            },
+            'ExportNamedDeclaration:not([source])'(node) {
+                if (node.declaration) {
+                    checkNode(node.declaration);
+                }
+                else {
+                    for (const specifier of node.specifiers) {
+                        followReference(specifier.local);
+                    }
+                }
+            },
+            TSExportAssignment(node) {
+                checkNode(node.expression);
+            },
+            'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression'(node) {
+                foundFunctions.push(node);
+            },
+            'Program:exit'() {
+                for (const func of foundFunctions) {
+                    if (isExportedHigherOrderFunction(func)) {
+                        checkNode(func);
+                    }
+                }
+            },
+        };
+        function checkParameters(node) {
+            function checkParameter(param) {
+                function report(namedMessageId, unnamedMessageId) {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        context.report({
+                            node: param,
+                            messageId: namedMessageId,
+                            data: { name: param.name },
+                        });
+                    }
+                    else if (param.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                        context.report({
+                            node: param,
+                            messageId: unnamedMessageId,
+                            data: { type: 'Array pattern' },
+                        });
+                    }
+                    else if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                        context.report({
+                            node: param,
+                            messageId: unnamedMessageId,
+                            data: { type: 'Object pattern' },
+                        });
+                    }
+                    else if (param.type === utils_1.AST_NODE_TYPES.RestElement) {
+                        if (param.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            context.report({
+                                node: param,
+                                messageId: namedMessageId,
+                                data: { name: param.argument.name },
+                            });
+                        }
+                        else {
+                            context.report({
+                                node: param,
+                                messageId: unnamedMessageId,
+                                data: { type: 'Rest' },
+                            });
+                        }
+                    }
+                }
+                switch (param.type) {
+                    case utils_1.AST_NODE_TYPES.ArrayPattern:
+                    case utils_1.AST_NODE_TYPES.Identifier:
+                    case utils_1.AST_NODE_TYPES.ObjectPattern:
+                    case utils_1.AST_NODE_TYPES.RestElement:
+                        if (!param.typeAnnotation) {
+                            report('missingArgType', 'missingArgTypeUnnamed');
+                        }
+                        else if (options.allowArgumentsExplicitlyTypedAsAny !== true &&
+                            param.typeAnnotation.typeAnnotation.type ===
+                                utils_1.AST_NODE_TYPES.TSAnyKeyword) {
+                            report('anyTypedArg', 'anyTypedArgUnnamed');
+                        }
+                        return;
+                    case utils_1.AST_NODE_TYPES.TSParameterProperty:
+                        return checkParameter(param.parameter);
+                    case utils_1.AST_NODE_TYPES.AssignmentPattern: // ignored as it has a type via its assignment
+                        return;
+                }
+            }
+            for (const arg of node.params) {
+                checkParameter(arg);
+            }
+        }
+        /**
+         * Checks if a function name is allowed and should not be checked.
+         */
+        function isAllowedName(node) {
+            if (!node || !options.allowedNames || options.allowedNames.length === 0) {
+                return false;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                return (node.id?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    options.allowedNames.includes(node.id.name));
+            }
+            else if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+                node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition ||
+                (node.type === utils_1.AST_NODE_TYPES.Property && node.method) ||
+                node.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.key.value === 'string') {
+                    return options.allowedNames.includes(node.key.value);
+                }
+                if (node.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                    node.key.expressions.length === 0) {
+                    return options.allowedNames.includes(node.key.quasis[0].value.raw);
+                }
+                if (!node.computed && node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return options.allowedNames.includes(node.key.name);
+                }
+            }
+            return false;
+        }
+        function isExportedHigherOrderFunction(node) {
+            let current = node.parent;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                    // the parent of a return will always be a block statement, so we can skip over it
+                    current = current.parent.parent;
+                    continue;
+                }
+                if (!(0, util_1.isFunction)(current) ||
+                    !(0, explicitReturnTypeUtils_1.doesImmediatelyReturnFunctionExpression)(current)) {
+                    return false;
+                }
+                if (checkedFunctions.has(current)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function followReference(node) {
+            const scope = (0, eslint_utils_1.getScope)(context);
+            const variable = scope.set.get(node.name);
+            /* istanbul ignore if */ if (!variable) {
+                return;
+            }
+            // check all of the definitions
+            for (const definition of variable.defs) {
+                // cases we don't care about in this rule
+                if ([
+                    scope_manager_1.DefinitionType.ImplicitGlobalVariable,
+                    scope_manager_1.DefinitionType.ImportBinding,
+                    scope_manager_1.DefinitionType.CatchClause,
+                    scope_manager_1.DefinitionType.Parameter,
+                ].includes(definition.type)) {
+                    continue;
+                }
+                checkNode(definition.node);
+            }
+            // follow references to find writes to the variable
+            for (const reference of variable.references) {
+                if (
+                // we don't want to check the initialization ref, as this is handled by the declaration check
+                !reference.init &&
+                    reference.writeExpr) {
+                    checkNode(reference.writeExpr);
+                }
+            }
+        }
+        function checkNode(node) {
+            if (node == null || alreadyVisited.has(node)) {
+                return;
+            }
+            alreadyVisited.add(node);
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                case utils_1.AST_NODE_TYPES.FunctionExpression:
+                    return checkFunctionExpression(node);
+                case utils_1.AST_NODE_TYPES.ArrayExpression:
+                    for (const element of node.elements) {
+                        checkNode(element);
+                    }
+                    return;
+                case utils_1.AST_NODE_TYPES.PropertyDefinition:
+                    if (node.accessibility === 'private' ||
+                        node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                        return;
+                    }
+                    return checkNode(node.value);
+                case utils_1.AST_NODE_TYPES.ClassDeclaration:
+                case utils_1.AST_NODE_TYPES.ClassExpression:
+                    for (const element of node.body.body) {
+                        checkNode(element);
+                    }
+                    return;
+                case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                    return checkFunction(node);
+                case utils_1.AST_NODE_TYPES.MethodDefinition:
+                case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
+                    if (node.accessibility === 'private' ||
+                        node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                        return;
+                    }
+                    return checkNode(node.value);
+                case utils_1.AST_NODE_TYPES.Identifier:
+                    return followReference(node);
+                case utils_1.AST_NODE_TYPES.ObjectExpression:
+                    for (const property of node.properties) {
+                        checkNode(property);
+                    }
+                    return;
+                case utils_1.AST_NODE_TYPES.Property:
+                    return checkNode(node.value);
+                case utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression:
+                    return checkEmptyBodyFunctionExpression(node);
+                case utils_1.AST_NODE_TYPES.VariableDeclaration:
+                    for (const declaration of node.declarations) {
+                        checkNode(declaration);
+                    }
+                    return;
+                case utils_1.AST_NODE_TYPES.VariableDeclarator:
+                    return checkNode(node.init);
+            }
+        }
+        function checkEmptyBodyFunctionExpression(node) {
+            const isConstructor = node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                node.parent.kind === 'constructor';
+            const isSetAccessor = (node.parent.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition ||
+                node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) &&
+                node.parent.kind === 'set';
+            if (!isConstructor && !isSetAccessor && !node.returnType) {
+                context.report({
+                    node,
+                    messageId: 'missingReturnType',
+                });
+            }
+            checkParameters(node);
+        }
+        function checkFunctionExpression(node) {
+            if (checkedFunctions.has(node)) {
+                return;
+            }
+            checkedFunctions.add(node);
+            if (isAllowedName(node.parent) ||
+                (0, explicitReturnTypeUtils_1.isTypedFunctionExpression)(node, options) ||
+                (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node)) {
+                return;
+            }
+            (0, explicitReturnTypeUtils_1.checkFunctionExpressionReturnType)(node, options, sourceCode, loc => {
+                context.report({
+                    node,
+                    loc,
+                    messageId: 'missingReturnType',
+                });
+            });
+            checkParameters(node);
+        }
+        function checkFunction(node) {
+            if (checkedFunctions.has(node)) {
+                return;
+            }
+            checkedFunctions.add(node);
+            if (isAllowedName(node) || (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node)) {
+                return;
+            }
+            (0, explicitReturnTypeUtils_1.checkFunctionReturnType)(node, options, sourceCode, loc => {
+                context.report({
+                    node,
+                    loc,
+                    messageId: 'missingReturnType',
+                });
+            });
+            checkParameters(node);
+        }
+    },
+});
+//# sourceMappingURL=explicit-module-boundary-types.js.map