---
title: Avoid stateful components in design systems
description:
  Design systems should very rarely leverage internal state when building
  re-usable UI components
date: '2025-11-05'
image: 'dmytro-yarish-KgtOr1cCECw-unsplash.webp'
---

Design system components should be thought of as akin to Lego bricks &mdash;
composable pieces of a user interface that empower engineers working on
applications to build consistent and branded user experiences. At times, design
systems drift towards larger, stateful components to help with code sharing and
re-usability. In theory, this makes sense! In practice, however, design system
teams rarely have the business context required to successfully engineer
components that can handle a wide enough variety of use cases.

How can a design systems team identify when a component is veering into this
territory, and becoming less like a Lego brick and more like a glued-together
Lego kit? It all starts with **internal component state**.

## Stateless components

Design system components tend to expose customization options via component
props and event handlers. Consider a simple button component:

```tsx
function Button({
  variant,
  children,
  onClick,
}: {
  variant: 'primary' | 'secondary' | 'destructive'
  children: React.ReactNode
  onClick: (e: React.MouseEvent<HTMLButtonElement>) => void
}) {
  return <button onClick={onClick}>{children}</button>
}
```

The button accepts three props (`variant`, `children`, and `onClick`). The
button has _no opinions about what happens when it is clicked_ but allows
application engineers to handle those decisions in their application code.

## Stateful components

The `Button` we defined as part of our design system, **maintains no internal
state** and is updated entirely from the outside.

Next, our team wants to tackle a `SortButton` component that can be used in
sorting scenarios for other UI elements like data tables. According to the
provided UX specs, when clicked, the sorting state for the button should toggle
between `"none"`, `"ascending"` and `"descending"`.

```tsx
import { type ComponentProps, useState } from 'react'
import { Button } from '@com/ui'

function SortButton({ children, onClick, ...props }: ComponentProps<typeof Button>) {
  // `useState` here allows for reactive updates from inside the component as opposed to externally
  const [sort, setSort] = useState<'ascending' | 'descending' | 'none'>('none')

  /** Click handler to manage sorting state */
  const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => {
    const getNextSort = () => {
      if (sort === "none") return "ascending"

      if (sort === "ascending") return "descending"

      if (sort === "descending") return "none"

      return "none"
    }

    setSort(getNextSort())

    /** Any passed-in onClick handler fires last */
    onClick(e)
  }

  return (
    <Button {...props} onClick={handleClick}>
      {children}

      {sort === "none" ? ↕️ : null}

      {sort === "ascending" ? ⬆️ : null}

      {sort === "descending" ? ⬇️ : null}
    </Button>
  )
}
```

Now our `SortButton` updates the UI based on the next possible sort state.

## ...Three weeks later

Our design system is a raging success, and application engineers are using our
stateless `Button` and stateful `SortButton` components. The `SortButton` works
great for sorting tables and other organized data UI. What could possibly go
wrong?

### URL state

For many sortable/filterable user interfaces, the ability to determine state
from the URL is a common pattern using
[query string parameters](https://developer.mozilla.org/en-US/docs/Web/API/URL/search).
Our application wants to update a `SortButton` instance according to a query
string in their application URL with three different possible states:

```txt
https://app.mycom.com
https://app.mycom.com?sort=ascending
https://app.mycom.com?sort=descending
```

Unfortunately, our current `SortButton` is completely unable to handle this
feature request! The design system team never considered that something _other
than a user click_ could cause the state of the button to update. Because the
state of our component is controlled by an internal `useState` hook, our options
for updating this component (particularly in a non-breaking fashion) are limited
or at the very least, highly complex.

### Making the best of a bad situation

We can "fix" this problem by allowing external state to initialize the
`SortButton` component state:

```tsx
import { type ComponentProps, useState } from 'react'
import { Button } from '@com/ui'

type SortDir = 'ascending' | 'descending' | 'none'

function SortButton({ children, onClick, sort = 'none', ...props }: ComponentProps<typeof Button> & { sort: SortDir }) {
  // `useState` here allows for reactive updates from inside the component as opposed to externally
  const [sortState, setSortState] = useState<SortDir>(sort)

  /** Click handler to manage sorting state */
  const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => {
    /** Determine the next sort state according to the previous sort state */
    const getNextSort = () => {
      if (sortState === "none") return "ascending"

      if (sortState === "ascending") return "descending"

      if (sortState === "descending") return "none"

      return "none"
    }

    // Internal state handling
    setSortState(getNextSort())

    // Any passed-in onClick handler fires last
    onClick(e)
  }

  return (
    <Button {...props} onClick={handleClick}>
      {children}

      {sortState === "none" ? ↕️ : null}

      {sortState === "ascending" ? ⬆️ : null}

      {sortState === "descending" ? ⬇️ : null}
    </Button>
  )
}
```

Now, the component can at least initially be updated externally with the URL
state like so:

```tsx
const url = new URL(window.location.href) // "https://app.mycom.com?sort=ascending"
const sort = url.searchParams.get('sort') // "ascending"

function MyApp() {
  return <SortButton sort={sort}>Sort items</SortButton>
}
```

Note that this "fix" **only works when the sort value is set before the
component first renders**. If the URL changes after the component is already
mounted (for example, when navigating with client-side routing or when users
manually edit the URL), the component's internal state won't update to reflect
the latest URL.

## Stateless from the beginning

The `SortButton` component could have been implemented successfully, taking in
the URL search updating _as well as any other source of state in the future_ by
building **stateless** components instead of **stateful** components. In fact,
by limiting design system components to only expose props and event handlers,
application engineers can handle state management while the complexity of design
system source code drops tremendously.

```tsx
import { type ComponentProps } from 'react'
import { Button } from '@com/ui'

type SortDir = 'ascending' | 'descending' | 'none'

function SortButton({ children, sort = 'none', ...props }: ComponentProps<typeof Button> & { sort: SortDir }) {
  return (
    <Button {...props}>
      {children}

      {sort === "none" ? ↕️ : null}

      {sort === "ascending" ? ⬆️ : null}

      {sort === "descending" ? ⬇️ : null}
    </Button>
  )
}
```

The component definition itself is nearly half as long, and can account for any
future external state that an application engineer might use to handle sorting.

Then, an application engineer can control the state of the button, keeping it in
sync with any required business logic or source of UI state. In this example,
the `MyDataTable` reads from and updates the application URL in response to user
clicks of the `SortButton`:

```tsx
function MyDataTable() {
  const [searchParams, setSearchParams] = useSearchParams()
  const sort = (searchParams.get('sort') as SortDir) || 'none'

  const handleSortClick = () => {
    /** Determine the next sort state according to the previous sort state */
    const getNextSort = () => {
      if (sort === 'none') return 'ascending'

      if (sort === 'ascending') return 'descending'

      if (sort === 'descending') return 'none'

      return 'none'
    }

    setSearchParams({ sort: getNextSort() })
  }

  return (
    <SortButton sort={sort} onClick={handleSortClick}>
      Sort items
    </SortButton>
  )
}
```

## Conclusion

Design system components are Lego bricks from which to build larger user
interfaces &mdash; they should not ship glued together Lego kits with their own
internal state! In general, **avoid building a design system component that
manages its own internal state**. Keep components simple and stateless, by only
providing props and event handlers.


Design systems should very rarely leverage internal state when building re-usable UI components

Avoid stateful components in design systems

---
title: Type safe, auto-generating test data for API mocking
description:
  How to efficiently generate valid, type safe, realistic data for use in
  automated testing
image: benjamin-voros-phIFdC6lA4E-unsplash.webp
date: '2025-04-05'
---

> This article is part 2 in a series. Part 1
> ([No more trust me bro data fetching](/post/no-more-trust-me-bro-data-fetching))
> covers how to use Zod (or similar validation libraries) to tightly couple both
> runtime and build time data validation. Part 2 continues with using these data
> schemas to help mock APIs when authoring automated tests.

## Avoid flake, mock the backend

When automating application testing, managing the state of the backend in a
manner that is consistent and avoids flakiness is exceptionally difficult. To
address this problem, decoupled frontend user interfaces are often tested with a
mocked backend, intercepting HTTP requests in the browser and replacing their
responses with mock data.

- See [fixtures using Cypress.io](https://docs.cypress.io/api/commands/fixture)
- See [API mocking using Playwright](https://playwright.dev/docs/mock)

For the sake of simplicity, the rest of the examples in this post will use
[Playwright](https://playwright.dev/). This is the end result we will be
building towards &mdash; a rendered UI that fetches data from a mocked API
response:

```ts
import { test, expect, chromium } from '@playwright/test'
import { generateMock } from '@anatine/zod-mock'
import { z } from 'zod'
import { AccountSchema } from '../src/api'

const mockAccountList = generateMock(z.array(AccountSchema), { seed: 123 })

test('it shows accounts', async () => {
  const browser = await chromium.launch({ headless: false, slowMo: 200 })
  const context = await browser.newContext()
  const page = await context.newPage()

  // Mock the accounts API
  await page.route(
    'https://api.nicklemmon.com/accounts/list',
    async (route) => await route.fulfill({ json: mockAccountList })
  )

  // Visit the accounts page
  await page.goto('http://localhost:5173')

  // Validate the rendered result
  await expect(page.getByRole('heading', { name: 'Accounts' })).toBeVisible()
  await expect(page.getByText('Jane Turcotte / 471649368545782')).toBeVisible()
})
```

## Validating the backend

First, let's author some Zod schemas to validate the JSON response that will be
received from the backend. This example is directly from the prior article in
the series,
[“No more &lsquo;Trust me, bro&rsquo; data fetching in TypeScript applications”](/post/no-more-trust-me-bro-data-fetching).

Let's say that our `/accounts/list` endpoint returns a list of accounts. We can
validate that data at runtime using a library like `zod` to double check its
shape, and handle errors if an unexpected response is returned:

```ts
import { z } from 'zod'

// 👇 this is our schema defined with Zod (available at runtime)
const AccountSchema = z.object({
  id: z.string(),
  name: z.string(),
  holdings: z.number(),
})

// 👇 this is our type definition inferred from the Zod schema (available at build time)
type Account = z.infer<typeof AccountSchema>

export async function listAccounts() {
  const res = await fetch('https://api.nicklemmon.com/accounts/list')

  try {
    if (!res.ok) throw Error('Account fetching failed!')

    const json = z.array(AccountSchema).parse(await res.json())

    return json
  } catch (err) {
    throw Error(String(err))
  }
}
```

With our Zod schema defined, we can avoid a large category of type errors at
runtime, or at the very least, be well equipped to monitor our application for
data consistency errors.

## Building a UI

In this example, we will use our `listAccounts` function to fetch data in a
frontend single page application. Let's take a look at how this would work in a
React application (and use some of their newer features while we're at it). In
this example,
[@tanstack/react-query](https://tanstack.com/query/latest/docs/framework/react/quick-start).

```tsx
import {
  useQuery,
  useQueryClient,
  QueryClient,
  QueryClientProvider,
} from '@tanstack/react-query'
// 👇 Here, we import our `listAccounts` function with baked-in zod validation
import { listAccounts, type Account } from './api'

const queryClient = new QueryClient()

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      {/* Normally a router would be used here, but for the sake of simplicity we are using a component */}
      <AccountsPage />
    </QueryClientProvider>
  )
}

function AccountsPage() {
  // 👇 Our query fetches (and caches) the data as soon as the component mounts
  // Note that generics are used here to help with type inference. Since the `Account`
  // type definition is directly derived from our Zod schema, this is considered safe
  const { data, isLoading } = useQuery<Array<Account>>({
    queryKey: ['accounts'],
    queryFn: listAccounts,
  })

  return (
    <div>
      <h1>My accounts</h1>

      {isLoading ? (
        <div>Loading...</div>
      ) : (
        <ul>
          {data?.map((account) => {
            return (
              <li key={account.id}>
                {account.name} / {account.holdings}
              </li>
            )
          })}
        </ul>
      )}
    </div>
  )
}
```

## Mocking the backend

Our UI is built, our data is fetching, now we want to mock the data. Since we
have already used zod to validate our API response, we can _automatically create
mock test data using our zod schema_!

First, let's install
[@anatine/zod-mock](https://www.npmjs.com/package/@anatine/zod-mock) to create
fake test data generated directly from our Zod schemas:

```bash
npm i @anatine/zod-mock -D -E
```

We can then derive mock data from our schema in our test case without having to
manually author mocks. This allows mocks and source code to always stay in sync
&mdash; when our schemas change, our mocks update seamlessly.

```ts
import { test, expect, chromium } from '@playwright/test'
import { generateMock } from '@anatine/zod-mock'
import { z } from 'zod'
import { AccountSchema } from '../src/api'

// Generate mock account list from our zod schema
// Note we are using a seed here to force the account list to remain consistent for every test run and make sure it is deterministic,
// otherwise the test case will fail as the mock data will change each time the test runs
const mockAccountList = generateMock(z.array(AccountSchema), { seed: 123 })

test('it shows accounts', async () => {
  const browser = await chromium.launch({ headless: false, slowMo: 200 })
  const context = await browser.newContext()
  const page = await context.newPage()

  // Mock the accounts API
  await page.route(
    'https://api.nicklemmon.com/accounts/list',
    async (route) => await route.fulfill({ json: mockAccountList })
  )

  // Visit the accounts page
  await page.goto('http://localhost:5173')

  // Validate the rendered result
  await expect(page.getByRole('heading', { name: 'Accounts' })).toBeVisible()
  await expect(page.getByText('Jane Turcotte / 471649368545782')).toBeVisible()
})
```

## Putting it all together

Take a look at the
[GitHub repo showing this example](https://github.com/nicklemmon/blog-type-safe-data-mocking),
install the dependencies, and run the tests. The test cases launch and mock the
accounts API, showing generated data in its place.

```bash
git clone https://github.com/nicklemmon/blog-type-safe-data-mocking.git
cd blog-type-safe-data-mocking
npm run dev &
npx wait-on http://localhost:5173
npm run test
```


How to efficiently generate valid, type safe, realistic data for use in automated testing

Type safe, auto-generating test data for API mocking

---
title: No more “Trust me, bro” data fetching in TypeScript applications
description: Validate fetched data at runtime and build time
image: marek-piwnicki-HxPkohFqDGY-unsplash.webp
date: '2025-03-03'
---

TypeScript can help prevent a whole category of software defects, ensuring data
flows smoothly and predictably throughout an application &mdash; I have no idea
how I built applications without it in the past. When used insufficiently,
however, TypeScript does not offer this protection &mdash; rather, application
teams need to invest in adequate type safety, particularly when fetching data
&mdash; all while avoiding the temptation to tell the TypeScript compiler,
"trust me, bro."

> This is the first article in a series about predictable, type-safe data
> fetching in TypeScript applications. In part one, I will be covering common
> type checking failures when fetching data. In part two, I'll explore automated
> integration testing strategies that work well with type-safe data fetching.

## “Trust me, bro” data fetching

When fetching data, the JSON response is never typed by default, as the inferred
type of a typical fetching function is `Promise<any>`:

```ts
async function listAccounts() {
  const res = await fetch('https://api.nicklemmon.com/accounts/list')

  if (!res.ok) throw Error('Account fetching failed!')

  return await res.json() // 👈 The inferred return type is `Promise<any>`
}
```

In typical applications, this problem is addressed via a type assertion using
`as`. When using `as` in this scenario, this is a "trust me, bro" moment. The
developer is telling the TypeScript compiler to not worry about the shape of the
response &mdash; "Trust me, bro," the shape is _always exactly what I say it
is_. No need to check yourself, TypeScript!

```ts
type Account = {
  id: string
  name: string
  holdings: number
}

async function listAccounts() {
  const res = await fetch('https://api.nicklemmon.com/accounts/list')

  if (!res.ok) throw Error('Account fetching failed!')

  // Here is the type assertion 👇
  // "Trust me, bro! The response is definitely an array of accounts."
  return (await res.json()) as Array<Account>
}
```

At this point, the data you receive could come in _any_ shape, and by using
`as`, we have simply turned off any adequate protection that TypeScript might
provide when it comes to the shape of the data flowing throughout our
application.

Even fully fledged, popular frontend frameworks (like Angular), who expose a
service for data fetching (see the
[HttpClient documentation for more](https://angular.dev/guide/http/making-requests#fetching-json-data)),
still handle data typing via the "trust me, bro" strategy out of the box. In
this case, a generic is used instead of a type assertion, but the end result is
the same.

```ts
// This isn't using `as`, but a generic - the end result is the same - the shape of the data is not validated at runtime but is assumed!
// "Trust me, bro! The account list is *always* in the right shape!"
http.get<Array<Account>>('https://api.nicklemmon.com/accounts/list')
```

Unfortunately, this leaves a lot to be desired. If the shape of the API response
ever changes unexpectedly _or_ if the type definition of `Account` is
inaccurate, any application logic that assumes the return type of
`listAccounts()` is `Array<Account>` can _never_ be completely trusted. Even
though TypeScript is used in the data fetching function, runtime errors can and
will occur unpredictably over time.

## Actually type safe (and predictable) data fetching

Instead of blindly assuming that your data is shaped in a certain way, it is
best to first validate that data at runtime, typically using a schema validation
library like [zod](https://zod.dev/) or [valibot](https://valibot.dev/).

Let's re-write our `listAccounts` function to validate the shape of the response
using `zod`:

```ts
import { z } from 'zod'

// This feels similar to TypeScript, but available at runtime
const AccountSchema = z.object({
  id: z.string(),
  name: z.string(),
  holdings: z.number(),
})

async function listAccounts() {
  const res = await fetch('https://api.nicklemmon.com/accounts/list')

  try {
    if (!res.ok) throw Error('Account fetching failed!')

    // We `.parse` the awaited JSON response to ensure its in the right shape,
    // and catch any errors that might result. With a monitoring service in place,
    // we could flag type runtime errors more cleanly for fixing by API teams.
    const json = AccountSchema.parse(await res.json())

    return json // The inferred return type will match the shape of the `AccountSchema`
  } catch (err) {
    throw Error(String(err))
  }
}
```

The `AccountSchema` looks awfully similar to TypeScript, but with a few extra
lines we can have both a schema definition which can handle validation at
runtime _and_ a type definition at build time which are inherently linked:

```ts
import { z } from 'zod'

// Runtime schema
const AccountSchema = z.object({
  id: z.string(),
  name: z.string(),
  holdings: z.number(),
})

// Build time type definition
type Account = z.infer<typeof AccountSchema>
```

Now we can have type safe data fetching with type definitions _and_ runtime type
validation &mdash; all of which are tightly coupled to produce predictable
results.

## Schema and type usage in the UI layer

Now that we have a defined type, our UI can fetch data, and then render the
result predictably, all while passing the data down the component tree safely.
The following example uses [TanStack Router](https://tanstack.com/router/latest)
and React to help orchestrate fetching and rendering.

First, we define our route. We can import our `listAccounts` function and use it
in the route definition:

```tsx
import { createFileRoute } from '@tanstack/react-router'
import { listAccounts } from '../api'

export const Route = createFileRoute('/accounts/$list')({
  component: RouteComponent,
  loader: async () => {
    // Remember, this function validates the shape of the data
    // or throws an error if the data is in an unexpected shape
    return await listAccounts()
  },
})

function RouteComponent() {
  // The account list is made available through the baked-in `useLoaderData` hook
  const accountList = Route.useLoaderData()

  return <h1>List of accounts</h1>
}
```

Additionally, we can define an `<AccountListTable />` component, which expects
an `accountList` as a prop:

```tsx
import type { Account } from '../api'

function AccountListTable({ accountList }: { accountList: Array<Account> }) {
  return (
    <table>{/* Logic for rendering the account list table goes here */}</table>
  )
}
```

We can then render the `<AccountListTable />` in our accounts list route,
achieving end-to-end type safety, without relying on "trust me, bro" TypeScript
techniques. The shape of our API response may change unexpectedly, but error
handling will more catch errors at their source, making them dramatically easier
to debug.

```tsx
import { createFileRoute } from '@tanstack/react-router'
import { listAccounts } from '../api.ts'
import { AccountListTable } from '../account-list-table.tsx'

export const Route = createFileRoute('/accounts/$list')({
  component: RouteComponent,
  loader: async () => {
    // Remember, this function validates the shape of the data
    // or throws an error if the data is in an unexpected shape
    return await listAccounts()
  },
})

function RouteComponent() {
  // The account list is made available through the baked-in `useLoaderData` hook
  const accountList = Route.useLoaderData()

  return (
    <div>
      <h1>List of accounts</h1>

      {/* Ta-dah! The inferred type from the `listAccounts` function matches the expected type defined explicitly in the <AccountListTable /> */}
      <AccountListTable accountList={accountList} />
    </div>
  )
}
```

## Conclusion

`zod` (and other similar tools, like [valibot](https://valibot.dev)) provide a
protective layer against unexpected data shapes in TypeScript applications,
improving the predictability and reliability of application code, all while
avoiding the "trust me, bro" mistakes that are common when handling data
fetching.

> This is the first article in a series about predictable, type-safe data
> fetching in TypeScript applications. In part two, I'll explore automated
> integration testing strategies that work well with type-safe data fetching.


Validate fetched data at runtime and build time

No more “Trust me, bro” data fetching in TypeScript applications

---
title: Use string unions, not enums in TypeScript
description: Prefer string unions over enums in TypeScript projects!
date: '2025-02-08'
image: janosch-diggelmann-ZxlAVtQjcpI-unsplash.webp
---

[Enums](https://www.typescriptlang.org/docs/handbook/enums.html) in TypeScript
are a language feature that should generally be avoided &mdash; instead, use
string unions for most use cases. Ultimately, string unions are simpler to both
use and implement, allowing for end-to-end type safety without sacrificing
developer experience.

Often used for things like prop types or function parameters, an enum can be
used to define a union of possible acceptable values.

```tsx
enum Variant {
  Primary = 'primary',
  Secondary = 'secondary',
  Destructive = 'destructive',
}

function MyButton({ variant }: { variant: Variant }) {
  let className

  if (variant === Variant.Primary) {
    className = 'primary-btn'
  }

  if (variant === Variant.Secondary) {
    className = 'secondary-btn'
  }

  if (variant === Variant.Destructive) {
    className = 'destructive-btn'
  }

  return <button className={className}>Click me</button>
}
```

In this (fairly contrived) example, the enum is used to determine which CSS
class should be applied to the button. This solution works for defining several
valid variants (and excluding all others), but it offers worse developer
ergonomics over time than alternative approaches.

## Enum problems

### 1. Enums do not exist in JavaScript at runtime

By the time TypeScript compiles, the JavaScript engine running your program no
longer has a reference to the enum in a true 1 to 1 sense. As a result,
[an enum becomes an object at runtime](https://www.typescriptlang.org/docs/handbook/enums.html#enums-at-runtime).
This isn't necessarily a _problem_ but it can be confusing, particularly to
developers who may not be aware that all constructs in TypeScript do not map
one-to-one to JavaScript constructs.

Enums
[can have surprising differences](https://www.totaltypescript.com/why-i-dont-like-typescript-enums)
once compiled to JavaScript!

### 2. Enums add to bundle size

Because an `enum` must be imported and used as a value, it must be available at
runtime, adding to overall bundle size once compiled.

```ts
// This creates `VariantEnum` at runtime
enum Variant {
  Primary = 'primary',
  Secondary = 'secondary',
  Destructive = 'destructive',
}
```

```ts
// This is not available at runtime at all
type Variant = 'primary' | 'secondary' | 'destructive'
```

### 3. More boilerplate when passing enums to functions/components

When we use an enum to strictly type a function (or component props), developers
have to import that enum in order to use it when invoking the function (or
component), adding additional overhead that isn't required when using string
unions.

To take the previous example, let's use our `MyButton` component and pass a
variant:

```tsx
import { Variant, MyButton } from './my-button.tsx'

function MyPage() {
  return <MyButton variant={Variant.Primary} />
}
```

This is relatively painless in a React application, but when used in an Angular
component, things get a little unusual

#### Angular component props and enums

In this example, we define our `enum` (just like in the React `MyButton`
component) but there is a _lot_ more boilerplate required to implement the end
result.

```ts
import { Component, Input } from '@angular/core'
import { NgClass } from '@angular/common'

enum Variant {
  Primary = 'primary',
  Secondary = 'secondary',
  Destructive = 'destructive',
}

@Component({
  selector: 'my-button',
  imports: [NgClass],
  template: `
    <button
      [ngClass]="{
        primary: this.variant === this.Variant.Primary,
        secondary: this.variant === this.Variant.Secondary,
        destructive: this.variant === this.Variant.Destructive,
      }"
    >
      Click me
    </button>
  `,
})
export class MyButton {
  public Variant = Variant

  @Input()
  variant?: Variant
}
```

This works fairly cleanly when defining the component, though we do have to
expose the `Variant` enum has a public member of the `MyButton` class in order
to use it. Not only that, but we have to import and expose the `Variant` in each
component class that uses the button `variant` prop! That is a _lot_ of code to
pass a string.

```ts
import { Component } from '@angular/core'
import { MyButton, Variant } from './my-button'

@Component({
  selector: 'my-page',
  imports: [MyButton],
  template: `<my-button [variant]="this.Variant.Primary"></my-button>`,
})
export class MyPage {
  // 😥 exposing this to access it in the template
  public Variant = Variant
}
```

Not to mention, now the `MyPage` class exposes a public `Variant` that can be
accessed programmatically &mdash; and without a significant benefit since our
intention was only to leverage the value in the component template.

## String unions as an alternative

For most enum use cases, use string unions instead. This simplifies both our
prior React and Angular button examples substantially.

### React example

First, the button component.

```tsx
type Variant = 'primary' | 'secondary' | 'destructive'

// We can do a nice little look up here with each object key
// strictly typed to be a valid `Variant`
const VARIANT_CLASS_MAP: Record<Variant, string> = {
  primary: 'primary-btn',
  secondary: 'secondary-btn',
  destructive: 'destructive-btn',
}

function Button({ variant }: { variant: Variant }) {
  return <button className={VARIANT_CLASS_MAP[variant]}>Click me</button>
}
```

And now its usage.

```tsx
import { Button } from './my-button'

function MyPage() {
  // No need to import `Variant` at all!
  // *And* TypeScript will still throw an error at build time with an invalid value
  return <Button variant="primary" />
}
```

### Angular example

First, the button component.

```ts
import { Component, Input } from '@angular/core'
import { NgClass } from '@angular/common'

type Variant = 'primary' | 'secondary' | 'destructive'

@Component({
  selector: 'my-button',
  imports: [NgClass],
  template: `
    <button
      [ngClass]="{
        primary: this.variant === 'primary',
        secondary: this.variant === 'secondary',
        destructive: this.variant === 'destructive',
      }"
    >
      Click me
    </button>
  `,
})
export class MyButton {
  @Input()
  variant?: Variant
}
```

And now its usage:

```ts
import { Component } from '@angular/core'
import { MyButton } from './my-button'

@Component({
  selector: 'my-page',
  imports: [MyButton],
  template: `<my-button variant="primary"></my-button>`,
})
export class MyPage {}
```

### String unions at runtime

At times, string union values need to be made available at runtime. To achieve
this (and avoid repetition), define the string union values in a constant array
and derive the `type` from said array.

```ts
const VARIANTS = ['primary', 'secondary', 'destructive'] as const

type Variant = (typeof VARIANTS)[number]
```

It then becomes trivial to write a type guard function if needed using the same
constant array.

```ts
function isVariant(arg: any): arg is Variant {
  return VARIANTS.includes(arg)
}
```

### When you just can't quit enumerating

If you still insist on using enums (or need to refactor an existing codebase
that uses enums heavily), consider defining the enum `as const` which can help
avoid some of the aforementioned problems outlined in this article.

See more
[from Matt Pocock via Total TypeScript essentials](https://www.totaltypescript.com/books/total-typescript-essentials/deriving-types#using-as-const-for-javascript-style-enums).

## Conclusion

String unions are capable alternatives to TypeScript enums in most scenarios,
and enable improved developer ergonomics and simplified implementation
particularly when defining function parameters or component props (especially
Angular component props!). While enums still _can_ be used, string unions should
be used in their place in most circumstances.


Prefer string unions over enums in TypeScript projects!

A frontend engineering leader driven to create accessible user interfaces at scale.

The latest

Avoid stateful components in design systems

Type safe, auto-generating test data for API mocking

No more “Trust me, bro” data fetching in TypeScript applications

Use string unions, not enums in TypeScript