Guía
Show y For
Contenido que aparece y desaparece, y listas con clave que conservan cada nodo mientras su clave siga ahí.
<Show>
view`
<div class="app">
<Show when=${() => sesion() !== null}>
<Panel sesion=${() => sesion()!}/>
<Else>
<Login onentrar=${(s: Sesion) => sesion.set(s)}/>
</Else>
</Show>
</div>`;when es lo único reactivo. Cada rama se construye cuando se muestra: la
que no está visible no existe todavía, ni sus nodos ni sus efectos. Al cambiar
la condición, la rama anterior se libera entera —efectos, memos, listeners,
onCleanup— y se construye la otra.
Si when devuelve el mismo valor que ya tenía, no se reconstruye nada:
alternar un booleano que ya era true no toca el DOM. Se compara el valor,
no su veracidad: si when pasa de 1 a 2, la rama se reconstruye aunque las
dos sean verdaderas. Para evitarlo, que devuelva un booleano:
when=${() => items().length > 0}.
<Else> es opcional, va dentro del <Show> y solo puede haber uno. Una rama
puede tener varios nodos hermanos.
Con el valor
Cuando la rama necesita lo que when comprobó, el hijo puede ser una función
que lo recibe:
view`
<section>
<Show when=${() => club()}>
${(club) => view`<h2>${() => club().nombre}</h2>`}
<Else><p>Sin club.</p></Else>
</Show>
</section>`;club es un accesor ya estrechado: si fuera club() es un
Club | undefined, dentro es un Club, sin !, ?. ni ?? "". «No hay» es
null, undefined o false; un 0 o una cadena vacía cuentan como valor.
when puede ser una closure o cualquier cosa que se llame: when=${club}
con un signal o un resource funciona igual. El hijo tiene que ser una
función que recibe el accesor: ${(c) => Tarjeta(c)}, no ${Tarjeta} a
secas, que sería texto —y ascua-check lo marca como error—. En un
componente genérico el parámetro se puede anotar,
${(d: () => Present<T>) => …}; hace falta TypeScript 5.4 o posterior.
Y la rama se reconstruye solo cuando el valor aparece o desaparece. Si cambia por otro —un sondeo que cada quince segundos trae el club otra vez, en un objeto nuevo—, lo que lo lee dentro se actualiza sin rehacer nada.
<For>
view`
<ul class="tareas">
<For each=${() => tareas()}
key=${(t: Tarea) => t.id}
render=${(t: Tarea) => view`<li>${t.titulo}</li>`}/>
</ul>`;| Prop | Qué es |
|---|---|
each |
Una closure que devuelve el array. Es lo reactivo. |
key |
Qué identifica a cada item. Tiene que ser única. |
render |
Construye el nodo de un item. |
render se ejecuta una vez por clave. Mientras una clave siga en la lista,
su nodo se conserva y, si hace falta, se mueve; no se reconstruye. Eso preserva
lo que el framework no controla: el foco, la selección, el scroll, un
<input> a medio escribir.
Mover lo mínimo
Cuando la lista cambia de orden, las filas que siguen en el mismo orden relativo se quedan quietas y solo se mueven las demás —las que quedan fuera de la subsecuencia creciente más larga de las posiciones anteriores—. Intercambiar dos filas de mil son dos movimientos de DOM; mover una al final, uno. Y vaciar una lista que está sola en su padre es una sola operación, no mil.
Items que cambian
Como el nodo de cada clave no se rehace, para que el contenido de un item cambie, el item tiene que leer un signal por su cuenta:
interface Pedido {
id: number;
estado: Signal<"pendiente" | "enviado">;
}
render=${(p: Pedido) => view`
<li data-estado=${() => p.estado()}>#${p.id}: ${() => p.estado()}</li>`}Avanzar un pedido escribe en un texto y en un atributo, y ni la lista ni las demás filas se enteran.
Datos que llegan enteros: el segundo parámetro
Lo de arriba sirve cuando el estado es tuyo. Cuando los datos vienen de un
servidor —un sondeo cada quince segundos—, cada respuesta trae objetos nuevos,
y una fila construida con el primero no ve los siguientes: para el <For> es
la misma clave. Para eso render puede recibir un segundo parámetro:
render=${(c: Conversation, current: () => Conversation) => view`
<tr data-id=${c.id}>
<td>${c.patient}</td>
<td>${() => current().messages}</td>
<td class:active=${() => current().active}></td>
</tr>`}current() es el último objeto que llegó con esa clave, y es reactivo: lo que
lo lee se actualiza, sin reconstruir la fila ni perder su foco. Lo que no
cambia se sigue leyendo del primero (c.id). Con
ascua-query, un sondeo que trae lo mismo reusa cada
objeto, así que current() solo avisa a las filas que cambiaron.
Sin el segundo parámetro no hay signal por fila: no se paga lo que no se usa.
La fila seleccionada
Si cada fila lee un signal de «cuál está elegida», cambiarla despierta a todas.
Para eso está selector:
cada fila escucha solo su clave.
Dónde anclarlos
<Show> y <For> dejan un marcador invisible —un comentario— dentro de su
padre y colocan su contenido delante de él. Por eso necesitan un elemento
padre: no pueden ser la raíz de una plantilla. Pueden compartir padre con
otros nodos.
view`<Show when=${…}>…</Show>`; // ✗ sin padre
view`<section><Show when=${…}>…</Show></section>`; // ✓Dentro de la rama de otro <Show> no hace falta un elemento de por medio: el
padre es el de la región de fuera.
view`
<tbody>
<Show when=${() => loading()}>
<tr><td>Cargando…</td></tr>
<Else>
<Show when=${() => rows().length === 0}>
<tr><td>Sin resultados.</td></tr>
<Else><For each=${rows} key=${(r: Row) => r.id} render=${RowView}/></Else>
</Show>
</Else>
</Show>
</tbody>`;Un <div> ahí rompería la tabla. Cuando la rama de fuera se cierra, se lleva
lo que haya dentro, aunque haya cambiado desde que se mostró.