mb21's questions

No exemplo simplificado a seguir do meu problema:

const factory = <T extends unknown[]>(
  fn: (...args: T) => void
) => {
  const transformedFn = (...args: T) => {
    console.log('called with', ...args)
    return fn(...args)
  }

  // init
  transformedFn() // TypeScript error here

  return transformedFn
}

// usage:
const fn = (num?: number, str?: string) => {
  return JSON.stringify({ num, str })
}
factory(fn)()

Recebo o erro TypeScript:

O argumento do tipo '[]' não é atribuível ao parâmetro do tipo 'T'. '[]' é atribuível à restrição do tipo 'T', mas 'T' pode ser instanciado com um subtipo diferente da restrição 'unknown[]'.

Parque infantil

Confusamente, isso funciona:

const fn = <T extends unknown[]>(...args: T) => {
  return args
}
fn()

Como posso convencer o TypeScript de que é o mesmo Tem ambos os casos?

Estou tentando implementar uma função minimalista de tipo seguro que faz requisições HTTP contra uma API de servidor tipada, mas estou tendo dificuldades com os tipos. Especificamente, como tornar o terceiro argumento (o payload da requisição HTTP) opcional para as requisições GETand DELETE, enquanto o verifica e não é opcional para POSTand PUT.

Um exemplo simplificado ( TypeScript playground ):

export type Method = 'GET' | 'DELETE' | 'POST' | 'PUT'

// attempt 1:
const httpRequest1 = <M, D>(method: M, url: string, data?: D) =>
  'not implemented yet' as any


// attempt 2:
type HttpRequest <M extends Method, D, R=unknown> = M extends 'GET' | 'DELETE'
  ? (method: M, url: string) => Promise<R>
  : (method: M, url: string, data: D) => Promise<R>

const httpRequest2: HttpRequest = (method, url, data) =>
  'not implemented yet' as any


// expected usage:
interface Data {
  title: string;
}
httpRequest<'POST', Data>('POST', '/', { title: 'test' }) // should typecheck
httpRequest<'POST', Data>('POST', '/', { titleoops: 'test' }) // should NOT typecheck
httpRequest<'POST', Data>('POST', '/') // should NOT typecheck
httpRequest<'GET', undefined>('GET', '/') // should typecheck

Nunca consigo que todas as quatro condições sejam verificadas como esperado ao mesmo tempo. Pelo menos uma delas está sempre quebrada.

Edição: Se você estiver se perguntando, o caso de uso completo, atualizado com a solução funcional .

Eu tenho a seguinte função geradora:

async function * filterIterable (iter, predicate) {
  let i = 0
  for await (const val of iter) {
    if (predicate(val, i++)) {
      yield val
    }
  }
}

que eu gostaria de digitar para os dois casos a seguir:

// type predicate
const nonNullable = <T>(val: T | undefined | null): val is T =>
  val !== undefined && val !== null

async function * gen1 () {
  yield 1
  yield 2
  yield 3
}

async function * gen2 () {
  yield 1
  yield undefined
  yield 3
}

const it1 = filterIterable(gen1(), n => n % 2 === 0)
const it2 = filterIterable(gen2(), nonNullable) // should be AsyncIterable<1 | 2>

Eu criei esta interface:

interface FilterIterable {
  <T> (
    iter: AsyncIterable<T>,
    predicate: (val: T, index: number) => boolean,
  ): AsyncIterable<T>;
  <T, S extends T> (
    iter: AsyncIterable<T>,
    predicate: (val: T, index: number) => val is S,
  ): AsyncIterable<S>;
}

que eu poderia aplicar a uma expressão de função, mas aparentemente não a uma declaração de função de acordo com Como aplicar um tipo de função a uma declaração de função . Não é isso que o gerador é?

Considere este trecho ( playground ):

<textarea onInput={event => {
  console.log(event.key) // TypeScript error and undefined at runtime
  setState(event.currentTarget.value)
}} />

Quero detectar se o usuário pressionou enter ou shift-enter.

O evento nativo do navegador possui propriedades keye shiftKey, que estão ausentes no evento do Solid. Também não consigo encontrar um equivalente à event.nativeEventpropriedade do React.

Eu realmente preciso usar useKeyDownEvent ? Essa abordagem parece sofrer de uma condição de corrida ao usá-la dentro da área de texto onInput...