Ilustrasi flat vector cetakan kue menghasilkan banyak bentuk identik sebagai simbol komponen reusable

Di episode #112 kamu menguasai layout responsif. Tapi ada masalah yang makin terasa seiring kode bertambah: rangkaian class yang sama ditulis berulang-ulang. Tombol yang sama muncul di lima halaman dengan 12 class yang identik. Kalau suatu hari warnanya harus berubah, kamu berburu ke lima tempat. Episode ini menyelesaikan itu: cara membuat komponen reusable dengan Tailwind yang benar.

Kenapa penting? Karena ini titik di mana banyak orang salah belok dan kembali ke masalah CSS tradisional yang sudah kita tinggalkan. Godaannya besar: "bikin saja class .btn pakai @apply, beres". Padahal ada cara yang lebih baik, dan memahaminya adalah pembeda antara pengguna Tailwind pemula dan yang profesional. Di episode #114 kita akan memakai semua ini untuk membangun landing page utuh sebagai proyek penutup series.

Cara Berpikirnya: Cetakan Kue, Bukan Foto Kue

Bayangkan kamu jualan kue. Ada dua cara memastikan semua kue berbentuk sama. Cara pertama: foto satu kue yang bagus, lalu setiap bikin kue baru kamu menatap foto itu dan berusaha menirunya. Hasilnya mirip-mirip, tapi tidak pernah persis sama, dan melelahkan. Cara kedua: pakai cetakan. Sekali bikin cetakan, semua kue keluar identik tanpa usaha.

@apply itu seperti foto: kamu memotret rangkaian utility menjadi satu class CSS baru (.btn { @apply px-4 py-2 bg-blue-500 ... }), lalu berharap semua pemakaian meniru foto itu. Masalahnya, foto bisa diedit diam-diam: seseorang menambahkan properti ke .btn, dan tiba-tiba semua tombol berubah tanpa jejak di HTML-nya. Kamu kembali ke masalah lama: style yang tersembunyi di file CSS.

Component adalah cetakan yang sesungguhnya. Di React:

function Tombol({ children, varian = "utama", onKlik }) {
  const dasar = "px-4 py-2 rounded font-semibold transition";
  const gaya = {
    utama: "bg-blue-500 text-white hover:bg-blue-600",
    kedua: "bg-gray-200 text-gray-800 hover:bg-gray-300",
    bahaya: "bg-red-500 text-white hover:bg-red-600",
  };
  return (
    <button onClick={onKlik} className={`${dasar} ${gaya[varian]}`}>
      {children}
    </button>
  );
}

// Pakainya:
<Tombol varian="utama" onKlik={kirim}>Kirim</Tombol>
<Tombol varian="bahaya" onKlik={hapus}>Hapus</Tombol>

Perhatikan apa yang terjadi: rangkaian 12 class ditulis sekali di dalam component, dan pemakainya cuma menulis <Tombol varian="utama">. Utility-nya tetap terlihat jelas di definisi component (tidak disembunyikan), variasi ditangani lewat props (bukan class baru), dan mengubah warna tombol utama cukup di satu tempat. Ini cetakan: konsisten, terlacak, dan tidak bisa "diedit diam-diam" dari luar.

Berhenti dan tebak dulu! Component Tombol di atas dipakai 20 kali di aplikasi. Desainer minta semua tombol utama berubah dari biru menjadi hijau. Berapa tempat yang harus kamu ubah dengan pendekatan component vs pendekatan copy-paste class?

Jawaban: 1 tempat vs 20 tempat. Dengan component, kamu ubah bg-blue-500 jadi bg-green-500 di objek gaya, selesai. Dengan copy-paste, kamu berburu 20 lokasi dan berdoa tidak ada yang terlewat. Inilah matematika yang membuat component selalu menang untuk pola berulang: biaya perubahan = jumlah definisi, bukan jumlah pemakaian.

Dua Persepsi Salah yang Perlu Diluruskan

Mitos 1: "@apply adalah cara resmi bikin component di Tailwind." Bukan. @apply ada untuk kasus khusus: men-style markup pihak ketiga yang tidak bisa kamu ubah, atau pola yang benar-benar tidak bisa dicomponent-kan. Tim Tailwind sendiri menyarankan ekstraksi component di level framework dulu (React/Vue/Blade), @apply sebagai pilihan terakhir. Memakai @apply untuk semua tombol sama saja membangun kembali CSS tradisional dengan sintaks Tailwind.

Mitos 2: "Component kecil seperti tombol tidak worth it diekstrak." Justru component kecil yang paling sering berubah dan paling sering dipakai ulang. Aturannya bukan soal ukuran, tapi soal pengulangan: kalau rangkaian class yang sama muncul tiga kali, ekstrak. Tiga adalah angka ajaibnya: dua kali masih kebetulan, tiga kali sudah pola.

Pola Component yang Rapi: Kartu

Selain tombol, kartu adalah component kedua yang wajib kamu punya. Perhatikan bagaimana props mengendalikan variasi:

function Kartu({ judul, deskripsi, children }) {
  return (
    <article className="bg-white rounded-lg shadow p-6 hover:shadow-lg transition">
      <h3 className="text-lg font-semibold">{judul}</h3>
      <p className="mt-2 text-gray-600">{deskripsi}</p>
      {children && <div className="mt-4">{children}</div>}
    </article>
  );
}

Tiga keputusan desain di sini: pertama, struktur internal (padding, shadow) dikunci di dalam component, jadi semua kartu konsisten. Kedua, konten (judul, deskripsi) menjadi props, jadi component-nya fleksibel. Ketiga, children opsional memberi ruang untuk aksi tambahan (tombol, link) tanpa mengubah component. Ini adalah anatomi component reusable yang sehat: struktur dikunci, konten mengalir lewat props.

Untuk menggabungkan class secara dinamis dengan rapi, banyak tim memakai helper kecil clsx (atau classnames): clsx("px-4 py-2 rounded", varian === "utama" && "bg-blue-500"). Ia menggabungkan string class dan mengabaikan nilai falsy, sehingga logika kondisional tidak mengotori JSX. Ini bukan wajib, tapi begitu component-mu punya 4-5 varian dengan class yang bertumpuk, clsx membuat kodenya jauh lebih terbaca daripada template literal bersarang. Install-nya ringan (npm install clsx) dan pola ini dipakai luas di codebase profesional.

Satu jebakan terakhir: jangan membangun class secara dinamis dengan string concatenation seperti "bg-" + warna. Tailwind menghasilkan CSS dengan memindai nama class yang tertulis eksplisit di kodemu; class yang dirakit saat runtime tidak akan terdeteksi dan gayanya tidak keluar. Kalau butuh varian dinamis, daftarkan semua kemungkinan class-nya secara eksplisit (misalnya lewat objek gaya seperti contoh Tombol di atas), bukan dengan merangkai string.

Aturan Mainnya: Kapan Mengekstrak

Supaya tidak over-engineering (mengekstrak semuanya sampai punya 50 component untuk website satu halaman), pakai aturan ini:

  • Aturan tiga kali: rangkaian class yang sama muncul 3x atau lebih, ekstrak jadi component.
  • Component dulu, @apply belakangan: kalau memakai React/Vue/Blade, ekstraksi selalu di level component. @apply hanya untuk markup yang tidak bisa kamu component-kan.
  • Satu component, satu tanggung jawab: Tombol mengurus tampilan tombol. Jangan bikin TombolYangJugaBisaJadiKartu dengan 15 props.
  • Varian lewat props, bukan component baru: varian="bahaya" lebih baik daripada TombolBahaya yang terpisah. Daftar varian yang eksplisit juga menjadi dokumentasi desain.

Kuis cepat: Rangkaian class tombol yang sama dipakai di 4 halaman berbeda. Apa langkah terbaik?

Latihan: Bukan Mengetik Ulang

  1. Ambil tiga kartu dari latihan episode #112. Ubah menjadi component Kartu reusable (ikuti pola di artikel ini), lalu render ketiganya lewat component tersebut. Pastikan tampilannya tidak berubah sama sekali.
  2. Tambah: buat component Tombol dengan tiga varian (utama, kedua, bahaya). Pakai di dalam kartu-kartumu sebagai aksi. Coba ubah warna satu varian dan verifikasi semua pemakaian ikut berubah.
  3. Tantangan: buat component Input untuk form (label + input + pesan error opsional). Pikirkan: props apa saja yang ia butuhkan? Struktur mana yang dikunci, konten mana yang mengalir?

Di episode #114, penutup Series Tailwind CSS dari Nol, kita merakit semuanya menjadi landing page utuh: navbar responsif, hero, grid fitur, dan footer, semuanya dari component-component reusable yang kamu buat. Ini proyek yang layak masuk portofolio. Siapkan component Tombol dan Kartu-mu, karena mereka akan jadi bahan bangunan utamanya.