webpack doc

The webpack-dev-server is a little node.js Express server, which uses the [[webpack-dev-middleware]] to serve a webpack bundle. It also has a little runtime which is connected to the server via Socket.IO. The server emits information about the compilation state to the client, which reacts to those events. You can choose between different modes, depending on your needs. So let's say you have the following config file:

  1. var path = require("path");
  2. module.exports = {
  3. entry: {
  4. app: ["./app/main.js"]
  5. },
  6. output: {
  7. path: path.resolve(__dirname, "build"),
  8. publicPath: "/assets/",
  9. filename: "bundle.js"
  10. }
  11. };

You have an app folder with your initial entry point that webpack will bundle into a bundle.js file in the build folder.

Content Base

The webpack-dev-server will serve the files in the current directory, unless you configure a specific content base.

  1. $ webpack-dev-server --content-base build/

Using this config webpack-dev-server will serve the static files in your build folder. It'll watch your source files for changes and when changes are made the bundle will be recompiled. This modified bundle is served from memory at the relative path specified in publicPath (see API). It will not be written to your configured output directory. Where a bundle already exists at the same url path the bundle in memory will take precedence (by default).

For example with the configuration above your bundle will be available at localhost:8080/assets/bundle.js

To load your bundled files, you will need to create an index.html file in the build folder from which static files are served (--content-base option). e.g:

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Document</title>
  6. </head>
  7. <body>
  8. <script src="bundle.js"></script>
  9. </body>
  10. </html>

By default go to localhost:8080/ to launch your app. For example with the configuration above (with publicPath) go to localhost:8080/assets/.

Automatic Refresh

The webpack-dev-server supports multiple modes to automatic refresh the page:

  • Iframe mode (page is embedded in an iframe and reloaded on change)
  • Inline mode (a small webpack-dev-server client entry is added to the bundle which refresh the page on change)

Each mode also supports Hot Module Replacement in which the bundle is notified that a change happened instead of a full page reload. A Hot Module Replacement runtime could then load the updated modules and inject them into the running app.

Iframe mode

To use the iframe mode no additional configuration is needed. Just navigate the browser to http://:/webpack-dev-server/. I. e. with the above configuration http://localhost:8080/webpack\-dev\-server/index.html.

  • No configuration change needed.
  • Nice information bar on top of your app.
  • Url changes in the app are not reflected in the browsers url bar.

Inline mode

To use the inline mode, specify --inline on the command line (you cannot specify it in the configuration). This adds the webpack-dev-server client entry point to the webpack configuration. There is no change in the url required. Just navigate to http://:/. I. e. with the above configuration http://localhost:8080/index.html.

  • Command line flag needed.
  • Status information in the browser log.
  • Url changes in the app are reflected in the browsers url bar.

Inline mode with node.js API

There is no inline: true flag in the webpack-dev-server configuration, because the webpack-dev-server module has no access to the webpack configuration. Instead the user must add the webpack-dev-server client entry point to the webpack configuration.

To do this just add webpack-dev-server/client?http://:/ to (all) entry point(s). I. e. with the above configuration:

  1. var config = require("./webpack.config.js");
  2. config.entry.app.unshift("webpack-dev-server/client?http://localhost:8080/");
  3. var compiler = webpack(config);
  4. var server = new WebpackDevServer(compiler, {...});
  5. server.listen(8080);

Inline mode in HTML

There is also the option to add a reference to the webpack-dev-server client script to the HTML page:

  1. <script src="http://localhost:8080/webpack-dev-server.js"></script>

Hot Module Replacement

To enable Hot Module Replacement with the webpack-dev-server specify --hot on the command line. This adds the HotModuleReplacementPlugin to the webpack configuration.

The easiest way to use Hot Module Replacement with the webpack-dev-server is to use the inline mode.

Hot Module Replacement with Inline mode on CLI

Nothing more is needed. --inline --hot does all the relevant work automatically. The CLI of the webpack-dev-server automatically adds the special webpack/hot/dev-server entry point to your configuration.

Just navigate to http://:/ and let the magic happen.

You should see the following messages in the browser log:

  1. [HMR] Waiting for update signal from WDS...
  2. [WDS] Hot Module Replacement enabled.

Messages prefixed with [HMR] originate from the webpack/hot/dev-server module. Messages prefixed with [WDS] originate from the webpack-dev-server client.

It's important to specify a correct output.publicPath otherwise the hot update chunks cannot be loaded.

Hot Module Replacement with node.js API

Similar to the inline mode the user must make changes to the webpack configuration.

Three changes are needed:

  • add an entry point to the webpack configuration: webpack/hot/dev-server.
  • add the new webpack.HotModuleReplacementPlugin() to the webpack configuration.
  • add hot: true to the webpack-dev-server configuration to enable HMR on the server.

I. e. with the above configuration:

  1. var config = require("./webpack.config.js");
  2. config.entry.app.unshift("webpack-dev-server/client?http://localhost:8080/", "webpack/hot/dev-server");
  3. var compiler = webpack(config);
  4. var server = new webpackDevServer(compiler, {
  5. hot: true
  6. ...
  7. });
  8. server.listen(8080);

Working with editors/IDEs supporting "safe write"

Note that many editors support "safe write" feature and have it enabled by default, which makes dev server unable to watch files correctly. "Safe write" means changes are not written directly to original file but to temporary one instead, which is renamed and replaces original file when save operation is completed successfully. This behaviour causes file watcher to lose the track because the original file is removed. In order to prevent this issue, you have to disable "safe write" feature in your editor.

  • VIM - set ":set backupcopy=yes" (see documentation)
  • IntelliJ - Settings -> System Settings -> Synchronization -> disable "safe write" (may differ in various IntelliJ IDEs, but you can still use the search feature)

Proxy

The Webpack dev server makes use of node-http-proxy to optionally proxy requests to a separate, possibly external, backend server. A sample configuration is below.

  1. proxy: {
  2. '/some/path*': {
  3. target: 'https://other-server.example.com',
  4. secure: false
  5. }
  6. }

See the node-http-proxy Options documentation for available configuration.

Proxying some URLs can be useful for a variety of configurations. One example is to serve JavaScript files and other static assets from the local development server but still send API requests to an external backend development server. Another example is splitting requests between two separate backend servers such as an authentication backend and a application backend.

Bypass the Proxy

(Added in v1.13.0.) The proxy can be optionally bypassed based on the return from a function. The function can inspect the HTTP request, response, and any given proxy options. It must return either false or a URL path that will be served instead of continuing to proxy the request.

For example, the configuration below will not proxy HTTP requests that originate from a browser. This is similar to the historyApiFallback option: browser requests will receive the HTML file as normal but API requests will be proxied to the backend server.

  1. proxy: {
  2. '/some/path*': {
  3. target: 'https://other-server.example.com',
  4. secure: false,
  5. bypass: function(req, res, proxyOptions) {
  6. if (req.headers.accept.indexOf('html') !== -1) {
  7. console.log('Skipping proxy for browser request.');
  8. return '/index.html';
  9. }
  10. }
  11. }

Rewriting URLs of proxy request

(Added in v???) The request to the proxy can be optionally rewritten by providing a function. The function can inspect and change the HTTP request.

For example, the configuration below will rewrite the HTTP requests to remove the part /api at the beginning of the URL.

  1. proxy: {
  2. '/api/*': {
  3. target: 'https://other-server.example.com',
  4. rewrite: function(req) {
  5. req.url = req.url.replace(/^\/api/, '');
  6. }
  7. }
  8. }

webpack-dev-server CLI

  1. $ webpack-dev-server <entry>

All webpack [[CLI|cli]] options are valid for the webpack-dev-server CLI too, but there is no default argument. For the webpack-dev-server CLI a webpack.config.js (or the file passed by the --config option) is accepted as well.

There are some additional options:

  • --content-base : base path for the content.
  • --quiet: don't output anything to the console.
  • --no-info: suppress boring information.
  • --colors: add some colors to the output.
  • --no-colors: don't use colors in the output.
  • --compress: use gzip compression.
  • --host : hostname or IP. 0.0.0.0 binds to all hosts.
  • --port : port.
  • --inline: embed the webpack-dev-server runtime into the bundle.
  • --hot: adds the HotModuleReplacementPlugin and switch the server to hot mode. Note: make sure you don't add HotModuleReplacementPlugin twice.
  • --hot --inline also adds the webpack/hot/dev-server entry.
  • --lazy: no watching, compiles on request (cannot be combined with --hot).
  • --https: serves webpack-dev-server over HTTPS Protocol. Includes a self-signed certificate that is used when serving the requests.
  • --cert, --cacert, --key: Paths the certificate files.
  • --open: opens the url in default browser (for webpack-dev-server versions > 2.0).
  • --history-api-fallback: enables support for history API fallback.

Additional configuration options

When using the CLI it's possible to have the webpack-dev-server options in the configuration file under the key devServer. Options passed via CLI arguments override options in configuration file. For options under devServer see next section.

Example

  1. module.exports = {
  2. // ...
  3. devServer: {
  4. hot: true
  5. }
  6. }

API

  1. var WebpackDevServer = require("webpack-dev-server");
  2. var webpack = require("webpack");
  3. var compiler = webpack({
  4. // configuration
  5. });
  6. var server = new WebpackDevServer(compiler, {
  7. // webpack-dev-server options
  8. contentBase: "/path/to/directory",
  9. // or: contentBase: "http://localhost/",
  10. hot: true,
  11. // Enable special support for Hot Module Replacement
  12. // Page is no longer updated, but a "webpackHotUpdate" message is send to the content
  13. // Use "webpack/hot/dev-server" as additional module in your entry point
  14. // Note: this does _not_ add the `HotModuleReplacementPlugin` like the CLI option does.
  15. // Set this as true if you want to access dev server from arbitrary url.
  16. // This is handy if you are using a html5 router.
  17. historyApiFallback: false,
  18. // Set this if you want to enable gzip compression for assets
  19. compress: true,
  20. // Set this if you want webpack-dev-server to delegate a single path to an arbitrary server.
  21. // Use "*" to proxy all paths to the specified server.
  22. // This is useful if you want to get rid of 'http://localhost:8080/' in script[src],
  23. // and has many other use cases (see https://github.com/webpack/webpack-dev-server/pull/127 ).
  24. proxy: {
  25. "*": "http://localhost:9090"
  26. },
  27. // pass [static options](http://expressjs.com/en/4x/api.html#express.static) to inner express server
  28. staticOptions: {
  29. },
  30. // webpack-dev-middleware options
  31. quiet: false,
  32. noInfo: false,
  33. lazy: true,
  34. filename: "bundle.js",
  35. watchOptions: {
  36. aggregateTimeout: 300,
  37. poll: 1000
  38. },
  39. publicPath: "/assets/",
  40. headers: { "X-Custom-Header": "yes" },
  41. stats: { colors: true }
  42. });
  43. server.listen(8080, "localhost", function() {});
  44. // server.close();

See [[webpack-dev-middleware]] for documentation on middleware options.

Notice that webpack configuration is not passed to WebpackDevServer API, thus devServer option in webpack configuration is not used in this case. Also, there is no inline mode for WebpackDevServer API. should be inserted to HTML page manually.

The historyApiFallback option

If you are using the HTML5 history API you probably need to serve your index.html in place of 404 responses, which can be done by setting historyApiFallback: true. However, if you have modified output.publicPath in your Webpack configuration, you need to specify the URL to redirect to. This is done using the historyApiFallback.index option:

  1. // output.publicPath: '/foo-app/'
  2. historyApiFallback: {
  3. index: '/foo-app/'
  4. }

Combining with an existing server

You may want to run a backend server or a mock of it in development. You should not use the webpack-dev-server as a backend. Its only purpose is to serve static (webpacked) assets.

You can run two servers side-by-side: The webpack-dev-server and your backend server.

In this case you need to teach the webpack-generated assets to make requests to the webpack-dev-server even when running on a HTML-page sent by the backend server. On the other side you need to teach your backend server to generate HTML pages that include script tags that point to assets on the webpack-dev-server. In addition to that you need a connection between the webpack-dev-server and the webpack-dev-server runtime to trigger reloads on recompilation.

To teach webpack to make requests (for chunk loading or HMR) to the webpack-dev-server you need to provide a full URL in the output.publicPath option.

To make a connection between webpack-dev-server and its runtime best, use the inline mode with --inline. The webpack-dev-server CLI automatically includes an entry point which establishes a WebSocket connection. (You can also use the iframe mode if you point --content-base of the webpack-dev-server to your backend server. If you need a websocket connection to your backend server, you'll have to use iframe mode.

When you use the inline mode just open the backend server URL in your web browsers. (If you use the iframe mode open the /webpack-dev-server/ prefixed URL of the webpack-dev-server.)

Summary and example:

Or use the proxy option…