typescript/consistent-type-imports Style

🛠️ An auto-fix is available for this rule for some violations.

What it does

Enforce consistent usage of type imports.

Why is this bad?

inconsistent usage of type imports can make the code harder to read and understand.

Examples

Examples of incorrect code for this rule:

import { Foo } from "Foo";
type T = Foo;

type S = import("Foo");

Examples of correct code for this rule:

import type { Foo } from "Foo";

Options

{
  "typescript/consistent-type-imports": [
    "error",
    {
      "prefer": "type-imports",
      "fixStyle": "separate-type-imports",
      "disallowTypeAnnotations": true
    }
  ]
}

• prefer: Control whether to enforce type imports or value imports

  • "type-imports" (default): Will enforce that you always use import type Foo from '...' except referenced by metadata of decorators
  • "no-type-imports": Will enforce that you always use import Foo from '...'

• fixStyle: Determines how type imports are added when auto-fixing

  • "separate-type-imports" (default): Will add the type keyword after the import keyword import type { A } from '...'
  • "inline-type-imports": Will inline the type keyword import { type A } from '...' (only available in TypeScript 4.5+)

• disallowTypeAnnotations: Disallow using import() in type annotations

  • true (default): Disallows using import() in type annotations like type T = import('foo')
  • false: Allows import() type annotations

Examples with "prefer": "type-imports" (default)

Examples of incorrect code:

import { Foo } from "foo";
let foo: Foo;

Examples of correct code:

import type { Foo } from "foo";
let foo: Foo;

Examples with "prefer": "no-type-imports"

Examples of incorrect code:

import type { Foo } from "foo";
let foo: Foo;

Examples of correct code:

import { Foo } from "foo";
let foo: Foo;

Examples with "fixStyle": "inline-type-imports"

When fixing type imports, this option will use inline type modifiers:

// Before fixing
import { A, B } from "foo";
type T = A;
const b = B;

// After fixing
import { type A, B } from "foo";
type T = A;
const b = B;

Examples with "disallowTypeAnnotations": false

When set to false, allows import() type annotations:

type T = import("foo").Bar;

How to use

To enable this rule in the CLI or using the config file, you can use:

CLI

oxlint --deny typescript/consistent-type-imports

Config (.oxlintrc.json)

{
  "rules": {
    "typescript/consistent-type-imports": "error"
  }
}

References

• Rule Source