Is there a way to create a generic function that returns a specific type, if the generic is constrained to a discriminated union?

I'm trying to create a generic get-or-create function that accepts the tag of the union and want the output as the specific type of that tag.

type Apple = {
    name: string
    kind: "apple"
    props: {
        fleshiness: number
    }
}

type Orange = {
    name:string
    kind: "orange"
    props: {
        juiciness: number
    }
}

type Fruit = Apple | Orange


const myFruits:Fruit[] = [
    {
        name: "fruit2",
        kind: "orange",
        props: {
            juiciness: 0
        }
    },
    {
        name: "fruit1",
        kind: "apple",
        props: {
            fleshiness: 1
        }
    }
]

function getOrCreateFruit<T extends Fruit>(fruitName:string, fruitKind:T["kind"], props:T["props"]): T {

    const filteredFruits =  myFruits.filter((fruit): fruit is T => fruit.kind === fruitKind);   
    const fruitInMyFruits = filteredFruits.find((fruit) =>fruit.name === fruitName);

    const newFruit = {
        name: fruitName,
        kind: fruitKind,
        props: props
    }
    
    return fruitInMyFruits || newFruit;
}


const orange = getOrCreateFruit<Orange>("fruit1", "orange", {juiciness: 0})
const apple = getOrCreateFruit<Apple>("fruit2", "apple", {fleshiness:1})

But I'm getting the error that newFruit is not assignable to the return type :

Type 'T | { name: string; kind: T["kind"]; props: T["props"]; }' is not assignable to type 'T'.
  'T' could be instantiated with an arbitrary type which could be unrelated to 'T | { name: string; kind: T["kind"]; props: T["props"]; }'.

I've constrained T to be of type Fruit so I'm not sure what I'm overlooking. What are the cases for when T is instantiated as unrelated to the new object? And is there a better way to do this?

The problem occurs in the way that the arguments are being passed to getOrCreateFruit. As the arguments are passed in individually, you lose the power of the discriminated union type.

Each property is actually a union of the all the possible values for Fruit, for example T["kind"] (i.e. Fruit["kind"]) evaluates to 'apple' | 'orange'. So by the time you are rebuilding the object newFruit, the compiler can't tell what type of Fruit (Apple or Orange) you are attempting to build.

If you instead rework the argument to pass in an actual fruit fallback object (which contains the properties you want to extract for the function checks), the TS compiler will understand that you are returning a valid Fruit in the newFruit case.

function getOrCreateFruit<T extends Fruit>(fruitToCheckOrCreate: T): T {
const filteredFruits =  myFruits.filter((fruit): fruit is T => fruit.kind === fruitToCheckOrCreate.kind);   
const fruitInMyFruits = filteredFruits.find((fruit) =>fruit.name === fruitToCheckOrCreate.name);
const newFruit = fruitToCheckOrCreate
return fruitInMyFruits || newFruit;
}

https://tsplay.dev/Ndaydm