Cómo cobró vida el libro con desplazamiento para compartir sugerencias y trucos divertidos y aterradores este Chrometober.
Después de Designcember, este año quisimos crear Chrometober para ti como una forma de destacar y compartir contenido web de la comunidad y del equipo de Chrome. En Designcember, se mostró el uso de las consultas de contenedores, pero este año mostraremos la API de animaciones vinculadas al desplazamiento de CSS.
Consulta la experiencia de desplazamiento de libros en web.dev/chrometober-2022.
Descripción general
El objetivo del proyecto era ofrecer una experiencia divertida que destacara la API de animaciones vinculadas al desplazamiento. Sin embargo, además de ser divertida, la experiencia también debía ser responsiva y accesible. El proyecto también ha sido una excelente manera de probar el polyfill de la API que está en desarrollo activo, así como de probar diferentes técnicas y herramientas en combinación. Y todo con una temática festiva de Halloween.
La estructura de nuestro equipo se veía así:
- Tyler Reed: Ilustración y diseño
- Jhey Tompkins: Líder de arquitectura y creatividad
- Una Kravets: Líder del proyecto
- Bramus Van Damme: Colaborador del sitio
- Adam Argyle: Revisión de accesibilidad
- Aaron Forinton: Redacción de textos
Cómo redactar una experiencia de scrollytelling
Las ideas para Chrometober comenzaron a surgir en nuestra primera reunión externa del equipo en mayo de 2022. Una colección de garabatos nos hizo pensar en formas en que un usuario podría desplazarse por algún tipo de guion gráfico. Inspirados en los videojuegos, consideramos una experiencia de desplazamiento por escenas como cementerios y una casa embrujada.

Fue emocionante tener la libertad creativa para llevar mi primer proyecto de Google en una dirección inesperada. Este fue un prototipo inicial de cómo un usuario podría navegar por el contenido.
A medida que el usuario se desplaza hacia los lados, los bloques rotan y se acercan. Sin embargo, decidí descartar esta idea porque me preocupaba cómo podríamos hacer que esta experiencia fuera excelente para los usuarios en dispositivos de todos los tamaños. En cambio, me incliné por el diseño de algo que había hecho en el pasado. En 2020, tuve la suerte de tener acceso a ScrollTrigger de GreenSock para crear demostraciones de lanzamiento.
Una de las demostraciones que creé fue un libro en 3D-CSS en el que las páginas se daban vuelta a medida que te desplazabas, y esto parecía mucho más apropiado para lo que queríamos para Chrometober. La API de animaciones vinculadas al desplazamiento es un reemplazo perfecto para esa funcionalidad. También funciona bien con scroll-snap, como verás.
Nuestro ilustrador para el proyecto, Tyler Reed, fue excelente para modificar el diseño a medida que cambiábamos de idea. Tyler hizo un trabajo fantástico al tomar todas las ideas creativas que se le presentaron y darles vida. Fue muy divertido intercambiar ideas. Una gran parte de cómo queríamos que funcionara esto era tener funciones divididas en bloques aislados. De esa manera, podíamos componerlas en escenas y, luego, elegir qué darles vida.

La idea principal era que, a medida que el usuario avanzaba por el libro, pudiera acceder a bloques de contenido. También podían interactuar con toques de fantasía, incluidos los huevos de Pascua que habíamos incorporado en la experiencia; por ejemplo, un retrato en una casa embrujada, cuyos ojos seguían el puntero, o animaciones sutiles activadas por consultas de medios. Estas ideas y funciones se animarían al desplazarse. Una de las primeras ideas fue un conejo zombi que se levantaba y se desplazaba por el eje X cuando el usuario se desplazaba.
Familiarízate con la API
Antes de empezar a jugar con las funciones individuales y los huevos de Pascua, necesitábamos un libro. Por lo tanto, decidimos aprovechar esta oportunidad para probar el conjunto de funciones de la nueva API de animaciones vinculadas al desplazamiento de CSS. Actualmente, la API de animaciones vinculadas al desplazamiento no es compatible con ningún navegador. Sin embargo, mientras desarrollan la API, los ingenieros del equipo de interacciones han estado trabajando en un polyfill. Esto proporciona una forma de probar la forma de la API a medida que se desarrolla. Eso significa que podríamos usar esta API hoy, y los proyectos divertidos como este suelen ser un excelente lugar para probar funciones experimentales y proporcionar comentarios. Descubre lo que aprendimos y los comentarios que pudimos proporcionar más adelante en el artículo.
En términos generales, puedes usar esta API para vincular animaciones al desplazamiento. Es importante tener en cuenta que no puedes activar una animación con el desplazamiento, ya que esto podría ocurrir más adelante. Las animaciones vinculadas al desplazamiento también se dividen en dos categorías principales:
- Los que reaccionan a la posición de desplazamiento
- Las que reaccionan a la posición de un elemento en su contenedor de desplazamiento.
Para crear este último, usamos un ViewTimeline que se aplica a través de una propiedad animation-timeline.
Este es un ejemplo de cómo se ve el uso de ViewTimeline en CSS:
.element-moving-in-viewport {
view-timeline-name: foo;
view-timeline-axis: block;
}
.element-scroll-linked {
animation: rotate both linear;
animation-timeline: foo;
animation-delay: enter 0%;
animation-end-delay: cover 50%;
}
@keyframes rotate {
to {
rotate: 360deg;
}
}
Creamos un ViewTimeline con view-timeline-name y definimos el eje para él. En este ejemplo, block hace referencia a la block lógica. La animación se vincula al desplazamiento con la propiedad animation-timeline. animation-delay y animation-end-delay (en el momento de escribir este artículo) son la forma en que definimos las fases.
Estas fases definen los puntos en los que se debe vincular la animación en relación con la posición de un elemento en su contenedor de desplazamiento. En nuestro ejemplo, indicamos que la animación comience cuando el elemento ingrese (enter 0%) al contenedor de desplazamiento. Y finalizar cuando haya cubierto el 50% (cover 50%) del contenedor de desplazamiento.
Aquí tienes nuestra demostración en acción:
También puedes vincular una animación al elemento que se mueve en el viewport. Para ello, establece el animation-timeline como el view-timeline del elemento. Esto es útil para situaciones como las animaciones de listas. El comportamiento es similar a cómo animarías los elementos en la entrada con IntersectionObserver.
element-moving-in-viewport {
view-timeline-name: foo;
view-timeline-axis: block;
animation: scale both linear;
animation-delay: enter 0%;
animation-end-delay: cover 50%;
animation-timeline: foo;
}
@keyframes scale {
0% {
scale: 0;
}
}
Con esto,"Mover" se escala a medida que ingresa a la ventana de visualización, lo que activa la rotación de "Spinner".
Lo que descubrí al experimentar fue que la API funciona muy bien con scroll-snap. El ajuste de desplazamiento combinado con ViewTimeline sería ideal para ajustar los cambios de página en un libro.
Creación de prototipos de las mecánicas
Después de experimentar un poco, logré que funcionara un prototipo de libro. Desplázate horizontalmente para pasar las páginas del libro.
En la demostración, puedes ver los diferentes activadores destacados con bordes punteados.
El lenguaje de marcado se ve de la siguiente manera:
<body>
<div class="book-placeholder">
<ul class="book" style="--count: 7;">
<li
class="page page--cover page--cover-front"
data-scroll-target="1"
style="--index: 0;"
>
<div class="page__paper">
<div class="page__side page__side--front"></div>
<div class="page__side page__side--back"></div>
</div>
</li>
<!-- Markup for other pages here -->
</ul>
</div>
<div>
<p>intro spacer</p>
</div>
<div data-scroll-intro>
<p>scale trigger</p>
</div>
<div data-scroll-trigger="1">
<p>page trigger</p>
</div>
<!-- Markup for other triggers here -->
</body>
A medida que te desplazas, las páginas del libro se pasan, pero se abren o cierran de golpe. Esto depende de la alineación de ajuste de desplazamiento de los activadores.
html {
scroll-snap-type: x mandatory;
}
body {
grid-template-columns: repeat(var(--trigger-count), auto);
overflow-y: hidden;
overflow-x: scroll;
display: grid;
}
body > [data-scroll-trigger] {
height: 100vh;
width: clamp(10rem, 10vw, 300px);
}
body > [data-scroll-trigger] {
scroll-snap-align: end;
}
Esta vez, no conectamos el ViewTimeline en CSS, sino que usamos la API de Web Animations en JavaScript. Esto tiene el beneficio adicional de poder recorrer un conjunto de elementos y generar el ViewTimeline que necesitamos, en lugar de crearlos uno por uno de forma manual.
const triggers = document.querySelectorAll("[data-scroll-trigger]")
const commonProps = {
delay: { phase: "enter", percent: CSS.percent(0) },
endDelay: { phase: "enter", percent: CSS.percent(100) },
fill: "both"
}
const setupPage = (trigger, index) => {
const target = document.querySelector(
`[data-scroll-target="${trigger.getAttribute("data-scroll-trigger")}"]`
);
const viewTimeline = new ViewTimeline({
subject: trigger,
axis: 'inline',
});
target.animate(
[
{
transform: `translateZ(${(triggers.length - index) * 2}px)`
},
{
transform: `translateZ(${(triggers.length - index) * 2}px)`,
offset: 0.75
},
{
transform: `translateZ(${(triggers.length - index) * -1}px)`
}
],
{
timeline: viewTimeline,
…commonProps,
}
);
target.querySelector(".page__paper").animate(
[
{
transform: "rotateY(0deg)"
},
{
transform: "rotateY(-180deg)"
}
],
{
timeline: viewTimeline,
…commonProps,
}
);
};
const triggers = document.querySelectorAll('[data-scroll-trigger]')
triggers.forEach(setupPage);
Para cada activador, generamos un ViewTimeline. Luego, animamos la página asociada del activador con ese ViewTimeline. Eso vincula la animación de la página al desplazamiento. Para nuestra animación, rotamos un elemento de la página en el eje Y para pasar la página. También traducimos la página en el eje Z para que se comporte como un libro.
Revisión general
Una vez que definí el mecanismo del libro, pude enfocarme en darles vida a las ilustraciones de Tyler.
Astrofotografía
El equipo usó Astro para Designcember en 2021 y yo quería volver a usarlo para Chrometober. La experiencia del desarrollador de poder dividir las cosas en componentes es muy adecuada para este proyecto.
El libro en sí es un componente. También es una colección de componentes de página. Cada página tiene dos lados y fondos. Los elementos secundarios de un lado de la página son componentes que se pueden agregar, quitar y posicionar con facilidad.
Cómo crear un libro
Para mí, era importante que los bloques fueran fáciles de administrar. También quería que el resto del equipo pudiera hacer contribuciones con facilidad.
Las páginas de alto nivel se definen mediante un array de configuración. Cada objeto de página del array define el contenido, el fondo y otros metadatos de una página.
const pages = [
{
front: {
marked: true,
content: PageTwo,
backdrop: spreadOne,
darkBackdrop: spreadOneDark
},
back: {
content: PageThree,
backdrop: spreadTwo,
darkBackdrop: spreadTwoDark
},
aria: `page 1`
},
/* Obfuscated page objects */
]
Estos se pasan al componente Book.
<Book pages={pages} />
El componente Book es donde se aplica el mecanismo de desplazamiento y se crean las páginas del libro. Se usa el mismo mecanismo del prototipo, pero compartimos varias instancias de ViewTimeline que se crean de forma global.
window.CHROMETOBER_TIMELINES.push(viewTimeline);
De esta manera, podemos compartir las líneas de tiempo para usarlas en otros lugares en vez de volver a crearlas. Veremos eso más adelante.
Composición de la página
Cada página es un elemento de lista dentro de una lista:
<ul class="book">
{
pages.map((page, index) => {
const FrontSlot = page.front.content
const BackSlot = page.back.content
return (
<Page
index={index}
cover={page.cover}
aria={page.aria}
backdrop={
{
front: {
light: page.front.backdrop,
dark: page.front.darkBackdrop
},
back: {
light: page.back.backdrop,
dark: page.back.darkBackdrop
}
}
}>
{page.front.content && <FrontSlot slot="front" />}
{page.back.content && <BackSlot slot="back" />}
</Page>
)
})
}
</ul>
Y la configuración definida se pasa a cada instancia de Page. Las páginas usan la función de ranura de Astro para insertar contenido en cada página.
<li
class={className}
data-scroll-target={target}
style={`--index:${index};`}
aria-label={aria}
>
<div class="page__paper">
<div
class="page__side page__side--front"
aria-label={`Right page of ${index}`}
>
<picture>
<source
srcset={darkFront}
media="(prefers-color-scheme: dark)"
height="214"
width="150"
>
<img
src={lightFront}
class="page__background page__background--right"
alt=""
aria-hidden="true"
height="214"
width="150"
>
</picture>
<div class="page__content">
<slot name="front" />
</div>
</div>
<!-- Markup for back page -->
</div>
</li>
Este código sirve principalmente para configurar la estructura. Los colaboradores pueden trabajar en el contenido del libro en su mayor parte sin tener que tocar este código.
Fondos
El cambio creativo hacia un libro facilitó mucho la división de las secciones, y cada página doble del libro es una escena tomada del diseño original.

Como habíamos decidido una relación de aspecto para el libro, el fondo de cada página podía tener un elemento de imagen. Para lograrlo, configura el ancho de ese elemento en 200% y usa object-position según el lado de la página.
.page__background {
height: 100%;
width: 200%;
object-fit: cover;
object-position: 0 0;
position: absolute;
top: 0;
left: 0;
}
.page__background--right {
object-position: 100% 0;
}
Contenido de la página
Veamos cómo crear una de las páginas. En la página tres, aparece un búho en un árbol.
Se propaga con un componente PageThree, como se define en la configuración. Es un componente de Astro (PageThree.astro). Estos componentes se ven como archivos HTML, pero tienen un bloque de código en la parte superior similar a los metadatos iniciales. Esto nos permite realizar acciones como importar otros componentes. El componente de la página tres se ve de la siguiente manera:
---
import TreeOwl from '../TreeOwl/TreeOwl.astro'
import { contentBlocks } from '../../assets/content-blocks.json'
import ContentBlock from '../ContentBlock/ContentBlock.astro'
---
<TreeOwl/>
<ContentBlock {...contentBlocks[3]} id="four" />
<style is:global>
.content-block--four {
left: 30%;
bottom: 10%;
}
</style>
Nuevamente, las páginas son de naturaleza atómica. Se crean a partir de una colección de atributos. La página tres incluye un bloque de contenido y el búho interactivo, por lo que hay un componente para cada uno.
Los bloques de contenido son los vínculos al contenido que se ve en el libro. Estas también se controlan con un objeto de configuración.
{
"contentBlocks": [
{
"id": "one",
"title": "New in Chrome",
"blurb": "Lift your spirits with a round up of all the tools and features in Chrome.",
"link": "https://www.youtube.com/watch?v=qwdN1fJA_d8&list=PLNYkxOF6rcIDfz8XEA3loxY32tYh7CI3m"
},
…otherBlocks
]
}
Esta configuración se importa donde se requieren bloques de contenido. Luego, la configuración del bloque pertinente se pasa al componente ContentBlock.
<ContentBlock {...contentBlocks[3]} id="four" />
También hay un ejemplo de cómo usamos el componente de la página como un lugar para posicionar el contenido. Aquí se posiciona un bloque de contenido.
<style is:global>
.content-block--four {
left: 30%;
bottom: 10%;
}
</style>
Sin embargo, los estilos generales de un bloque de contenido se ubican junto con el código del componente.
.content-block {
background: hsl(0deg 0% 0% / 70%);
color: var(--gray-0);
border-radius: min(3vh, var(--size-4));
padding: clamp(0.75rem, 2vw, 1.25rem);
display: grid;
gap: var(--size-2);
position: absolute;
cursor: pointer;
width: 50%;
}
En cuanto a nuestro búho, es un elemento interactivo, uno de los muchos que hay en este proyecto. Este es un buen ejemplo breve para revisar que muestra cómo usamos la ViewTimeline compartida que creamos.
A nivel general, nuestro componente de búho importa un SVG y lo integra con el Fragment de Astro.
---
import { default as Owl } from '../Features/Owl.svg?raw'
---
<Fragment set:html={Owl} />
Y los estilos para posicionar nuestro búho se encuentran junto con el código del componente.
.owl {
width: 34%;
left: 10%;
bottom: 34%;
}
Hay un elemento de diseño adicional que define el comportamiento de transform para el búho.
.owl__owl {
transform-origin: 50% 100%;
transform-box: fill-box;
}
El uso de transform-box afecta el transform-origin. Hace que sea relativo al cuadro delimitador del objeto dentro del SVG. El búho se escala desde la parte inferior central, por lo que se usa transform-origin: 50% 100%.
La parte divertida es cuando vinculamos el búho a uno de nuestros ViewTimeline generados:
const setUpOwl = () => {
const owl = document.querySelector('.owl__owl');
owl.animate([
{
translate: '0% 110%',
},
{
translate: '0% 10%',
},
], {
timeline: CHROMETOBER_TIMELINES[1],
delay: { phase: "enter", percent: CSS.percent(80) },
endDelay: { phase: "enter", percent: CSS.percent(90) },
fill: 'both'
});
}
if (window.matchMedia('(prefers-reduced-motion: no-preference)').matches)
setUpOwl()
En este bloque de código, hacemos dos cosas:
- Verifica las preferencias de movimiento del usuario.
- Si no tiene ninguna preferencia, vincula una animación del búho para que se desplace.
En la segunda parte, el búho se anima en el eje Y con la API de Web Animations. Se usa la propiedad de transformación individual translate, que está vinculada a un ViewTimeline. Está vinculado a CHROMETOBER_TIMELINES[1] a través de la propiedad timeline. Este es un ViewTimeline que se genera para los cambios de página. Esto vincula la animación del búho al cambio de página con la fase enter. Define que, cuando la página se haya girado un 80%, se empiece a mover el búho. Al 90%, el búho debería terminar su traducción.
Funciones de libros
Ya viste el enfoque para compilar una página y cómo funciona la arquitectura del proyecto. Puedes ver cómo permite que los colaboradores se unan y trabajen en una página o función de su elección. Varias funciones del libro tienen sus animaciones vinculadas al cambio de página del libro; por ejemplo, el murciélago que entra y sale volando cuando se cambia de página.
También tiene elementos que se basan en animaciones de CSS.
Una vez que los bloques de contenido estuvieron en el libro, llegó el momento de ponerse creativos con otras funciones. Esto brindó la oportunidad de generar algunas interacciones diferentes y probar distintas formas de implementar las cosas.
Cómo mantener la capacidad de respuesta
Las unidades de viewport responsivas ajustan el tamaño del libro y sus funciones. Sin embargo, mantener las fuentes responsivas fue un desafío interesante. Las unidades de consulta de contenedor son una buena opción en este caso. Sin embargo, aún no se admiten en todas partes. El tamaño del libro está establecido, por lo que no necesitamos una consulta de contenedor. Se puede generar una unidad de consulta de contenedor intercalada con CSS calc() y usarla para el tamaño de la fuente.
.book-placeholder {
--size: clamp(12rem, 72vw, 80vmin);
--aspect-ratio: 360 / 504;
--cqi: calc(0.01 * (var(--size) * (var(--aspect-ratio))));
}
.content-block h2 {
color: var(--gray-0);
font-size: clamp(0.6rem, var(--cqi) * 4, 1.5rem);
}
.content-block :is(p, a) {
font-size: clamp(0.6rem, var(--cqi) * 3, 1.5rem);
}
Calabazas que brillan en la noche
Quienes tengan un ojo agudo pueden haber notado el uso de elementos <source> cuando se habló de los fondos de página anteriormente. Una quería tener una interacción que reaccionara a la preferencia de esquema de colores. Como resultado, los fondos admiten los modos claro y oscuro con diferentes variantes. Como puedes usar consultas de medios con el elemento <picture>, es una excelente manera de proporcionar dos estilos de fondo. El elemento <source> consulta la preferencia de esquema de colores y muestra el fondo adecuado.
<picture>
<source srcset={darkFront} media="(prefers-color-scheme: dark)" height="214" width="150">
<img src={lightFront} class="page__background page__background--right" alt="" aria-hidden="true" height="214" width="150">
</picture>
Podrías introducir otros cambios según esa preferencia de esquema de colores. Las calabazas de la página dos reaccionan a la preferencia de esquema de colores del usuario. El SVG que se usa tiene círculos que representan llamas, que se amplían y se animan en el modo oscuro.
.pumpkin__flame,
.pumpkin__flame circle {
transform-box: fill-box;
transform-origin: 50% 100%;
}
.pumpkin__flame {
scale: 0.8;
}
.pumpkin__flame circle {
transition: scale 0.2s;
scale: 0;
}
@media(prefers-color-scheme: dark) {
.pumpkin__flame {
animation: pumpkin-flicker 3s calc(var(--index, 0) * -1s) infinite linear;
}
.pumpkin__flame circle {
scale: 1;
}
@keyframes pumpkin-flicker {
50% {
scale: 1;
}
}
}
¿Este retrato te está mirando?
Si revisas la página 10, es posible que notes algo. ¡Te están vigilando! Los ojos del retrato seguirán el puntero a medida que te muevas por la página. El truco aquí es asignar la ubicación del puntero a un valor de traducción y pasarlo a CSS.
const mapRange = (inputLower, inputUpper, outputLower, outputUpper, value) => {
const INPUT_RANGE = inputUpper - inputLower
const OUTPUT_RANGE = outputUpper - outputLower
return outputLower + (((value - inputLower) / INPUT_RANGE) * OUTPUT_RANGE || 0)
}
Este código toma rangos de entrada y salida, y asigna los valores dados. Por ejemplo, este uso daría el valor 625.
mapRange(0, 100, 250, 1000, 50) // 625
Para el retrato, el valor de entrada es el punto central de cada ojo, más o menos cierta distancia en píxeles. El rango de salida es cuánto se pueden mover los ojos en píxeles. Luego, la posición del puntero en el eje X o Y se pasa como el valor. Para obtener el punto central de los ojos mientras se mueven, se duplican. Los originales no se mueven, son transparentes y se usan como referencia.
Luego, se trata de vincularlo y actualizar los valores de la propiedad personalizada de CSS en los ojos para que se puedan mover. Se vincula una función al evento pointermove en el window. Cuando esto se activa, los límites de cada ojo se usan para calcular los puntos centrales. Luego, la posición del puntero se asigna a valores que se establecen como valores de propiedad personalizados en los ojos.
const RANGE = 15
const LIMIT = 80
const interact = ({ x, y }) => {
// map a range against the eyes and pass in via custom properties
const LEFT_EYE_BOUNDS = LEFT_EYE.getBoundingClientRect()
const RIGHT_EYE_BOUNDS = RIGHT_EYE.getBoundingClientRect()
const CENTERS = {
lx: LEFT_EYE_BOUNDS.left + LEFT_EYE_BOUNDS.width * 0.5,
rx: RIGHT_EYE_BOUNDS.left + RIGHT_EYE_BOUNDS.width * 0.5,
ly: LEFT_EYE_BOUNDS.top + LEFT_EYE_BOUNDS.height * 0.5,
ry: RIGHT_EYE_BOUNDS.top + RIGHT_EYE_BOUNDS.height * 0.5,
}
Object.entries(CENTERS)
.forEach(([key, value]) => {
const result = mapRange(value - LIMIT, value + LIMIT, -RANGE, RANGE)(key.indexOf('x') !== -1 ? x : y)
EYES.style.setProperty(`--${key}`, result)
})
}
Una vez que los valores se pasan a CSS, los estilos pueden hacer lo que quieran con ellos. Lo mejor de todo es usar CSS clamp() para que el comportamiento sea diferente para cada ojo, de modo que puedas hacer que cada ojo se comporte de manera diferente sin volver a tocar el JavaScript.
.portrait__eye--mover {
transition: translate 0.2s;
}
.portrait__eye--mover.portrait__eye--left {
translate:
clamp(-10px, var(--lx, 0) * 1px, 4px)
clamp(-4px, var(--ly, 0) * 0.5px, 10px);
}
.portrait__eye--mover.portrait__eye--right {
translate:
clamp(-4px, var(--rx, 0) * 1px, 10px)
clamp(-4px, var(--ry, 0) * 0.5px, 10px);
}
Lanzar hechizos
Si revisas la página seis, ¿te sientes cautivado? Esta página abarca el diseño de nuestro fantástico zorro mágico. Si mueves el puntero, es posible que veas un efecto de estela personalizado. Esto usa la animación de lienzo. Un elemento <canvas> se ubica por encima del resto del contenido de la página con pointer-events: none. Esto significa que los usuarios aún pueden hacer clic en los bloques de contenido que se encuentran debajo.
.wand-canvas {
height: 100%;
width: 200%;
pointer-events: none;
right: 0;
position: fixed;
}
Al igual que nuestro retrato escucha un evento pointermove en window, también lo hace nuestro elemento <canvas>. Sin embargo, cada vez que se activa el evento, creamos un objeto para animar en el elemento <canvas>. Estos objetos representan las formas que se usan en la estela del cursor. Tienen coordenadas y un tono aleatorio.
Nuestra función mapRange anterior se vuelve a usar, ya que podemos usarla para asignar el delta del puntero a size y rate. Los objetos se almacenan en un array que se repite cuando se dibujan en el elemento <canvas>. Las propiedades de cada objeto le indican a nuestro elemento <canvas> dónde se deben dibujar los elementos.
const blocks = []
const createBlock = ({ x, y, movementX, movementY }) => {
const LOWER_SIZE = CANVAS.height * 0.05
const UPPER_SIZE = CANVAS.height * 0.25
const size = mapRange(0, 100, LOWER_SIZE, UPPER_SIZE, Math.max(Math.abs(movementX), Math.abs(movementY)))
const rate = mapRange(LOWER_SIZE, UPPER_SIZE, 1, 5, size)
const { left, top, width, height } = CANVAS.getBoundingClientRect()
const block = {
hue: Math.random() * 359,
x: x - left,
y: y - top,
size,
rate,
}
blocks.push(block)
}
window.addEventListener('pointermove', createBlock)
Para dibujar en el lienzo, se crea un bucle con requestAnimationFrame. La estela del cursor solo debe renderizarse cuando la página está visible. Tenemos un IntersectionObserver que actualiza y determina qué páginas están a la vista. Si una página está a la vista, los objetos se renderizan como círculos en el lienzo.
Luego, recorremos el array blocks y dibujamos cada parte del rastro. Cada fotograma reduce el tamaño y altera la posición del objeto según el rate. Esto produce ese efecto de caída y escalamiento. Si el objeto se reduce por completo, se quita del array blocks.
let wandFrame
const drawBlocks = () => {
ctx.clearRect(0, 0, CANVAS.width, CANVAS.height)
if (PAGE_SIX.className.indexOf('in-view') === -1 && wandFrame) {
blocks.length = 0
cancelAnimationFrame(wandFrame)
document.body.removeEventListener('pointermove', createBlock)
document.removeEventListener('resize', init)
}
for (let b = 0; b < blocks.length; b++) {
const block = blocks[b]
ctx.strokeStyle = ctx.fillStyle = `hsla(${block.hue}, 80%, 80%, 0.5)`
ctx.beginPath()
ctx.arc(block.x, block.y, block.size * 0.5, 0, 2 * Math.PI)
ctx.stroke()
ctx.fill()
block.size -= block.rate
block.y += block.rate
if (block.size <= 0) {
blocks.splice(b, 1)
}
}
wandFrame = requestAnimationFrame(drawBlocks)
}
Si la página sale de la vista, se quitan los objetos de escucha de eventos y se cancela el bucle de fotogramas de animación. También se borra el array blocks.
Aquí puedes ver la estela del cursor en acción.
Revisión de accesibilidad
Está muy bien crear una experiencia divertida para explorar, pero no sirve de nada si no es accesible para los usuarios. La experiencia de Adam en esta área resultó invaluable para preparar Chrometober para una revisión de accesibilidad antes del lanzamiento.
Estas son algunas de las áreas destacadas que se abordan:
- Asegurarse de que el HTML utilizado fuera semántico. Esto incluyó elementos de referencia adecuados, como
<main>para el libro, el uso del elemento<article>para cada bloque de contenido y los elementos<abbr>donde se presentan las siglas. Pensar con anticipación mientras se creaba el libro hizo que las cosas fueran más accesibles. El uso de encabezados y vínculos facilita la navegación del usuario. El uso de una lista para las páginas también significa que la tecnología de accesibilidad anuncia la cantidad de páginas. - Asegurarse de que todas las imágenes usen los atributos
altadecuados En el caso de los SVG intercalados, el elementotitleestá presente donde es necesario. - Usa atributos
ariacuando mejoren la experiencia. El uso dearia-labelpara las páginas y sus lados le comunica al usuario en qué página se encuentra. El uso dearia-describedByen los vínculos "Leer más" comunica el texto del bloque de contenido. Esto elimina la ambigüedad sobre a dónde llevará el vínculo al usuario. - En cuanto a los bloques de contenido, se puede hacer clic en toda la tarjeta y no solo en el vínculo "Más información".
- Anteriormente, se mencionó el uso de un
IntersectionObserverpara hacer un seguimiento de las páginas que se están viendo. Esto tiene muchos beneficios que no solo se relacionan con el rendimiento. Las páginas que no estén a la vista tendrán pausada cualquier animación o interacción. Sin embargo, estas páginas también tienen aplicado el atributoinert. Esto significa que los usuarios que usan un lector de pantalla pueden explorar el mismo contenido que los usuarios videntes. El enfoque permanece dentro de la página que se está viendo y los usuarios no pueden usar la tecla Tab para ir a otra página. - Por último, pero no menos importante, usamos consultas de medios para respetar la preferencia de movimiento del usuario.
Aquí tienes una captura de pantalla de la revisión en la que se destacan algunas de las medidas implementadas.
se identifica como el elemento que rodea todo el libro, lo que indica que debe ser el punto de referencia principal que deben encontrar los usuarios de tecnologías de accesibilidad. More is outlined in the screenshot." width="800" height="465">

Qué aprendimos
La motivación detrás de Chrometober no solo era destacar el contenido web de la comunidad, sino que también era una forma de probar el polyfill de la API de animaciones vinculadas al desplazamiento que está en desarrollo.
Durante la cumbre de nuestro equipo en Nueva York, reservamos una sesión para probar el proyecto y abordar los problemas que surgieron. La contribución del equipo fue invaluable. También fue una gran oportunidad para enumerar todas las cosas que debíamos abordar antes de publicar el contenido.

Por ejemplo, cuando se probó el libro en dispositivos, se detectó un problema de renderización. Nuestro libro no se renderizaría como se espera en dispositivos iOS. Las unidades de viewport ajustan el tamaño de la página, pero cuando había un recorte, este afectaba al libro. La solución fue usar viewport-fit=cover en el viewport de meta:
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
En esta sesión, también se plantearon algunos problemas con el polyfill de la API. Bramus planteó estos problemas en el repositorio de polyfill. Posteriormente, encontró soluciones para esos problemas y las combinó en el polyfill. Por ejemplo, esta solicitud de extracción mejoró el rendimiento agregando almacenamiento en caché a parte del polyfill.


Eso es todo.
Fue un proyecto muy divertido, que dio como resultado una experiencia de desplazamiento fantástica que destaca el increíble contenido de la comunidad. No solo eso, sino que también ha sido excelente para probar el polyfill y proporcionar comentarios al equipo de ingeniería para ayudar a mejorarlo.
Chrometober 2022 llegó a su fin.
Esperamos que lo hayas disfrutado. ¿Cuál es tu función favorita? Envíame un tweet y cuéntanos.

Incluso podrías obtener algunas calcomanías de uno de los miembros del equipo si nos ves en un evento.