Como você faz o tipo de retorno de uma função depender de seu tipo de argumento?

Digamos que eu tenha algo assim:

type TIn = {
    xa?: number;
    xb?: string;
    xc?: boolean;
    // ...
}

type TOut = {
    ya: number | undefined;
    yb: string | undefined;
    yc: TPerson | undefined;
    // ...
}

type TPerson = {
    name: string;
    age: number;
}

function fn(input: TIn): TOut {
    // ...
}

Agora, digamos que eu queira aplicar a verificação estática de nulidade dos campos de saída em relação à entrada. Por exemplo:

• quando xaé um number, o relacionado yatambém será um number;

• quando xaé undefined, yaserá também undefined;

• quando xbé um string, o relacionado ybpode ser um stringou undefined;

• quando xbé undefined, ybserá também undefined;

E assim por diante.

Em C#, há atributos especiais para instruir o compilador sobre como verificar estaticamente a nulidade.

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/nullable-análise

Gostaria de saber se existe algum "substituto" (quero dizer, brincar com tipos e utilitários) no TypeScript para obter uma verificação de nulidade mais completa.

Além disso, não é uma solução personalizada "como este exemplo", mas sim uma ferramenta modular para usar em qualquer caso.

EDIT: Aqui está uma tentativa de resolver, não está funcionando, mas foi adicionada para maior clareza.

Abaixo estão os supostos ajudantes:

//maps TResult when T1 is not undefined
//undefined otheriwse
type TNotNull<T1, TResult> = T1 extends {}
    ? TResult
    : undefined;

//maps TResult | undefined when T1 is not undefined
//undefined otheriwse
type TMaybeNull<T1, TResult> = T1 extends {}
    ? TResult | undefined
    : undefined;

//maps TResult when both T1 and T2 are not undefined
//undefined otheriwse
type TNotNullWhenBoth<T1, T2, TResult> = T1 extends {}
    ? T2 extends {} ? TResult : undefined
    : undefined;

Poderia haver muito mais (mais argumentos, lógica mais complexa, etc.)

Agora, como exemplo, vamos definir o contrato de entrada da função:

type TIn = {
    a?: number;
    b?: number;
    s?: string;
}

Para o tipo de saída, a ideia é compô-lo usando os supostos auxiliares:

type TOut<T extends TIn> = {
    inv_a: TNotNull<T["a"], number>;
    flag: TMaybeNull<T["b"], boolean>;
    str: TNotNull<T["s"], string>;
    sum: TNotNullWhenBoth<T["a"], T["b"], number>;
}

Ou seja, para inv_a:

• quando aé um número, inv_atambém é um número
• quando aé indefinido, inv_atambém é indefinido

Para flag:

• quando bé um número, flagé um booleano ou indefinido
• quando bé indefinido, flagtambém é indefinido

Para str, similarmente a inv_a:

• quando sé uma string, strtambém é uma string
• quando sem indefinido, strtambém é indefinido

Para sum, mesma lógica que inv_a, mas dois argumentos AND-ed:

• quando ambos ae bsão números, sumtambém é um número
• sumserá indefinido caso contrário

Por fim, vamos escrever a função. Aqui, a implementação não é importante. Fora da função, precisamos apenas que o contrato de entrada/saída seja sempre satisfeito.

const flags: Array<boolean> = new Array(10);
flags[3] = true;

function fn(input: TIn): TOut<TIn> {
    const { a, b, s } = input;
    //just an example of implementation
    const inv_a = typeof a === "number"
        ? 1 / a
        : void 0;
    const flag = typeof b === "number"
        ? flags[b]
        : void 0;
    const str = typeof s === "string"
        ? s + "hello!"
        : void 0;
    const sum = typeof a === "number" && typeof b === "number"
        ? a + b
        : void 0;
    return { inv_a, flag, str, sum }
}

Neste ponto, aqui estão alguns casos de uso e como a inferência de resultados é esperada:

//expected inference: all undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({});

//expected inference: flag:boolean | undefined; rest undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ b: 3 });

//expected inference: inv_a:number; str:string; flag, sum:undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ a: 5, s: "xyz" });

//expected inference: inv_a, sum:number; flag, str:undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ a: 5, b: 3 });

Infelizmente, não funciona.