Langsung ke konten

Next.js: Cara Bikin Smart Sticky Toolbar, Biar Toolbar Gak Nutupin Bacaan Lagi

Oleh 10 menit baca

Toolbar di bawah artikel yang minggir saat kalian scroll turun dan muncul lagi saat scroll naik.

en
Tulisan Bikin Smart Sticky Toolbar di samping ilustrasi artikel dengan toolbar kecil di bagian bawahnya

Smart sticky toolbar adalah toolbar yang nempel di bagian bawah layar selama kalian membaca, minggir saat kalian scroll turun, dan muncul lagi begitu kalian scroll naik sedikit. Di Next.js 16, semuanya bisa dibikin cuma dengan satu listener scroll, satu IntersectionObserver, dan beberapa baris CSS, tanpa library tambahan. Per Oktober 2026 juga ada jalan pintas CSS murni lewat scroll-state(scrolled), tapi baru jalan di browser berbasis Chromium, jadi JavaScript masih jadi jalan utama.

Kalian pasti pernah ketemu situs yang header-nya makan sepertiga layar HP, di bawahnya ada banner cookie, lalu di pojok ada tombol chat yang melayang. Sisa ruang buat teksnya tinggal secuil. Toolbar di bawah setiap artikel aconymous.com lahir dari kekesalan yang sama. Gua pengin ukuran huruf, tombol bagikan, dan komentar selalu dekat, tapi gak ganggu orang yang lagi fokus baca.

Di tulisan ini gua bongkar cara bikinnya, dari logika arah scroll sampai detail aksesibilitas yang biasanya kelupaan. Semua kodenya udah gua uji di Next.js 16.4.2, dan di tengah artikel ada playground yang bisa langsung kalian mainkan.

Apa Itu Smart Sticky Toolbar?

Smart sticky toolbar adalah toolbar dengan posisi tetap di layar yang tahu kapan harus muncul dan kapan harus sembunyi. Bedanya dengan toolbar sticky biasa ada di tiga perilaku.

Pertama, dia cuma muncul di dalam artikel. Waktu pembaca masih di judul, belum ada yang butuh. Begitu sampai di komentar, dia harus minggir supaya gak nutupin tombol kirim. Kedua, dia membaca arah scroll. Scroll turun biasanya tanda orang lagi baca, jadi toolbar sembunyi. Scroll naik biasanya tanda orang lagi nyari sesuatu, jadi toolbar muncul. Ketiga, dia gak boleh jadi penghalang, baik buat mata, jempol, maupun keyboard.

Yang ketiga ini paling sering dilewatin, jadi nanti gua bahas di bagian sendiri.

Coba Dulu di Playground

Sebelum masuk ke kode, mungkin bisa dicoba dulu simulasinya. Scroll di dalam layar kecil di bawah ini, lalu ubah pengaturannya. Perhatikan nilai selisihnya. Gerakan yang lebih kecil dari ambang bakal diabaikan, dan toolbar baru mulai bereaksi setelah posisi scroll melewati titik "mulai bereaksi setelah".

Demo

Coba juga matikan "Cuma di dalam artikel", lalu scroll sampai ke komentar. Toolbar-nya bakal nongkrong tepat di atas kotak komentar, dan dari situ langsung kelihatan kenapa batas itu penting. Nyalakan "Kurangi gerakan", dan toolbar berhenti kabur-kaburan, persis seperti yang dialami orang yang mengaktifkan pengaturan itu di sistem operasinya.

Struktur Proyek

Gua mulai dari proyek Next.js 16 yang dibuat lewat create-next-app dengan pengaturan bawaan. Cuma file-file ini yang kita sentuh:

app/
├── layout.tsx
├── globals.css
├── _components/
│   ├── scroll-direction.tsx
│   └── site-header.tsx
└── blog/
    └── [slug]/
        ├── page.tsx
        └── reader-bar.tsx

Tugasnya sengaja dipisah. ScrollDirection cuma membaca arah scroll dan menulisnya sebagai atribut di elemen <html>. ReaderBar cuma tahu apakah pembaca lagi di dalam artikel. Urusan kapan muncul dan kapan sembunyi diserahkan ke CSS. Dengan begitu, header dan toolbar bisa bereaksi barengan tanpa saling kenal, dan React gak perlu render ulang setiap kali kalian scroll.

Langkah 1: Membaca Arah Scroll Tanpa Bikin Browser Ngos-ngosan

File app/_components/scroll-direction.tsx:

TypeScript
'use client'

import { useEffect } from 'react'

type Props = { threshold?: number; offset?: number }

export function ScrollDirection({ threshold = 8, offset = 120 }: Props) {
  useEffect(() => {
    const root = document.documentElement
    const calm = window.matchMedia('(prefers-reduced-motion: reduce)')
    let last = window.scrollY
    let frame = 0

    const set = (value: 'up' | 'down') => {
      if (root.dataset.scroll !== value) root.dataset.scroll = value
    }

    const read = () => {
      frame = 0
      const y = Math.max(0, window.scrollY)
      const delta = y - last
      if (calm.matches || y < offset) {
        set('up')
        last = y
        return
      }
      if (Math.abs(delta) < threshold) return
      set(delta > 0 ? 'down' : 'up')
      last = y
    }

    const onScroll = () => {
      if (!frame) frame = requestAnimationFrame(read)
    }

    const onFocus = (event: FocusEvent) => {
      if (event.target instanceof Element && event.target.closest('[data-sticky]')) set('up')
    }

    set('up')
    window.addEventListener('scroll', onScroll, { passive: true })
    document.addEventListener('focusin', onFocus)
    return () => {
      window.removeEventListener('scroll', onScroll)
      document.removeEventListener('focusin', onFocus)
      cancelAnimationFrame(frame)
      delete root.dataset.scroll
    }
  }, [threshold, offset])

  return null
}

Kodenya pendek, tapi ada beberapa keputusan kecil yang efeknya lumayan besar.

Listener-nya dipasang dengan { passive: true }. Ini janji ke browser bahwa listener kita gak akan memanggil preventDefault(), jadi browser bisa langsung menggulir halaman tanpa menunggu JavaScript selesai. Penjelasan lengkapnya ada di artikel Chrome soal passive event listeners.

Pembacaannya ditunda ke requestAnimationFrame supaya kerjanya nempel ke jadwal render browser. Selama masih ada frame yang menunggu, event berikutnya diabaikan, jadi logika kita jalan maksimal sekali per frame, mau layarnya 60 Hz atau 120 Hz.

Lalu ada threshold. Tanpa ambang, gesekan trackpad sekecil 1 piksel udah cukup bikin toolbar muncul, hilang, muncul lagi, dan pembaca bakal mengira layarnya kesurupan. Perhatikan juga, last cuma diperbarui kalau gerakannya melewati ambang. Jadi geseran kecil yang dicicil, misalnya 3 piksel lima kali, tetap terhitung sebagai satu gerakan 15 piksel.

Ambang gerak 8 piksel: gerakan scroll kecil di bawah ambang diabaikan, dan toolbar baru sembunyi atau muncul lagi setelah gerakannya melewati ambang
Geseran kecil diabaikan, toolbar baru bereaksi setelah gerakannya lewat 8 piksel.

Math.max(0, window.scrollY) ada untuk Safari di iPhone. Waktu halaman ditarik melewati batas atas, efek pantulnya bisa bikin scrollY bernilai negatif sesaat, dan tanpa pengaman itu arah scroll bisa terbaca terbalik.

offset menjaga header dan toolbar tetap tampil selama pembaca masih di 120 piksel pertama. Di area itu orang biasanya masih membaca judul, dan header yang tiba-tiba kabur cuma karena scroll sedikit rasanya kurang sopan.

Pengguna yang mengaktifkan pengaturan kurangi gerakan di sistem operasinya juga dihormati lewat matchMedia('(prefers-reduced-motion: reduce)'). Untuk mereka, header dan toolbar gak pernah sembunyi, karena elemen yang naik turun mengikuti scroll termasuk gerakan yang paling sering bikin pusing.

Terakhir, focusin. Kalau pengguna keyboard menekan Tab dan fokusnya masuk ke elemen yang punya atribut data-sticky, arah dipaksa jadi up supaya elemen itu tampil. Tanpa ini, tombol bisa aja difokus padahal posisinya lagi ngumpet di luar layar.

Langkah 2: Header yang Ikut Minggir

File app/_components/site-header.tsx:

TypeScript
import Link from 'next/link'

export function SiteHeader() {
  return (
    <header className="site-header" data-sticky>
      <Link href="/" className="logo">
        Catatan Dev
      </Link>
      <nav aria-label="Utama">
        <Link href="/blog/toolbar-pintar">Blog</Link>
      </nav>
    </header>
  )
}

Header ini tetap jadi Server Component. Dia gak butuh state apa pun, karena yang menyembunyikannya adalah CSS yang membaca atribut data-scroll di <html>. Atribut data-sticky cuma penanda buat logika fokus tadi.

Lalu pasang keduanya di root layout. File app/layout.tsx:

TypeScript
import type { Metadata, Viewport } from 'next'
import { ScrollDirection } from './_components/scroll-direction'
import { SiteHeader } from './_components/site-header'
import './globals.css'

export const metadata: Metadata = {
  title: { default: 'Catatan Dev', template: '%s · Catatan Dev' },
}

export const viewport: Viewport = {
  viewportFit: 'cover',
}

export default function RootLayout({ children }: LayoutProps<'/'>) {
  return (
    <html lang="id">
      <body>
        <ScrollDirection />
        <SiteHeader />
        {children}
      </body>
    </html>
  )
}

viewportFit: 'cover' bikin Next.js menulis viewport-fit=cover ke meta viewport. Tanpa itu, nilai env(safe-area-inset-bottom) yang nanti kita pakai di CSS tetap 0 di iPhone, dan toolbar bisa mepet ke garis home indicator.

Kenapa ScrollDirection butuh 'use client' sementara header gak? Karena cuma dia yang butuh useEffect dan API browser. Soal batas 'use client' ini pernah gua bahas panjang di tulisan Belajar Next.js 16, dan dokumentasi use client menyebutnya sebagai pintu masuk dari server ke klien. Komponen ini mengembalikan null, jadi yang dikirim ke browser cuma potongan logika kecilnya.

Langkah 3: Tahu Kapan Pembaca Ada di Dalam Artikel

Cara paling gampang buat tahu pembaca udah melewati judul adalah memanggil getBoundingClientRect() di setiap event scroll. Itu jalan, tapi bikin browser terus menghitung posisi elemen di main thread. Intersection Observer API dibuat persis buat masalah ini: browser yang mengamati, kita cuma dikabari kalau ada yang berubah.

Triknya, taruh dua elemen penanda kosong di halaman. Satu tepat setelah kepala artikel, satu lagi tepat setelah isi artikel. File app/blog/[slug]/reader-bar.tsx:

TypeScript
'use client'

import { useEffect, useState } from 'react'

const sizes = [
  { key: 'm', label: 'normal' },
  { key: 'l', label: 'besar' },
  { key: 'xl', label: 'besar sekali' },
] as const

export function ReaderBar({ title }: { title: string }) {
  const [inside, setInside] = useState(false)
  const [size, setSize] = useState(0)
  const [copied, setCopied] = useState(false)

  useEffect(() => {
    const start = document.querySelector('[data-reader-start]')
    const end = document.querySelector('[data-reader-end]')
    if (!start || !end) return

    const seen = new Map<Element, IntersectionObserverEntry>()
    const observer = new IntersectionObserver((entries) => {
      for (const entry of entries) seen.set(entry.target, entry)
      const a = seen.get(start)
      const b = seen.get(end)
      if (!a || !b) return
      const passedStart = !a.isIntersecting && a.boundingClientRect.top < 0
      const beforeEnd = !b.isIntersecting && b.boundingClientRect.top > 0
      setInside(passedStart && beforeEnd)
    })

    observer.observe(start)
    observer.observe(end)
    return () => observer.disconnect()
  }, [])

  useEffect(() => {
    const root = document.documentElement
    root.dataset.size = sizes[size].key
    return () => {
      delete root.dataset.size
    }
  }, [size])

  const share = async () => {
    const url = window.location.href
    if (typeof navigator.share === 'function') {
      await navigator.share({ title, url }).catch(() => null)
      return
    }
    await navigator.clipboard.writeText(url)
    setCopied(true)
    window.setTimeout(() => setCopied(false), 1800)
  }

  const toTop = () => {
    const calm = window.matchMedia('(prefers-reduced-motion: reduce)').matches
    window.scrollTo({ top: 0, behavior: calm ? 'instant' : 'smooth' })
    document.getElementById('title')?.focus({ preventScroll: true })
  }

  return (
    <div className="reader-bar" role="group" aria-label="Alat baca" data-sticky data-shown={inside || undefined} inert={!inside}>
      <button type="button" onClick={() => setSize((s) => (s + 1) % sizes.length)} aria-label={`Ukuran teks: ${sizes[size].label}`}>
        aA
      </button>
      <button type="button" onClick={share} aria-label="Bagikan">
        <svg viewBox="0 0 20 20" width="18" height="18" fill="none" stroke="currentColor" strokeWidth="1.6" aria-hidden="true">
          <path d="M10 3v10M6 7l4-4 4 4M4 12v4h12v-4" />
        </svg>
      </button>
      <button type="button" onClick={toTop} aria-label="Kembali ke atas">
        <svg viewBox="0 0 20 20" width="18" height="18" fill="none" stroke="currentColor" strokeWidth="1.6" aria-hidden="true">
          <path d="M10 16V5M5 9l5-5 5 5" />
        </svg>
      </button>
      <p role="status" className="reader-toast">
        {copied ? 'Tautan tersalin. Kirim ke grup, jangan cuma disimpan sendiri.' : ''}
      </p>
    </div>
  )
}

Logika di callback-nya pendek, tapi layak dibaca pelan-pelan. Pembaca dianggap ada di dalam artikel kalau penanda awal udah lewat ke atas layar dan penanda akhir masih di bawahnya. Begitu penanda akhir masuk layar, toolbar minggir, karena bagian komentar di bawahnya butuh ruang.

Toolbar cuma tampil di dalam isi artikel dan ikut arah scroll, lalu sembunyi lagi sebelum judul dan setelah artikel selesai

Map bernama seen ada karena callback IntersectionObserver cuma menerima entri yang berubah. Kalau yang berubah cuma penanda akhir, kita tetap butuh status terakhir penanda awal buat ambil keputusan.

Waktu toolbar ada di luar artikel, dia diberi atribut inert. Menurut MDN soal atribut inert, elemen yang inert gak bisa difokus atau diklik, dan dikeluarkan dari pohon aksesibilitas. Jadi tombol yang gak kelihatan juga gak bisa dijangkau pengguna keyboard atau pembaca layar. Di React 19, inert bisa langsung dipakai sebagai prop boolean.

Tombol bagikan memakai navigator.share kalau tersedia, biasanya di HP, dan jatuh ke clipboard kalau gak ada. Pesan konfirmasinya ditaruh di elemen role="status" supaya ikut dibacakan pembaca layar.

Tombol kembali ke atas memindahkan fokus ke judul setelah scroll, karena tombolnya sendiri sebentar lagi jadi inert. Kalau fokusnya dibiarkan di situ, browser bakal melemparnya ke <body>, dan pengguna keyboard harus mulai menekan Tab dari awal lagi.

Halaman artikelnya, file app/blog/[slug]/page.tsx:

TypeScript
import type { Metadata } from 'next'
import { notFound } from 'next/navigation'
import { Suspense } from 'react'
import { getPost, getPosts } from '@/lib/posts'
import { ReaderBar } from './reader-bar'

export async function generateStaticParams() {
  const posts = await getPosts()
  return posts.map((post) => ({ slug: post.slug }))
}

export async function generateMetadata({ params }: PageProps<'/blog/[slug]'>): Promise<Metadata> {
  const { slug } = await params
  const post = await getPost(slug)
  return post ? { title: post.title, description: post.excerpt } : {}
}

export default function Page({ params }: PageProps<'/blog/[slug]'>) {
  return (
    <Suspense fallback={<p className="article">Memuat artikel…</p>}>
      <Article params={params} />
    </Suspense>
  )
}

async function Article({ params }: { params: Promise<{ slug: string }> }) {
  const { slug } = await params
  const post = await getPost(slug)
  if (!post) notFound()

  return (
    <main className="article">
      <header>
        <h1 id="title" tabIndex={-1}>
          {post.title}
        </h1>
        <p className="excerpt">{post.excerpt}</p>
      </header>
      <div data-reader-start aria-hidden="true" />
      <div className="prose" dangerouslySetInnerHTML={{ __html: post.html }} />
      <div data-reader-end aria-hidden="true" />
      <section aria-labelledby="comments" className="comments">
        <h2 id="comments">Komentar</h2>
        <p>Belum ada komentar. Sepi kayak grup kelas setelah lulus.</p>
      </section>
      <ReaderBar title={post.title} />
    </main>
  )
}

Pola Suspense di sini sama dengan yang gua pakai di tulisan Next.js sebelumnya. params baru di-await di dalam batas Suspense supaya kerangka halaman tetap masuk ke static shell. Ganti getPost dan getPosts dengan sumber data kalian sendiri. h1 diberi tabIndex={-1} supaya bisa menerima fokus dari tombol kembali ke atas tanpa ikut masuk urutan Tab.

Langkah 4: CSS yang Mengatur Semuanya

File app/globals.css:

CSS
:root {
  --paper: #ffffff;
  --ink: #111111;
  --lime: #e5ff11;
  --ease: cubic-bezier(0.22, 1, 0.36, 1);
}

html {
  scroll-padding-block: 4.5rem 6rem;
}

body {
  margin: 0;
  background: var(--paper);
  color: var(--ink);
  font-family: system-ui, sans-serif;
}

.site-header {
  position: sticky;
  top: 0;
  z-index: 20;
  display: flex;
  height: 3.5rem;
  align-items: center;
  justify-content: space-between;
  padding-inline: 1rem;
  border-bottom: 1px solid rgb(0 0 0 / 0.08);
  background: rgb(255 255 255 / 0.94);
  transition: translate 300ms var(--ease);
}

:root[data-scroll='down'] .site-header {
  translate: 0 -100%;
}

.reader-bar {
  position: fixed;
  bottom: max(1rem, env(safe-area-inset-bottom));
  left: 50%;
  z-index: 30;
  display: flex;
  gap: 0.25rem;
  padding: 0.375rem;
  border: 1px solid rgb(0 0 0 / 0.08);
  border-radius: 0.5rem;
  background: rgb(255 255 255 / 0.94);
  box-shadow: 0 8px 32px rgb(0 0 0 / 0.12);
  opacity: 0;
  translate: -50% calc(100% + 1.5rem);
  transition:
    translate 300ms var(--ease),
    opacity 200ms;
}

.reader-bar[data-shown] {
  opacity: 1;
  translate: -50% 0;
}

:root[data-scroll='down'] .reader-bar[data-shown] {
  opacity: 0;
  translate: -50% calc(100% + 1.5rem);
}

@supports (backdrop-filter: blur(1px)) {
  .site-header,
  .reader-bar {
    background: rgb(255 255 255 / 0.72);
    backdrop-filter: saturate(180%) blur(20px);
  }
}

.reader-bar button {
  display: grid;
  min-width: 2.75rem;
  height: 2.75rem;
  place-items: center;
  border: 0;
  border-radius: 0.3125rem;
  background: transparent;
  color: inherit;
  font: 600 0.9375rem/1 system-ui, sans-serif;
  cursor: pointer;
}

.reader-bar button:hover,
.reader-bar button:active {
  background: var(--lime);
}

.reader-bar button:focus-visible {
  outline: 2px solid var(--ink);
  outline-offset: 2px;
}

.reader-toast {
  position: absolute;
  bottom: calc(100% + 0.5rem);
  left: 50%;
  margin: 0;
  padding: 0.5rem 0.75rem;
  background: var(--ink);
  color: var(--paper);
  font-size: 0.8125rem;
  white-space: nowrap;
  translate: -50% 0;
}

.reader-toast:empty {
  display: none;
}

.article {
  max-width: 42rem;
  margin: 0 auto;
  padding: 2rem 1rem 8rem;
}

.prose {
  font-size: 1.0625rem;
  line-height: 1.7;
}

:root[data-size='l'] .prose {
  font-size: 1.1875rem;
}

:root[data-size='xl'] .prose {
  font-size: 1.3125rem;
}

@media (prefers-reduced-motion: reduce) {
  .site-header,
  .reader-bar {
    transition: none;
  }
}

Toolbar disembunyikan pakai translate dan opacity, bukan display: none atau mengubah bottom. Dua properti itu bisa dianimasikan tanpa menghitung ulang layout, jadi gerakannya tetap halus walaupun halamannya lagi sibuk.

Ada dua lapis syarat. [data-shown] dari ReaderBar menentukan toolbar boleh muncul atau gak, sementara :root[data-scroll='down'] dari ScrollDirection bisa menyembunyikannya sementara. Kalau dua-duanya diurus di satu komponen React, hasilnya komponen yang render ulang setiap kali arah berubah, plus header yang harus dikabari lewat context atau store. Dengan atribut di <html>, semua elemen cukup membaca status yang sama.

bottom: max(1rem, env(safe-area-inset-bottom)) menjaga toolbar gak tenggelam di balik home indicator. Fungsi env() mengembalikan 0 di layar persegi biasa, jadi di desktop jaraknya tetap 1rem.

Efek kacanya pakai backdrop-filter yang dibungkus @supports, jadi browser yang belum mendukung tetap dapat latar putih yang cukup pekat buat dibaca.

Oiya, ada satu jebakan yang pernah gua alami sendiri. Menu mobile di situs ini dulu cuma setinggi 109 piksel, padahal harusnya memenuhi layar. Penyebabnya panel menu position: fixed yang ada di dalam header ber-backdrop-filter. Ternyata elemen dengan backdrop-filter, filter, atau transform menjadi containing block buat turunannya yang fixed, jadi panelnya terjebak di dalam header. Itu sebabnya toolbar di tutorial ini sengaja gak ditaruh di dalam elemen yang punya efek kaca.

Tombolnya 44 piksel. WCAG 2.2 sebenernya cuma mewajibkan target minimal 24 piksel lewat kriteria Target Size (Minimum), tapi toolbar ini lebih sering diketuk jempol sambil jalan, jadi gua bikin lebih besar.

Jangan Sampai Toolbar Menutupi yang Lagi Difokus

Ini bagian yang paling sering absen. WCAG 2.2 punya kriteria 2.4.11 Focus Not Obscured (Minimum) di level AA: elemen yang menerima fokus keyboard gak boleh tertutup sepenuhnya oleh konten yang kita bikin sendiri. Contoh di ringkasan WCAG 2.2 dari W3C malah persis soal banner yang nempel di bawah halaman.

Header dan toolbar sticky adalah tersangka utamanya. Bayangkan pengguna menekan Tab ke tautan di paragraf terakhir yang kelihatan. Browser menggulir tautan itu sampai mepet tepi layar, dan di situ persis toolbar kita tinggal.

Solusinya udah ada di aturan pertama CSS tadi:

CSS
html {
  scroll-padding-block: 4.5rem 6rem;
}

scroll-padding memberi tahu browser bahwa ada area di atas dan bawah layar yang tertutup. Saat browser menggulir elemen yang difokus ke dalam layar, dia menyisakan ruang itu, jadi elemennya berhenti di atas toolbar, bukan di baliknya. Angkanya disesuaikan dengan tinggi header dan toolbar, plus sedikit ruang napas.

Tanpa scroll-padding, tautan yang difokus tertutup toolbar; dengan scroll-padding, browser berhenti tepat di atas toolbar

Coba kalian terapkan dengan cara sederhana: buka artikel kalian, klik di area kosong paling atas, lalu tekan Tab berulang-ulang tanpa menyentuh mouse. Kalau ada satu aja tautan yang fokusnya hilang di balik header atau toolbar, berarti scroll-padding-nya perlu ditambah.

Bisa Gak Cuma Pakai CSS?

Bisa, tapi belum di semua browser. Chrome 144 yang rilis 13 Januari 2026 menambahkan dukungan scrolled di container query scroll-state, menurut catatan rilis Chrome 144. Dengan itu, CSS bisa tahu arah scroll terakhir tanpa JavaScript sama sekali:

CSS
html {
  container-type: scroll-state;
}

@container scroll-state(scrolled: block-end) {
  .site-header {
    translate: 0 -100%;
  }
}

Gua udah coba di Chromium 153. Header langsung sembunyi begitu gua scroll turun dan muncul lagi waktu scroll naik. Sintaks lengkapnya dijelaskan di panduan MDN soal container scroll-state queries.

Tapi per Oktober 2026, Safari dan Firefox belum mendukungnya. Versi CSS murni ini juga gak punya ambang gerak, jadi geseran 1 piksel pun dihitung, dan dia gak tahu batas artikel. Kalau mau eksperimen, mungkin jangan digabung dengan versi JavaScript di elemen yang sama, karena aturan CSS-nya bakal tetap menyembunyikan header walaupun gerakannya kecil dan sengaja kita abaikan.

Kesalahan yang Sering Gua Lihat

Kesalahan paling umum adalah menyimpan scrollY di state React dan memanggil setState di setiap event scroll. Komponennya jadi render ulang puluhan kali per detik, padahal yang dibutuhkan cuma satu atribut di DOM. Biarin aja CSS yang kerja.

Yang kedua, toolbar yang disembunyikan dengan opacity: 0 aja tanpa inert. Tombolnya hilang dari mata, tapi masih ada di urutan Tab dan masih dibacakan pembaca layar.

Yang ketiga, lupa ambang gerak, sehingga toolbar berkedip setiap kali trackpad tersentuh. Lalu toolbar yang tetap nongkrong di atas kolom komentar atau footer, dan elemen fixed yang ditaruh di dalam elemen ber-backdrop-filter atau transform.

Dan yang paling klasik, cuma dites pakai mouse di laptop sendiri. Works on my machine, tapi pembaca kalian bukan mesin kalian. Coba pakai keyboard, coba nyalakan pengaturan kurangi gerakan, dan coba buka di HP pakai jempol.

Toolbar kecil kayak gini kelihatannya sepele, tapi justru di sini pembaca merasakan apakah sebuah situs menghargai waktu mereka atau gak. Mulai aja dari satu halaman artikel, pasang ScrollDirection dan ReaderBar tadi, lalu pakai sendiri selama seminggu. Angka ambang dan offset yang pas biasanya baru ketemu setelah dipakai beneran, bukan setelah kebanyakan dipikirin.

Makasih udah baca sampai sini. Kalau toolbar di bawah layar barusan sempat muncul waktu kalian scroll naik buat ngecek kode, berarti dia kerja sesuai rencana.

Hafidz Nc

Fractional Head of Digital

Diskusi