Skip to main content

ยท 17 min read
Josh Goldberg

typescript-eslint is the tooling that enables standard JavaScript tools such as ESLint and Prettier to support TypeScript code. We've been working on a set of breaking changes and general features that we're excited to get in released! ๐ŸŽ‰

We'd previously blogged about v6 in Announcing typescript-eslint v6 Beta. This blog post contains much of the same information as that one, but updated for changes made since the beta - including a few breaking changes.

ยท 15 min read
Josh Goldberg
Newer Information Available

This blog post is now out of date, as we've released typescript-eslint v6! ๐Ÿš€ Please see Announcing typescript-eslint v6 for the latest information.

typescript-eslint is the tooling that enables standard JavaScript tools such as ESLint and Prettier to support TypeScript code. We've been working on a set of breaking changes and general features that we're excited to get in front of users soon. And now, after over two years of development, we're excited to say that typescript-eslint v6 is ready for public beta testing! ๐ŸŽ‰

Our plan for typescript-eslint v6 is to:

  1. Have users try out betas starting in early March of 2023
  2. Respond to user feedback for the next 1-3 months
  3. Release a stable version summer of 2023

Nothing mentioned in this blog post is set in stone. If you feel passionately about any of the choices we've made here -positively or negatively- then do let us know on the typescript-eslint Discord's #v6 channel!

ยท 6 min read
Josh Goldberg

import and export statements are core features of the JavaScript language. They were added as part of the ECMAScript Modules (ESM) specification, and now are generally available in most mainstream JavaScript environments, including all evergreen browsers and Node.js.

When writing TypeScript code with ESM, it can sometimes be desirable to import or export a type only in the type system. Code may wish to refer to a type, but not actually import or export a corresponding value.

For that purpose, TypeScript 3.8 added type-only imports and exports to the TypeScript language:

import type { SomeThing } from './some-module.js';
export type { SomeThing };

The key difference with export type and import type is that they do not represent runtime code. Attempting to use a value imported as only a type in runtime code will cause a TypeScript error:

import type { SomeThing } from './some-module.js';

new SomeThing();
// ~~~~~~~~~
// 'SomeThing' cannot be used as a value
// because it was imported using 'import type'.

TypeScript 4.5 also added inline type qualifiers, which allow for indicating that only some specifiers in a statement should be type-system-only:

import { type SomeType, SomeValue } from './some-module.js';

Type-only imports and exports are not emitted as runtime code when code is transpiled to JavaScript. This brings up two questions:

  • Why would you want to use these type-only imports and exports?
  • How can you enforce a project use them whenever necessary?

Let's Dig In!

ยท 4 min read
Josh Goldberg

Programmers who work with tools like ESLint and Prettier often refer to ASTs. But what is an AST, why is it useful for these kinds of tools, and how does that interact with ESLint and TypeScript tooling? Let's dig in!

What's an AST?โ€‹

Static analysis tools are those that look at code without running it. They typically parse code, or transform it from a string into a standard format they can reason about known as an Abstract Syntax Tree (AST). ASTs are called such because although they might contain information on the location of constructs within source code, they are an abstract representation that cares more about the semantic structure.

In other words, an AST is a description of your code's syntax.

An Example ASTโ€‹

Take this single line of code:

1 + 2;

ESLint's AST format, ESTree, would describe that line of code as an object like:

"type": "ExpressionStatement",
"expression": {
"type": "BinaryExpression",
"left": {
"type": "Literal",
"value": 1,
"raw": "1"
"operator": "+",
"right": {
"type": "Literal",
"value": 2,
"raw": "2"

Each piece of code described within an AST description is referred to as a node, or AST node. Each node is given a node type indicating the type of code syntax it represents That code snippet includes four nodes of the following types:

  • ExpressionStatement: 1 + 2;
  • BinaryExpression: 1 + 2
  • Literal: 1
  • Literal: 2

That ESTree object representation of the code is what static analysis tools such as ESLint and Prettier work with.

AST Formatsโ€‹

ESTree is more broadly used than just for ESLint -- it is a popular community standard. ESLint's built-in parser that outputs an ESTree-shaped AST is also a separate package, called Espree.

TypeScript has its own separate AST format, often referred to as the TypeScript AST. Because TypeScript is developed separately and with different goals from ESLint, ESTree, and Espree, its AST also represents nodes differently in many cases.

  • TS's AST is optimized for its use case of parsing incomplete code and typechecking.
  • ESTree is unoptimized and intended for "general purpose" use-cases of traversing the AST.

ESLint rules are by default only given nodes in the ESTree AST format - which has no knowledge of TypeScript-specific syntax such as interfaces. On the other hand, TypeScript's type checking APIs require nodes in the TypeScript AST format.

Enter TSESTreeโ€‹

To resolve the incompatibilities between ESTrees and the TypeScript AST typescript-eslint provides its own @typescript-eslint/parser package which:

  1. First parses TypeScript syntax into a TypeScript AST
  2. Creates an ESTree AST based on that TypeScript AST
  3. Keeps track of equivalent nodes across each AST

By creating both an ESTree AST and a TypeScript AST, the typescript-eslint parser allows ESLint rules to work with TypeScript code. That's why the Getting Started guide for typescript-eslint has you specify parser: '@typescript-eslint/parser' in your ESLint config!

We commonly refer to the ESTree format that also includes TypeScript-specific syntax as TSESTree.

AST Playgroundโ€‹

The typescript-eslint playground contains an AST explorer that generates an interactive AST for any code entered into the playground. You can activate it under Options > AST Explorer on its left sidebar by selecting the value of AST Viewer.

Further Resourcesโ€‹

You can play more with various other ASTs on, including those for other languages such as CSS and HTML.

The AST Wikipedia article has a great deal more context and history on ASTs.


Putting together all the terms introduces in this article:

  • AST (Abstract Syntax Tree): An object representation of your code's syntax.
  • Espree: ESLint's built-in parser that outputs an ESTree-shaped AST.
  • ESTree: The AST specification used by ESLint and other common JavaScript tools.
  • Node Type: What kind of code syntax an AST node refers to, such as BinaryExpression or Literal.
  • Node: A single range of code syntax in an AST.
  • Parser: A tool that reads in a string and outputs an AST.
  • TSESTree: Our extension to the ESTree AST format that also includes TypeScript-specific syntax.

TypeScript Lint Rules and ASTsโ€‹

Interested in how these ASTs work with ESLint rules? We collaborated with our friends at Sourcegraph on a Tour de Source on typescript-eslint. Read on to learn how ESLint rules use ASTs to analyze code files and, thanks to @typescript-eslint/parser, call TypeScript's type checking APIs to analyze code.

ยท 7 min read
Josh Goldberg

The typescript-eslint website at is the canonical location for documentation on how to use ESLint on TypeScript code. The site includes a documentation page for each of the over 100 ESLint rules exposed by its ESLint plugin. Each of those rule docs pages includes a description of the rule, any options it allows, links to its source code, and other important information about its usage.

Until recently, keeping descriptions of rules consistent between their source code and docs pages was a cumbersome manual chore. We'd written a suite of Jest tests to verify they matched -- but those tests didn't capture everything, often failed with cryptic messages, and were missed by less experienced contributors.

We're happy to say that now, we've overhauled rule docs pages to automatically generate metadata information from rule source code. That means the pages always display up-to-date information without developers needing to manually rewrite docs on rule changes. Hooray! ๐ŸŽ‰

This blog post gives an overview of the chore to generate rule docs options automatically.