Carcigenicate's questions

Eu tenho uma união e um objeto como este:

type FilterType = 'equals' | 'notEquals';

const labelMap: {[filterType in FilterType]: string} = {
    equals: 'Equals',
    notEquals: 'Not Equals',
} as const;

E eu gostaria de derivar disto o equivalente a:

type Labels = 'Equals' | 'Not Equals';

O mais próximo que consegui chegar disso foi:

type Labels = labelMap[keyof labelMap];

Isso funciona se eu remover a {[filterType in FilterType]: string}anotação, mas gostaria de mantê-la para que, se adicionarmos novos filtros, sejamos forçados a adicionar um rótulo.

Como posso anotar o tipo das chaves do objeto e também extrair os valores? Eu poderia fazer os valores seu próprio tipo explícito e então usar:

const labelMap: {[filterType in FilterType]: ValueType} = {

Mas eu preferiria mantê-lo centralizado, se possível, para que você não precise ir a vários lugares só para adicionar um novo filtro.

Existe uma maneira de definir o tipo de retorno da função para depender do tipo de uma variável local?

Eu tenho um conjunto de métodos de validação:

validateA(things: Thing[]): { badA: string[], badB: number[] }
validateB(things: Thing[]): { anotherBadA: string[], anotherBadB: number[] }

E então eu tenho um wrapper destinado a basicamente executar todos eles e mesclar seus resultados:

validateAllTheThings(things: Thing[]) {
    const problems = {
      ...this.validateA(things),
      ...this.validateB(things),
    };

    return problems;
}

Portanto, validateAllTheThingsdeve ter o tipo de retorno igual ao tipo de problems, que são todos os objetos retornados mesclados.

A maneira mais limpa que encontrei para usar ReturnType:

function validateAllTheThings(things: Thing[]): ReturnType<WrapperClass['validateA']> & ReturnType<WrapperClass['validateB']> {

Mas isso é muito detalhado e não será bem dimensionado. Seria bom se eu pudesse vincular o tipo de retorno da função ao tipo inferido de problems.