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

package/dist/rules/no-duplicate-type-constituents.js

@@ -0,0 +1,219 @@
+"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 tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const astIgnoreKeys = new Set(['loc', 'parent', 'range']);
+const isSameAstNode = (actualNode, expectedNode) => {
+    if (actualNode === expectedNode) {
+        return true;
+    }
+    if (actualNode &&
+        expectedNode &&
+        typeof actualNode === 'object' &&
+        typeof expectedNode === 'object') {
+        if (Array.isArray(actualNode) && Array.isArray(expectedNode)) {
+            if (actualNode.length !== expectedNode.length) {
+                return false;
+            }
+            return !actualNode.some((nodeEle, index) => !isSameAstNode(nodeEle, expectedNode[index]));
+        }
+        const actualNodeKeys = Object.keys(actualNode).filter(key => !astIgnoreKeys.has(key));
+        const expectedNodeKeys = Object.keys(expectedNode).filter(key => !astIgnoreKeys.has(key));
+        if (actualNodeKeys.length !== expectedNodeKeys.length) {
+            return false;
+        }
+        if (actualNodeKeys.some(actualNodeKey => !Object.hasOwn(expectedNode, actualNodeKey))) {
+            return false;
+        }
+        if (actualNodeKeys.some(actualNodeKey => !isSameAstNode(actualNode[actualNodeKey], expectedNode[actualNodeKey]))) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+};
+exports.default = (0, util_1.createRule)({
+    name: 'no-duplicate-type-constituents',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow duplicate constituents of union or intersection types',
+            recommended: 'recommended',
+            requiresTypeChecking: true,
+        },
+        fixable: 'code',
+        messages: {
+            duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
+            unnecessary: 'Explicit undefined is unnecessary on an optional parameter.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ignoreIntersections: {
+                        type: 'boolean',
+                        description: 'Whether to ignore `&` intersections.',
+                    },
+                    ignoreUnions: {
+                        type: 'boolean',
+                        description: 'Whether to ignore `|` unions.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            ignoreIntersections: false,
+            ignoreUnions: false,
+        },
+    ],
+    create(context, [{ ignoreIntersections, ignoreUnions }]) {
+        const parserServices = (0, util_1.getParserServices)(context);
+        const { sourceCode } = context;
+        function report(messageId, constituentNode, data) {
+            const getUnionOrIntersectionToken = (where, at) => sourceCode[`getTokens${where}`](constituentNode, {
+                filter: token => ['&', '|'].includes(token.value) &&
+                    constituentNode.parent.range[0] <= token.range[0] &&
+                    token.range[1] <= constituentNode.parent.range[1],
+            }).at(at);
+            const beforeUnionOrIntersectionToken = getUnionOrIntersectionToken('Before', -1);
+            let afterUnionOrIntersectionToken;
+            let bracketBeforeTokens;
+            let bracketAfterTokens;
+            if (beforeUnionOrIntersectionToken) {
+                bracketBeforeTokens = sourceCode.getTokensBetween(beforeUnionOrIntersectionToken, constituentNode);
+                bracketAfterTokens = sourceCode.getTokensAfter(constituentNode, {
+                    count: bracketBeforeTokens.length,
+                });
+            }
+            else {
+                afterUnionOrIntersectionToken = (0, util_1.nullThrows)(getUnionOrIntersectionToken('After', 0), util_1.NullThrowsReasons.MissingToken('union or intersection token', 'duplicate type constituent'));
+                bracketAfterTokens = sourceCode.getTokensBetween(constituentNode, afterUnionOrIntersectionToken);
+                bracketBeforeTokens = sourceCode.getTokensBefore(constituentNode, {
+                    count: bracketAfterTokens.length,
+                });
+            }
+            context.report({
+                loc: {
+                    start: constituentNode.loc.start,
+                    end: (bracketAfterTokens.at(-1) ?? constituentNode).loc.end,
+                },
+                node: constituentNode,
+                messageId,
+                data,
+                fix: fixer => [
+                    beforeUnionOrIntersectionToken,
+                    ...bracketBeforeTokens,
+                    constituentNode,
+                    ...bracketAfterTokens,
+                    afterUnionOrIntersectionToken,
+                ].flatMap(token => (token ? fixer.remove(token) : [])),
+            });
+        }
+        function checkDuplicateRecursively(unionOrIntersection, constituentNode, uniqueConstituents, cachedTypeMap, forEachNodeType) {
+            const type = parserServices.getTypeAtLocation(constituentNode);
+            if (tsutils.isIntrinsicErrorType(type)) {
+                return;
+            }
+            const duplicatedPrevious = uniqueConstituents.find(ele => isSameAstNode(ele, constituentNode)) ??
+                cachedTypeMap.get(type);
+            if (duplicatedPrevious) {
+                report('duplicate', constituentNode, {
+                    type: unionOrIntersection,
+                    previous: sourceCode.getText(duplicatedPrevious),
+                });
+                return;
+            }
+            forEachNodeType?.(type, constituentNode);
+            cachedTypeMap.set(type, constituentNode);
+            uniqueConstituents.push(constituentNode);
+            if ((unionOrIntersection === 'Union' &&
+                constituentNode.type === utils_1.AST_NODE_TYPES.TSUnionType) ||
+                (unionOrIntersection === 'Intersection' &&
+                    constituentNode.type === utils_1.AST_NODE_TYPES.TSIntersectionType)) {
+                for (const constituent of constituentNode.types) {
+                    checkDuplicateRecursively(unionOrIntersection, constituent, uniqueConstituents, cachedTypeMap, forEachNodeType);
+                }
+            }
+        }
+        function checkDuplicate(node, forEachNodeType) {
+            const cachedTypeMap = new Map();
+            const uniqueConstituents = [];
+            const unionOrIntersection = node.type === utils_1.AST_NODE_TYPES.TSIntersectionType
+                ? 'Intersection'
+                : 'Union';
+            for (const type of node.types) {
+                checkDuplicateRecursively(unionOrIntersection, type, uniqueConstituents, cachedTypeMap, forEachNodeType);
+            }
+        }
+        return {
+            ...(!ignoreIntersections && {
+                TSIntersectionType(node) {
+                    if (node.parent.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                        return;
+                    }
+                    checkDuplicate(node);
+                },
+            }),
+            ...(!ignoreUnions && {
+                TSUnionType: (node) => {
+                    if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                        return;
+                    }
+                    checkDuplicate(node, (constituentNodeType, constituentNode) => {
+                        const maybeTypeAnnotation = node.parent;
+                        if (maybeTypeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+                            const maybeIdentifier = maybeTypeAnnotation.parent;
+                            if (maybeIdentifier.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                maybeIdentifier.optional) {
+                                const maybeFunction = maybeIdentifier.parent;
+                                if ((0, util_1.isFunctionOrFunctionType)(maybeFunction) &&
+                                    maybeFunction.params.includes(maybeIdentifier) &&
+                                    tsutils.isTypeFlagSet(constituentNodeType, ts.TypeFlags.Undefined)) {
+                                    report('unnecessary', constituentNode);
+                                }
+                            }
+                        }
+                    });
+                },
+            }),
+        };
+    },
+});

package/dist/rules/no-dynamic-delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"dynamicDelete", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-dynamic-delete.js

@@ -0,0 +1,42 @@
+"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: 'no-dynamic-delete',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow using the `delete` operator on computed key expressions',
+            recommended: 'strict',
+        },
+        messages: {
+            dynamicDelete: 'Do not delete dynamically computed property keys.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'UnaryExpression[operator=delete]'(node) {
+                if (node.argument.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                    !node.argument.computed ||
+                    isAcceptableIndexExpression(node.argument.property)) {
+                    return;
+                }
+                context.report({
+                    node: node.argument.property,
+                    messageId: 'dynamicDelete',
+                });
+            },
+        };
+    },
+});
+function isAcceptableIndexExpression(property) {
+    return ((property.type === utils_1.AST_NODE_TYPES.Literal &&
+        ['number', 'string'].includes(typeof property.value)) ||
+        (property.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+            property.operator === '-' &&
+            property.argument.type === utils_1.AST_NODE_TYPES.Literal &&
+            typeof property.argument.value === 'number'));
+}

package/dist/rules/no-empty-function.d.ts

@@ -0,0 +1,16 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected" | "suggestComment", [{
+    allow?: string[];
+}], unknown, {
+    FunctionDeclaration(node: TSESTree.FunctionDeclaration): void;
+    FunctionExpression(node: TSESTree.FunctionExpression): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected" | "suggestComment", [{
+    allow?: string[];
+}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-empty-function.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-empty-function');
+const defaultOptions = [
+    {
+        allow: [],
+    },
+];
+const schema = (0, util_1.deepMerge)(
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- https://github.com/microsoft/TypeScript/issues/17002
+Array.isArray(baseRule.meta.schema)
+    ? baseRule.meta.schema[0]
+    : baseRule.meta.schema, {
+    properties: {
+        allow: {
+            description: 'Locations and kinds of functions that are allowed to be empty.',
+            items: {
+                type: 'string',
+                enum: [
+                    'functions',
+                    'arrowFunctions',
+                    'generatorFunctions',
+                    'methods',
+                    'generatorMethods',
+                    'getters',
+                    'setters',
+                    'constructors',
+                    'private-constructors',
+                    'protected-constructors',
+                    'asyncFunctions',
+                    'asyncMethods',
+                    'decoratedFunctions',
+                    'overrideMethods',
+                ],
+            },
+        },
+    },
+});
+exports.default = (0, util_1.createRule)({
+    name: 'no-empty-function',
+    meta: {
+        type: 'suggestion',
+        defaultOptions,
+        docs: {
+            description: 'Disallow empty functions',
+            extendsBaseRule: true,
+            recommended: 'stylistic',
+        },
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: [schema],
+    },
+    defaultOptions,
+    create(context, [{ allow = [] }]) {
+        const rules = baseRule.create(context);
+        const isAllowedProtectedConstructors = allow.includes('protected-constructors');
+        const isAllowedPrivateConstructors = allow.includes('private-constructors');
+        const isAllowedDecoratedFunctions = allow.includes('decoratedFunctions');
+        const isAllowedOverrideMethods = allow.includes('overrideMethods');
+        /**
+         * Check if the method body is empty
+         * @param node the node to be validated
+         * @returns true if the body is empty
+         * @private
+         */
+        function isBodyEmpty(node) {
+            return node.body.body.length === 0;
+        }
+        /**
+         * Check if method has parameter properties
+         * @param node the node to be validated
+         * @returns true if the body has parameter properties
+         * @private
+         */
+        function hasParameterProperties(node) {
+            return node.params.some(param => param.type === utils_1.AST_NODE_TYPES.TSParameterProperty);
+        }
+        /**
+         * @param node the node to be validated
+         * @returns true if the constructor is allowed to be empty
+         * @private
+         */
+        function isAllowedEmptyConstructor(node) {
+            const parent = node.parent;
+            if (isBodyEmpty(node) &&
+                parent.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                parent.kind === 'constructor') {
+                const { accessibility } = parent;
+                return (
+                // allow protected constructors
+                (accessibility === 'protected' && isAllowedProtectedConstructors) ||
+                    // allow private constructors
+                    (accessibility === 'private' && isAllowedPrivateConstructors) ||
+                    // allow constructors which have parameter properties
+                    hasParameterProperties(node));
+            }
+            return false;
+        }
+        /**
+         * @param node the node to be validated
+         * @returns true if a function has decorators
+         * @private
+         */
+        function isAllowedEmptyDecoratedFunctions(node) {
+            if (isAllowedDecoratedFunctions && isBodyEmpty(node)) {
+                const decorators = node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition
+                    ? node.parent.decorators
+                    : undefined;
+                return !!decorators && !!decorators.length;
+            }
+            return false;
+        }
+        function isAllowedEmptyOverrideMethod(node) {
+            return (isAllowedOverrideMethods &&
+                isBodyEmpty(node) &&
+                node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                node.parent.override);
+        }
+        return {
+            ...rules,
+            FunctionExpression(node) {
+                if (isAllowedEmptyConstructor(node) ||
+                    isAllowedEmptyDecoratedFunctions(node) ||
+                    isAllowedEmptyOverrideMethod(node)) {
+                    return;
+                }
+                rules.FunctionExpression(node);
+            },
+        };
+    },
+});

package/dist/rules/no-empty-interface.d.ts

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

package/dist/rules/no-empty-interface.js

@@ -0,0 +1,102 @@
+"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");
+exports.default = (0, util_1.createRule)({
+    name: 'no-empty-interface',
+    meta: {
+        type: 'suggestion',
+        deprecated: {
+            deprecatedSince: '8.0.0',
+            replacedBy: [
+                {
+                    rule: {
+                        name: '@typescript-eslint/no-empty-object-type',
+                        url: 'https://typescript-eslint.io/rules/no-empty-object-type',
+                    },
+                },
+            ],
+            url: 'https://github.com/typescript-eslint/typescript-eslint/pull/8977',
+        },
+        docs: {
+            description: 'Disallow the declaration of empty interfaces',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            noEmpty: 'An empty interface is equivalent to `{}`.',
+            noEmptyWithSuper: 'An interface declaring no members is equivalent to its supertype.',
+        },
+        replacedBy: ['@typescript-eslint/no-empty-object-type'],
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowSingleExtends: {
+                        type: 'boolean',
+                        description: 'Whether to allow empty interfaces that extend a single other interface.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowSingleExtends: false,
+        },
+    ],
+    create(context, [{ allowSingleExtends }]) {
+        return {
+            TSInterfaceDeclaration(node) {
+                if (node.body.body.length !== 0) {
+                    // interface contains members --> Nothing to report
+                    return;
+                }
+                const extend = node.extends;
+                if (extend.length === 0) {
+                    context.report({
+                        node: node.id,
+                        messageId: 'noEmpty',
+                    });
+                }
+                else if (extend.length === 1 &&
+                    // interface extends exactly 1 interface --> Report depending on rule setting
+                    !allowSingleExtends) {
+                    const fix = (fixer) => {
+                        let typeParam = '';
+                        if (node.typeParameters) {
+                            typeParam = context.sourceCode.getText(node.typeParameters);
+                        }
+                        return fixer.replaceText(node, `type ${context.sourceCode.getText(node.id)}${typeParam} = ${context.sourceCode.getText(extend[0])}`);
+                    };
+                    const scope = context.sourceCode.getScope(node);
+                    const mergedWithClassDeclaration = scope.set
+                        .get(node.id.name)
+                        ?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+                    const isInAmbientDeclaration = (0, util_1.isDefinitionFile)(context.filename) &&
+                        scope.type === scope_manager_1.ScopeType.tsModule &&
+                        scope.block.declare;
+                    const useAutoFix = !(isInAmbientDeclaration || mergedWithClassDeclaration);
+                    context.report({
+                        node: node.id,
+                        messageId: 'noEmptyWithSuper',
+                        ...(useAutoFix
+                            ? { fix }
+                            : !mergedWithClassDeclaration
+                                ? {
+                                    suggest: [
+                                        {
+                                            messageId: 'noEmptyWithSuper',
+                                            fix,
+                                        },
+                                    ],
+                                }
+                                : null),
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-empty-object-type.d.ts

@@ -0,0 +1,15 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type AllowInterfaces = 'always' | 'never' | 'with-single-extends';
+export type AllowObjectTypes = 'always' | 'never';
+export type Options = [
+    {
+        allowInterfaces?: AllowInterfaces;
+        allowObjectTypes?: AllowObjectTypes;
+        allowWithName?: string;
+    }
+];
+export type MessageIds = 'noEmptyInterface' | 'noEmptyInterfaceWithSuper' | 'noEmptyObject' | 'replaceEmptyInterface' | 'replaceEmptyInterfaceWithSuper' | 'replaceEmptyObjectType';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;