Um evento para "Posição:fixa do CSS"

Texto longo, leia o resumo

Aqui está um segredo: talvez você não precise de eventos scroll no seu próximo app. Usando um IntersectionObserver, eu mostro como disparar um evento personalizado quando elementos position:sticky são corrigidos ou quando param de ser vinculados. Tudo isso sem o uso de listeners de rolagem. Há até uma demonstração incrível para provar:

Confira a demonstração | Fonte

Apresentação do evento sticky-change

Uma das limitações práticas do uso da posição fixa do CSS é que ele não fornece um indicador da plataforma para saber quando a propriedade está ativa. Em outras palavras, não há evento para saber quando um elemento se torna fixo ou quando ele para de ser fixo.

Confira o exemplo abaixo, que corrige uma <div class="sticky"> de 10 pixels da parte de cima do contêiner pai:

.sticky {
  position: sticky;
  top: 10px;
}

Não seria bom se o navegador informasse quando os elementos alcançassem essa marca? Aparentemente, não sou a única pessoa que tem essa opinião. Um sinal para position:sticky pode possibilitar vários casos de uso:

  1. Aplique uma sombra projetada a um banner enquanto ele é fixado.
  2. À medida que um usuário lê seu conteúdo, registre os hits de análise para saber o progresso dele.
  3. À medida que o usuário rola a página, atualize um widget de TOC flutuante para a seção atual.

Com esses casos de uso em mente, criamos uma meta final: criar um evento que é disparado quando um elemento position:sticky é fixo. Vamos chamá-lo de evento sticky-change:

document.addEventListener('sticky-change', e => {
  const header = e.detail.target;  // header became sticky or stopped sticking.
  const sticking = e.detail.stuck; // true when header is sticky.
  header.classList.toggle('shadow', sticking); // add drop shadow when sticking.

  document.querySelector('.who-is-sticking').textContent = header.textContent;
});

A demonstração usa esse evento para adicionar uma sombra projetada ao cabeçalho quando elas são corrigidas. Ele também atualiza o novo título na parte superior da página.

Na demonstração, os efeitos são aplicados sem os eventos de rolagem.

Efeitos de rolagem sem eventos de rolagem?

Estrutura da página.
Estrutura da página.

Vamos remover um pouco da terminologia para que eu possa me referir a esses nomes em todo o restante da postagem:

  1. Contêiner de rolagem: a área de conteúdo (janela de visualização visível) que contém a lista de "postagens do blog".
  2. Headers: título azul em cada seção que tem position:sticky.
  3. Seções fixas: cada seção de conteúdo. O texto que rola abaixo dos cabeçalhos fixos.
  4. "Modo aderente": quando position:sticky é aplicado ao elemento.

Para saber qual cabeçalho entra no "modo fixo", precisamos de alguma maneira de determinar o deslocamento de rolagem do contêiner de rolagem. Isso nos daria uma maneira de calcular o header que está sendo exibido. No entanto, isso fica muito complicado sem eventos scroll :) O outro problema é que position:sticky remove o elemento do layout quando ele é corrigido.

Assim, sem eventos de rolagem, perdemos a capacidade de realizar cálculos relacionados ao layout nos cabeçalhos.

Adicionar um DOM fictício para determinar a posição de rolagem

Em vez de eventos scroll, vamos usar um IntersectionObserver para determinar quando os headers entram e saem do modo tecla fixa. A adição de dois nós (também conhecidos como sentinelas) em cada seção fixa, um na parte superior e outro na parte inferior funciona como waypoints para descobrir a posição de rolagem. À medida que esses marcadores entram e saem do contêiner, a visibilidade deles muda, e o Intersection Observer aciona um callback.

Sem elementos de sentinela aparecendo
Os elementos de sentinela ocultos.

Precisamos de duas sentinelas para cobrir quatro casos de rolagem para cima e para baixo:

  1. Rolar para baixo: o cabeçalho fica fixo quando a sentinela superior cruza a parte de cima do contêiner.
  2. Rolar para baixo: o cabeçalho sai do modo fixo ao chegar à parte de baixo da seção e a sentinela inferior cruza a parte de cima do contêiner.
  3. Rolagem para cima: o cabeçalho sai do modo fixo quando a sentinela superior rola de volta para a visualização.
  4. Rolar para cima: o cabeçalho fica fixo à medida que a sentinela inferior cruza de volta para a visualização a partir do topo.

Um screencast de 1 a 4 é útil na ordem em que acontecem:

Os observadores de intersecção disparam callbacks quando as sentinelas entram/saem do contêiner de rolagem.

O CSS

As sentinelas são posicionadas nas partes superior e inferior de cada seção. .sticky_sentinel--top fica na parte de cima do cabeçalho, enquanto .sticky_sentinel--bottom fica na parte de baixo da seção:

Sentinela inferior atingindo o limite.
Posição dos elementos de sentinela de cima e de baixo.
:root {
  --default-padding: 16px;
  --header-height: 80px;
}
.sticky {
  position: sticky;
  top: 10px; /* adjust sentinel height/positioning based on this position. */
  height: var(--header-height);
  padding: 0 var(--default-padding);
}
.sticky_sentinel {
  position: absolute;
  left: 0;
  right: 0; /* needs dimensions */
  visibility: hidden;
}
.sticky_sentinel--top {
  /* Adjust the height and top values based on your on your sticky top position.
  e.g. make the height bigger and adjust the top so observeHeaders()'s
  IntersectionObserver fires as soon as the bottom of the sentinel crosses the
  top of the intersection container. */
  height: 40px;
  top: -24px;
}
.sticky_sentinel--bottom {
  /* Height should match the top of the header when it's at the bottom of the
  intersection container. */
  height: calc(var(--header-height) + var(--default-padding));
  bottom: 0;
}

Como configurar o Intersection Observers

Os Intersection Observers observam de maneira assíncrona as mudanças na interseção de um elemento de destino e a janela de visualização do documento ou um contêiner pai. No nosso caso, estamos observando interseções com um contêiner pai.

O molho mágico é o IntersectionObserver. Cada sentinela recebe um IntersectionObserver para observar a visibilidade da interseção dentro do contêiner de rolagem. Quando uma sentinela rola até a janela de visualização visível, sabemos que um cabeçalho se fixa ou parou de ser fixo. Da mesma forma, quando uma sentinela saia da janela de visualização.

Primeiro, configurei observadores para as sentinelas de cabeçalho e rodapé:

/**
 * Notifies when elements w/ the `sticky` class begin to stick or stop sticking.
 * Note: the elements should be children of `container`.
 * @param {!Element} container
 */
function observeStickyHeaderChanges(container) {
  observeHeaders(container);
  observeFooters(container);
}

observeStickyHeaderChanges(document.querySelector('#scroll-container'));

Em seguida, adicionei um observador para disparar quando os elementos .sticky_sentinel--top passarem pela parte superior do contêiner de rolagem (em qualquer direção). A função observeHeaders cria as principais sentinelas e as adiciona a cada seção. O observador calcula a interseção da sentinela com o topo do contêiner e decide se ela entra ou sai da janela de visualização. Essas informações determinam se o cabeçalho da seção está sendo mantido ou não.

/**
 * Sets up an intersection observer to notify when elements with the class
 * `.sticky_sentinel--top` become visible/invisible at the top of the container.
 * @param {!Element} container
 */
function observeHeaders(container) {
  const observer = new IntersectionObserver((records, observer) => {
    for (const record of records) {
      const targetInfo = record.boundingClientRect;
      const stickyTarget = record.target.parentElement.querySelector('.sticky');
      const rootBoundsInfo = record.rootBounds;

      // Started sticking.
      if (targetInfo.bottom < rootBoundsInfo.top) {
        fireEvent(true, stickyTarget);
      }

      // Stopped sticking.
      if (targetInfo.bottom >= rootBoundsInfo.top &&
          targetInfo.bottom < rootBoundsInfo.bottom) {
       fireEvent(false, stickyTarget);
      }
    }
  }, {threshold: [0], root: container});

  // Add the top sentinels to each section and attach an observer.
  const sentinels = addSentinels(container, 'sticky_sentinel--top');
  sentinels.forEach(el => observer.observe(el));
}

O observador é configurado com threshold: [0] para que o callback seja disparado assim que a sentinela se torna visível.

O processo é semelhante para a sentinela inferior (.sticky_sentinel--bottom). Um segundo observador é criado para disparar quando os rodapés passam pela parte de baixo do contêiner de rolagem. A função observeFooters cria os nós da sentinela e os anexa a cada seção. O observador calcula a interseção da sentinela com o fundo do contêiner e decide se ela está entrando ou saindo. Essas informações determinam se o cabeçalho da seção está permaneando ou não.

/**
 * Sets up an intersection observer to notify when elements with the class
 * `.sticky_sentinel--bottom` become visible/invisible at the bottom of the
 * container.
 * @param {!Element} container
 */
function observeFooters(container) {
  const observer = new IntersectionObserver((records, observer) => {
    for (const record of records) {
      const targetInfo = record.boundingClientRect;
      const stickyTarget = record.target.parentElement.querySelector('.sticky');
      const rootBoundsInfo = record.rootBounds;
      const ratio = record.intersectionRatio;

      // Started sticking.
      if (targetInfo.bottom > rootBoundsInfo.top && ratio === 1) {
        fireEvent(true, stickyTarget);
      }

      // Stopped sticking.
      if (targetInfo.top < rootBoundsInfo.top &&
          targetInfo.bottom < rootBoundsInfo.bottom) {
        fireEvent(false, stickyTarget);
      }
    }
  }, {threshold: [1], root: container});

  // Add the bottom sentinels to each section and attach an observer.
  const sentinels = addSentinels(container, 'sticky_sentinel--bottom');
  sentinels.forEach(el => observer.observe(el));
}

O observador é configurado com threshold: [1] para que o callback seja acionado quando todo o nó estiver na visualização.

Por fim, há meus dois utilitários para disparar o evento personalizado sticky-change e gerar as sentinelas:

/**
 * @param {!Element} container
 * @param {string} className
 */
function addSentinels(container, className) {
  return Array.from(container.querySelectorAll('.sticky')).map(el => {
    const sentinel = document.createElement('div');
    sentinel.classList.add('sticky_sentinel', className);
    return el.parentElement.appendChild(sentinel);
  });
}

/**
 * Dispatches the `sticky-event` custom event on the target element.
 * @param {boolean} stuck True if `target` is sticky.
 * @param {!Element} target Element to fire the event on.
 */
function fireEvent(stuck, target) {
  const e = new CustomEvent('sticky-change', {detail: {stuck, target}});
  document.dispatchEvent(e);
}

Pronto!

Demonstração final

Criamos um evento personalizado quando elementos com position:sticky são fixos e adicionamos efeitos de rolagem sem o uso de eventos scroll.

Confira a demonstração | Fonte

Conclusão

Muitas vezes, me perguntei se o IntersectionObserver seria uma ferramenta útil para substituir alguns dos padrões de interface baseados em eventos do scroll que se desenvolveram ao longo dos anos. A resposta é sim e não. A semântica da API IntersectionObserver dificulta o uso para tudo. Mas, como mostrei aqui, é possível usá-lo para algumas técnicas interessantes.

Outra maneira de detectar mudanças de estilo?

Na verdade, não. O que precisávamos era uma maneira de observar as mudanças de estilo em um elemento DOM. Não há nada nas APIs da plataforma Web que permita observar as mudanças de estilo.

Um MutationObserver seria uma primeira escolha lógica, mas isso não funciona na maioria dos casos. Por exemplo, na demonstração, receberíamos um callback quando a classe sticky fosse adicionada a um elemento, mas não quando o estilo calculado do elemento mudasse. Lembre-se de que a classe sticky já foi declarada no carregamento de página.

No futuro, uma extensão "Style Mutation Observer" (em inglês) para Mutation Observers pode ser útil para observar mudanças nos estilos calculados de um elemento. position: sticky.