Usando genéricos para tornar um argumento opcional

Talvez você não queira uma função genérica. Em vez disso, você pode querer uma função em que o tipo de parâmetro seja uma união de tuplas que representam todas as combinações possíveis de argumentos que você permite.

Então você quer um tipo como este:

type EventArgs =
  | [eventName: "event1"]
  | [eventName: "event2", extraData: { user: number }]

E agora você usa esse tipo na sua logEventfunção assim:

function logEvent(...[eventName, extraData]: EventArgs) {
  console.log(eventName, extraData)
}

logEvent('event1') // fine
logEvent('event1', undefined) // type error

logEvent('event2') // type error
logEvent('event2', { user: 123 }) // fine

Agora, cada nome de evento é pareado com os outros argumentos que o nome de evento específico precisa.

Veja o parque infantil

Então, como você gera esse EventArgstipo a partir de EventType?

Com um tipo mapeado que mapeia sobre cada propriedade de EventTypee cria a tupla necessária para cada uma. Poderia parecer assim:

type EventArgs = {
  [K in keyof EventType]:
    EventType[K] extends undefined
      ? [eventName: K]
      : [eventName: K, extraArgs: EventType[K]]
}[keyof EventType]

Isso mapeia sobre cada propriedade e verifica se o valor dessa propriedade undefined. Se for undefined, então a tupla é apenas o nome da chave como o único argumento para a função. Se não for indefinido, use uma tupla com 2 membros, um para o nome da chave e um para o extraData.

Veja o parque infantil

Infelizmente, o TypeScript não trata automaticamente parâmetros finais que aceitam undefinedcomo opcionais . Há uma solicitação de recurso para isso em microsoft/TypeScript#12400 , mas não faz parte da linguagem desde o TypeScript 5.6.

Se você quiser um comportamento como esse, precisará escrevê-lo você mesmo. Há várias maneiras de fazer isso, supondo que você queira manter isso como uma função genérica . Aqui estão duas:

Uma abordagem é usar um tipo condicional para operar no tipo tuple de parâmetros finais. Aqui está uma maneira de fazer isso:

type UndefinedToOptional<T extends any[]> =
  { [I in keyof T]: undefined } extends T ? Partial<T> : T

O tipo mapeado {[I in keyof T]: undefined} parece Tmas com cada elemento undefined. Então se Tfor [x: string | undefined, y: number], então o tipo mapeado parece [x: undefined, y: undefined]. O tipo condicional verifica se esse tipo mapeado é atribuível a T. Se for, então a coisa toda pode muito bem ser opcional, como representado por Partial<T>. Se não for, então não pode ser opcional (pelo menos não a coisa toda). Então se fizermos isso com sua função, obtemos:

type EventType = {
  event1: undefined,
  event2: {
    user: number
  }
  event3?: {
    id: string;
  }
}

declare function logEvent<K extends keyof EventType>(
  eventName: K,
  ...rest: UndefinedToOptional<[extraData: EventType[K]]>): void;

Onde a [extraData: EventType[K]]tupla restante será transformada [extraData?: EventType[K]]quando EventType[K]aceitar undefined. Vamos testar:

logEvent('event1', undefined) // okay
logEvent('event1'); // okay
logEvent('event2', { user: 5 }) // okay
logEvent('event2'); // error
logEvent('event3', { id: "abc" }); // okay
logEvent('event3'); // okay

Ou você pode escrever sobrecargas em vez disso, se não quiser mexer com tuplas rest. Você ainda precisa de algum tipo de tipo condicional para calcular quais coisas são opcionais. Para seu código, pode parecer:

type UndefinableKeys<T> = (keyof T) & { 
  [K in keyof T]: undefined extends T[K] ? K : never 
}[keyof T]
type UndefinableEvents = UndefinableKeys<EventType>;
//   ^? type UndefinableEvents = "event1" | "event3"

Aqui UndefinableKeys<T>retorna o subconjunto das chaves de Tfor que undefinedé atribuível à propriedade correspondente. Então você pode simplesmente fazer duas assinaturas de chamada, uma para cada maneira de chamá-la:

declare function logEvent<K extends keyof EventType>(
  eventName: K, extraData: EventType[K]): void;
declare function logEvent<K extends UndefinableEvents>(
  eventName: K, extraData?: EventType[K]): void;

logEvent('event1', undefined) // okay
logEvent('event1'); // okay
logEvent('event2', { user: 5 }) // okay
logEvent('event2'); // error
logEvent('event3', { id: "abc" }); // okay
logEvent('event3'); // okay

Link do playground para o código

Você pode usar parâmetros de descanso condicionais:

Parque infantil

declare function logEvent<K extends keyof EventType>(eventName: K, 
  ...args: undefined extends EventType[K] ? 
    [] | [undefined] | [Exclude<EventType[K], undefined>]: 
    [extraData: EventType[K]]
): void;