noUnsafeTypeAssertion

TypeScript and TSX

Summary

Rule available since: v2.5.9
Diagnostic Category: lint/nursery/noUnsafeTypeAssertion
This rule doesn’t have a fix.
The default severity of this rule is error.

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "nursery": {
5
        "noUnsafeTypeAssertion": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow TypeScript type assertions other than const assertions.

Type assertions override TypeScript’s inferred type without performing any runtime checks. This can hide invalid assumptions about a value and lead to runtime errors.

Safer alternatives include:

Type annotations
The satisfies operator
Type predicates
Assertion functions
Control-flow narrowing
Validation libraries, like Zod, Valibot, or arktype

Examples

Invalid

1
interface SomeType {
2
    value: string;
3
}
4
declare const value;
5
const asserted = value as SomeType;

code-block.ts:5:24 lint/nursery/noUnsafeTypeAssertion ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Avoid unsafe type assertions.
  
    3 │ }
    4 │ declare const value;
  > 5 │ const asserted = value as SomeType;
      │                        ^^^^^^^^^^^
    6 │ 
  
  ℹ Type assertions override the type for this expression, which can hide type errors and lead to runtime errors.
  
  ℹ Use a type annotation, the satisfies operator, a type predicate, or control-flow narrowing instead.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.

1
interface SomeType {
2
    value: string;
3
}
4
declare const value;
5
const asserted = <SomeType>value;

code-block.ts:5:18 lint/nursery/noUnsafeTypeAssertion ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Avoid unsafe type assertions.
  
    3 │ }
    4 │ declare const value;
  > 5 │ const asserted = <SomeType>value;
      │                  ^^^^^^^^^^
    6 │ 
  
  ℹ Type assertions override the type for this expression, which can hide type errors and lead to runtime errors.
  
  ℹ Use a type annotation, the satisfies operator, a type predicate, or control-flow narrowing instead.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.

1
interface SomeType {
2
    value: string;
3
}
4
declare const asserted;
5
(asserted as SomeType).value = "foo";

code-block.ts:5:11 lint/nursery/noUnsafeTypeAssertion ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Avoid unsafe type assertions.
  
    3 │ }
    4 │ declare const asserted;
  > 5 │ (asserted as SomeType).value = “foo”;
      │           ^^^^^^^^^^^
    6 │ 
  
  ℹ Type assertions override the type for this expression, which can hide type errors and lead to runtime errors.
  
  ℹ Use a type annotation, the satisfies operator, a type predicate, or control-flow narrowing instead.
  
  ℹ This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.

Valid

const assertions are allowed:

1
const tuple = ["value", 1] as const;

Use a type annotation:

1
const annotated: string = "value";

Use the satisfies operator:

1
const checked = { value: "value" } satisfies { value: string };

Use a type predicate:

1
function isString(value: unknown): value is string {
2
    return typeof value === "string";
3
}

Use an assertion function:

1
function assertIsString(value: unknown): asserts value is string {
2
    if (!isString(value)) {
3
        throw new TypeError("Expected a string");
4
    }
5
}

Use control-flow narrowing:

1
function narrow(value: string | undefined) {
2
    if (value !== undefined) {
3
        return value.length;
4
    }
5
}