@depup/typescript-eslint__eslint-plugin 8.70.1-depup.0 → 8.71.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.70.1 |
-| Processed | 2026-09-22 |
+| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.71.0 |
+| Processed | 2026-09-29 |
 | 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.9 |
+| ignore | ^7.0.5 | ^7.0.10 |
 
 ---
 

package/changes.json

@@ -2,9 +2,9 @@
   "bumped": {
     "ignore": {
       "from": "^7.0.5",
-      "to": "^7.0.9"
+      "to": "^7.0.10"
     }
   },
-  "timestamp": "2026-09-22T00:32:40.856Z",
+  "timestamp": "2026-09-29T00:34:06.060Z",
   "totalUpdated": 1
 }

package/dist/configs/eslintrc/all.d.ts

@@ -92,6 +92,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-assignment': "error";
         '@typescript-eslint/no-unsafe-call': "error";
         '@typescript-eslint/no-unsafe-declaration-merging': "error";
+        '@typescript-eslint/no-unsafe-enum-assignment': "error";
         '@typescript-eslint/no-unsafe-enum-comparison': "error";
         '@typescript-eslint/no-unsafe-function-type': "error";
         '@typescript-eslint/no-unsafe-member-access': "error";

package/dist/configs/eslintrc/all.js

@@ -99,6 +99,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-assignment': 'error',
         '@typescript-eslint/no-unsafe-call': 'error',
         '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'error',
         '@typescript-eslint/no-unsafe-enum-comparison': 'error',
         '@typescript-eslint/no-unsafe-function-type': 'error',
         '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/configs/eslintrc/disable-type-checked.d.ts

@@ -35,6 +35,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-argument': "off";
         '@typescript-eslint/no-unsafe-assignment': "off";
         '@typescript-eslint/no-unsafe-call': "off";
+        '@typescript-eslint/no-unsafe-enum-assignment': "off";
         '@typescript-eslint/no-unsafe-enum-comparison': "off";
         '@typescript-eslint/no-unsafe-member-access': "off";
         '@typescript-eslint/no-unsafe-return': "off";

package/dist/configs/eslintrc/disable-type-checked.js

@@ -38,6 +38,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',
         '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'off',
         '@typescript-eslint/no-unsafe-enum-comparison': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',

package/dist/configs/eslintrc/strict-type-checked-only.d.ts

@@ -27,6 +27,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-argument': "error";
         '@typescript-eslint/no-unsafe-assignment': "error";
         '@typescript-eslint/no-unsafe-call': "error";
+        '@typescript-eslint/no-unsafe-enum-assignment': "error";
         '@typescript-eslint/no-unsafe-enum-comparison': "error";
         '@typescript-eslint/no-unsafe-member-access': "error";
         '@typescript-eslint/no-unsafe-return': "error";

package/dist/configs/eslintrc/strict-type-checked-only.js

@@ -34,6 +34,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-argument': 'error',
         '@typescript-eslint/no-unsafe-assignment': 'error',
         '@typescript-eslint/no-unsafe-call': 'error',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'error',
         '@typescript-eslint/no-unsafe-enum-comparison': 'error',
         '@typescript-eslint/no-unsafe-member-access': 'error',
         '@typescript-eslint/no-unsafe-return': 'error',

package/dist/configs/eslintrc/strict-type-checked.d.ts

@@ -48,6 +48,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-assignment': "error";
         '@typescript-eslint/no-unsafe-call': "error";
         '@typescript-eslint/no-unsafe-declaration-merging': "error";
+        '@typescript-eslint/no-unsafe-enum-assignment': "error";
         '@typescript-eslint/no-unsafe-enum-comparison': "error";
         '@typescript-eslint/no-unsafe-function-type': "error";
         '@typescript-eslint/no-unsafe-member-access': "error";

package/dist/configs/eslintrc/strict-type-checked.js

@@ -56,6 +56,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-assignment': 'error',
         '@typescript-eslint/no-unsafe-call': 'error',
         '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'error',
         '@typescript-eslint/no-unsafe-enum-comparison': 'error',
         '@typescript-eslint/no-unsafe-function-type': 'error',
         '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/configs/flat/all.js

@@ -112,6 +112,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unsafe-assignment': 'error',
             '@typescript-eslint/no-unsafe-call': 'error',
             '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+            '@typescript-eslint/no-unsafe-enum-assignment': 'error',
             '@typescript-eslint/no-unsafe-enum-comparison': 'error',
             '@typescript-eslint/no-unsafe-function-type': 'error',
             '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/configs/flat/disable-type-checked.js

@@ -43,6 +43,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',
         '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'off',
         '@typescript-eslint/no-unsafe-enum-comparison': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',

package/dist/configs/flat/strict-type-checked-only.js

@@ -47,6 +47,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unsafe-argument': 'error',
             '@typescript-eslint/no-unsafe-assignment': 'error',
             '@typescript-eslint/no-unsafe-call': 'error',
+            '@typescript-eslint/no-unsafe-enum-assignment': 'error',
             '@typescript-eslint/no-unsafe-enum-comparison': 'error',
             '@typescript-eslint/no-unsafe-member-access': 'error',
             '@typescript-eslint/no-unsafe-return': 'error',

package/dist/configs/flat/strict-type-checked.js

@@ -69,6 +69,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unsafe-assignment': 'error',
             '@typescript-eslint/no-unsafe-call': 'error',
             '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+            '@typescript-eslint/no-unsafe-enum-assignment': 'error',
             '@typescript-eslint/no-unsafe-enum-comparison': 'error',
             '@typescript-eslint/no-unsafe-function-type': 'error',
             '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/index.d.ts

@@ -94,6 +94,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-assignment': "error";
                 '@typescript-eslint/no-unsafe-call': "error";
                 '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                '@typescript-eslint/no-unsafe-enum-assignment': "error";
                 '@typescript-eslint/no-unsafe-enum-comparison': "error";
                 '@typescript-eslint/no-unsafe-function-type': "error";
                 '@typescript-eslint/no-unsafe-member-access': "error";
@@ -199,6 +200,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-argument': "off";
                 '@typescript-eslint/no-unsafe-assignment': "off";
                 '@typescript-eslint/no-unsafe-call': "off";
+                '@typescript-eslint/no-unsafe-enum-assignment': "off";
                 '@typescript-eslint/no-unsafe-enum-comparison': "off";
                 '@typescript-eslint/no-unsafe-member-access': "off";
                 '@typescript-eslint/no-unsafe-return': "off";
@@ -498,6 +500,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-assignment': "error";
                 '@typescript-eslint/no-unsafe-call': "error";
                 '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                '@typescript-eslint/no-unsafe-enum-assignment': "error";
                 '@typescript-eslint/no-unsafe-enum-comparison': "error";
                 '@typescript-eslint/no-unsafe-function-type': "error";
                 '@typescript-eslint/no-unsafe-member-access': "error";
@@ -575,6 +578,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-argument': "error";
                 '@typescript-eslint/no-unsafe-assignment': "error";
                 '@typescript-eslint/no-unsafe-call': "error";
+                '@typescript-eslint/no-unsafe-enum-assignment': "error";
                 '@typescript-eslint/no-unsafe-enum-comparison': "error";
                 '@typescript-eslint/no-unsafe-member-access': "error";
                 '@typescript-eslint/no-unsafe-return': "error";
@@ -957,6 +961,9 @@ declare const _default: {
         'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-unsafe-enum-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeEnumAccess" | "unsafeEnumArgument" | "unsafeEnumAssertion" | "unsafeEnumAssignment" | "unsafeEnumMutation" | "unsafeEnumReturn", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/dist/raw-plugin.d.ts

@@ -116,6 +116,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-assignment': "error";
                     '@typescript-eslint/no-unsafe-call': "error";
                     '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "error";
                     '@typescript-eslint/no-unsafe-enum-comparison': "error";
                     '@typescript-eslint/no-unsafe-function-type': "error";
                     '@typescript-eslint/no-unsafe-member-access': "error";
@@ -221,6 +222,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-argument': "off";
                     '@typescript-eslint/no-unsafe-assignment': "off";
                     '@typescript-eslint/no-unsafe-call': "off";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "off";
                     '@typescript-eslint/no-unsafe-enum-comparison': "off";
                     '@typescript-eslint/no-unsafe-member-access': "off";
                     '@typescript-eslint/no-unsafe-return': "off";
@@ -521,6 +523,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-assignment': "error";
                     '@typescript-eslint/no-unsafe-call': "error";
                     '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "error";
                     '@typescript-eslint/no-unsafe-enum-comparison': "error";
                     '@typescript-eslint/no-unsafe-function-type': "error";
                     '@typescript-eslint/no-unsafe-member-access': "error";
@@ -598,6 +601,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-argument': "error";
                     '@typescript-eslint/no-unsafe-assignment': "error";
                     '@typescript-eslint/no-unsafe-call': "error";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "error";
                     '@typescript-eslint/no-unsafe-enum-comparison': "error";
                     '@typescript-eslint/no-unsafe-member-access': "error";
                     '@typescript-eslint/no-unsafe-return': "error";
@@ -980,6 +984,9 @@ declare const _default: {
             'no-unsafe-declaration-merging': TSESLint.RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
+            'no-unsafe-enum-assignment': TSESLint.RuleModule<"unsafeEnumAccess" | "unsafeEnumArgument" | "unsafeEnumAssertion" | "unsafeEnumAssignment" | "unsafeEnumMutation" | "unsafeEnumReturn", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+                name: string;
+            };
             'no-unsafe-enum-comparison': TSESLint.RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };

package/dist/rules/enum-utils/shared.d.ts

@@ -24,6 +24,10 @@ export declare function getEnumTypes(typeChecker: ts.TypeChecker, type: ts.Type)
  * compared against a non-enum value of the same primitive kind.
  */
 export declare function isMismatchedEnumComparisonTypes(typeChecker: ts.TypeChecker, leftType: ts.Type, rightType: ts.Type): boolean;
+/**
+ * @returns What type a type's enum value is (number or string), if either.
+ */
+export declare function getEnumValueType(type: ts.Type): ts.TypeFlags | undefined;
 /**
  * Returns the enum key that matches the given literal node, or null if none
  * match. For example:

package/dist/rules/enum-utils/shared.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnumLiterals = getEnumLiterals;
 exports.getEnumTypes = getEnumTypes;
 exports.isMismatchedEnumComparisonTypes = isMismatchedEnumComparisonTypes;
+exports.getEnumValueType = getEnumValueType;
 exports.getEnumKeyForLiteral = getEnumKeyForLiteral;
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));

package/dist/rules/index.d.ts

@@ -278,6 +278,9 @@ declare const rules: {
     'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'no-unsafe-enum-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeEnumAccess" | "unsafeEnumArgument" | "unsafeEnumAssertion" | "unsafeEnumAssignment" | "unsafeEnumMutation" | "unsafeEnumReturn", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };

package/dist/rules/index.js

@@ -84,6 +84,7 @@ const no_unsafe_argument_1 = __importDefault(require("./no-unsafe-argument"));
 const no_unsafe_assignment_1 = __importDefault(require("./no-unsafe-assignment"));
 const no_unsafe_call_1 = __importDefault(require("./no-unsafe-call"));
 const no_unsafe_declaration_merging_1 = __importDefault(require("./no-unsafe-declaration-merging"));
+const no_unsafe_enum_assignment_1 = __importDefault(require("./no-unsafe-enum-assignment"));
 const no_unsafe_enum_comparison_1 = __importDefault(require("./no-unsafe-enum-comparison"));
 const no_unsafe_function_type_1 = __importDefault(require("./no-unsafe-function-type"));
 const no_unsafe_member_access_1 = __importDefault(require("./no-unsafe-member-access"));
@@ -220,6 +221,7 @@ const rules = {
     'no-unsafe-assignment': no_unsafe_assignment_1.default,
     'no-unsafe-call': no_unsafe_call_1.default,
     'no-unsafe-declaration-merging': no_unsafe_declaration_merging_1.default,
+    'no-unsafe-enum-assignment': no_unsafe_enum_assignment_1.default,
     'no-unsafe-enum-comparison': no_unsafe_enum_comparison_1.default,
     'no-unsafe-function-type': no_unsafe_function_type_1.default,
     'no-unsafe-member-access': no_unsafe_member_access_1.default,

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

@@ -509,8 +509,13 @@ exports.default = (0, util_1.createRule)({
                 while (current && !(0, util_1.isFunction)(current)) {
                     current = current.parent;
                 }
-                return (0, util_1.nullThrows)(current, util_1.NullThrowsReasons.MissingParent);
+                return current;
             })();
+            // A `return` with no enclosing function is legal in a CommonJS module, and
+            // there is no function signature for the returned value to be misused against.
+            if (!functionNode) {
+                return;
+            }
             if (functionNode.returnType &&
                 !isPossiblyFunctionType(functionNode.returnType)) {
                 return;

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

@@ -308,7 +308,9 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'primitiveOverridden',
                                 data: {
                                     literal: typeValues.map(name => name.typeName).join(' | '),
-                                    primitive: primitiveTypeFlagNames[primitive],
+                                    primitive: primitiveTypeFlagNames[
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
+                                    primitive],
                                 },
                             });
                         }

package/dist/rules/no-unnecessary-condition.js

@@ -41,6 +41,7 @@ const assertionFunctionUtils_1 = require("../util/assertionFunctionUtils");
 // #region
 const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
 function isNullishType(type) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
     return tsutils.isTypeFlagSet(type, nullishFlag);
 }
 function isAlwaysNullish(type) {

package/dist/rules/no-unnecessary-type-assertion.d.ts

@@ -4,7 +4,7 @@ export type Options = [
         typesToIgnore?: string[];
     }
 ];
-export type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion';
+export type MessageIds = 'contextuallyInferredTypeArguments' | 'contextuallyUnnecessary' | 'unnecessaryAssertion';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-unnecessary-type-assertion.js

@@ -48,6 +48,7 @@ exports.default = (0, util_1.createRule)({
         },
         fixable: 'code',
         messages: {
+            contextuallyInferredTypeArguments: 'The type arguments for this generic call may be inferred from the assertion. Specify them explicitly instead.',
             contextuallyUnnecessary: 'This assertion is unnecessary since the receiver accepts the original type of the expression.',
             unnecessaryAssertion: 'This assertion is unnecessary since it does not change the type of the expression.',
         },
@@ -381,6 +382,27 @@ exports.default = (0, util_1.createRule)({
         function hasGenericCallSignature(type) {
             return type.getCallSignatures().some(hasTypeParams);
         }
+        function getInnermostCall(expression) {
+            switch (expression.type) {
+                case utils_1.AST_NODE_TYPES.AwaitExpression:
+                    return getInnermostCall(expression.argument);
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                    return expression;
+                case utils_1.AST_NODE_TYPES.ChainExpression:
+                case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+                    return getInnermostCall(expression.expression);
+                case utils_1.AST_NODE_TYPES.SequenceExpression:
+                    return getInnermostCall((0, util_1.nullThrows)(expression.expressions.at(-1), 'Expected SequenceExpression to have at least one expression'));
+                default:
+                    return undefined;
+            }
+        }
+        function isGenericCallWithInferredTypeArguments(expression) {
+            const call = getInnermostCall(expression);
+            return (call != null &&
+                call.typeArguments == null &&
+                hasGenericCallSignature(services.getTypeAtLocation(call.callee)));
+        }
         function isArgumentToOverloadedFunction(node) {
             const { parent } = node;
             if ((parent.type !== utils_1.AST_NODE_TYPES.CallExpression &&
@@ -647,11 +669,19 @@ exports.default = (0, util_1.createRule)({
                     ? isImplicitlyNarrowedLiteralDeclaration(node)
                     : !typeAnnotationIsConstAssertion;
                 if (typeIsUnchanged && wouldSameTypeBeInferred) {
-                    context.report({
-                        node,
-                        messageId: 'unnecessaryAssertion',
-                        fix: createAssertionFixer(node),
-                    });
+                    if (isGenericCallWithInferredTypeArguments(node.expression)) {
+                        context.report({
+                            node,
+                            messageId: 'contextuallyInferredTypeArguments',
+                        });
+                    }
+                    else {
+                        context.report({
+                            node,
+                            messageId: 'unnecessaryAssertion',
+                            fix: createAssertionFixer(node),
+                        });
+                    }
                     return;
                 }
                 const originalNode = services.esTreeNodeToTSNodeMap.get(node);

package/dist/rules/no-unnecessary-type-constraint.js

@@ -62,6 +62,7 @@ exports.default = (0, util_1.createRule)({
             [utils_1.AST_NODE_TYPES.TSUnknownKeyword, 'unknown'],
         ]);
         function checkRequiresGenericDeclarationDisambiguation(filename) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
             const pathExt = (0, node_path_1.extname)(filename).toLocaleLowerCase();
             switch (pathExt) {
                 case ts.Extension.Cts:

package/dist/rules/no-unsafe-enum-assignment.d.ts

@@ -0,0 +1,5 @@
+type MessageIds = 'unsafeEnumAccess' | 'unsafeEnumArgument' | 'unsafeEnumAssertion' | 'unsafeEnumAssignment' | 'unsafeEnumMutation' | 'unsafeEnumReturn';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-unsafe-enum-assignment.js

@@ -0,0 +1,473 @@
+"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 getParentFunctionNode_1 = require("../util/getParentFunctionNode");
+const shared_1 = require("./enum-utils/shared");
+const assigningOperators = new Set([
+    '=',
+    '&&=',
+    '&=',
+    '??=',
+    '^=',
+    '|=',
+    '||=',
+]);
+const bitwiseOperators = new Set(['&', '^', '|']);
+exports.default = (0, util_1.createRule)({
+    name: 'no-unsafe-enum-assignment',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow assigning non-enum values to enum typed locations',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            unsafeEnumAccess: 'The computed key used here does not have a shared enum type with the expected enum {{enumNames}}.',
+            unsafeEnumArgument: 'The argument passed here does not have a shared enum type with the expected enum {{enumNames}}.',
+            unsafeEnumAssertion: 'The value asserted here does not have a shared enum type with the expected enum {{enumNames}}.',
+            unsafeEnumAssignment: 'The value assigned here does not have a shared enum type with the expected enum {{enumNames}}.',
+            unsafeEnumMutation: 'This mutation can produce a value outside of the expected enum {{enumNames}}.',
+            unsafeEnumReturn: 'The value returned here does not have a shared enum type with the expected enum {{enumNames}}.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const checkedNodes = new WeakSet();
+        function report(node, messageId, receiverTypes) {
+            context.report({
+                node,
+                messageId,
+                data: { enumNames: describeEnumTypes(checker, receiverTypes) },
+            });
+        }
+        // Literals inside an already reported value would otherwise be reported
+        // again by their own handlers:
+        //
+        // ```ts
+        // const value: T = [Fruit.Apple, 1] as const;
+        // ```
+        function markChecked(node) {
+            checkedNodes.add(node);
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.ArrayExpression:
+                    node.elements.forEach(element => {
+                        if (element) {
+                            markChecked(element);
+                        }
+                    });
+                    break;
+                case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                    markChecked(node.consequent);
+                    markChecked(node.alternate);
+                    break;
+                case utils_1.AST_NODE_TYPES.LogicalExpression:
+                    markChecked(node.left);
+                    markChecked(node.right);
+                    break;
+                case utils_1.AST_NODE_TYPES.ObjectExpression:
+                    node.properties.forEach(markChecked);
+                    break;
+                case utils_1.AST_NODE_TYPES.Property:
+                    markChecked(node.value);
+                    break;
+                case utils_1.AST_NODE_TYPES.SpreadElement:
+                    markChecked(node.argument);
+                    break;
+                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:
+                    markChecked(node.expression);
+                    break;
+            }
+        }
+        function getContextualType(node) {
+            return checker.getContextualType(services.esTreeNodeToTSNodeMap.get(node));
+        }
+        // Bitwise combinations of an enum's own members are its bit flags:
+        //
+        // ```ts
+        // const readWrite: Flags = Flags.Read | Flags.Write;
+        // flags &= ~Flags.Write;
+        // ```
+        function isSafeEnumBitwiseExpression(node, receiverType) {
+            function isSafeOperand(operand) {
+                return (isSafeEnumBitwiseExpression(operand, receiverType) ||
+                    !isMismatchedEnumAssignmentTypes(checker, services.getTypeAtLocation(operand), receiverType));
+            }
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.BinaryExpression:
+                    return (bitwiseOperators.has(node.operator) &&
+                        isSafeOperand(node.left) &&
+                        isSafeOperand(node.right));
+                case utils_1.AST_NODE_TYPES.UnaryExpression:
+                    return node.operator === '~' && isSafeOperand(node.argument);
+                default:
+                    return false;
+            }
+        }
+        function isUnsafeAssignment(senderNode, receiverType, senderType = services.getTypeAtLocation(senderNode)) {
+            return (hasDeepEnumAssignmentMismatch(checker, senderType, receiverType) &&
+                !isSafeEnumBitwiseExpression(senderNode, receiverType));
+        }
+        function checkAssignment(receiverType, senderNode, reportingNode, messageId = 'unsafeEnumAssignment', senderType) {
+            // Object and array literals are reported per property and element by
+            // their own handlers instead:
+            //
+            // ```ts
+            // const box: { fruit: Fruit } = { fruit: 1 };
+            // ```
+            if (senderNode.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                senderNode.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                !isUnsafeAssignment(senderNode, receiverType, senderType)) {
+                return;
+            }
+            report(reportingNode, messageId, [receiverType]);
+            markChecked(senderNode);
+        }
+        function checkArguments(node, args) {
+            const signature = util_1.FunctionSignature.create(checker, services.esTreeNodeToTSNodeMap.get(node));
+            if (node.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) {
+                // The first parameter receives the template's strings, not a value.
+                signature.getNextParameterType();
+            }
+            for (const argument of args) {
+                if (argument.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    const spreadType = services.getTypeAtLocation(argument.argument);
+                    // takesFruits(...[Fruit.Apple, 1]);
+                    if (checker.isTupleType(spreadType)) {
+                        const mismatchedParameterTypes = checker
+                            .getTypeArguments(spreadType)
+                            .flatMap(elementType => {
+                            const parameterType = signature.getNextParameterType();
+                            return parameterType != null &&
+                                hasDeepEnumAssignmentMismatch(checker, elementType, parameterType)
+                                ? [parameterType]
+                                : [];
+                        });
+                        if (mismatchedParameterTypes.length > 0) {
+                            report(argument, 'unsafeEnumArgument', mismatchedParameterTypes);
+                        }
+                        if (spreadType.target.combinedFlags & ts.ElementFlags.Variable) {
+                            signature.consumeRemainingArguments();
+                        }
+                        continue;
+                    }
+                }
+                // takesFruit(1);
+                // takesFruits(...numbers);
+                const parameterType = signature.getNextParameterType();
+                if (parameterType != null) {
+                    checkAssignment(parameterType, argument, argument, 'unsafeEnumArgument');
+                }
+            }
+        }
+        function checkClassMember(node) {
+            // Class members don't get contextually typed by the members they
+            // implement or override, so those types are also checked explicitly:
+            //
+            // ```ts
+            // class Basket implements HasFruit {
+            //   fruit = 1;
+            // }
+            // ```
+            const heritageMemberTypes = getHeritageMemberTypes(node);
+            if (heritageMemberTypes.length > 0 &&
+                heritageMemberTypes.every(heritageMemberType => isUnsafeAssignment(node.value, heritageMemberType))) {
+                report(node, 'unsafeEnumAssignment', heritageMemberTypes);
+                markChecked(node.value);
+                return;
+            }
+            checkAssignment(services.getTypeAtLocation(node), node.value, node);
+        }
+        function getHeritageMemberTypes(node) {
+            const memberName = (0, util_1.getStaticMemberAccessValue)(node, context);
+            if (typeof memberName !== 'string') {
+                return [];
+            }
+            const classNode = services.esTreeNodeToTSNodeMap.get(node).parent;
+            return (classNode.heritageClauses ?? []).flatMap(heritageClause => heritageClause.types.flatMap(heritageType => {
+                const memberSymbol = checker
+                    .getTypeAtLocation(heritageType)
+                    .getProperty(memberName);
+                return memberSymbol ? [checker.getTypeOfSymbol(memberSymbol)] : [];
+            }));
+        }
+        function checkMutation(targetNode, reportingNode) {
+            const targetType = services.getTypeAtLocation(targetNode);
+            if ((0, shared_1.getEnumTypes)(checker, getConstraintType(checker, targetType)).length > 0) {
+                report(reportingNode, 'unsafeEnumMutation', [targetType]);
+            }
+        }
+        function checkReturn(returnNode, reportingNode) {
+            const functionNode = (0, getParentFunctionNode_1.getParentFunctionNode)(returnNode);
+            if (functionNode == null) {
+                // return 1;
+                return;
+            }
+            const signature = (0, util_1.nullThrows)(checker.getSignatureFromDeclaration(services.esTreeNodeToTSNodeMap.get(functionNode)), 'Expected the function to have a signature.');
+            let receiverType = signature.getReturnType();
+            let senderType = services.getTypeAtLocation(returnNode);
+            // async function getFruit(): Promise<Fruit> {
+            //   return Promise.resolve(1);
+            // }
+            if (functionNode.async) {
+                receiverType = checker.getAwaitedType(receiverType);
+                senderType = checker.getAwaitedType(senderType);
+            }
+            if (receiverType && senderType) {
+                checkAssignment(receiverType, returnNode, reportingNode, 'unsafeEnumReturn', senderType);
+            }
+        }
+        function checkTypeAssertion(node) {
+            checkAssignment(services.getTypeAtLocation(node.typeAnnotation), node.expression, node, 'unsafeEnumAssertion');
+        }
+        return {
+            'AccessorProperty[value != null], PropertyDefinition[value != null]': checkClassMember,
+            ArrayExpression(node) {
+                if (checkedNodes.has(node)) {
+                    return;
+                }
+                // const fruits: Fruit[] = [1, ...numbers];
+                for (const element of node.elements) {
+                    if (element) {
+                        const receiverType = getContextualType(element);
+                        if (receiverType) {
+                            checkAssignment(receiverType, element, element);
+                        }
+                    }
+                }
+            },
+            'ArrowFunctionExpression[body.type != "BlockStatement"]'(node) {
+                checkReturn(node.body, node.body);
+            },
+            AssignmentExpression(node) {
+                if (assigningOperators.has(node.operator)) {
+                    checkAssignment(services.getTypeAtLocation(node.left), node.right, node);
+                }
+                else {
+                    checkMutation(node.left, node);
+                }
+            },
+            AssignmentPattern(node) {
+                checkAssignment(services.getTypeAtLocation(node.left), node.right, node);
+            },
+            'CallExpression, NewExpression'(node) {
+                checkArguments(node, node.arguments);
+            },
+            'JSXAttribute > JSXExpressionContainer > :not(JSXEmptyExpression)'(node) {
+                const receiverType = getContextualType(node);
+                if (receiverType) {
+                    checkAssignment(receiverType, node, node);
+                }
+            },
+            'MemberExpression[computed = true]'(node) {
+                const receiverTypes = checker
+                    .getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(node).expression)
+                    ?.declarations?.flatMap(declaration => getMappedKeyConstraintTypes(checker, declaration)) ?? [];
+                if (receiverTypes.length === 0) {
+                    return;
+                }
+                // declare const foo: { [key in Fruit]: string };
+                // foo[0];
+                const senderType = services.getTypeAtLocation(node.property);
+                if (receiverTypes.every(receiverType => hasDeepEnumAssignmentMismatch(checker, senderType, receiverType) || !checker.isTypeAssignableTo(senderType, receiverType))) {
+                    report(node.property, 'unsafeEnumAccess', receiverTypes);
+                }
+            },
+            ObjectExpression(node) {
+                if (checkedNodes.has(node)) {
+                    return;
+                }
+                // const box: { fruit: Fruit } = { fruit: 1, ...source };
+                for (const property of node.properties) {
+                    const [receiverNode, senderNode] = property.type === utils_1.AST_NODE_TYPES.SpreadElement
+                        ? [node, property.argument]
+                        : [property.value, property.value];
+                    const receiverType = getContextualType(receiverNode);
+                    if (receiverType) {
+                        checkAssignment(receiverType, senderNode, property);
+                    }
+                }
+            },
+            ReturnStatement(node) {
+                if (node.argument) {
+                    checkReturn(node.argument, node);
+                }
+            },
+            TaggedTemplateExpression(node) {
+                checkArguments(node, node.quasi.expressions);
+            },
+            TSAsExpression: checkTypeAssertion,
+            TSTypeAssertion: checkTypeAssertion,
+            UpdateExpression(node) {
+                checkMutation(node.argument, node);
+            },
+            'VariableDeclarator[init != null]'(node) {
+                checkAssignment(services.getTypeAtLocation(node.id), node.init, node);
+            },
+        };
+    },
+});
+function getConstraintType(checker, type) {
+    return checker.getBaseConstraintOfType(type) ?? type;
+}
+function getTypeArguments(checker, type) {
+    return tsutils.isTypeReference(type) ? checker.getTypeArguments(type) : [];
+}
+function hasDeepEnumAssignmentMismatch(checker, senderType, receiverType, visited = new WeakMap()) {
+    const constrainedSenderType = getConstraintType(checker, senderType);
+    const constrainedReceiverType = getConstraintType(checker, receiverType);
+    // Recursive types would otherwise be visited endlessly.
+    let visitedReceiverTypes = visited.get(constrainedSenderType);
+    if (visitedReceiverTypes == null) {
+        visitedReceiverTypes = new WeakSet();
+        visited.set(constrainedSenderType, visitedReceiverTypes);
+    }
+    else if (visitedReceiverTypes.has(constrainedReceiverType)) {
+        return false;
+    }
+    visitedReceiverTypes.add(constrainedReceiverType);
+    if (isMismatchedEnumAssignmentTypes(checker, constrainedSenderType, constrainedReceiverType)) {
+        return true;
+    }
+    // Set<number> -> Set<Fruit>
+    const senderTypeArguments = getTypeArguments(checker, constrainedSenderType);
+    const receiverTypeArguments = getTypeArguments(checker, constrainedReceiverType);
+    if (senderTypeArguments.length === receiverTypeArguments.length &&
+        senderTypeArguments.some((senderTypeArgument, index) => hasDeepEnumAssignmentMismatch(checker, senderTypeArgument, receiverTypeArguments[index], visited))) {
+        return true;
+    }
+    // [number, Fruit] -> Fruit[]
+    const senderElementType = constrainedSenderType.getNumberIndexType();
+    const receiverElementType = constrainedReceiverType.getNumberIndexType();
+    if (senderElementType &&
+        receiverElementType &&
+        hasDeepEnumAssignmentMismatch(checker, senderElementType, receiverElementType, visited)) {
+        return true;
+    }
+    // { fruit: number } -> { fruit: Fruit }
+    return constrainedReceiverType.getProperties().some(receiverProperty => {
+        const senderProperty = constrainedSenderType.getProperty(receiverProperty.name);
+        return (senderProperty != null &&
+            hasDeepEnumAssignmentMismatch(checker, checker.getTypeOfSymbol(senderProperty), checker.getTypeOfSymbol(receiverProperty), visited));
+    });
+}
+function getMappedKeyConstraintTypes(checker, declaration) {
+    if (!(ts.isGetAccessorDeclaration(declaration) ||
+        ts.isParameter(declaration) ||
+        ts.isPropertyDeclaration(declaration) ||
+        ts.isPropertySignature(declaration) ||
+        ts.isVariableDeclaration(declaration)) ||
+        declaration.type == null) {
+        return [];
+    }
+    const typeNode = declaration.type;
+    // { [key in Fruit]: string } -> [Fruit]
+    if (ts.isMappedTypeNode(typeNode)) {
+        return [
+            checker.getTypeFromTypeNode((0, util_1.nullThrows)(typeNode.typeParameter.constraint, 'Expected the mapped type parameter to have a constraint.')),
+        ];
+    }
+    // { [Fruit.Apple]: string; [Vegetable.Asparagus]: string } -> [Fruit.Apple, Vegetable.Asparagus]
+    if (ts.isTypeLiteralNode(typeNode)) {
+        return typeNode.members.flatMap(member => {
+            const name = ts.getNameOfDeclaration(member);
+            return name && ts.isComputedPropertyName(name)
+                ? [checker.getTypeAtLocation(name.expression)]
+                : [];
+        });
+    }
+    return [];
+}
+// [Fruit, Set<Vegetable>] -> 'Fruit', 'Vegetable'
+function describeEnumTypes(checker, types) {
+    const enumNames = new Set();
+    const visited = new Set();
+    function visit(type) {
+        const constrainedType = getConstraintType(checker, type);
+        if (visited.has(constrainedType)) {
+            return;
+        }
+        visited.add(constrainedType);
+        for (const enumType of (0, shared_1.getEnumTypes)(checker, constrainedType)) {
+            enumNames.add(checker.typeToString(enumType));
+        }
+        for (const typeArgument of getTypeArguments(checker, constrainedType)) {
+            visit(typeArgument);
+        }
+        const elementType = constrainedType.getNumberIndexType();
+        if (elementType) {
+            visit(elementType);
+        }
+        for (const property of constrainedType.getProperties()) {
+            visit(checker.getTypeOfSymbol(property));
+        }
+    }
+    types.forEach(visit);
+    return [...enumNames]
+        .sort()
+        .map(enumName => `'${enumName}'`)
+        .join(', ');
+}
+function isMismatchedEnumAssignmentTypes(checker, senderType, receiverType) {
+    const receiverEnumTypes = (0, shared_1.getEnumTypes)(checker, receiverType);
+    const receiverTypeParts = tsutils.unionConstituents(receiverType);
+    const receiverEnumValueTypes = new Set(receiverTypeParts.map(shared_1.getEnumValueType));
+    const receiverNonEnumParts = receiverTypeParts.filter(receiverTypePart => (0, shared_1.getEnumTypes)(checker, receiverTypePart).length === 0);
+    return tsutils.unionConstituents(senderType).some(senderTypePart => 
+    // const fruit: Fruit = 1;
+    ((receiverEnumValueTypes.has(ts.TypeFlags.Number) &&
+        (0, util_1.isNumberLike)(senderTypePart)) ||
+        (receiverEnumValueTypes.has(ts.TypeFlags.String) &&
+            (0, util_1.isStringLike)(senderTypePart))) &&
+        // const fruit: Fruit = Fruit.Apple;
+        !hasSharedEnumType(checker, senderTypePart, receiverEnumTypes) &&
+        // const fruitOrNumber: Fruit | number = 1;
+        !receiverNonEnumParts.some(receiverTypePart => checker.isTypeAssignableTo(senderTypePart, receiverTypePart)));
+}
+function hasSharedEnumType(checker, type, expectedEnumTypes) {
+    const typeEnumTypes = new Set((0, shared_1.getEnumTypes)(checker, type));
+    return expectedEnumTypes.some(expectedEnumType => typeEnumTypes.has(expectedEnumType));
+}
+//# sourceMappingURL=no-unsafe-enum-assignment.js.map

package/dist/rules/prefer-nullish-coalescing.js

@@ -195,10 +195,9 @@ exports.default = (0, util_1.createRule)({
             if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
                 return false;
             }
-            if (tsutils
-                .typeConstituents(type)
-                .some(t => tsutils
+            if (tsutils.typeConstituents(type).some(t => tsutils
                 .intersectionConstituents(t)
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
                 .some(t => tsutils.isTypeFlagSet(t, ignorableFlags)))) {
                 return false;
             }

package/dist/rules/prefer-optional-chain-utils/analyzeChain.js

@@ -45,6 +45,7 @@ function includesType(parserServices, node, typeFlagIn) {
     const typeFlag = typeFlagIn | ts.TypeFlags.Any | ts.TypeFlags.Unknown;
     const types = (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node));
     for (const type of types) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
         if ((0, util_1.isTypeFlagSet)(type, typeFlag)) {
             return true;
         }
@@ -57,11 +58,15 @@ function isValidAndLastChainOperand(ComparisonValueType, comparisonType, parserS
     const types = (0, ts_api_utils_1.unionConstituents)(type);
     switch (comparisonType) {
         case gatherLogicalOperands_1.ComparisonType.Equal: {
-            const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
+            ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
             return !isNullish;
         }
         case gatherLogicalOperands_1.ComparisonType.StrictEqual: {
-            const isUndefined = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
+            const isUndefined = types.some(t => 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
+            (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
             return !isUndefined;
         }
         case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: {
@@ -78,11 +83,15 @@ function isValidOrLastChainOperand(ComparisonValueType, comparisonType, parserSe
     const types = (0, ts_api_utils_1.unionConstituents)(type);
     switch (comparisonType) {
         case gatherLogicalOperands_1.ComparisonType.NotEqual: {
-            const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
+            ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
             return !isNullish;
         }
         case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: {
-            const isUndefined = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
+            const isUndefined = types.some(t => 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
+            (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
             return !isUndefined;
         }
         case gatherLogicalOperands_1.ComparisonType.Equal:

package/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js

@@ -124,6 +124,7 @@ function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserService
     if (options.checkBigInt === true) {
         allowedFlags |= ts.TypeFlags.BigIntLike;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
     return primitiveAndObjectParts.every(t => (0, util_1.isTypeFlagSet)(t, allowedFlags));
 }
 function gatherLogicalOperands(node, parserServices, sourceCode, options) {

package/dist/rules/strict-void-return.js

@@ -303,6 +303,7 @@ exports.default = util.createRule({
                 .getCallSignaturesOfType(actualType)
                 .map(signature => signature.getReturnType())
                 .flatMap(returnType => tsutils.unionConstituents(returnType))
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
                 .every(type => tsutils.isTypeFlagSet(type, allowedReturnType))) {
                 // The function is already void.
                 return;
@@ -396,6 +397,7 @@ exports.default = util.createRule({
                     continue;
                 }
                 const returnType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(statement.argument));
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
                 if (tsutils.isTypeFlagSet(returnType, allowedReturnType)) {
                     // Only visit return statements with invalid type.
                     continue;

package/dist/rules/switch-exhaustiveness-check.js

@@ -140,7 +140,7 @@ exports.default = (0, util_1.createRule)({
             return {
                 containsNonLiteralType,
                 defaultCase: defaultCase ?? getCommentDefaultCase(node),
-                missingLiteralBranchTypes,
+                missingLiteralBranchTypes: missingLiteralBranchTypes.sort((a, b) => typeToString(a).localeCompare(typeToString(b))),
                 symbolName,
             };
         }

package/dist/rules/unbound-method.js

@@ -310,19 +310,13 @@ function checkIfMethod(symbol, ignoreStatic) {
         return { dangerous: false };
     }
     switch (valueDeclaration.kind) {
-        case ts.SyntaxKind.PropertyDeclaration:
-            return {
-                dangerous: valueDeclaration.initializer?.kind ===
-                    ts.SyntaxKind.FunctionExpression,
-            };
-        case ts.SyntaxKind.PropertyAssignment: {
-            const assignee = valueDeclaration.initializer;
-            if (assignee.kind !== ts.SyntaxKind.FunctionExpression) {
-                return {
-                    dangerous: false,
-                };
+        case ts.SyntaxKind.PropertyAssignment:
+        case ts.SyntaxKind.PropertyDeclaration: {
+            const { initializer } = valueDeclaration;
+            if (!initializer || !ts.isFunctionExpression(initializer)) {
+                return { dangerous: false };
             }
-            return checkMethod(assignee, ignoreStatic);
+            return checkMethod(initializer, ignoreStatic);
         }
         case ts.SyntaxKind.MethodDeclaration:
         case ts.SyntaxKind.MethodSignature: {

package/dist/util/getOperatorPrecedence.js

@@ -417,6 +417,7 @@ function getBinaryOperatorPrecedence(kind) {
     }
     // -1 is lower than all other precedences.  Returning it will cause binary expression
     // parsing to stop.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
     return -1;
 }
 //# sourceMappingURL=getOperatorPrecedence.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/typescript-eslint__eslint-plugin",
-  "version": "8.70.1-depup.0",
+  "version": "8.71.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.70.1",
-    "@typescript-eslint/type-utils": "8.70.1",
-    "@typescript-eslint/utils": "8.70.1",
-    "@typescript-eslint/visitor-keys": "8.70.1",
-    "ignore": "^7.0.9",
+    "@typescript-eslint/scope-manager": "8.71.0",
+    "@typescript-eslint/type-utils": "8.71.0",
+    "@typescript-eslint/utils": "8.71.0",
+    "@typescript-eslint/visitor-keys": "8.71.0",
+    "ignore": "^7.0.10",
     "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.70.1",
-    "@typescript-eslint/rule-tester": "8.70.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.71.0",
+    "@typescript-eslint/rule-tester": "8.71.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.70.1",
+    "@typescript-eslint/parser": "^8.71.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.9"
+        "to": "^7.0.10"
       }
     },
     "depsUpdated": 1,
     "originalPackage": "@typescript-eslint/eslint-plugin",
-    "originalVersion": "8.70.1",
-    "processedAt": "2026-09-22T00:32:50.942Z",
+    "originalVersion": "8.71.0",
+    "processedAt": "2026-09-29T00:34:20.528Z",
     "smokeTest": "passed"
   }
 }