@alexlit/lint-kit 112.0.0 → 112.1.0

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

@@ -1,281 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@typescript-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 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, context.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 = context.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 = context.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 = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(lastDecorator), util_1.NullThrowsReasons.MissingToken('token', 'last decorator'));
-                    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, context.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/packages/config-eslint/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"explicit-member-accessibility.js","sourceRoot":"","sources":["../../src/rules/explicit-member-accessibility.ts"],"names":[],"mappings":";;AACA,oDAA2E;AAE3E,kCAKiB;AA0BjB,kBAAe,IAAA,iBAAU,EAAsB;IAC7C,IAAI,EAAE,+BAA+B;IACrC,IAAI,EAAE;QACJ,cAAc,EAAE,IAAI;QACpB,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EACT,0EAA0E;YAC5E,oCAAoC;SACrC;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACR,oBAAoB,EAClB,sDAAsD;YACxD,2BAA2B,EACzB,qDAAqD;YACvD,wBAAwB,EAAE,yCAAyC;SACpE;QACD,MAAM,EAAE;YACN;gBACE,KAAK,EAAE;oBACL,kBAAkB,EAAE;wBAClB,KAAK,EAAE;4BACL;gCACE,IAAI,EAAE,QAAQ;gCACd,IAAI,EAAE,CAAC,UAAU,CAAC;gCAClB,WAAW,EAAE,6BAA6B;6BAC3C;4BACD;gCACE,IAAI,EAAE,QAAQ;gCACd,IAAI,EAAE,CAAC,WAAW,CAAC;gCACnB,WAAW,EAAE,yCAAyC;6BACvD;4BACD;gCACE,IAAI,EAAE,QAAQ;gCACd,IAAI,EAAE,CAAC,KAAK,CAAC;gCACb,WAAW,EAAE,2CAA2C;6BACzD;yBACF;qBACF;iBACF;gBACD,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,aAAa,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE;oBAC7D,SAAS,EAAE;wBACT,IAAI,EAAE,QAAQ;wBACd,UAAU,EAAE;4BACV,SAAS,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE;4BACzD,YAAY,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE;4BAC5D,OAAO,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE;4BACvD,UAAU,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE;4BAC1D,mBAAmB,EAAE;gCACnB,IAAI,EAAE,oCAAoC;6BAC3C;yBACF;wBAED,oBAAoB,EAAE,KAAK;qBAC5B;oBACD,kBAAkB,EAAE;wBAClB,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE;4BACL,IAAI,EAAE,QAAQ;yBACf;qBACF;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;KACF;IACD,cAAc,EAAE,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;IAC/C,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC;QACtB,MAAM,SAAS,GAAuB,MAAM,CAAC,aAAa,IAAI,UAAU,CAAC;QACzE,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC;QACtD,MAAM,aAAa,GAAG,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC;QACvD,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC;QACnD,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU,IAAI,SAAS,CAAC;QACpD,MAAM,cAAc,GAAG,SAAS,CAAC,mBAAmB,IAAI,SAAS,CAAC;QAClE,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC;QAEpE;;;WAGG;QACH,SAAS,gCAAgC,CACvC,gBAA2C;YAE3C,IAAI,gBAAgB,CAAC,GAAG,CAAC,IAAI,KAAK,sBAAc,CAAC,iBAAiB,EAAE,CAAC;gBACnE,OAAO;YACT,CAAC;YAED,IAAI,QAAQ,GAAG,mBAAmB,CAAC;YACnC,IAAI,KAAK,GAAG,SAAS,CAAC;YACtB,QAAQ,gBAAgB,CAAC,IAAI,EAAE,CAAC;gBAC9B,KAAK,QAAQ;oBACX,KAAK,GAAG,WAAW,CAAC;oBACpB,MAAM;gBACR,KAAK,aAAa;oBAChB,KAAK,GAAG,SAAS,CAAC;oBAClB,MAAM;gBACR,KAAK,KAAK,CAAC;gBACX,KAAK,KAAK;oBACR,KAAK,GAAG,aAAa,CAAC;oBACtB,QAAQ,GAAG,GAAG,gBAAgB,CAAC,IAAI,oBAAoB,CAAC;oBACxD,MAAM;YACV,CAAC;YAED,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,IAAA,wBAAiB,EAC5C,gBAAgB,EAChB,OAAO,CAAC,UAAU,CACnB,CAAC;YAEF,IAAI,KAAK,KAAK,KAAK,IAAI,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC1D,OAAO;YACT,CAAC;YAED,IACE,KAAK,KAAK,WAAW;gBACrB,gBAAgB,CAAC,aAAa,KAAK,QAAQ,EAC3C,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI,EAAE,gBAAgB;oBACtB,SAAS,EAAE,6BAA6B;oBACxC,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,UAAU;qBACjB;oBACD,GAAG,EAAE,mCAAmC,CAAC,gBAAgB,CAAC;iBAC3D,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,KAAK,KAAK,UAAU,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,CAAC;gBACnE,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI,EAAE,gBAAgB;oBACtB,SAAS,EAAE,sBAAsB;oBACjC,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,UAAU;qBACjB;oBACD,OAAO,EAAE,kCAAkC,CAAC,gBAAgB,CAAC;iBAC9D,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED;;WAEG;QACH,SAAS,mCAAmC,CAC1C,IAKgC;YAEhC,OAAO,UAAU,KAAyB;gBACxC,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;gBAClD,IAAI,aAAkC,CAAC;gBACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACvC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBACxB,IACE,KAAK,CAAC,IAAI,KAAK,uBAAe,CAAC,OAAO;wBACtC,KAAK,CAAC,KAAK,KAAK,QAAQ,EACxB,CAAC;wBACD,MAAM,yBAAyB,GAC7B,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;wBAC7C,IAAI,yBAAyB,CAAC,MAAM,EAAE,CAAC;4BACrC,sCAAsC;4BACtC,UAAU;4BACV,aAAa,GAAG;gCACd,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gCACd,yBAAyB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;6BACtC,CAAC;4BACF,MAAM;wBACR,CAAC;6BAAM,CAAC;4BACN,sBAAsB;4BACtB,UAAU;4BACV,aAAa,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;4BACzD,MAAM;wBACR,CAAC;oBACH,CAAC;gBACH,CAAC;gBACD,OAAO,KAAK,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;YAC1C,CAAC,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,SAAS,kCAAkC,CACzC,IAKgC;YAEhC,SAAS,GAAG,CACV,aAAqC,EACrC,KAAyB;gBAEzB,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;oBAC3B,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBAClE,MAAM,SAAS,GAAG,IAAA,iBAAU,EAC1B,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,EAC/C,wBAAiB,CAAC,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAC1D,CAAC;oBACF,OAAO,KAAK,CAAC,gBAAgB,CAAC,SAAS,EAAE,GAAG,aAAa,GAAG,CAAC,CAAC;gBAChE,CAAC;gBACD,OAAO,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,GAAG,aAAa,GAAG,CAAC,CAAC;YAC3D,CAAC;YAED,OAAO;gBACL;oBACE,SAAS,EAAE,0BAA0B;oBACrC,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBACxB,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;iBACnC;gBACD;oBACE,SAAS,EAAE,0BAA0B;oBACrC,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;oBACzB,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC;iBACpC;gBACD;oBACE,SAAS,EAAE,0BAA0B;oBACrC,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;oBAC3B,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC;iBACtC;aACF,CAAC;QACJ,CAAC;QAED;;;WAGG;QACH,SAAS,kCAAkC,CACzC,kBAEyC;YAEzC,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,KAAK,sBAAc,CAAC,iBAAiB,EAAE,CAAC;gBACrE,OAAO;YACT,CAAC;YAED,MAAM,QAAQ,GAAG,gBAAgB,CAAC;YAElC,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,IAAA,wBAAiB,EAC9C,kBAAkB,EAClB,OAAO,CAAC,UAAU,CACnB,CAAC;YACF,IACE,SAAS,KAAK,WAAW;gBACzB,kBAAkB,CAAC,aAAa,KAAK,QAAQ,EAC7C,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI,EAAE,kBAAkB;oBACxB,SAAS,EAAE,6BAA6B;oBACxC,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,YAAY;qBACnB;oBACD,GAAG,EAAE,mCAAmC,CAAC,kBAAkB,CAAC;iBAC7D,CAAC,CAAC;YACL,CAAC;iBAAM,IACL,SAAS,KAAK,UAAU;gBACxB,CAAC,kBAAkB,CAAC,aAAa,EACjC,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI,EAAE,kBAAkB;oBACxB,SAAS,EAAE,sBAAsB;oBACjC,IAAI,EAAE;wBACJ,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,YAAY;qBACnB;oBACD,OAAO,EAAE,kCAAkC,CAAC,kBAAkB,CAAC;iBAChE,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED;;;WAGG;QACH,SAAS,2CAA2C,CAClD,IAAkC;YAElC,MAAM,QAAQ,GAAG,oBAAoB,CAAC;YACtC,0DAA0D;YAC1D,IACE,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU;gBACjD,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,sBAAc,CAAC,iBAAiB,EACxD,CAAC;gBACD,OAAO;YACT,CAAC;YAED,MAAM,QAAQ,GACZ,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU;gBAC/C,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI;gBACrB,CAAC,CAAC,qDAAqD;oBACpD,IAAI,CAAC,SAAS,CAAC,IAA4B,CAAC,IAAI,CAAC;YAExD,QAAQ,cAAc,EAAE,CAAC;gBACvB,KAAK,UAAU,CAAC,CAAC,CAAC;oBAChB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;wBACxB,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI;4BACJ,SAAS,EAAE,sBAAsB;4BACjC,IAAI,EAAE;gCACJ,IAAI,EAAE,QAAQ;gCACd,IAAI,EAAE,QAAQ;6BACf;4BACD,OAAO,EAAE,kCAAkC,CAAC,IAAI,CAAC;yBAClD,CAAC,CAAC;oBACL,CAAC;oBACD,MAAM;gBACR,CAAC;gBACD,KAAK,WAAW,CAAC,CAAC,CAAC;oBACjB,IAAI,IAAI,CAAC,aAAa,KAAK,QAAQ,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACrD,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI;4BACJ,SAAS,EAAE,6BAA6B;4BACxC,IAAI,EAAE;gCACJ,IAAI,EAAE,QAAQ;gCACd,IAAI,EAAE,QAAQ;6BACf;4BACD,GAAG,EAAE,mCAAmC,CAAC,IAAI,CAAC;yBAC/C,CAAC,CAAC;oBACL,CAAC;oBACD,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO;YACL,8CAA8C,EAC5C,gCAAgC;YAClC,kDAAkD,EAChD,kCAAkC;YACpC,mBAAmB,EAAE,2CAA2C;SACjE,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

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

@@ -1,386 +0,0 @@
-"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 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]) {
-        // tracks all of the functions we've already checked
-        const checkedFunctions = new Set();
-        const functionStack = [];
-        const functionReturnsMap = new Map();
-        // all nodes visited, avoids infinite recursion for cyclic references
-        // (such as class member referring to itself)
-        const alreadyVisited = new Set();
-        function getReturnsInFunction(node) {
-            return functionReturnsMap.get(node) ?? [];
-        }
-        function enterFunction(node) {
-            functionStack.push(node);
-            functionReturnsMap.set(node, []);
-        }
-        function exitFunction() {
-            functionStack.pop();
-        }
-        /*
-        # 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:exit'(node) {
-                checkNode(node.declaration);
-            },
-            'ExportNamedDeclaration:not([source]):exit'(node) {
-                if (node.declaration) {
-                    checkNode(node.declaration);
-                }
-                else {
-                    for (const specifier of node.specifiers) {
-                        followReference(specifier.local);
-                    }
-                }
-            },
-            'TSExportAssignment:exit'(node) {
-                checkNode(node.expression);
-            },
-            'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression': enterFunction,
-            'ArrowFunctionExpression:exit': exitFunction,
-            'FunctionDeclaration:exit': exitFunction,
-            'FunctionExpression:exit': exitFunction,
-            'Program:exit'() {
-                for (const [node, returns] of functionReturnsMap) {
-                    if (isExportedHigherOrderFunction({ node, returns })) {
-                        checkNode(node);
-                    }
-                }
-            },
-            ReturnStatement(node) {
-                const current = functionStack[functionStack.length - 1];
-                functionReturnsMap.get(current)?.push(node);
-            },
-        };
-        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)) {
-                    return false;
-                }
-                const returns = getReturnsInFunction(current);
-                if (!(0, explicitReturnTypeUtils_1.doesImmediatelyReturnFunctionExpression)({ node: current, returns })) {
-                    return false;
-                }
-                if (checkedFunctions.has(current)) {
-                    return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        }
-        function followReference(node) {
-            const scope = context.sourceCode.getScope(node);
-            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: {
-                    const returns = getReturnsInFunction(node);
-                    return checkFunctionExpression({ node, returns });
-                }
-                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: {
-                    const returns = getReturnsInFunction(node);
-                    return checkFunction({ node, returns });
-                }
-                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, returns, }) {
-            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, returns }, options, context.sourceCode, loc => {
-                context.report({
-                    node,
-                    loc,
-                    messageId: 'missingReturnType',
-                });
-            });
-            checkParameters(node);
-        }
-        function checkFunction({ node, returns, }) {
-            if (checkedFunctions.has(node)) {
-                return;
-            }
-            checkedFunctions.add(node);
-            if (isAllowedName(node) || (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node)) {
-                return;
-            }
-            (0, explicitReturnTypeUtils_1.checkFunctionReturnType)({ node, returns }, options, context.sourceCode, loc => {
-                context.report({
-                    node,
-                    loc,
-                    messageId: 'missingReturnType',
-                });
-            });
-            checkParameters(node);
-        }
-    },
-});
-//# sourceMappingURL=explicit-module-boundary-types.js.map