How to prevent enum values collision in Typescript

I have a plenty of enums across my application, and some of these enums have the same values (although from different enum types). I also have a generic function that takes any of these enums and try to describe/handle based on the enum type and value. The problem is that the enum values are duplicated if the key is the same.

Is there some way to fix this issue? I've illustrated the problem below:

enum Car {
  bmw = "bmw",
  ferrari = "ferrari"
}

enum Brand {
  bmw = "bmw",
  ferrari = "ferrari"
}

function describeIt(it: string) {
  switch (it) {
    case Car.bmw:
      console.log("It's a BMW car");
      break
    case Brand.bmw:
      console.log("It's the BMW brand");
      break
    case Car.ferrari:
      console.log("It's a Ferrari car");
      break
    case Brand.ferrari:
      console.log("It's the Ferrari brand");
      break
  }
}

describeIt(Car.bmw)   // Got: It's a BMW car, correct!
describeIt(Brand.bmw) // Got: It's a BMW car, expected: It's the BMW brand

Try it at the Typescript Playground.

I'm 90% sure this would be a X Y problem if I asked "How to generate a unique value across all enum values?" so instead I'm asking "How to prevent enum values collision?" that is the core problem here.

I would like to keep the simple syntax if possible, I know that I can prepend the enum type like this, for instance:

enum Brand {
  bmw = "Brand.bmw",
  ferrari = "Brand.ferrari"
}

But this is not what I'm looking for, I want a solution that comes from the enum type itself.

I've tried searching across many questions but none of them addresses this specific problem.

switch statements match expressions against case values according to the strict equality comparison algorithm (ref: MDN, ECMAScript spec).

Because of this, string enum values that are the same string will always compare as equal (even if in different enums) — and the first case with the same string value will always match.

In order to discriminate values and still use the "enum" idiom, you can use an object with values which will never compare as equal (e.g. objects, symbols, etc.) — the TypeScript handbook actually suggests this object pattern:

> ## Objects vs Enums
>
> In modern TypeScript, you may not need an enum when an object with as const could suffice:
>
> ...
>
> The biggest argument in favour of this format over TypeScript’s enum is that it keeps your codebase aligned with the state of JavaScript, and when/if enums are added to JavaScript then you can move to the additional syntax.

Here's an example using symbol values:

TS Playground

type Values<T> = T[keyof T];

const Car = {
  Bmw: Symbol("bmw"),
  Ferrari: Symbol("ferrari"),
} as const;

type Car = Values<typeof Car>;

const Brand = {
  Bmw: Symbol("bmw"),
  Ferrari: Symbol("ferrari"),
} as const;

type Brand = Values<typeof Brand>;

function describeIt(it: Car | Brand): void {
  switch (it) {
    case Car.Bmw:
      console.log("It's a BMW car");
      break;
    case Brand.Bmw:
      console.log("It's the BMW brand");
      break;
    case Car.Ferrari:
      console.log("It's a Ferrari car");
      break;
    case Brand.Ferrari:
      console.log("It's the Ferrari brand");
      break;
  }
}

describeIt(Car.Bmw); // "It's a BMW car"
describeIt(Brand.Bmw); // "It's the BMW brand"

console.log(Car.Bmw === Car.Bmw); // true
console.log(Car.Bmw === Brand.Bmw); // false

And if, for some reason, you need enum values which can be serialized as strings, you could create an object type with customized toString and toJSON methods like this:

TS Playground

class UniqueString {
  constructor(public value: string) {}
  toString(): string { return this.value; }
  toJSON(): string { return this.value; }
}

type Values<T> = T[keyof T];

const Car = {
  Bmw: new UniqueString("bmw"),
  Ferrari: new UniqueString("ferrari"),
} as const;

type Car = Values<typeof Car>;

const Brand = {
  Bmw: new UniqueString("bmw"),
  Ferrari: new UniqueString("ferrari"),
} as const;

type Brand = Values<typeof Brand>;

// ...etc. (same as previous example)

console.log(String(Car.Bmw)); // "bmw"
console.log(JSON.stringify(Car.Bmw)); // '"bmw"'