Typescript generic conditional does not precise the type

Here is a piece of code (playground, Typescript 5.0.4) that takes a generic function, and do some operation depending on the type:

type TypeToValue = {
  one: number;
  two: string;
};
function MyFunction<T extends keyof TypeToValue>(
  value: TypeToValue[T],
  type: T,
) {
  if (type === 'one') return value.toFixed(2); // fail "Property 'toFixed' does not exist on type 'string | number'."
  if (type === 'two') return value.toString()
  throw Error('invalid type')
}

However, I expect it not to fail because Typescript should be aware that after type === 'one', then the generic T is 'one' hence value is typed as number.

Is there a workaround to have the type automatically inferred?

Thanks !

I think the inference is not smart enough to understand the proper type. However, that's just my humble opinion.

Anyway, here is a slightly different version, where it simply evaluates the type at runtime. That also ensures the proper inference.

type TypeToValue = {
  one: number;
  two: string;
};
function MyFunction<T extends keyof TypeToValue>(
  value: TypeToValue[T],
  //  type: T,
) {
  if (typeof value === 'number') return value.toFixed(2);
  if (typeof value === 'string') return value.toString()
  throw Error('invalid type')
}

let s: string;
s = MyFunction<"one">(123.456);
console.log(s);    //prints "123.46" 

s = MyFunction<"two">("hello");
console.log(s);    //prints "hello"

Also no need of the second argument.

You need something more generic for your task. Playground

interface Interface1 {
a: string;
b: number;
}
interface Interface2 {
c: boolean;
d: any;
}
function isInterface<T>(value: any): value is T {
if (typeof value !== 'object' || value === null) {
return false;
}
for (const key in value) {
if (value[key] === undefined) {
return false;
}
}
return true;
}
type TypeToValue = number | string | Interface1 | Interface2;    
function MyFunction(t: TypeToValue) {
if (typeof t === "number") {
return t.toFixed(2);
}
if (typeof t === "string") {
return t.toString();
}
if (isInterface<Interface1>(t)) {
console.log('processing obj of type Interface1');
return t; // or do something with object of type Interface1
}
if (isInterface<Interface2>(t)) {
console.log('processing obj of type Interface2');
return t; // or do something with object of type Interface2
}
throw new Error("Invalid type");
}
// test
const obj1 = { a: 'hello', b: 100 };
const obj2 = { c: true, d: 'world' };
console.log(MyFunction(100));
console.log(MyFunction("one hundred"));
console.log(MyFunction(obj1));
console.log(MyFunction(obj2)); 

Thank you @jcalz for providing a valid workaround (playground):

type TypeToValue = {
  one: number;
  two: string;
};


type MyFunctionArgs = { [K in keyof TypeToValue]: [value: TypeToValue[K], type: K] }[keyof TypeToValue]

function MyFunction(...[value, type]: MyFunctionArgs) {
  if (type === 'one') return value.toFixed(2); // okay
  if (type === 'two') return value.toString()
  throw Error('invalid type')
}