@depup/typescript-eslint__eslint-plugin 8.68.0-depup.0 → 8.69.0-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typescript-eslint__eslint-plugin
 
 | Field | Value |
 |-------|-------|
-| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.68.0 |
-| Processed | 2026-08-25 |
+| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.69.0 |
+| Processed | 2026-09-01 |
 | Smoke test | passed |
 | Deps updated | 1 |
 
@@ -22,7 +22,7 @@ npm install @depup/typescript-eslint__eslint-plugin
 
 | Dependency | From | To |
 |------------|------|-----|
-| ignore | ^7.0.5 | ^7.0.6 |
+| ignore | ^7.0.5 | ^7.0.8 |
 
 ---
 

package/changes.json

@@ -2,9 +2,9 @@
   "bumped": {
     "ignore": {
       "from": "^7.0.5",
-      "to": "^7.0.6"
+      "to": "^7.0.8"
     }
   },
-  "timestamp": "2026-08-25T00:16:47.315Z",
+  "timestamp": "2026-09-01T00:39:42.146Z",
   "totalUpdated": 1
 }

package/dist/index.d.ts

@@ -855,7 +855,7 @@ declare const _default: {
         }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/raw-plugin.d.ts

@@ -878,7 +878,7 @@ declare const _default: {
             }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
-            'no-meaningless-void-operator': TSESLint.RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+            'no-meaningless-void-operator': TSESLint.RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
             'no-misused-new': TSESLint.RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {

package/dist/rules/index.d.ts

@@ -180,7 +180,7 @@ declare const rules: {
     }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
     'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/rules/no-meaningless-void-operator.d.ts

@@ -4,7 +4,7 @@ export type Options = [
         checkNever: boolean;
     }
 ];
-declare const _default: TSESLint.RuleModule<"meaninglessVoidOperator" | "removeVoid", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+declare const _default: TSESLint.RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

package/dist/rules/no-meaningless-void-operator.js

@@ -49,6 +49,7 @@ exports.default = (0, util_1.createRule)({
         fixable: 'code',
         hasSuggestions: true,
         messages: {
+            meaninglessVoidOnNonCall: "void operator is useless here; it should only discard a call's return value",
             meaninglessVoidOperator: "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
             removeVoid: "Remove 'void'",
         },
@@ -59,7 +60,7 @@ exports.default = (0, util_1.createRule)({
                 properties: {
                     checkNever: {
                         type: 'boolean',
-                        description: 'Whether to suggest removing `void` when the argument has type `never`.',
+                        description: "Whether to suggest removing `void` when a call's return type is `never`.",
                     },
                 },
             },
@@ -77,6 +78,27 @@ exports.default = (0, util_1.createRule)({
                         context.sourceCode.getTokens(node)[1].range[0],
                     ]);
                 };
+                const inner = unwrapVoidArgument(node.argument);
+                if (inner.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                    // `void 0` is a common undefined idiom, not a discarded call.
+                    if (inner.type === utils_1.AST_NODE_TYPES.Literal && inner.value === 0) {
+                        return;
+                    }
+                    const tsArgument = services.esTreeNodeToTSNodeMap.get(node.argument);
+                    const argType = services.getTypeAtLocation(node.argument);
+                    // Allow `void promiseValue` so this rule does not fight no-floating-promises.
+                    if (tsutils.isThenableType(checker, tsArgument, argType)) {
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'meaninglessVoidOnNonCall',
+                        fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement
+                            ? fix
+                            : undefined,
+                    });
+                    return;
+                }
                 const argType = services.getTypeAtLocation(node.argument);
                 const unionParts = tsutils.unionConstituents(argType);
                 if (unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
@@ -100,4 +122,23 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+function unwrapVoidArgument(node) {
+    let current = node;
+    while (true) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.ChainExpression:
+            case utils_1.AST_NODE_TYPES.TSAsExpression:
+            case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                continue;
+            case utils_1.AST_NODE_TYPES.SequenceExpression:
+                current = (0, util_1.nullThrows)(current.expressions.at(-1), 'Expected SequenceExpression to have at least one expression');
+                continue;
+            default:
+                return current;
+        }
+    }
+}
 //# sourceMappingURL=no-meaningless-void-operator.js.map

package/dist/rules/no-misused-promises.d.ts

@@ -1,11 +1,15 @@
 import type { TSESLint } from '@typescript-eslint/utils';
 export type Options = [
     {
-        checksConditionals?: boolean;
+        checksConditionals?: boolean | ChecksConditionalsOptions;
         checksSpreads?: boolean;
         checksVoidReturn?: boolean | ChecksVoidReturnOptions;
     }
 ];
+export type FlagUnionsOptions = 'all' | 'none' | 'strict';
+export interface ChecksConditionalsOptions {
+    flagUnions?: FlagUnionsOptions;
+}
 export interface ChecksVoidReturnOptions {
     arguments?: boolean;
     attributes?: boolean;

package/dist/rules/no-misused-promises.js

@@ -89,8 +89,25 @@ exports.default = (0, util_1.createRule)({
                 additionalProperties: false,
                 properties: {
                     checksConditionals: {
-                        type: 'boolean',
                         description: 'Whether to warn when a Promise is provided to conditional statements.',
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                description: 'Whether to check conditionals.',
+                            },
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                description: 'Detailed settings for conditional inspection.',
+                                properties: {
+                                    flagUnions: {
+                                        type: 'string',
+                                        description: 'Configures how union types containing Promise-like types are checked.',
+                                        enum: ['all', 'strict', 'none'],
+                                    },
+                                },
+                            },
+                        ],
                     },
                     checksSpreads: {
                         type: 'boolean',
@@ -151,6 +168,7 @@ exports.default = (0, util_1.createRule)({
         const services = (0, util_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();
         const checkedNodes = new Set();
+        const flagUnionsOption = normalizeFlagUnionsOption(checksConditionals);
         const conditionalChecks = {
             'CallExpression > MemberExpression': checkArrayPredicates,
             ConditionalExpression: checkTestConditional,
@@ -284,6 +302,22 @@ exports.default = (0, util_1.createRule)({
                     node,
                     messageId: 'conditional',
                 });
+                return;
+            }
+            if (
+            // none -> Report `Promise` but not `Promise | ...`
+            (flagUnionsOption === 'none' && isAlwaysThenable(checker, tsNode)) ||
+                //
+                // all -> Report `Promise` and `Promise | ...`
+                (flagUnionsOption === 'all' && isSometimesThenable(checker, tsNode)) ||
+                //
+                // strict -> Report `Promise<T> | T` but not `Promise<T> | NotT`
+                (flagUnionsOption === 'strict' &&
+                    hasMatchingPromiseTypeArgument(checker, tsNode))) {
+                context.report({
+                    node,
+                    messageId: 'conditional',
+                });
             }
         }
         function checkArrayPredicates(node) {
@@ -801,4 +835,30 @@ function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) {
         return isVoidReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node));
     });
 }
+/**
+ * Check that the Promise argument is the same as the rest of the type when it is a Union that contains Promise.
+ */
+function hasMatchingPromiseTypeArgument(checker, node) {
+    const type = checker.getTypeAtLocation(node);
+    const unionConstituents = tsutils.unionConstituents(checker.getApparentType(type));
+    const promiseType = unionConstituents.find(type => tsutils.isThenableType(checker, node, type));
+    if (!promiseType) {
+        return false;
+    }
+    const nonPromiseUnionConstituents = unionConstituents.filter(type => type !== promiseType);
+    const awaitedType = checker.getAwaitedType(promiseType);
+    if (!awaitedType) {
+        return false;
+    }
+    const awaitedTypeConstituents = tsutils.unionConstituents(awaitedType);
+    return (nonPromiseUnionConstituents.length === awaitedTypeConstituents.length &&
+        nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => checker.isTypeAssignableTo(type, awaited) &&
+            checker.isTypeAssignableTo(awaited, type))));
+}
+function normalizeFlagUnionsOption(checksConditionals) {
+    if (!checksConditionals || checksConditionals === true) {
+        return 'none';
+    }
+    return checksConditionals.flagUnions ?? 'none';
+}
 //# sourceMappingURL=no-misused-promises.js.map

package/dist/rules/no-mixed-enums.js

@@ -62,14 +62,40 @@ exports.default = (0, util_1.createRule)({
     create(context) {
         const parserServices = (0, util_1.getParserServices)(context);
         const typeChecker = parserServices.program.getTypeChecker();
+        function getModuleName(id) {
+            if (id.type === utils_1.AST_NODE_TYPES.Literal) {
+                return JSON.stringify(id.value);
+            }
+            let qualifiers = '';
+            let current = id;
+            while (current.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                qualifiers = `.${current.right.name}${qualifiers}`;
+                current = current.left;
+            }
+            return context.sourceCode.getText(current) + qualifiers;
+        }
+        function getMergedScopes(scope) {
+            const { block } = scope;
+            if (block.type !== utils_1.AST_NODE_TYPES.TSModuleDeclaration) {
+                return [scope];
+            }
+            const name = getModuleName(block.id);
+            return getEnclosingScopes(block).flatMap(enclosing => enclosing.childScopes.filter(childScope => childScope.block.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+                getModuleName(childScope.block.id) === name));
+        }
+        function getEnclosingScopes(node) {
+            const enclosing = (0, util_1.nullThrows)(context.sourceCode.getScope(node).upper, util_1.NullThrowsReasons.MissingParent);
+            return node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration
+                ? getMergedScopes(enclosing)
+                : [enclosing];
+        }
         function collectNodeDefinitions(node) {
             const { name } = node.id;
             const found = {
                 imports: [],
                 previousSibling: undefined,
             };
-            let scope = context.sourceCode.getScope(node);
-            for (const definition of scope.upper?.set.get(name)?.defs ?? []) {
+            for (const definition of getEnclosingScopes(node).flatMap(enclosing => enclosing.set.get(name)?.defs ?? [])) {
                 if (definition.node.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration &&
                     definition.node.range[0] < node.range[0] &&
                     definition.node.body.members.length > 0) {
@@ -77,6 +103,7 @@ exports.default = (0, util_1.createRule)({
                     break;
                 }
             }
+            let scope = context.sourceCode.getScope(node);
             while (scope) {
                 scope.set.get(name)?.defs.forEach(definition => {
                     if (definition.type === scope_manager_1.DefinitionType.ImportBinding) {
@@ -138,33 +165,16 @@ exports.default = (0, util_1.createRule)({
             // Case: Multiple enum declarations in the same file
             // enum MyEnum { A }
             // enum MyEnum { B }
-            if (previousSibling) {
-                return getMemberType(previousSibling.body.members[0]);
-            }
-            // Case: Namespace declaration merging
+            //
+            // ...including ones merged across namespace declarations
             // namespace MyNamespace {
             //   export enum MyEnum { A }
             // }
             // namespace MyNamespace {
             //   export enum MyEnum { B }
             // }
-            if (node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-                node.parent.parent.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
-                // https://github.com/typescript-eslint/typescript-eslint/issues/8352
-                // TODO: We don't need to dip into the TypeScript type checker here!
-                // Merged namespaces must all exist in the same file.
-                // We could instead compare this file's nodes to find the merges.
-                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.id);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const declarations = typeChecker
-                    .getSymbolAtLocation(tsNode)
-                    .getDeclarations();
-                const [{ initializer }] = declarations[0]
-                    .members;
-                return initializer &&
-                    tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(initializer), ts.TypeFlags.StringLike)
-                    ? AllowedType.String
-                    : AllowedType.Number;
+            if (previousSibling) {
+                return getMemberType(previousSibling.body.members[0]);
             }
             // Finally, we default to the type of the first enum member
             return getMemberType(node.body.members[0]);

package/dist/rules/unified-signatures.js

@@ -334,8 +334,7 @@ exports.default = (0, util_1.createRule)({
                 (b.type === utils_1.AST_NODE_TYPES.RestElement) && optionalA === optionalB);
         }
         function typeParametersAreEqual(a, b) {
-            return (a.name.name === b.name.name &&
-                constraintsAreEqual(a.constraint, b.constraint));
+            return (a.name.name === b.name.name && typesAreEqual(a.constraint, b.constraint));
         }
         function typesAreEqual(a, b) {
             return (a === b ||
@@ -343,9 +342,6 @@ exports.default = (0, util_1.createRule)({
                     b != null &&
                     context.sourceCode.getText(a) === context.sourceCode.getText(b)));
         }
-        function constraintsAreEqual(a, b) {
-            return a === b || (a != null && a.type === b?.type);
-        }
         /* Returns the first index where `a` and `b` differ. */
         function getIndexOfFirstDifference(a, b, equal) {
             for (let i = 0; i < a.length && i < b.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/typescript-eslint__eslint-plugin",
-  "version": "8.68.0-depup.0",
+  "version": "8.69.0-depup.0",
   "description": "TypeScript plugin for ESLint (with updated dependencies)",
   "files": [
     "dist",
@@ -55,11 +55,11 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.68.0",
-    "@typescript-eslint/type-utils": "8.68.0",
-    "@typescript-eslint/utils": "8.68.0",
-    "@typescript-eslint/visitor-keys": "8.68.0",
-    "ignore": "^7.0.6",
+    "@typescript-eslint/scope-manager": "8.69.0",
+    "@typescript-eslint/type-utils": "8.69.0",
+    "@typescript-eslint/utils": "8.69.0",
+    "@typescript-eslint/visitor-keys": "8.69.0",
+    "ignore": "^7.0.8",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
   },
@@ -68,8 +68,8 @@
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.68.0",
-    "@typescript-eslint/rule-tester": "8.68.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.69.0",
+    "@typescript-eslint/rule-tester": "8.69.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -89,7 +89,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.68.0",
+    "@typescript-eslint/parser": "^8.69.0",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },
@@ -144,13 +144,13 @@
     "changes": {
       "ignore": {
         "from": "^7.0.5",
-        "to": "^7.0.6"
+        "to": "^7.0.8"
       }
     },
     "depsUpdated": 1,
     "originalPackage": "@typescript-eslint/eslint-plugin",
-    "originalVersion": "8.68.0",
-    "processedAt": "2026-08-25T00:16:59.780Z",
+    "originalVersion": "8.69.0",
+    "processedAt": "2026-09-01T00:39:55.232Z",
     "smokeTest": "passed"
   }
 }