Como o livro de rolagem foi criado para compartilhar dicas e sugestões divertidas e assustadoras neste Chrometober.
Depois do Designcember, criamos o Chrometober para você este ano como uma forma de destacar e compartilhar conteúdo da Web da comunidade e da equipe do Chrome. O Designcember mostrou o uso de consultas de contêiner, mas este ano estamos mostrando a API CSS de animações vinculadas à rolagem.
Confira a experiência de rolagem de livros em web.dev/chrometober-2022.
Visão geral
O objetivo do projeto era oferecer uma experiência divertida que destacasse a API Animation Scroll-linked. Mas, além de ser divertida, a experiência também precisava ser responsiva e acessível. O projeto também foi uma ótima maneira de testar o polyfill da API que está em desenvolvimento ativo, além de testar diferentes técnicas e ferramentas em combinação. E tudo com um tema festivo de Halloween!
A estrutura da nossa equipe era assim:
- Tyler Reed: ilustração e design
- Jhey Tompkins: líder de arquitetura e criatividade
- Una Kravets: líder do projeto
- Bramus Van Damme: colaborador do site
- Adam Argyle: revisão de acessibilidade
- Aaron Forinton: redação
Como criar uma experiência de scrollytelling
As ideias para o Chrometober começaram a surgir no primeiro evento externo da nossa equipe, em maio de 2022. Uma coleção de rabiscos nos fez pensar em maneiras de um usuário rolar a tela ao longo de algum tipo de storyboard. Inspirados em videogames, consideramos uma experiência de rolagem por cenas como cemitérios e uma casa mal-assombrada.

Foi emocionante ter a liberdade criativa para levar meu primeiro projeto do Google em uma direção inesperada. Esse foi um protótipo inicial de como um usuário poderia navegar pelo conteúdo.
Conforme o usuário rola para os lados, os blocos giram e aumentam de tamanho. Mas decidi abandonar essa ideia porque queria garantir uma ótima experiência para os usuários em dispositivos de todos os tamanhos. Em vez disso, me inspirei no design de algo que eu já tinha feito. Em 2020, tive a sorte de ter acesso ao ScrollTrigger da GreenSock para criar demonstrações de lançamento.
Uma das demonstrações que criei foi um livro em CSS 3D em que as páginas viravam conforme você rolava, e isso parecia muito mais apropriado para o que queríamos para o Chrometober. A API de animações vinculadas à rolagem é uma substituição perfeita para essa funcionalidade. Ele também funciona bem com o scroll-snap, como você vai ver.
O ilustrador do projeto, Tyler Reed, foi ótimo em alterar o design conforme mudávamos de ideia. Tyler fez um trabalho fantástico ao pegar todas as ideias criativas que recebeu e dar vida a elas. Foi muito divertido discutir ideias juntos. Uma grande parte de como queríamos que isso funcionasse era ter recursos divididos em blocos isolados. Assim, poderíamos compor as cenas e escolher o que daria vida a elas.

A ideia principal era que, conforme o usuário avançasse no livro, ele pudesse acessar blocos de conteúdo. Eles também podiam interagir com toques de fantasia, incluindo os easter eggs que criamos na experiência. Por exemplo, um retrato em uma casa assombrada, com olhos que seguiam o ponteiro, ou animações sutis acionadas por consultas de mídia. Essas ideias e recursos seriam animados ao rolar a tela. Uma ideia inicial era um coelho zumbi que se levantava e se movia ao longo do eixo x quando o usuário rolava a tela.
Como conhecer a API
Antes de começarmos a brincar com recursos individuais e easter eggs, precisávamos de um livro. Por isso, decidimos aproveitar essa oportunidade para testar o conjunto de recursos da nova API CSS Scroll-Linked Animations. No momento, a API de animações vinculadas à rolagem não é compatível com nenhum navegador. No entanto, enquanto desenvolvem a API, os engenheiros da equipe de interações estão trabalhando em um polyfill. Isso permite testar o formato da API à medida que ela é desenvolvida. Isso significa que podemos usar essa API hoje, e projetos divertidos como esse costumam ser um ótimo lugar para testar recursos experimentais e dar feedback. Confira o que aprendemos e o feedback que conseguimos dar mais adiante no artigo.
Em termos gerais, é possível usar essa API para vincular animações à rolagem. É importante observar que não é possível acionar uma animação ao rolar a tela. Isso é algo que pode ser adicionado mais tarde. As animações vinculadas à rolagem também se dividem em duas categorias principais:
- Os que reagem à posição de rolagem.
- As que reagem à posição de um elemento no contêiner de rolagem.
Para criar o segundo, usamos um ViewTimeline aplicado por uma propriedade animation-timeline.
Veja um exemplo de como usar ViewTimeline no 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;
}
}
Criamos um ViewTimeline com view-timeline-name e definimos o eixo para ele. Neste exemplo, block se refere ao block lógico. A animação é vinculada à rolagem com a propriedade animation-timeline. animation-delay e animation-end-delay (no momento em que este artigo foi escrito) são como definimos as fases.
Essas fases definem os pontos em que a animação precisa ser vinculada em relação à posição de um elemento no contêiner de rolagem. No nosso exemplo, estamos dizendo para iniciar a animação quando o elemento entrar (enter 0%) no contêiner de rolagem. E terminar quando cobrir 50% (cover 50%) do contêiner de rolagem.
Confira nossa demonstração em ação:
Você também pode vincular uma animação ao elemento que está se movendo na janela de visualização. Para fazer isso, defina o animation-timeline como o view-timeline do elemento. Isso é bom para cenários como animações de lista. O comportamento é semelhante ao de animar elementos na entrada usando 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;
}
}
Com isso,"Mover" aumenta de tamanho ao entrar na janela de visualização, acionando a rotação de "Spinner".
Descobri que a API funciona muito bem com scroll-snap. O ajuste de rolagem combinado com ViewTimeline seria ótimo para ajustar as páginas de um livro.
Prototipagem da mecânica
Depois de alguns testes, consegui fazer um protótipo de livro funcionar. Você rola na horizontal para virar as páginas do livro.
Na demonstração, é possível ver os diferentes acionadores destacados com bordas tracejadas.
A marcação é mais ou menos assim:
<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>
Ao rolar, as páginas do livro viram, mas se abrem ou fecham de forma abrupta. Isso depende do alinhamento de ajuste de rolagem dos acionadores.
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;
}
Desta vez, não conectamos o ViewTimeline em CSS, mas usamos a API Web Animations em JavaScript. Isso tem o benefício adicional de poder repetir um conjunto de elementos e gerar o ViewTimeline de que precisamos, em vez de criar cada um manualmente.
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 acionador, geramos um ViewTimeline. Em seguida, animamos a página associada ao acionador usando esse ViewTimeline. Isso vincula a animação da página à rolagem. Para nossa animação, estamos girando um elemento da página no eixo y para virar a página. Também traduzimos a própria página no eixo Z para que ela se comporte como um livro.
Como tudo funciona em conjunto
Depois de definir o mecanismo do livro, pude me concentrar em dar vida às ilustrações do Tyler.
Astrofotografia
A equipe usou o Astro para o Designcember em 2021, e eu queria usá-lo novamente para o Chrometober. A experiência do desenvolvedor de poder dividir as coisas em componentes é adequada para este projeto.
O livro em si é um componente. Também é uma coleção de componentes de página. Cada página tem dois lados e planos de fundo. Os filhos de uma página são componentes que podem ser adicionados, removidos e posicionados com facilidade.
Como criar um livro
Para mim, era importante que os blocos fossem fáceis de gerenciar. Também queria facilitar as contribuições do restante da equipe.
As páginas em um nível alto são definidas por uma matriz de configuração. Cada objeto de página na matriz define o conteúdo, o plano de fundo e outros metadados de uma 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 */
]
Eles são transmitidos para o componente Book.
<Book pages={pages} />
O componente Book é onde o mecanismo de rolagem é aplicado e as páginas do livro são criadas. O mesmo mecanismo do protótipo é usado, mas compartilhamos várias instâncias de ViewTimeline que são criadas globalmente.
window.CHROMETOBER_TIMELINES.push(viewTimeline);
Dessa forma, podemos compartilhar as linhas do tempo para serem usadas em outros lugares, em vez de recriá-las. Saiba mais sobre isso mais adiante.
Composição da página
Cada página é um item de lista dentro de uma 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>
A configuração definida é transmitida para cada instância de Page. As páginas usam o recurso de slot do Astro para inserir conteúdo em 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>
Esse código serve principalmente para configurar a estrutura. Os colaboradores podem trabalhar no conteúdo do livro sem precisar tocar nesse código.
Pano de fundo
A mudança criativa para um livro facilitou muito a divisão das seções, e cada página dupla do livro é uma cena tirada do design original.

Como decidimos uma proporção para o livro, o plano de fundo de cada página pode ter um elemento de imagem. Definir esse elemento como 200% de largura e usar object-position com base no lado da página resolve o problema.
.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;
}
Conteúdo da página
Vamos criar uma das páginas. A página três mostra uma coruja que aparece em uma árvore.
Ele é preenchido com um componente PageThree, conforme definido na configuração. É um componente Astro (PageThree.astro). Esses componentes parecem arquivos HTML, mas têm um bloco de código na parte de cima, semelhante ao frontmatter. Isso permite que façamos coisas como importar outros componentes. O componente da página três é assim:
---
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>
As páginas são atômicas por natureza. Eles são criados com base em uma coleção de recursos. A página três tem um bloco de conteúdo e a coruja interativa, então há um componente para cada um.
Os blocos de conteúdo são os links para o conteúdo visto no livro. Eles também são orientados por um objeto de configuração.
{
"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
]
}
Essa configuração é importada quando os blocos de conteúdo são necessários. Em seguida, a configuração de bloco relevante é transmitida para o componente ContentBlock.
<ContentBlock {...contentBlocks[3]} id="four" />
Também há um exemplo de como usamos o componente da página como um local para posicionar o conteúdo. Aqui, um bloco de conteúdo é posicionado.
<style is:global>
.content-block--four {
left: 30%;
bottom: 10%;
}
</style>
No entanto, os estilos gerais de um bloco de conteúdo são colocados no mesmo local que o código do 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%;
}
A coruja é um recurso interativo, um dos muitos deste projeto. Este é um exemplo simples que mostra como usamos a ViewTimeline compartilhada que criamos.
Em geral, nosso componente de coruja importa um SVG e o incorpora usando o Fragment do Astro.
---
import { default as Owl } from '../Features/Owl.svg?raw'
---
<Fragment set:html={Owl} />
E os estilos para posicionar nossa coruja estão no mesmo local que o código do componente.
.owl {
width: 34%;
left: 10%;
bottom: 34%;
}
Há um elemento de estilo extra que define o comportamento de transform para a coruja.
.owl__owl {
transform-origin: 50% 100%;
transform-box: fill-box;
}
O uso de transform-box afeta o transform-origin. Ele o torna relativo à caixa delimitadora do objeto no SVG. A coruja aumenta de tamanho a partir do centro inferior, por isso o uso de transform-origin: 50% 100%.
A parte divertida é quando vinculamos a coruja a um dos ViewTimelines gerados:
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()
Nesse bloco de código, fazemos duas coisas:
- Verifique as preferências de movimento do usuário.
- Se não tiverem preferência, vincule uma animação da coruja à rolagem.
Na segunda parte, a coruja é animada no eixo y usando a API Web Animations. A propriedade de transformação individual translate é usada e vinculada a um ViewTimeline. Ele está vinculado a CHROMETOBER_TIMELINES[1] pela propriedade timeline. Este é um ViewTimeline gerado para as viradas de página. Isso vincula a animação da coruja à virada de página usando a fase enter. Ele define que, quando a página estiver 80% virada, a coruja vai começar a se mover. Aos 90%, a coruja deve terminar a tradução.
Recursos do livro
Agora você já conhece a abordagem para criar uma página e como funciona a arquitetura do projeto. É possível ver como ele permite que os colaboradores entrem e trabalhem em uma página ou recurso de sua escolha. Vários recursos do livro têm animações vinculadas à virada de página, como o morcego que entra e sai voando quando as páginas são viradas.
Ele também tem elementos que usam animações CSS.
Depois que os blocos de conteúdo foram adicionados ao livro, foi hora de usar a criatividade com outros recursos. Isso deu a oportunidade de gerar algumas interações diferentes e testar maneiras diferentes de implementar as coisas.
Como manter a responsividade
As unidades de janela de visualização responsivas dimensionam o livro e os recursos dele. No entanto, manter as fontes responsivas foi um desafio interessante. As unidades de consulta de contêiner são uma boa opção aqui. No entanto, eles ainda não estão disponíveis em todos os lugares. O tamanho do livro é definido, então não precisamos de uma consulta de contêiner. Uma unidade de consulta de contêiner inline pode ser gerada com CSS calc() e usada para dimensionar fontes.
.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);
}
Abóboras brilham à noite
Se você prestou atenção, deve ter notado o uso de elementos <source> ao discutirmos os planos de fundo da página anteriormente. Una queria uma interação que reagisse à preferência de esquema de cores. Como resultado, os planos de fundo são compatíveis com os modos claro e escuro com diferentes variantes. Como é possível usar consultas de mídia com o elemento <picture>, essa é uma ótima maneira de fornecer dois estilos de plano de fundo. O elemento <source> consulta a preferência de esquema de cores e mostra o plano de fundo adequado.
<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>
Você pode introduzir outras mudanças com base nessa preferência de esquema de cores. As abóboras na página dois reagem à preferência de esquema de cores do usuário. O SVG usado tem círculos que representam chamas, que são ampliadas e animadas no modo escuro.
.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 está olhando para você?
Se você conferir a página 10, vai notar algo. Você está sendo vigiado! Os olhos do retrato vão seguir o ponteiro conforme você se move pela página. O truque aqui é mapear o local do ponteiro para um valor de translação e transmiti-lo ao 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)
}
Esse código usa intervalos de entrada e saída e mapeia os valores fornecidos. Por exemplo, esse uso resultaria no valor 625.
mapRange(0, 100, 250, 1000, 50) // 625
Para o retrato, o valor de entrada é o ponto central de cada olho, mais ou menos uma distância de pixel. O intervalo de saída é o quanto os olhos podem se mover em pixels. Em seguida, a posição do ponteiro no eixo x ou y é transmitida como o valor. Para encontrar o ponto central dos olhos ao movê-los, eles são duplicados. Os originais não se movem, são transparentes e usados como referência.
Depois, é só juntar tudo e atualizar os valores da propriedade personalizada de CSS nos olhos para que eles possam se mover. Uma função é vinculada ao evento pointermove em relação ao window. Quando isso acontece, os limites de cada olho são usados para calcular os pontos centrais. Em seguida, a posição do ponteiro é mapeada para valores que são definidos como valores de propriedade personalizada nos olhos.
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)
})
}
Depois que os valores são transmitidos para o CSS, os estilos podem fazer o que quiserem com eles. A melhor parte é usar CSS clamp() para diferenciar o comportamento de cada olho sem precisar mexer no JavaScript de novo.
.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);
}
Lançar feitiços
Se você olhar a página seis, vai se sentir fascinado? Esta página mostra o design da nossa fantástica raposa mágica. Se você mover o ponteiro, poderá ver um efeito de rastro personalizado. Isso usa a animação de tela. Um elemento <canvas> fica acima do restante do conteúdo da página com pointer-events: none. Isso significa que os usuários ainda podem clicar nos blocos de conteúdo abaixo.
.wand-canvas {
height: 100%;
width: 200%;
pointer-events: none;
right: 0;
position: fixed;
}
Assim como o retrato detecta um evento pointermove em window, o elemento <canvas> também faz isso. No entanto, sempre que o evento é acionado, criamos um objeto para animar no elemento <canvas>. Esses objetos representam formas usadas no rastro do cursor. Eles têm coordenadas e uma tonalidade aleatória.
A função mapRange anterior é usada novamente, já que podemos usá-la para mapear o delta do ponteiro para size e rate. Os objetos são armazenados em uma matriz que é repetida quando os objetos são desenhados no elemento <canvas>. As propriedades de cada objeto informam ao elemento <canvas> onde as coisas devem ser desenhadas.
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 desenhar na tela, um loop é criado com requestAnimationFrame. O rastro do cursor só deve ser renderizado quando a página estiver visível. Temos um IntersectionObserver que atualiza e determina quais páginas estão em exibição. Se uma página estiver em exibição, os objetos serão renderizados como círculos na tela.
Em seguida, fazemos um loop na matriz blocks e desenhamos cada parte do rastro. Cada frame reduz o tamanho e altera a posição do objeto pelo rate. Isso produz o efeito de queda e escalonamento. Se o objeto encolher completamente, ele será removido da matriz 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)
}
Se a página sair da visualização, os listeners de eventos serão removidos, e o loop do frame de animação será cancelado. A matriz blocks também é limpa.
Veja o rastro do cursor em ação!
Análise de acessibilidade
É ótimo criar uma experiência divertida para explorar, mas não adianta se ela não for acessível aos usuários. A experiência de Adam nessa área foi fundamental para preparar o Chrometober para uma análise de acessibilidade antes do lançamento.
Algumas das áreas importantes abordadas:
- Garantir que o HTML usado seja semântico. Isso inclui elementos de ponto de referência adequados, como
<main>para o livro, o uso do elemento<article>para cada bloco de conteúdo e elementos<abbr>em que as siglas são apresentadas. Pensar no futuro enquanto o livro era criado tornou as coisas mais acessíveis. O uso de títulos e links facilita a navegação do usuário. O uso de uma lista para as páginas também significa que o número de páginas é anunciado pela tecnologia adaptativa. - Garantir que todas as imagens usem os atributos
altadequados. Para SVGs inline, o elementotitleestá presente quando necessário. - Usar atributos
ariaquando eles melhoram a experiência. O uso dearia-labelpara páginas e as laterais delas comunica ao usuário em qual página ele está. O uso dearia-describedBynos links "Leia mais" comunica o texto do bloco de conteúdo. Isso elimina a ambiguidade sobre o destino do link. - Sobre os blocos de conteúdo, é possível clicar em todo o card, não apenas no link "Leia mais".
- O uso de um
IntersectionObserverpara rastrear quais páginas estão em visualização foi mencionado anteriormente. Isso tem muitos benefícios que não estão relacionados apenas ao desempenho. As páginas que não estiverem visíveis terão as animações ou interações pausadas. Mas essas páginas também têm o atributoinertaplicado. Isso significa que os usuários que usam um leitor de tela podem acessar o mesmo conteúdo que os usuários com visão. O foco permanece na página que está em exibição, e os usuários não podem usar a tecla Tab para acessar outra página. - Por último, mas não menos importante, usamos consultas de mídia para respeitar a preferência do usuário por movimento.
Confira uma captura de tela da análise que destaca algumas das medidas em vigor.
é identificado como ao redor de todo o livro, indicando que ele deve ser o principal ponto de referência para os usuários de tecnologia adaptativa encontrarem. A opção "Mais" está destacada na captura de tela." width="800" height="465">

O que descobrimos
O objetivo do Chrometober não era apenas destacar o conteúdo da Web da comunidade, mas também testar o polyfill da API Scroll-Linked Animations, que está em desenvolvimento.
Durante nossa reunião de equipe em Nova York, reservamos uma sessão para testar o projeto e resolver os problemas que surgiram. A contribuição da equipe foi inestimável. Também foi uma ótima oportunidade para listar tudo o que precisava ser resolvido antes de entrarmos no ar.

Por exemplo, o teste do livro em dispositivos levantou um problema de renderização. Nosso livro não seria renderizado como esperado em dispositivos iOS. As unidades da janela de visualização dimensionam a página, mas, quando havia um notch, isso afetava o livro. A solução foi usar viewport-fit=cover na janela de visualização meta:
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
Essa sessão também levantou alguns problemas com o polyfill da API. Bramus levantou esses problemas no repositório de polyfill. Depois, ele encontrou soluções para esses problemas e as mesclou ao polyfill. Por exemplo, esta solicitação de pull (link em inglês) melhorou o desempenho adicionando armazenamento em cache a parte do polyfill.


Pronto!
Foi um projeto muito divertido de trabalhar, que resultou em uma experiência de rolagem lúdica que destaca o conteúdo incrível da comunidade. Além disso, tem sido ótimo para testar o polyfill e fornecer feedback à equipe de engenharia para ajudar a melhorar o polyfill.
O Chrometober 2022 acabou.
Esperamos que você tenha gostado. Qual é seu recurso favorito? Envie um tweet para mim e conte o que você achou.

Você pode até ganhar alguns adesivos de um membro da equipe se encontrar a gente em um evento.