Typescript generic conditional-partial property without type assertion

I am trying to create a type that has an optional property depending on the generic parameter passed. Something like:

type PartialWhen<Bool, T> = Bool extends true ? Partial<T> : T
type PartialWhenExtends<Base, Parent, T> = PartialWhen<Base extends Parent ? true : false, T>

type Props<V> = {
  value: V
} & PartialWhenExtends<V, string, {
  getValue: (item: V) => string
}>

function getPropsValue<V>({ value, getValue }: Props<V>): string {
  if (getValue !== undefined) {
    return getValue(value)
  }

  return value
}

const props1: Props<string> = {
  value: '123'
}
console.log(getPropsValue(props1))

const props2: Props<number> = {
  value: 123,
  getValue: (val) => val.toString()
}
console.log(getPropsValue(props2))

const props3: Props<string> = {
  value: 'abc',
  getValue: (val) => val.concat(val)
}
console.log(getPropsValue(props3))

In the example above, I want the getValue to be required when V is not string. When calling getPropsValue, the typehint works correctly. The problem is in the return value of getPropsValue in which I got Type 'V' is not assignable to type 'string', even though it is required when V is not string and would have returned in the condition above it.

The only solution I am able to use to solve this is by asserting the value as string.
I also tried changing the partial types definition multiple times & using union types, but unfortunately the result is the same.
Another solution that I tried is to check if the value is type of string, if not, just returns an empty string. While this works in this case, it is not possible where the return value is a generic.
I will use the PartialWhenExtends quite a lot, and would prefer to not do assertion everywhere.
Is there a way I can write the partial types so Typescript can correctly infer the type? If not, is there any other solution that can fit into this kind of use case?

Solution:

1. Fix your code to be correct for Props<string | number> case
2. Make your code explicitly check for a string

type PartialWhen<Bool, T> = Bool extends true ? Partial<T> : T
type PartialWhenExtends<Base, Parent, T> = Base extends Parent ? Partial<T> : T

type Props<V> =
    { value: V } &
    PartialWhenExtends<[V], [string], { getValue: (item: V) => string }>
    
function getPropsValue<V>({ value, getValue }: Props<V>): string {
    if (getValue !== undefined) {
        return getValue(value)
    }
    if (typeof value === 'string')
        return value
    throw new Error()
}
// ok
getPropsValue<string>({ value: 'asd' })
// ^?
getPropsValue<'asd'>({ value: 'asd' })
// ^?
getPropsValue<string & { a: 1 }>({ value: 'asd' as any })
// ^?

// errors
getPropsValue<string | number>({ value: 123 })
// ^?
getPropsValue<number>({ value: 123 })
// ^?

Your function can be called as

getPropsValue<string | number>({} as any)
// ^? 
function getPropsValue<string | number>({ value, getValue }: {
    value: string | number;
} & ({
    getValue: (item: string | number) => string;
} | Partial<{
    getValue: (item: string | number) => string;
}>)): string

so TS is correct about your code being wrong.

I've got the code working without assertion as

function getPropsValue<V>(
    data: V extends string
        ? { value: V, getValue?: undefined } | { value: V, getValue: (item: V) => string }
        : { value: V, getValue: (item: V) => string }
): string
getPropsValue<number | string>({} as any)
// ^?
// function getPropsValue<string | number>(data: {
//     value: string;
//     getValue?: undefined;
// } | {
//     value: string;
//     getValue: (item: string) => string;
// } | {
//     value: number;
//     getValue: (item: number) => string;
// }): string

but at the moment it loses non-split { value: V, getValue?: undefined } it stops working.