webpack-dev-service 0.5.2 → 0.5.4

package/server/cjs/hot.cjs

@@ -1,216 +1,213 @@
 /**
- * @package webpack-dev-service
- * @license MIT
- * @version 0.5.2
- * @author nuintun <nuintun@qq.com>
- * @description A koa 2 middleware for webpack development and hot reloading.
- * @see https://github.com/nuintun/webpack-dev-service#readme
- */
-
+  * @package webpack-dev-service
+  * @license MIT
+  * @version 0.5.4
+  * @author nuintun <nuintun@qq.com>
+  * @description A koa 2 middleware for webpack development and hot reloading.
+  * @see https://github.com/nuintun/webpack-dev-service#readme
+  */
+ 
 'use strict';
 
 const WebSocket = require('ws');
 const webpack = require('webpack');
 
-function _interopDefault(e) {
-  return e && e.__esModule ? e : { default: e };
-}
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-const WebSocket__default = /*#__PURE__*/ _interopDefault(WebSocket);
-const webpack__default = /*#__PURE__*/ _interopDefault(webpack);
+const WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+const webpack__default = /*#__PURE__*/_interopDefault(webpack);
 
 /**
  * @module hot
  */
 const WEBSOCKET_RE = /^websocket$/i;
 function isObject(value) {
-  return Object.prototype.toString.call(value) === '[object Object]';
+    return Object.prototype.toString.call(value) === '[object Object]';
 }
 function resolveStatsOptions(compiler) {
-  const options = {
-    all: false,
-    hash: true,
-    colors: true,
-    errors: true,
-    assets: false,
-    builtAt: true,
-    warnings: true,
-    errorDetails: false
-  };
-  const { stats } = compiler.options;
-  if (isObject(stats)) {
-    const { warningsFilter } = stats;
-    if (warningsFilter !== undefined) {
-      options.warningsFilter = warningsFilter;
+    const options = {
+        all: false,
+        hash: true,
+        colors: true,
+        errors: true,
+        assets: false,
+        builtAt: true,
+        warnings: true,
+        errorDetails: false
+    };
+    const { stats } = compiler.options;
+    if (isObject(stats)) {
+        const { warningsFilter } = stats;
+        if (warningsFilter !== undefined) {
+            options.warningsFilter = warningsFilter;
+        }
     }
-  }
-  return options;
+    return options;
 }
 function normalize(path) {
-  const segments = [];
-  const parts = path.split(/[\\/]+/);
-  for (const segment of parts) {
-    switch (segment) {
-      case '.':
-        break;
-      case '..':
-        segments.pop();
-        break;
-      default:
-        segments.push(segment);
-        break;
+    const segments = [];
+    const parts = path.split(/[\\/]+/);
+    for (const segment of parts) {
+        switch (segment) {
+            case '.':
+                break;
+            case '..':
+                segments.pop();
+                break;
+            default:
+                segments.push(segment);
+                break;
+        }
     }
-  }
-  const pathname = segments.join('/');
-  return pathname.startsWith('/') ? pathname : `/${pathname}`;
+    const pathname = segments.join('/');
+    return pathname.startsWith('/') ? pathname : `/${pathname}`;
 }
 function resolveOptions(options) {
-  const settings = {
-    hmr: true,
-    path: '/hot',
-    progress: true,
-    ...options
-  };
-  settings.path = normalize(settings.path);
-  return settings;
+    const settings = {
+        hmr: true,
+        path: '/hot',
+        progress: true,
+        ...options
+    };
+    settings.path = normalize(settings.path);
+    return settings;
 }
 function isUpgradable(context, detector) {
-  const { upgrade } = context.headers;
-  return !!upgrade && detector.test(upgrade.trim());
+    const { upgrade } = context.headers;
+    return !!upgrade && detector.test(upgrade.trim());
 }
 function hasProblems(problems) {
-  return !!problems && problems.length > 0;
+    return !!problems && problems.length > 0;
 }
 class HotServer {
-  stats;
-  compiler;
-  server;
-  options;
-  name = 'webpack-hot-middleware';
-  logger;
-  constructor(compiler, options) {
-    this.compiler = compiler;
-    this.options = resolveOptions(options);
-    this.logger = compiler.getInfrastructureLogger(this.name);
-    this.server = new WebSocket.WebSocketServer({ path: this.options.path, noServer: true });
-    this.setupWss();
-    this.setupHooks();
-    this.setupPlugins();
-  }
-  setupWss() {
-    const { server, logger } = this;
-    server.on('error', error => {
-      logger.error(error.message);
-    });
-    server.on('connection', client => {
-      if (this.stats) {
-        this.broadcastStats([client], this.stats);
-      }
-    });
-  }
-  setupHooks() {
-    const { compiler } = this;
-    const { hooks } = compiler;
-    const statsOptions = resolveStatsOptions(compiler);
-    hooks.done.tapAsync(this.name, (stats, next) => {
-      next();
-      this.stats = stats.toJson(statsOptions);
-      this.broadcastStats(this.clients(), this.stats);
-    });
-    hooks.invalid.tap(this.name, (path, builtAt) => {
-      this.broadcast(this.clients(), 'invalid', { path, builtAt });
-    });
-  }
-  setupPlugins() {
-    const { options, compiler } = this;
-    const plugins = [
-      new webpack__default.default.NoEmitOnErrorsPlugin(),
-      new webpack__default.default.DefinePlugin({
-        __WDS_HOT_OPTIONS__: JSON.stringify({
-          ...options,
-          name: compiler.name
-        })
-      })
-    ];
-    if (options.hmr) {
-      plugins.push(new webpack__default.default.HotModuleReplacementPlugin());
+    stats;
+    compiler;
+    server;
+    options;
+    name = 'webpack-hot-middleware';
+    logger;
+    constructor(compiler, options) {
+        this.compiler = compiler;
+        this.options = resolveOptions(options);
+        this.logger = compiler.getInfrastructureLogger(this.name);
+        this.server = new WebSocket.WebSocketServer({ path: this.options.path, noServer: true });
+        this.setupWss();
+        this.setupHooks();
+        this.setupPlugins();
     }
-    if (options.progress) {
-      let value = 0;
-      plugins.push(
-        new webpack__default.default.ProgressPlugin((percentage, status, message) => {
-          const nextValue = Math.floor(percentage * 100);
-          if (nextValue > value || nextValue === 0) {
-            value = nextValue;
-            switch (value) {
-              case 0:
-                status = 'start';
-                message = 'end idle';
-                break;
-              case 100:
-                status = 'finish';
-                message = 'begin idle';
-                break;
+    setupWss() {
+        const { server, logger } = this;
+        server.on('error', error => {
+            logger.error(error.message);
+        });
+        server.on('connection', client => {
+            if (this.stats) {
+                this.broadcastStats([client], this.stats);
             }
-            this.broadcast(this.clients(), 'progress', { status, message, value });
-          }
-        })
-      );
+        });
+    }
+    setupHooks() {
+        const { compiler } = this;
+        const { hooks } = compiler;
+        const statsOptions = resolveStatsOptions(compiler);
+        hooks.done.tapAsync(this.name, (stats, next) => {
+            next();
+            this.stats = stats.toJson(statsOptions);
+            this.broadcastStats(this.clients(), this.stats);
+        });
+        hooks.invalid.tap(this.name, (path, builtAt) => {
+            this.broadcast(this.clients(), 'invalid', { path, builtAt });
+        });
     }
-    for (const plugin of plugins) {
-      plugin.apply(compiler);
+    setupPlugins() {
+        const { options, compiler } = this;
+        const plugins = [
+            new webpack__default.default.NoEmitOnErrorsPlugin(),
+            new webpack__default.default.DefinePlugin({
+                __WDS_HOT_OPTIONS__: JSON.stringify({
+                    ...options,
+                    name: compiler.name
+                })
+            })
+        ];
+        if (options.hmr) {
+            plugins.push(new webpack__default.default.HotModuleReplacementPlugin());
+        }
+        if (options.progress) {
+            let value = 0;
+            plugins.push(new webpack__default.default.ProgressPlugin((percentage, status, message) => {
+                const nextValue = Math.floor(percentage * 100);
+                if (nextValue > value || nextValue === 0) {
+                    value = nextValue;
+                    switch (value) {
+                        case 0:
+                            status = 'start';
+                            message = 'end idle';
+                            break;
+                        case 100:
+                            status = 'finish';
+                            message = 'begin idle';
+                            break;
+                    }
+                    this.broadcast(this.clients(), 'progress', { status, message, value });
+                }
+            }));
+        }
+        for (const plugin of plugins) {
+            plugin.apply(compiler);
+        }
     }
-  }
-  clients() {
-    return this.server.clients;
-  }
-  upgrade(context) {
-    const { server } = this;
-    const { req: request } = context;
-    if (isUpgradable(context, WEBSOCKET_RE) && server.shouldHandle(request)) {
-      context.respond = false;
-      const { socket } = context;
-      const head = Buffer.alloc(0);
-      server.handleUpgrade(request, socket, head, client => {
-        server.emit('connection', client, request);
-      });
-      return true;
+    clients() {
+        return this.server.clients;
     }
-    return false;
-  }
-  broadcast(clients, action, payload) {
-    for (const client of clients) {
-      if (client.readyState === WebSocket__default.default.OPEN) {
-        client.send(JSON.stringify({ action, payload }));
-      }
+    upgrade(context) {
+        const { server } = this;
+        const { req: request } = context;
+        if (isUpgradable(context, WEBSOCKET_RE) && server.shouldHandle(request)) {
+            context.respond = false;
+            const { socket } = context;
+            const head = Buffer.alloc(0);
+            server.handleUpgrade(request, socket, head, client => {
+                server.emit('connection', client, request);
+            });
+            return true;
+        }
+        return false;
     }
-  }
-  broadcastStats(clients, stats) {
-    if (clients.size > 0 || clients.length > 0) {
-      const { hash, builtAt, errors, warnings } = stats;
-      this.broadcast(clients, 'hash', { hash });
-      if (hasProblems(errors) || hasProblems(warnings)) {
-        this.broadcast(clients, 'problems', { errors, warnings, builtAt });
-      } else {
-        this.broadcast(clients, 'ok', { builtAt });
-      }
+    broadcast(clients, action, payload) {
+        for (const client of clients) {
+            if (client.readyState === WebSocket__default.default.OPEN) {
+                client.send(JSON.stringify({ action, payload }));
+            }
+        }
+    }
+    broadcastStats(clients, stats) {
+        if (clients.size > 0 || clients.length > 0) {
+            const { hash, builtAt, errors, warnings } = stats;
+            this.broadcast(clients, 'hash', { hash });
+            if (hasProblems(errors) || hasProblems(warnings)) {
+                this.broadcast(clients, 'problems', { errors, warnings, builtAt });
+            }
+            else {
+                this.broadcast(clients, 'ok', { builtAt });
+            }
+        }
     }
-  }
 }
 function hot(compiler, options = {}) {
-  const server = new HotServer(compiler, options);
-  const hotMiddleware = async (context, next) => {
-    if (!server.upgrade(context)) {
-      await next();
-    }
-  };
-  hotMiddleware.clients = () => {
-    return server.clients();
-  };
-  hotMiddleware.broadcast = (clients, action, payload) => {
-    server.broadcast(clients, action, payload);
-  };
-  return hotMiddleware;
+    const server = new HotServer(compiler, options);
+    const hotMiddleware = async (context, next) => {
+        if (!server.upgrade(context)) {
+            await next();
+        }
+    };
+    hotMiddleware.clients = () => {
+        return server.clients();
+    };
+    hotMiddleware.broadcast = (clients, action, payload) => {
+        server.broadcast(clients, action, payload);
+    };
+    return hotMiddleware;
 }
 
 module.exports = hot;

package/server/cjs/index.cjs

@@ -1,33 +1,32 @@
 /**
- * @package webpack-dev-service
- * @license MIT
- * @version 0.5.2
- * @author nuintun <nuintun@qq.com>
- * @description A koa 2 middleware for webpack development and hot reloading.
- * @see https://github.com/nuintun/webpack-dev-service#readme
- */
-
+  * @package webpack-dev-service
+  * @license MIT
+  * @version 0.5.4
+  * @author nuintun <nuintun@qq.com>
+  * @description A koa 2 middleware for webpack development and hot reloading.
+  * @see https://github.com/nuintun/webpack-dev-service#readme
+  */
+ 
 'use strict';
 
 const compose = require('koa-compose');
 const dev = require('./dev.cjs');
 const hot = require('./hot.cjs');
 
-function _interopDefault(e) {
-  return e && e.__esModule ? e : { default: e };
-}
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-const compose__default = /*#__PURE__*/ _interopDefault(compose);
+const compose__default = /*#__PURE__*/_interopDefault(compose);
 
 /**
  * @module index
  */
 function server(compiler, options = {}) {
-  const { hot: hotOptions, ...devOptions } = options;
-  const devMiddleware = dev(compiler, devOptions);
-  if (hotOptions === false) return devMiddleware;
-  const hotMiddleware = hot(compiler, hotOptions);
-  return Object.assign(compose__default.default([devMiddleware, hotMiddleware]), devMiddleware, hotMiddleware);
+    const { hot: hotOptions, ...devOptions } = options;
+    const devMiddleware = dev(compiler, devOptions);
+    if (hotOptions === false)
+        return devMiddleware;
+    const hotMiddleware = hot(compiler, hotOptions);
+    return Object.assign(compose__default.default([devMiddleware, hotMiddleware]), devMiddleware, hotMiddleware);
 }
 
 module.exports = server;

package/server/esm/dev.js

@@ -1,42 +1,38 @@
 /**
- * @package webpack-dev-service
- * @license MIT
- * @version 0.5.2
- * @author nuintun <nuintun@qq.com>
- * @description A koa 2 middleware for webpack development and hot reloading.
- * @see https://github.com/nuintun/webpack-dev-service#readme
- */
-
+  * @package webpack-dev-service
+  * @license MIT
+  * @version 0.5.4
+  * @author nuintun <nuintun@qq.com>
+  * @description A koa 2 middleware for webpack development and hot reloading.
+  * @see https://github.com/nuintun/webpack-dev-service#readme
+  */
+ 
 import webpackDevMiddleware from 'webpack-dev-middleware';
 
 /**
  * @module dev
  */
 function dev(compiler, options) {
-  const middleware = webpackDevMiddleware(compiler, options);
-  const devMiddleware = async (context, next) => {
-    context.remove('Content-Type');
-    await middleware(
-      context.req,
-      {
-        locals: context.state,
-        send(body) {
-          context.body = body;
-        },
-        status(statusCode) {
-          context.status = statusCode;
-        },
-        set(field, value) {
-          context.response.set(field, value);
-        },
-        get(field) {
-          return context.response.get(field);
-        }
-      },
-      next
-    );
-  };
-  return Object.assign(devMiddleware, middleware);
+    const middleware = webpackDevMiddleware(compiler, options);
+    const devMiddleware = async (context, next) => {
+        context.remove('Content-Type');
+        await middleware(context.req, {
+            locals: context.state,
+            send(body) {
+                context.body = body;
+            },
+            status(statusCode) {
+                context.status = statusCode;
+            },
+            set(field, value) {
+                context.response.set(field, value);
+            },
+            get(field) {
+                return context.response.get(field);
+            }
+        }, next);
+    };
+    return Object.assign(devMiddleware, middleware);
 }
 
 export { dev as default };