Module Bundler & Build Tool

Proyek JavaScript modern membutuhkan build tool: bundler untuk menggabungkan module, transpiler untuk kompatibilitas, linter untuk kualitas kode, dan formatter untuk konsistensi. Artikel ini membahas Vite, Webpack, Babel, ESLint, dan Prettier.

Pendahuluan

Saat proyek JavaScript tumbuh, kita menghadapi masalah baru:

  • Banyak file module — browser perlu banyak request HTTP (lambat).
  • Fitur modern — sebagian browser belum mendukung (?., ??, class field).
  • Kualitas kode — tanpa aturan, kode menjadi tidak konsisten.
  • Aset non-JS — CSS, gambar, font perlu diproses.
  • Optimasi produksi — minifikasi, tree shaking, code splitting.

Build tool menyelesaikan masalah ini. Artikel ini membahas:

  • Bundler — Vite (rekomendasi modern) dan Webpack.
  • Transpiler — Babel (dan esbuild/SWC).
  • Linter — ESLint.
  • Formatter — Prettier.

Asumsi: Anda sudah memahami Node.js dan npm dari artikel sebelumnya. Semua contoh menggunakan npm.


Mengapa Perlu Build Tool?

Masalah Tanpa Build Tool

<!-- Banyak tag script — banyak request HTTP -->
<script src="utils.js"></script>
<script src="api.js"></script>
<script src="components/button.js"></script>
<script src="components/modal.js"></script>
<script src="app.js"></script>
<!-- ... 50 file lagi -->
  • Banyak request — setiap file = satu request HTTP.
  • Urutan manual — dependency harus dimuat dalam urutan yang benar.
  • Tidak ada optimasi — kode tidak diminifikasi.
  • Kompatibilitas — fitur modern mungkin gagal di browser lama.

Solusi Build Tool

Source code (banyak file, fitur modern)
         ↓  Build tool
Bundle (satu/beberapa file, dioptimasi, kompatibel)
         ↓
Browser

Build tool menangani:

  • Bundling — menggabungkan module menjadi satu/beberapa file.
  • Transpiling — mengubah fitur modern ke kode yang kompatibel.
  • Minifikasi — menghapus spasi, komentar, memperpendek nama.
  • Tree shaking — menghapus kode yang tidak dipakai.
  • Code splitting — memecah bundle agar dimuat sesuai kebutuhan.
  • Asset handling — memproses CSS, gambar, font.
  • Dev server — live reload / hot reload.

Vite — Bundler Modern (Rekomendasi)

Vite (dibaca “vit”, bahasa Prancis untuk “cepat”) adalah build tool modern yang dikembangkan oleh Evan You (pembuat Vue). Vite menggunakan esbuild (sangat cepat) untuk development dan Rollup untuk produksi.

Mengapa Vite?

  • Sangat cepat — dev server启动 dalam milidetik (bukan detik).
  • Hot Module Replacement (HMR) instan.
  • Konfigurasi minimal — bekerja out-of-the-box.
  • Native ES Module di development — tidak perlu bundling saat dev.
  • Optimasi produksi — Rollup + minifikasi.

Membuat Proyek Vite

npm create vite@latest my-app

Ikuti prompt:

? Select a framework: › Vanilla
? Select a variant: › JavaScript

Atau langsung:

npm create vite@latest my-app -- --template vanilla

Masuk dan jalankan:

cd my-app
npm install
npm run dev

Output:

  VITE v5.0.0  ready in 312 ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose

Struktur Proyek Vite

my-app/
├── index.html          # Entry point HTML
├── package.json
├── vite.config.js      # Konfigurasi (opsional)
├── public/             # Aset statis (tidak diproses)
│   └── favicon.ico
└── src/
    ├── main.js         # Entry point JS
    ├── style.css
    └── counter.js

index.html — entry point (bukan src/index.html):

<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <title>Vite App</title>
</head>
<body>
  <div id="app"></div>
  <script type="module" src="/src/main.js"></script>
</body>
</html>

src/main.js:

import "./style.css";
import { setupCounter } from "./counter.js";

document.querySelector("#app").innerHTML = `
  <h1>Hello Vite!</h1>
  <button id="counter">count is 0</button>
`;

setupCounter(document.querySelector("#counter"));

src/counter.js:

export function setupCounter(element) {
  let counter = 0;

  const setCounter = (count) => {
    counter = count;
    element.textContent = `count is ${counter}`;
  };

  element.addEventListener("click", () => setCounter(counter + 1));
  setCounter(0);
}

Perintah Vite

npm run dev      # Dev server (HMR)
npm run build    # Build untuk produksi → dist/
npm run preview  # Preview hasil build

Konfigurasi Vite (vite.config.js)

import { defineConfig } from "vite";

export default defineConfig({
  server: {
    port: 3000,
    open: true,          // buka browser otomatis
    proxy: {
      "/api": {
        target: "http://localhost:5000",
        changeOrigin: true
      }
    }
  },
  build: {
    outDir: "dist",
    sourcemap: true,
    minify: "esbuild"
  }
});

Environment Variables di Vite

Vite hanya mengekspos variable dengan prefix VITE_:

# .env
VITE_API_URL=https://api.example.com
VITE_APP_TITLE=Toko Online
console.log(import.meta.env.VITE_API_URL);
console.log(import.meta.env.VITE_APP_TITLE);
console.log(import.meta.env.MODE);  // "development" / "production"
console.log(import.meta.env.DEV);   // true di development
console.log(import.meta.env.PROD);  // true di production

⚠️ Peringatan: Semua VITE_* variable terekspos di bundle client. Jangan simpan rahasia (API key server, password) di sini.

Import Aset di Vite

// CSS
import "./style.css";

// Gambar — menghasilkan URL
import logo from "./assets/logo.png";
document.querySelector("img").src = logo;

// JSON
import data from "./data.json";
console.log(data);

// Dynamic import (code splitting)
const module = await import("./heavy-module.js");

Vite untuk React/Vue

# React
npm create vite@latest my-app -- --template react

# Vue
npm create vite@latest my-app -- --template vue

# TypeScript
npm create vite@latest my-app -- --template vanilla-ts

Webpack — Bundler Klasik

Webpack adalah bundler paling populer sebelum Vite. Masih sangat banyak digunakan, terutama di proyek lama dan enterprise.

Kelebihan dan Kekurangan

Kelebihan Kekurangan
Ekosistem plugin & loader sangat besar Konfigurasi kompleks
Fleksibel — bisa handle apa saja Dev server lebih lambat dari Vite
Banyak digunakan di enterprise Kurva belajar curam
Dukungan jangka panjang Setup awal memakan waktu

Instalasi

npm install --save-dev webpack webpack-cli webpack-dev-server

Konfigurasi Dasar (webpack.config.js)

const path = require("path");
const HtmlWebpackPlugin = require("html-webpack-plugin");

module.exports = {
  mode: "development",
  entry: "./src/index.js",
  output: {
    path: path.resolve(__dirname, "dist"),
    filename: "[name].[contenthash].js",
    clean: true
  },
  module: {
    rules: [
      {
        test: /\.css$/i,
        use: ["style-loader", "css-loader"]
      },
      {
        test: /\.(png|svg|jpg|jpeg|gif)$/i,
        type: "asset/resource"
      },
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: "babel-loader",
          options: {
            presets: ["@babel/preset-env"]
          }
        }
      }
    ]
  },
  plugins: [
    new HtmlWebpackPlugin({
      template: "./src/index.html"
    })
  ],
  devServer: {
    static: "./dist",
    port: 3000,
    hot: true,
    open: true
  },
  devtool: "source-map"
};

Script package.json

{
  "scripts": {
    "start": "webpack serve --mode development",
    "build": "webpack --mode production"
  }
}

Konsep Webpack

  • Entry — file awal yang menjadi titik masuk.
  • Output — tempat hasil bundle.
  • Loaders — memproses file non-JS (CSS, gambar, dll.) sebelum di-bundle.
  • Plugins — melakukan tugas tambahan (generate HTML, minify, dll.).
  • Mode — development (cepat, debug) atau production (optimasi).

Rekomendasi: Untuk proyek baru, gunakan Vite. Untuk proyek lama atau yang butuh konfigurasi sangat spesifik, Webpack masih relevan.


Babel — Transpiler

Babel mengubah kode JavaScript modern menjadi kode yang kompatibel dengan browser lama.

Mengapa Babel?

// Kode modern
const sapa = (nama) => `Halo, ${nama}!`;
const user = data?.user ?? "Anonim";

// Setelah Babel (target browser lama)
var sapa = function sapa(nama) {
  return "Halo, ".concat(nama, "!");
};
var user = (_data$user = data === null || data === void 0 ? void 0 : data.user) !== null && _data$user !== void 0 ? _data$user : "Anonim";

Instalasi

npm install --save-dev @babel/core @babel/cli @babel/preset-env

Konfigurasi (babel.config.json)

{
  "presets": [
    ["@babel/preset-env", {
      "targets": "> 0.5%, last 2 versions, not dead",
      "useBuiltIns": "usage",
      "corejs": 3
    }]
  ]
}

targets menentukan browser yang didukung:

  • "> 0.5%, last 2 versions, not dead" — browser dengan market share > 0.5%, 2 versi terakhir, yang masih di-maintain.
  • "last 2 chrome versions" — hanya Chrome 2 versi terakhir.
  • "ie 11" — termasuk IE11 (butuh banyak polyfill).

Menggunakan Babel

# Transpile satu file
npx babel src/index.js --out-file dist/index.js

# Transpile folder
npx babel src --out-dir dist

Babel dengan Bundler

Babel biasanya digunakan bersama Webpack (via babel-loader) atau Vite (via plugin). Untuk Vite, transpilasi dilakukan oleh esbuild secara otomatis — Babel hanya diperlukan untuk fitur yang belum didukung esbuild.

Preset Umum

Preset Kegunaan
@babel/preset-env Transpile ES6+ ke target browser
@babel/preset-react JSX untuk React
@babel/preset-typescript TypeScript

Polyfill

Babel tidak menambahkan fitur baru (seperti Promise, Array.includes) — itu tugas polyfill. Gunakan core-js:

npm install core-js

Dengan useBuiltIns: "usage", Babel otomatis mengimpor polyfill yang dibutuhkan.

Catatan: Vite (esbuild) dan browser modern sudah mendukung sebagian besar fitur. Polyfill hanya diperlukan untuk browser lama.


ESLint — Linter

ESLint menganalisis kode untuk menemukan error dan masalah style sebelum dijalankan.

Mengapa ESLint?

// ESLint akan menandai:
if (x == 5) { }           // gunakan ===
const unused = 10;        // variabel tidak dipakai
function f() { return; }
console.log(y);           // y tidak dideklarasikan

Instalasi

npm install --save-dev eslint
npx eslint --init

Ikuti prompt:

? How would you like to use ESLint? › To check syntax, find problems, and enforce code style
? What type of modules does your project use? › JavaScript modules (import/export)
? Which framework does your project use? › None of these
? Does your project use TypeScript? › No
? Where does your code run? › Browser, Node
? How would you like to define a style for your project? › Use a popular style guide
? Which style guide do you want to follow? › Airbnb
? What format do you want your config file to be in? › JSON

Menghasilkan eslint.config.js (flat config, ESLint 9+) atau .eslintrc.json (lama).

Konfigurasi Flat (eslint.config.js)

import js from "@eslint/js";

export default [
  js.configs.recommended,
  {
    languageOptions: {
      ecmaVersion: 2022,
      sourceType: "module",
      globals: {
        window: "readonly",
        document: "readonly",
        console: "readonly"
      }
    },
    rules: {
      "no-unused-vars": "warn",
      "no-console": "off",
      "eqeqeq": "error",
      "prefer-const": "error",
      "no-var": "error"
    }
  }
];

Menjalankan ESLint

# Cek semua file
npx eslint .

# Cek satu file
npx eslint src/index.js

# Auto-fix
npx eslint . --fix

# Format output
npx eslint . --format stylish

Tingkat Rule

Level Arti
"off" / 0 Nonaktif
"warn" / 1 Peringatan (tidak gagal)
"error" / 2 Error (gagal)

Script package.json

{
  "scripts": {
    "lint": "eslint .",
    "lint:fix": "eslint . --fix"
  }
}

Integrasi Editor

Install extension ESLint di VS Code — error dan warning muncul langsung di editor.


Prettier — Formatter

Prettier memformat kode secara otomatis agar konsisten — spasi, indentasi, tanda kutip, titik koma, dll.

Mengapa Prettier?

// Sebelum Prettier
const   user={nama:"Budi",umur:25,alamat:{kota:"Jakarta"}}
function sapa(nama){return `Halo, ${nama}!`}

// Setelah Prettier
const user = { nama: "Budi", umur: 25, alamat: { kota: "Jakarta" } };
function sapa(nama) {
  return `Halo, ${nama}!`;
}

Instalasi

npm install --save-dev prettier

Konfigurasi (.prettierrc)

{
  "semi": true,
  "singleQuote": false,
  "tabWidth": 2,
  "trailingComma": "es5",
  "printWidth": 80,
  "arrowParens": "always"
}
Opsi Arti
semi Titik koma di akhir statement
singleQuote Gunakan ' bukan "
tabWidth Lebar indentasi
trailingComma Koma di akhir (es5, all, none)
printWidth Panjang baris maksimum
arrowParens Kurung pada arrow function satu parameter

Menjalankan Prettier

# Format semua file
npx prettier . --write

# Cek tanpa mengubah
npx prettier . --check

# Format file tertentu
npx prettier src/index.js --write

.prettierignore

node_modules/
dist/
package-lock.json
*.min.js

Script package.json

{
  "scripts": {
    "format": "prettier . --write",
    "format:check": "prettier . --check"
  }
}

Integrasi dengan ESLint

ESLint dan Prettier bisa bertugas secara terpisah:

  • ESLint — kualitas kode (bug, best practice).
  • Prettier — format (spasi, indentasi).

Untuk menghindari konflik rule, gunakan eslint-config-prettier:

npm install --save-dev eslint-config-prettier
// eslint.config.js
import js from "@eslint/js";
import prettier from "eslint-config-prettier";

export default [
  js.configs.recommended,
  prettier, // nonaktifkan rule ESLint yang konflik dengan Prettier
  // ...
];

Integrasi Editor

Install extension Prettier di VS Code, lalu aktifkan format on save di .vscode/settings.json:

{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

Contoh Setup Proyek Lengkap

Mari gabungkan semua: Vite + ESLint + Prettier.

1. Buat Proyek Vite

npm create vite@latest toko-app -- --template vanilla
cd toko-app
npm install

2. Instal ESLint & Prettier

npm install --save-dev eslint @eslint/js prettier eslint-config-prettier

3. Konfigurasi ESLint (eslint.config.js)

import js from "@eslint/js";
import prettier from "eslint-config-prettier";

export default [
  js.configs.recommended,
  prettier,
  {
    languageOptions: {
      ecmaVersion: 2022,
      sourceType: "module",
      globals: {
        window: "readonly",
        document: "readonly",
        console: "readonly"
      }
    },
    rules: {
      "no-unused-vars": "warn",
      "eqeqeq": "error",
      "prefer-const": "error",
      "no-var": "error"
    }
  }
];

4. Konfigurasi Prettier (.prettierrc)

{
  "semi": true,
  "singleQuote": false,
  "tabWidth": 2,
  "printWidth": 80,
  "trailingComma": "es5"
}

5. Tambahkan Script

{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview",
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
    "format": "prettier . --write",
    "format:check": "prettier . --check"
  }
}

6. Jalankan

npm run dev          # development
npm run lint         # cek kualitas kode
npm run format       # format kode
npm run build        # build produksi

7. .gitignore

node_modules/
dist/
.env
*.log
.DS_Store

Ringkasan Alat Build

Alat Kategori Kegunaan Rekomendasi
Vite Bundler + Dev Server Bundling, HMR, optimasi ✅ Proyek baru
Webpack Bundler Bundling dengan plugin/loader Proyek lama/enterprise
Rollup Bundler Bundling library Library npm
esbuild Bundler/Transpiler Sangat cepat Digunakan Vite
Babel Transpiler Kompatibilitas browser lama, JSX Dengan Webpack
ESLint Linter Kualitas kode & bug ✅ Semua proyek
Prettier Formatter Konsistensi format ✅ Semua proyek

Tips & Best Practice

  1. Gunakan Vite untuk proyek baru — lebih cepat dan konfigurasi minimal.

  2. Gunakan ESLint + Prettier di semua proyek — kualitas & konsistensi.

  3. Aktifkan format on save di editor — kode selalu rapi tanpa manual.

  4. Jalankan lint & format di pre-commit hook (via Husky + lint-staged) — mencegah kode jelek masuk repo.

  5. Jangan commit dist/ atau node_modules/ — tambahkan ke .gitignore.

  6. Gunakan environment variables untuk konfigurasi — jangan hardcode.

  7. Untuk library, gunakan Rollup atau Vite library mode — bukan Webpack.

  8. Tree shaking — gunakan ES Module (import/export), bukan CommonJS, agar kode yang tidak dipakai bisa dihapus.

  9. Code splitting — manfaatkan dynamic import() untuk memuat kode sesuai kebutuhan.

  10. Source map — aktifkan di development untuk debugging, pertimbangkan mematikannya di produksi (keamanan).


Ringkasan

Konsep Poin Penting
Bundler Menggabungkan module menjadi file siap pakai
Vite Bundler modern, cepat, konfigurasi minimal
Webpack Bundler klasik, fleksibel, ekosistem besar
Babel Transpiler untuk kompatibilitas browser
esbuild Transpiler/bundler sangat cepat (Vite)
ESLint Linter — kualitas & bug
Prettier Formatter — konsistensi
Tree shaking Menghapus kode tidak dipakai
Code splitting Memecah bundle agar dimuat sesuai kebutuhan
HMR Hot Module Replacement — update tanpa reload

Poin penting:

  • Vite adalah pilihan default untuk proyek baru — cepat dan minimal konfigurasi.
  • Webpack masih relevan untuk proyek lama dan kebutuhan spesifik.
  • Babel hanya diperlukan untuk target browser lama; Vite/esbuild sudah cukup untuk modern.
  • ESLint + Prettier adalah kombinasi wajib untuk kualitas & konsistensi kode.
  • Environment variables di Vite hanya yang berprefix VITE_ — jangan simpan rahasia.
  • Tree shaking bekerja optimal dengan ES Module.
  • Jangan commit dist/ dan node_modules/ — gunakan .gitignore.

Pada artikel berikutnya, kita akan membahas Testing JavaScript — unit test dengan Jest/Vitest.

Top