Is no-unsafe-enum-assignment in Recommended?

typescript-eslint published v8.71.0 on 28 September 2026: new typed rule @typescript-eslint/no-unsafe-enum-assignment (flags plain numbers/unsafe values assigned into enum-typed locations) plus fixes for no-misused-promises, no-unnecessary-type-assertion, unbound-method, and switch-exhaustiveness-check. npm latest confirmed 8.71.0; ShopperCove docs checklist only; pairs with live ESLint 10.12 coverage; no affiliate.

5 October 20264 min read

Summary

typescript-eslint 8.71.0: no-unsafe-enum-assignment + rule fixes (28 Sep 2026)

No: typescript-eslint 8.71.0 (28 September 2026) enables the new @typescript-eslint/no-unsafe-enum-assignment rule through plugin:@typescript-eslint/strict-type-checked, so recommended (non-strict) configs do not turn it on and you add it yourself. It requires type information, has no options, and flags plain numbers, coincidental numeric literals and arithmetic results assigned into numeric enum types.

There is no affiliate link in this article. This post has no affiliate links.

New rule: `@typescript-eslint/no-unsafe-enum-assignment`

Extending plugin:@typescript-eslint/strict-type-checked enables this rule. It requires type information (with the usual type-checked lint performance tradeoffs).

What it targets: TypeScript is deliberately lenient about assigning plain number values into numeric enums (useful for bit-flag combinations). The cost is that any number—including one that matches no enum member—can land in an enum-typed location. Numeric literals that merely coincide with a member’s value, and arithmetic that yields a plain number, have the same problem.

The rule reports those unsafe assignments so you depend on named members, not accidental numeric coincidence.

From the official examples:

Pattern	Notes
`const fruit: Fruit = someNumber`	Plain `number` into enum type — flagged
`const fruit: Fruit = 0` when `Fruit.Apple === 0`	Literal that only “works” because of the member value — flagged
`mutated++` / `mutated += 1` on an enum-typed variable	Yields plain number — flagged
`const fruit: Fruit = Fruit.Apple`	Named member — OK
Reassign with another named member	OK

Options: none (not configurable).

When not to use it (per docs): codebases that intentionally derive enum values with non-bitwise operators; validating untrusted API/user input before treating it as an enum (temporary disables or a validator like Zod may be better); third-party enums imported only as types; or teams that treat enums as a namespaced bag of values (consider const object + union instead).

Enable explicitly if you are not on strict-type-checked:

// eslint.config.mjs (flat)
rules: {
  "@typescript-eslint/no-unsafe-enum-assignment": "error",
}

Fixes in 8.71.0

From the release notes:

Rule	Fix
`no-misused-promises`	Handle a `return` outside of any function (`#12912`)
`no-unnecessary-type-assertion`	Specialize generic assertion report message (`#12832`)
`unbound-method`	Respect `this: void` on class properties
`switch-exhaustiveness-check`	Always sort literal cases in stable order (`#12885`)

Hands-on upgrade checklist

Inventory: npm ls @typescript-eslint/eslint-plugin (and matching @typescript-eslint/parser / utils). Note whether you are below 8.71.0.
Pin / bump in staging: install @typescript-eslint/eslint-plugin@8.71.0 (and keep sister packages on the same 8.71.0 line). Confirm with npm view @typescript-eslint/eslint-plugin version → expect 8.71.0 as latest as of sources read 5 Oct 2026.
Type-aware config: if you use strict-type-checked, expect no-unsafe-enum-assignment to light up on numeric-enum assignment patterns. If you only use recommended (non-strict) configs, decide whether to enable the rule deliberately.
Re-run lint CI: watch for new enum-assignment findings and for quieter/more accurate results on the four fixed rules above.
Do not invent security urgency: this minor is features + bugfixes in the official release notes; ShopperCove is not attaching CVE IDs.

ShopperCove did not change production typescript-eslint versions for this article. Prefer the GitHub release and rule docs over third-party roundups. For core ESLint (not this plugin), see the live ShopperCove note on ESLint v10.12.0.

Bottom line

typescript-eslint v8.71.0 (28 Sep 2026) adds no-unsafe-enum-assignment for type-aware configs and ships four useful rule fixes. Pin @typescript-eslint/*@8.71.0 when ready. No affiliate.

FAQ

Is no-unsafe-enum-assignment enabled in the recommended config?

No. Per the rule docs it is enabled by strict-type-checked. On recommended, add "@typescript-eslint/no-unsafe-enum-assignment": "error" to your flat config rules.

What does no-unsafe-enum-assignment flag?

Assigning a plain number, a literal that only matches a member's value (Fruit = 0), or ++ / += results to an enum-typed location. Assigning named members like Fruit.Apple is fine.

Does the rule need type information?

Yes. It is a type-aware rule, so it runs only with typed linting and has the usual type-checked performance cost.

Sources

typescript-eslint eslint typescript linting static analysis enum web development

Lab evidence

What I found running this

Sources read 5 Oct 2026 (Asia/Calcutta) via WebFetch/npm: GitHub release v8.71.0 (published 2026-09-28T17:07:50Z); npm @typescript-eslint/eslint-plugin@8.71.0 (time 2026-09-28T17:13:54.998Z; dist-tag latest=8.71.0). Rule docs Open typescript-eslint.io — requires type information; enabled via plugin:@typescript-eslint/strict-type-checked. Checklist: bump @typescript-eslint/* to 8.71.0; enable or review no-unsafe-enum-assignment if on strict-type-checked; re-run CI for fixed rules. No production lint suite upgraded on ShopperCove; no invented CVEs; no affiliate.

Explore the product

Untested by us, and no traffic result is guaranteed. Check the live offer and refund terms first.

AI Traffic Secrets for AI-era SEO

See AI Traffic Secrets details

Ready Client Sites for prebuilt websites

See Ready Client Sites details