Extending string-based enums

[nomaed]

Before string based enums, many would fall back to objects. Using objects also allows extending of types. For example:

const BasicEvents = {
 Start: "Start",
 Finish: "Finish"
};

const AdvEvents = {
 ...BasicEvents,
 Pause: "Pause",
 Resume: "Resume"
};

When switching over to string enums, it"s impossible to achieve this without re-defining the enum.

I would be very useful to be able to do something like this:

enum BasicEvents {
 Start = "Start",
 Finish = "Finish"
};

// extend enum using "extends" keyword
enum AdvEvents extends BasicEvents {
 Pause = "Pause",
 Resume = "Resume"
};

Considering that the produced enums are objects, this won"t be too horrible either:

// extend enum using spread
enum AdvEvents {
 ...BasicEvents,
 Pause = "Pause",
 Resume = "Resume"
};

[nomaed]

Just played with it a little bit and it is currently possible to do this extension using an object for the extended type, so this should work fine:

enum BasicEvents {
 Start = "Start",
 Finish = "Finish"
};

// extend enum using "extends" keyword
const AdvEvents = {
 ...BasicEvents,
 Pause: "Pause",
 Resume: "Resume"
};

[aluanhaddad]

Note, you can get close with

enum E {}

enum BasicEvents {
 Start = 'Start',
 Finish = 'Finish'
}
enum AdvEvents {
 Pause = 'Pause',
 Resume = 'Resume'
}
function enumerate<T1 extends typeof E, T2 extends typeof E>(e1: T1, e2: T2) {
 enum Events {
 Restart = 'Restart'
 }
 return Events as typeof Events & T1 & T2;
}

const e = enumerate(BasicEvents, AdvEvents);

[aj-r]

Another option, depending on your needs, is to use a union type:

const enum BasicEvents {
 Start = 'Start',
 Finish = 'Finish'
}
const enum AdvEvents {
 Pause = 'Pause',
 Resume = 'Resume'
}
type Events = BasicEvents | AdvEvents;

let e: Events = AdvEvents.Pause;

Downside is you can't use Events.Pause; you have to use AdvEvents.Pause. If you're using const enums, this is probably ok. Otherwise, it might not be sufficient for your use case.

[serhiipalash]

We need this feature for strongly typed Redux reducers. Please add it in TypeScript.

[aj-r]

Another workaround is to not use enums, but use something that looks like an enum:

const BasicEvents = {
 Start: 'Start' as 'Start',
 Finish: 'Finish' as 'Finish'
};
type BasicEvents = (typeof BasicEvents)[keyof typeof BasicEvents];

const AdvEvents = {
 ...BasicEvents,
 Pause: 'Pause' as 'Pause',
 Resume: 'Resume' as 'Resume'
};
type AdvEvents = (typeof AdvEvents)[keyof typeof AdvEvents];

[Xenya0815]

All workarounds are nice but I would like to see the enum inheritance support from typescript itself so that I can use exhaustive checks as simple as possible.

[nOstap]

Just use class instead of enum.

[guptaamol]

I was just trying this out.

const BasicEvents = {
 Start: 'Start' as 'Start',
 Finish: 'Finish' as 'Finish'
};

type BasicEvents = (typeof BasicEvents)[keyof typeof BasicEvents];

const AdvEvents = {
 ...BasicEvents,
 Pause: 'Pause' as 'Pause',
 Resume: 'Resume' as 'Resume'
};

type AdvEvents = (typeof AdvEvents)[keyof typeof AdvEvents];

type sometype<T extends AdvEvents> =
 T extends typeof AdvEvents.Start ? 'Some String' :
 T extends typeof AdvEvents.Finish ? 'Some Other String' :
 T extends typeof AdvEvents.Pause ? 'Abc' :
 T extends typeof AdvEvents.Resume ? 'Xyz' : never;
type r = sometype<typeof AdvEvents.Finish>;

There has got to be a better way of doing this.

[cshaa]

Why isn't this a feature already? No breaking changes, intuitive behavior, 80+ people who actively searched for and demand this feature – it seems like a no-brainer.

Even re-exporting enum from a different file in a namespace is really weird without extending enums (and it's impossible to re-export the enum in a way it's still enum and not object and type):

import { Foo as _Foo } from './Foo';

namespace Bar
{
 enum Foo extends _Foo {} // nope, doesn't work

 const Foo = _Foo;
 type Foo = _Foo;
}

Bar.Foo // actually not an enum

[LukePetruzzi]

+1
Currently using a workaround, but this should be a native enum feature.

[masak]

I skimmed through this issue to see if anyone has posed the following question. (Seems not.)

From OP:

enum BasicEvents {
 Start = "Start",
 Finish = "Finish"
};

// extend enum using "extends" keyword
enum AdvEvents extends BasicEvents {
 Pause = "Pause",
 Resume = "Resume"
};

Would people expect AdvEvents to be assignable to BasicEvents? (As is, for example, the case with extends for classes.)

If yes, then how well does that mesh with the fact that enum types are meant to be final and not possible to extend?