Type Polymorphic Functions using Enums

I have a factory method with the following signature:

enum FactoryType {
  CAR = 'CAR',
  BIKE = 'BIKE'
}

type CarParamType = {
  cylinders: number
}

type BikeParamType = {
  gears: number
}

factory<F extends FactoryType>(factoryType: F, params: ParamType<F>) {
  switch (factoryType) {
    case FactoryType.CAR:
      return new CarFactory(params);
    case FactoryType.BIKE:
      return new BikeFactory(params);
    default:
       throw new Error('unrecognized factory');
  }

}

Where BikeFactory and CarFactory would have constructors that took in their respective param types.

Is there a way for me to do this in Typescript? That is, using an Enum, determine the actual type of the ParamType is such that I don't get compile errors within the factory method when I try to pass the params into their respective constructors?

I thought ParamType could look something like this:

type ParamType<T> = T extends FactoryType.CAR ? CarParamType
  : T extends FactoryType.BIKE ? BikeParamType : never;

But I don't think there's enough "hints" to give the compiler what it needs.

The only supported way to get the narrowing to work with switch/case statements if for factoryType and params to be part of a discriminated union where factoryType is the discriminant property. That requires that they be packaged in a single object, and even though it doesn't look like it, they are. You can think of factory() as having a rest parameter whose type is a discriminated union of tuple types:

function factory(
  ...args:
    [FactoryType.CAR, CarParamType] |
    [FactoryType.BIKE, BikeParamType]
) {
  switch (args[0]) {
    case FactoryType.CAR:
      return new CarFactory(args[1]); // okay
    case FactoryType.BIKE:
      return new BikeFactory(args[1]); // okay
  }
}

That works, but you've lost your factoryType and params names. Luckily, TypeScript also supports destructured discriminated unions, where you destructure into separate variables but the compiler keeps track of the relationship between those variables as if they were properties of the original discriminated union. That brings us to:

function factory(
  ...[factoryType, params]:
    [FactoryType.CAR, CarParamType] |
    [FactoryType.BIKE, BikeParamType]
) {
  switch (factoryType) {
    case FactoryType.CAR:
      return new CarFactory(params); // okay
    case FactoryType.BIKE:
      return new BikeFactory(params); // okay
  }   
}

The code compiles to the slightly weird function factory(...[factoryType, params]) {...} instead of function factory(factoryType, params) {...}, but it acts the same.

Playground link to code