@danilqa/eslint-plugin-ts-pattern

Warns when you compare a string-literal union type with === / !==, and points you at ts-pattern's exhaustive match instead.

Problem

type State = 'failed' | 'success' | 'pending'

interface Payment {
  state: State
}

function describe(payment: Payment) {
  // Case 1.
  // When "State" later grows a "refunded" variant, the compiler does not flag this "if". The branch silently misses
  // the new case — and so does every other `if` block scattered across the codebase.
  if (payment.state === 'failed') return 'a'

  // Case 2.
  // We implicitly convert union to "boolean" type instead of covering all cases now and in the future. Added 'refunded'?
  // It will be implicitly mached to "b" and we won't notice.
  return payment.state === 'failed' ? 'a' : 'b'
}

Solution

import { match } from 'ts-pattern'

function describe(payment: Payment) {
  return match(payment.state)
    .with('failed', () => 'a')
    .with('success', () => 'b')
    .with('pending', () => 'c')
    .exhaustive()
}

.exhaustive() makes a missing case a compile-time error. Adding 'refunded' to State immediately fails the build everywhere it isn't handled.

Install

npm i --dev @danilqa/eslint-plugin-ts-pattern

yarn add -D @danilqa/eslint-plugin-ts-pattern

pnpm add -D @danilqa/eslint-plugin-ts-pattern

Usage

import tsPattern from '@danilqa/eslint-plugin-ts-pattern'

export default [
  {
    // ...
    plugins: { 'ts-pattern': tsPattern },
    rules: {
      'ts-pattern/prefer-match-on-union': 'warn',
    },
    // ...
  },
]

Rules

type State = 'failed' | 'success' | 'pending'
let state: State

The rule fires on any === / !== comparison between a string-literal union and a literal — no matter where the expression lives (if, ternary, return, variable initializer, function argument, etc.). The one exception is while / do-while loop tests, which describe iteration rather than branching and have no match() equivalent.

| Case | Example | Fires | | --------------------------------------------------- | ------------------------------------- | :---: | | String-literal union, === with literal | if (state === 'failed') {} | ✅ | | String-literal union, !== with literal | if (state !== 'failed') {} | ✅ | | Literal on the left side | if ('failed' === state) {} | ✅ | | Ternary on a string-literal union | state === 'failed' ? 1 : 0 | ✅ | | Member access into a union property | if (payment.state === 'failed') {} | ✅ | | Optional chain on non-nullable receiver | if (payment?.state === 'failed') {} | ✅ | | Optional / nullable property (State \| undefined) | if (payment.state === 'failed') {} | ✅ | | Inside && / \|\| / ! | if (s === 'failed' \|\| other) {} | ✅ | | Variable initializer | const isFailed = s === 'failed' | ✅ | | return expression | return s === 'failed' | ✅ | | Function argument / object value / array element | log(s === 'failed') | ✅ | | Plain string operand | if (s === 'hi') {} | ❌ | | Single-member literal type ('only') | if (x === 'only') {} | ❌ | | Number- or boolean-literal union (1 \| 2) | if (n === 1) {} | ❌ | | Mixed-type union ('a' \| number) | if (m === 'a') {} | ❌ | | Loose equality (== / !=) | if (s == 'failed') {} | ❌ | | Both operands are non-literal | if (a === b) {} | ❌ | | while / do-while loop test | while (s !== 'failed') {} | ❌ | | switch statement | switch (s) { case 'failed': … } | ❌ |