Typescript Extention or Inheritance with Enums (Enumerations)

I was wondering about enumerations that depend on each other, and if there is a pattern that doesn't involve gluing enumerations together with another type structure.

enum FruitEnum {
    Apple = "APPLE",
    Orange = "ORANGE"
}

// DesertEnum extends FruitEnum
enum DesertEnum {
    Apple = FruitEnum.Apple,
    Orange = FruitEnum.Orange,
    CheeseCake = "CHEESE_CAKE",
    ChocolateCake = "CHOCOLATE_CAKE",
    Pie = "PIE"
}

// CakeEnum inherits from DesertsEnum
enum CakeEnum {
    CheeseCake = DesertEnum.CheeseCake,
    ChocolateCake = DesertEnum.ChocolateCake
}

/*
    Type 'DesertEnum.Pie | CakeEnum' is not assignable to type 'DesertsEnum'.
    Type 'CakeEnum.CheeseCake' is not assignable to type 'DesertsEnum'.(2322)
*/
const whichCake: DesertEnum = Object.values(CakeEnum)
                                    .find(cake => cake === CakeEnum.ChocolateCake) ?? DesertEnum.Pie

/*
    Type 'FruitEnum | DesertsEnum.Pie' is not assignable to type 'DesertsEnum'.
    Type 'FruitEnum.Apple' is not assignable to type 'DesertsEnum'.(2322)
*/
const whichFruit: DesertEnum = Object.values(FruitEnum)
                                     .find(fruit => fruit === FruitEnum.Apple) ?? DesertEnum.Pie

I tried using types that combine everything, but it just seams like extra code that is error prone.

// This feels like a hack, it should be inferred by at least one of the patterns.
// If we were to add a new type of desert, it would be necessary to both create 
// the enumeration and add it to the DesertsType structure.

type DesertsType = FruitEnum | CakeEnum | DesertEnum

If you're not tied to using TypeScript's enum keyword specifically, you can create JavaScript objects that act practically identically to TypeScript enums by creating as const objects, and creating types for them with the same name using the (typeof MyEnum)[keyof typeof MyEnum] pattern. This creates the type as a string union, which allows TypeScript to figure out this sort of crossover.

Using JavaScript objects instead of TypeScript enums has a couple of advantages, though it's not all positive.

+ The syntax is more familiar to JavaScript developers who are new to TypeScript

+ The generated JavaScript is more obvious, because only TypeScript annotations are removed

+ TypeScript won't generate reverse lookups for number enums, which can be unintuitive and cause unexpected problems

- TypeScript won't generate the type associated with an enum for you, so you need to create it yourself, making the code a bit more verbose

- Because the type is constructed as a union of constant types (e.g. 'a' | 'b'), you may not get as useful autocomplete in your IDE because it will suggest those values directly rather than suggesting you access them through your enum object

In my opinion the upsides outweigh the downsides, so I use this approach in my own work, but also the differences are minor enough that it comes largely down to code style or personal preference. I think you've hit on one of the few instances where it actually makes a difference.

Here's your example, using custom enums with a utility EnumTypeOf type to make the custom type construction a bit more obvious:

type EnumTypeOf<T extends Record<string, unknown>> = T[keyof T];

const FruitEnum = {
    Apple: "APPLE",
    Orange: "ORANGE"
} as const;
type FruitEnum = EnumTypeOf<typeof FruitEnum>;

// DesertEnum extends FruitEnum
const DesertEnum = {
    Apple: FruitEnum.Apple,
    Orange: FruitEnum.Orange,
    CheeseCake: "CHEESE_CAKE",
    ChocolateCake: "CHOCOLATE_CAKE",
    Pie: "PIE"
} as const;
type DesertEnum = EnumTypeOf<typeof DesertEnum>;

// CakeEnum inherits from DesertsEnum
const CakeEnum = {
    CheeseCake: DesertEnum.CheeseCake,
    ChocolateCake: DesertEnum.ChocolateCake
} as const;
type CakeEnum = EnumTypeOf<typeof CakeEnum>;


const whichCake: DesertEnum = (Object.values(CakeEnum))
                                    .find((cake) => cake === CakeEnum.ChocolateCake) ?? DesertEnum.Pie;

const whichFruit: DesertEnum = Object.values(FruitEnum)
                                     .find((fruit) => fruit === FruitEnum.Apple) ?? DesertEnum.Pie;

TypeScript Playground