Webpack has four core concepts:

1. Entry: The starting point where Webpack begins building the dependency graph
2. Output: Where and how to emit the bundles
3. Loaders: Transform files from different languages/formats into modules
4. Plugins: Extend Webpack's functionality for optimization, asset management, etc.

module.exports = {
  entry: './src/index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js'
  },
  module: {
    rules: [{ test: /\.js$/, use: 'babel-loader' }]
  },
  plugins: [new HtmlWebpackPlugin()]
};

A basic webpack.config.js structure:

const path = require('path');

module.exports = {
  mode: 'development', // or 'production'
  entry: './src/index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js'
  },
  module: {
    rules: [
      // Loader configurations
    ]
  },
  plugins: [
    // Plugin instances
  ],
  resolve: {
    // Module resolution options
  },
  devServer: {
    // Dev server configuration
  }
};

Loaders transform files from different languages or formats into modules that Webpack can understand. They run during the build process and transform files on a per-file basis.

module.exports = {
  module: {
    rules: [
      {
        test: /\.css$/,
        use: ['style-loader', 'css-loader']
      },
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader',
          options: {
            presets: ['@babel/preset-env']
          }
        }
      }
    ]
  }
};

Loaders are processed right-to-left (or bottom-to-top) in the use array.

css-loader:

• Interprets @import and url() like import/require()
• Resolves CSS dependencies and returns CSS as a string

style-loader:

• Injects CSS into the DOM by adding <style> tags
• Usually used after css-loader in the chain

// This processes CSS files and injects them into the DOM
{
  test: /\.css$/,
  use: ['style-loader', 'css-loader']
}

For production, you might use MiniCssExtractPlugin.loader instead of style-loader to extract CSS into separate files.

Plugins:

• Perform actions on the entire bundle or compilation
• Can modify the build process, add files, or optimize output
• Work at the bundle level

Loaders:

• Transform individual files during the build process
• Work at the file level
• Process files before they're added to the bundle

const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
  plugins: [
    new HtmlWebpackPlugin({
      template: './src/index.html'
    })
  ]
};

HtmlWebpackPlugin automatically generates HTML files that include your Webpack bundles. It's useful because:

• Automatic injection: Automatically adds script and link tags for your bundles
• Template support: Can use HTML templates with variables
• Multiple pages: Can generate multiple HTML files
• Cache busting: Works with filename hashing for cache invalidation

new HtmlWebpackPlugin({
  template: './src/index.html',
  filename: 'index.html',
  chunks: ['app'], // Only include specific chunks
  minify: process.env.NODE_ENV === 'production'
})

module.exports = {
  devServer: {
    static: './dist',
    port: 3000,
    open: true,
    hot: true,
    compress: true,
    historyApiFallback: true, // For SPA routing
    proxy: {
      '/api': {
        target: 'http://localhost:8080',
        changeOrigin: true
      }
    }
  }
};

Key options:

• static: Serve static files from directory
• hot: Enable HMR
• proxy: Proxy API requests to another server
• historyApiFallback: Handle client-side routing