@depup/typescript-eslint__eslint-plugin 8.57.1-depup.0

package/dist/rules/consistent-return.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('consistent-return');
+const defaultOptions = [{ treatUndefinedAsUnspecified: false }];
+exports.default = (0, util_1.createRule)({
+    name: 'consistent-return',
+    meta: {
+        type: 'suggestion',
+        defaultOptions,
+        docs: {
+            description: 'Require `return` statements to either always or never specify values',
+            extendsBaseRule: true,
+            requiresTypeChecking: true,
+        },
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: baseRule.meta.schema,
+    },
+    defaultOptions,
+    create(context, [options]) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const rules = baseRule.create(context);
+        const functions = [];
+        const treatUndefinedAsUnspecified = options?.treatUndefinedAsUnspecified === true;
+        function enterFunction(node) {
+            functions.push(node);
+        }
+        function exitFunction() {
+            functions.pop();
+        }
+        function getCurrentFunction() {
+            return functions[functions.length - 1] ?? null;
+        }
+        function isPromiseVoid(node, type) {
+            if (tsutils.isThenableType(checker, node, type) &&
+                tsutils.isTypeReference(type)) {
+                const awaitedType = type.typeArguments?.[0];
+                if (awaitedType) {
+                    if ((0, util_1.isTypeFlagSet)(awaitedType, ts.TypeFlags.Void)) {
+                        return true;
+                    }
+                    return isPromiseVoid(node, awaitedType);
+                }
+            }
+            return false;
+        }
+        function isReturnVoidOrThenableVoid(node) {
+            const functionType = services.getTypeAtLocation(node);
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const callSignatures = functionType.getCallSignatures();
+            return callSignatures.some(signature => {
+                const returnType = signature.getReturnType();
+                if (node.async) {
+                    return isPromiseVoid(tsNode, returnType);
+                }
+                return (0, util_1.isTypeFlagSet)(returnType, ts.TypeFlags.Void);
+            });
+        }
+        return {
+            ...rules,
+            ArrowFunctionExpression: enterFunction,
+            'ArrowFunctionExpression:exit'(node) {
+                exitFunction();
+                rules['ArrowFunctionExpression:exit'](node);
+            },
+            FunctionDeclaration: enterFunction,
+            'FunctionDeclaration:exit'(node) {
+                exitFunction();
+                rules['FunctionDeclaration:exit'](node);
+            },
+            FunctionExpression: enterFunction,
+            'FunctionExpression:exit'(node) {
+                exitFunction();
+                rules['FunctionExpression:exit'](node);
+            },
+            ReturnStatement(node) {
+                const functionNode = getCurrentFunction();
+                if (!node.argument &&
+                    functionNode &&
+                    isReturnVoidOrThenableVoid(functionNode)) {
+                    return;
+                }
+                if (treatUndefinedAsUnspecified && node.argument) {
+                    const returnValueType = services.getTypeAtLocation(node.argument);
+                    if (returnValueType.flags === ts.TypeFlags.Undefined) {
+                        rules.ReturnStatement({
+                            ...node,
+                            argument: null,
+                        });
+                        return;
+                    }
+                }
+                rules.ReturnStatement(node);
+            },
+        };
+    },
+});

package/dist/rules/consistent-type-assertions.d.ts

@@ -0,0 +1,14 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'angle-bracket' | 'as' | 'never' | 'replaceArrayTypeAssertionWithAnnotation' | 'replaceArrayTypeAssertionWithSatisfies' | 'replaceObjectTypeAssertionWithAnnotation' | 'replaceObjectTypeAssertionWithSatisfies' | 'unexpectedArrayTypeAssertion' | 'unexpectedObjectTypeAssertion';
+type OptUnion = {
+    assertionStyle: 'angle-bracket' | 'as';
+    objectLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never';
+    arrayLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never';
+} | {
+    assertionStyle: 'never';
+};
+export type Options = readonly [OptUnion];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/consistent-type-assertions.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const getWrappedCode_1 = require("../util/getWrappedCode");
+exports.default = (0, util_1.createRule)({
+    name: 'consistent-type-assertions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent usage of type assertions',
+            recommended: 'stylistic',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.",
+            as: "Use 'as {{cast}}' instead of '<{{cast}}>'.",
+            never: 'Do not use any type assertions.',
+            replaceArrayTypeAssertionWithAnnotation: 'Use const x: {{cast}} = [ ... ] instead.',
+            replaceArrayTypeAssertionWithSatisfies: 'Use const x = [ ... ] satisfies {{cast}} instead.',
+            replaceObjectTypeAssertionWithAnnotation: 'Use const x: {{cast}} = { ... } instead.',
+            replaceObjectTypeAssertionWithSatisfies: 'Use const x = { ... } satisfies {{cast}} instead.',
+            unexpectedArrayTypeAssertion: 'Always prefer const x: T[] = [ ... ].',
+            unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.',
+        },
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            assertionStyle: {
+                                type: 'string',
+                                description: 'The expected assertion style to enforce.',
+                                enum: ['never'],
+                            },
+                        },
+                        required: ['assertionStyle'],
+                    },
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            arrayLiteralTypeAssertions: {
+                                type: 'string',
+                                description: 'Whether to always prefer type declarations for array literals used as variable initializers, rather than type assertions.',
+                                enum: ['allow', 'allow-as-parameter', 'never'],
+                            },
+                            assertionStyle: {
+                                type: 'string',
+                                description: 'The expected assertion style to enforce.',
+                                enum: ['as', 'angle-bracket'],
+                            },
+                            objectLiteralTypeAssertions: {
+                                type: 'string',
+                                description: 'Whether to always prefer type declarations for object literals used as variable initializers, rather than type assertions.',
+                                enum: ['allow', 'allow-as-parameter', 'never'],
+                            },
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            arrayLiteralTypeAssertions: 'allow',
+            assertionStyle: 'as',
+            objectLiteralTypeAssertions: 'allow',
+        },
+    ],
+    create(context, [options]) {
+        function isConst(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return false;
+            }
+            return (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.typeName.name === 'const');
+        }
+        function reportIncorrectAssertionType(node) {
+            const messageId = options.assertionStyle;
+            // If this node is `as const`, then don't report an error.
+            if (isConst(node.typeAnnotation) && messageId === 'never') {
+                return;
+            }
+            context.report({
+                node,
+                messageId,
+                data: messageId !== 'never'
+                    ? { cast: context.sourceCode.getText(node.typeAnnotation) }
+                    : {},
+                fix: messageId === 'as'
+                    ? (fixer) => {
+                        // lazily access parserServices to avoid crashing on non TS files (#9860)
+                        const tsNode = (0, util_1.getParserServices)(context, true).esTreeNodeToTSNodeMap.get(node);
+                        const expressionCode = context.sourceCode.getText(node.expression);
+                        const typeAnnotationCode = context.sourceCode.getText(node.typeAnnotation);
+                        const asPrecedence = (0, util_1.getOperatorPrecedence)(ts.SyntaxKind.AsExpression, ts.SyntaxKind.Unknown);
+                        const parentPrecedence = (0, util_1.getOperatorPrecedence)(tsNode.parent.kind, ts.isBinaryExpression(tsNode.parent)
+                            ? tsNode.parent.operatorToken.kind
+                            : ts.SyntaxKind.Unknown, ts.isNewExpression(tsNode.parent)
+                            ? tsNode.parent.arguments != null &&
+                                tsNode.parent.arguments.length > 0
+                            : undefined);
+                        const expressionPrecedence = (0, util_1.getOperatorPrecedenceForNode)(node.expression);
+                        const expressionCodeWrapped = (0, getWrappedCode_1.getWrappedCode)(expressionCode, expressionPrecedence, asPrecedence);
+                        const text = `${expressionCodeWrapped} as ${typeAnnotationCode}`;
+                        return fixer.replaceText(node, (0, util_1.isParenthesized)(node, context.sourceCode)
+                            ? text
+                            : (0, getWrappedCode_1.getWrappedCode)(text, asPrecedence, parentPrecedence));
+                    }
+                    : undefined,
+            });
+        }
+        function checkType(node) {
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+                    return false;
+                case utils_1.AST_NODE_TYPES.TSTypeReference:
+                    return (
+                    // Ignore `as const` and `<const>`
+                    !isConst(node) ||
+                        // Allow qualified names which have dots between identifiers, `Foo.Bar`
+                        node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName);
+                default:
+                    return true;
+            }
+        }
+        function getSuggestions(node, annotationMessageId, satisfiesMessageId) {
+            const suggestions = [];
+            if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                !node.parent.id.typeAnnotation) {
+                const { parent } = node;
+                suggestions.push({
+                    messageId: annotationMessageId,
+                    data: { cast: context.sourceCode.getText(node.typeAnnotation) },
+                    fix: fixer => [
+                        fixer.insertTextAfter(parent.id, `: ${context.sourceCode.getText(node.typeAnnotation)}`),
+                        fixer.replaceText(node, (0, util_1.getTextWithParentheses)(context.sourceCode, node.expression)),
+                    ],
+                });
+            }
+            suggestions.push({
+                messageId: satisfiesMessageId,
+                data: { cast: context.sourceCode.getText(node.typeAnnotation) },
+                fix: fixer => [
+                    fixer.replaceText(node, (0, util_1.getTextWithParentheses)(context.sourceCode, node.expression)),
+                    fixer.insertTextAfter(node, ` satisfies ${context.sourceCode.getText(node.typeAnnotation)}`),
+                ],
+            });
+            return suggestions;
+        }
+        function isAsParameter(node) {
+            return (node.parent.type === utils_1.AST_NODE_TYPES.NewExpression ||
+                node.parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                node.parent.type === utils_1.AST_NODE_TYPES.ThrowStatement ||
+                node.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern ||
+                node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer ||
+                (node.parent.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                    node.parent.parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression));
+        }
+        function checkExpressionForObjectAssertion(node) {
+            if (options.assertionStyle === 'never' ||
+                options.objectLiteralTypeAssertions === 'allow' ||
+                node.expression.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return;
+            }
+            if (options.objectLiteralTypeAssertions === 'allow-as-parameter' &&
+                isAsParameter(node)) {
+                return;
+            }
+            if (checkType(node.typeAnnotation)) {
+                const suggest = getSuggestions(node, 'replaceObjectTypeAssertionWithAnnotation', 'replaceObjectTypeAssertionWithSatisfies');
+                context.report({
+                    node,
+                    messageId: 'unexpectedObjectTypeAssertion',
+                    suggest,
+                });
+            }
+        }
+        function checkExpressionForArrayAssertion(node) {
+            if (options.assertionStyle === 'never' ||
+                options.arrayLiteralTypeAssertions === 'allow' ||
+                node.expression.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                return;
+            }
+            if (options.arrayLiteralTypeAssertions === 'allow-as-parameter' &&
+                isAsParameter(node)) {
+                return;
+            }
+            if (checkType(node.typeAnnotation)) {
+                const suggest = getSuggestions(node, 'replaceArrayTypeAssertionWithAnnotation', 'replaceArrayTypeAssertionWithSatisfies');
+                context.report({
+                    node,
+                    messageId: 'unexpectedArrayTypeAssertion',
+                    suggest,
+                });
+            }
+        }
+        return {
+            TSAsExpression(node) {
+                if (options.assertionStyle !== 'as') {
+                    reportIncorrectAssertionType(node);
+                    return;
+                }
+                checkExpressionForObjectAssertion(node);
+                checkExpressionForArrayAssertion(node);
+            },
+            TSTypeAssertion(node) {
+                if (options.assertionStyle !== 'angle-bracket') {
+                    reportIncorrectAssertionType(node);
+                    return;
+                }
+                checkExpressionForObjectAssertion(node);
+                checkExpressionForArrayAssertion(node);
+            },
+        };
+    },
+});

package/dist/rules/consistent-type-definitions.d.ts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/consistent-type-definitions.js

@@ -0,0 +1,100 @@
+"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: 'consistent-type-definitions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce type definitions to consistently use either `interface` or `type`',
+            recommended: 'stylistic',
+        },
+        fixable: 'code',
+        messages: {
+            interfaceOverType: 'Use an `interface` instead of a `type`.',
+            typeOverInterface: 'Use a `type` instead of an `interface`.',
+        },
+        schema: [
+            {
+                type: 'string',
+                description: 'Which type definition syntax to prefer.',
+                enum: ['interface', 'type'],
+            },
+        ],
+    },
+    defaultOptions: ['interface'],
+    create(context, [option]) {
+        /**
+         * Iterates from the highest parent to the currently traversed node
+         * to determine whether any node in tree is globally declared module declaration
+         */
+        function isCurrentlyTraversedNodeWithinModuleDeclaration(node) {
+            return context.sourceCode
+                .getAncestors(node)
+                .some(node => node.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+                node.declare &&
+                node.kind === 'global');
+        }
+        return {
+            ...(option === 'interface' && {
+                "TSTypeAliasDeclaration[typeAnnotation.type='TSTypeLiteral']"(node) {
+                    context.report({
+                        node: node.id,
+                        messageId: 'interfaceOverType',
+                        fix(fixer) {
+                            const typeToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.id, token => token.value === 'type'), util_1.NullThrowsReasons.MissingToken('type keyword', 'type alias'));
+                            const equalsToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.typeAnnotation, token => token.value === '='), util_1.NullThrowsReasons.MissingToken('=', 'type alias'));
+                            const beforeEqualsToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(equalsToken, {
+                                includeComments: true,
+                            }), util_1.NullThrowsReasons.MissingToken('before =', 'type alias'));
+                            return [
+                                // replace 'type' with 'interface'.
+                                fixer.replaceText(typeToken, 'interface'),
+                                // delete from the = to the { of the type, and put a space to be pretty.
+                                fixer.replaceTextRange([beforeEqualsToken.range[1], node.typeAnnotation.range[0]], ' '),
+                                // remove from the closing } through the end of the statement.
+                                fixer.removeRange([
+                                    node.typeAnnotation.range[1],
+                                    node.range[1],
+                                ]),
+                            ];
+                        },
+                    });
+                },
+            }),
+            ...(option === 'type' && {
+                TSInterfaceDeclaration(node) {
+                    const fix = isCurrentlyTraversedNodeWithinModuleDeclaration(node)
+                        ? null
+                        : (fixer) => {
+                            const typeNode = node.typeParameters ?? node.id;
+                            const fixes = [];
+                            const firstToken = context.sourceCode.getTokenBefore(node.id);
+                            if (firstToken) {
+                                fixes.push(fixer.replaceText(firstToken, 'type'));
+                                fixes.push(fixer.replaceTextRange([typeNode.range[1], node.body.range[0]], ' = '));
+                            }
+                            node.extends.forEach(heritage => {
+                                const typeIdentifier = context.sourceCode.getText(heritage);
+                                fixes.push(fixer.insertTextAfter(node.body, ` & ${typeIdentifier}`));
+                            });
+                            if (node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
+                                fixes.push(fixer.removeRange([node.parent.range[0], node.range[0]]), fixer.insertTextAfter(node.body, `\nexport default ${node.id.name}`));
+                            }
+                            return fixes;
+                        };
+                    context.report({
+                        node: node.id,
+                        messageId: 'typeOverInterface',
+                        /**
+                         * remove automatically fix when the interface is within a declare global
+                         * @see {@link https://github.com/typescript-eslint/typescript-eslint/issues/2707}
+                         */
+                        fix,
+                    });
+                },
+            }),
+        };
+    },
+});

package/dist/rules/consistent-type-exports.d.ts

@@ -0,0 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        fixMixedExportsWithInlineTypeSpecifier: boolean;
+    }
+];
+export type MessageIds = 'multipleExportsAreTypes' | 'singleExportIsType' | 'typeOverValue';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;