2024-08-15
1785
#typescript
Kealan Parr
121310
Aug 15, 2024 ⋅ 6 min read

How to extend enums in TypeScript

Kealan Parr Software engineer, technical writer and member of the Unicode Consortium.

Recent posts:

the replay 108 graphic

The Replay (10/8/25): Data enrichment, CSS is back, TypeScript 5.9

Discover what’s new in The Replay, LogRocket’s newsletter for dev and engineering leaders, in the October 8th issue.

Matt MacCormack
Oct 8, 2025 ⋅ 30 sec read
Goodbye, messy data: An engineer’s guide to scalable data enrichment

Goodbye, messy data: An engineer’s guide to scalable data enrichment

Walk through building a data enrichment workflow that moves beyond simple lead gen to become a powerful internal tool for enterprises.

Alexandra Spalato
Oct 8, 2025 ⋅ 6 min read

DesignCoder and the future of AI-generated UI

From sketches to code in minutes, DesignCoder shows how AI-generated, hierarchy-aware UIs could change the way developers prototype and ship apps.

Rosario De Chiara
Oct 7, 2025 ⋅ 5 min read

Should you use if() functions in CSS?

It’s 2025, and CSS finally thinks logically. The if() function brings real conditional styling — no hacks, no JS workarounds. Here’s how to use it right.

Ikeh Akinyemi
Oct 7, 2025 ⋅ 16 min read
View all posts

2 Replies to "How to extend enums in TypeScript"

  1. >In the above code block, we used an intersection type. The intersection acts like an “or,” which simply means that the DoorState type will either be of type Door or of type DoorFrame.

    Isn’t that a union type? Although, the resultant type will let code only compile if the type is used such that only properties in the *intersection* of the types being unioned is accessed.

  2. > Can you extend enums?
    > The short answer is no, you can’t extend enums because TypeScript offers no language feature to > extend them.

    Depends on what you mean by “extend”… but either way, this sentence is pretty falsy. You might not be able to use an `extends` heritage clause as you would with interfaces or classes, but enums are subject to declaration merging in the same manner as namespaces (both `namespace` and the legacy `module` keyword), and interfaces/classes (at the type-level).

    You can also extend the functionality of an enum with static methods, in the same way you would by defining a namespace with the same name as an existing class or function to add types or static methods/properties.

    Here’s a brief real world example:
    “`ts
    // svg path segment commands
    enum Command {
    MoveToAbs = “M”,
    MoveToRel = “m”,
    LineToAbs = “L”,
    LineToRel = “l”,
    // …
    }

    namespace Command {
    // adding types, available as `Command.Absolute` or `Command.Relative`:
    export type Absolute = Command.MoveToAbs | Command.LineToAbs;
    export type Relative = Command.MoveToRel | Command.LineToRel;

    // add runtime functionality with type guards
    export function isAbsolute(it: unknown): it is Absolute {
    return it === Command.MoveToAbs || it === Command.LineToAbs;
    }

    export function isRelative(it: unknown): it is Relative {
    return it === Command.MoveToRel || it === Command.LineToRel;
    }
    }
    “`

Leave a Reply