Alex's questions

Existe alguma maneira de ter tipos para argumentos de retorno de chamada, em vez de any's?

type Listener = {
  callback: (...data: any[]) => void,
  once: boolean;
}

class EventEmitter{

  eventMap: Map<string, Listener[]> = new Map();


  on(event: string, callback: Listener["callback"], once: boolean = false) {
    const listeners = this.eventMap.get(event) ?? [];
    listeners.push({ callback, once });
    this.eventMap.set(event, listeners);
    return this;
  }

  once(event: string, callback: Listener['callback']): this {
    this.on(event, callback, true);
    return this;
  }

  emit(event: string, ...data: any[]) {
    const listeners = this.eventMap.get(event) ?? [];

    for (let i = 0; i < listeners.length; i++) {
      const { callback, once } = listeners[i];

      callback(...data);
      if (once) {
        listeners.splice(i, 1);
        this.eventMap.set(event, listeners);
      }
    }
  }
}

Emit tem que aceitar qualquer, porque é o ponto de entrada. Digamos que eu chamo isso de:

events.emit("x", 1, true); 
events.emit("y", "test"); 

Quero que os retornos de chamada sejam conectados xpara ver os tipos reais, como:

events.on("x", (arg1, arg2) => { // <= args should have types number and bool

e

events.on("y", (arg1) => { // <= args should have type string

Tenho uma propriedade que deve permitir apenas certos números:

{
   ...
   x: 1 | -1
}

Como definir isso no esquema de validação de entrada?

Se a entrada for JSON, é fácil:

x: z.union([z.literal(-1), z.literal(1)])

mas se a entrada vier na consulta de pesquisa, então os valores serão strings, então preciso ser capaz de forçar o número, mas ainda limitar a -1 e 1 para tornar o tipo inferido do esquema compatível com o tipo TypeScript.

Estou tentando usar Web Workers e percebi que para melhorar o desempenho você pode usar objetos "transferíveis" empostMessage

https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers

No Deno, objeto transferível significa ArrayBuffer, mas como transformar uma variável de array em ArrayBuffer?

meu caso de uso é enviar uma matriz de cerca de 10 mil elementos para o web worker, então eu gostaria de não copiá-lo, se possível.

Componente pai:

<script>
    import Child from "./Child.svelte"
    import { onMount } from "svelte";
    import apireq from "./api.js";
    
    let items = $state.raw([]);

    let splitItems = $derived(items.splice(0, 5));

    onMount(() => {
        apireq().then(v => items = v)
    })
</script>
<h1>item count in parent {items.length}</h1>
<Child items={splitItems} />

Componente filho

<script>
  let props = $props();
  let { items} = props;
</script>

item count in child:
<div>{items.length}</div>

O componente filho não é atualizado após a solicitação da API. Ainda mostra contagem 0. O componente pai é atualizado.

Eu tentei com ambos $statee $state.raw. Mas eu não quero reatividade total porque é uma matriz grande, e a reatividade na atribuição deve ser suficiente

Isso costumava ser muito simples no Svelte 4, mas no 5 nada funciona como esperado :(

Como posso fazer um loop em um array muito grande e ainda conseguir mover elementos para o final do array sem quebrar o loop?

No loop estou consumindo os elementos, mas alguns deles dependem de outros, e esses eu quero mover no final. Eventualmente todos os elementos serão consumidos, então o loop não será infinito.

Eu sei que a maneira mais fácil é usar apenas uma matriz secundária e não alterar a matriz original no loop, mas os dados são muito grandes e seria muito lento

Como tornar dataarg opcional somente se cato argumento não for 1?

export class MyClass<T extends 1 | 2 | 3>{
  constructor(
    public cat: T,
    public data?: T extends 1 ? string[] : undefined,
  ) {
    ...
  }
}