webpack-dev-service 0.5.4 → 0.5.6

package/server/esm/hot.js

@@ -1,12 +1,12 @@
 /**
-  * @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
-  */
- 
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.5.6
+ * @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 WebSocket, { WebSocketServer } from 'ws';
 import webpack from 'webpack';
 
@@ -15,192 +15,193 @@ import webpack from 'webpack';
  */
 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 WebSocketServer({ path: this.options.path, noServer: true });
-        this.setupWss();
-        this.setupHooks();
-        this.setupPlugins();
+  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 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.NoEmitOnErrorsPlugin(),
+      new webpack.DefinePlugin({
+        __WDS_HOT_OPTIONS__: JSON.stringify({
+          ...options,
+          name: compiler.name
+        })
+      })
+    ];
+    if (options.hmr) {
+      plugins.push(new webpack.HotModuleReplacementPlugin());
     }
-    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);
+    if (options.progress) {
+      let value = 0;
+      plugins.push(
+        new webpack.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 });
+          }
+        })
+      );
     }
-    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.NoEmitOnErrorsPlugin(),
-            new webpack.DefinePlugin({
-                __WDS_HOT_OPTIONS__: JSON.stringify({
-                    ...options,
-                    name: compiler.name
-                })
-            })
-        ];
-        if (options.hmr) {
-            plugins.push(new webpack.HotModuleReplacementPlugin());
-        }
-        if (options.progress) {
-            let value = 0;
-            plugins.push(new webpack.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.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;
-    }
-    broadcast(clients, action, payload) {
-        for (const client of clients) {
-            if (client.readyState === WebSocket.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 });
-            }
-        }
+  }
+  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;
 }
 
 export { hot as default };

package/server/esm/index.js

@@ -1,12 +1,12 @@
 /**
-  * @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
-  */
- 
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.5.6
+ * @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 compose from 'koa-compose';
 import dev from './dev.js';
 import hot from './hot.js';
@@ -15,12 +15,11 @@ import hot from './hot.js';
  * @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([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([devMiddleware, hotMiddleware]), devMiddleware, hotMiddleware);
 }
 
 export { server as default };

package/types/client/client.d.ts

@@ -2,12 +2,12 @@
  * @module client
  */
 export interface Options {
-    readonly hmr: boolean;
-    readonly name: string;
-    readonly path: string;
-    readonly live: boolean;
-    readonly origin: string;
-    readonly overlay: boolean;
-    readonly progress: boolean;
+  readonly hmr: boolean;
+  readonly name: string;
+  readonly path: string;
+  readonly live: boolean;
+  readonly origin: string;
+  readonly overlay: boolean;
+  readonly progress: boolean;
 }
 export default function createClient(options: Options): void;

package/types/client/events.d.ts

@@ -4,18 +4,18 @@
 import { Options } from './client';
 import * as Message from './message';
 interface Messages {
-    ok: Message.OK['payload'];
-    hash: Message.Hash['payload'];
-    invalid: Message.Invalid['payload'];
-    problems: Message.Problems['payload'];
-    progress: Message.Progress['payload'];
+  ok: Message.OK['payload'];
+  hash: Message.Hash['payload'];
+  invalid: Message.Invalid['payload'];
+  problems: Message.Problems['payload'];
+  progress: Message.Progress['payload'];
 }
 interface Events {
-    ok: (message: Messages['ok'], options: Options) => void;
-    hash: (message: Messages['hash'], options: Options) => void;
-    invalid: (message: Messages['invalid'], options: Options) => void;
-    problems: (message: Messages['problems'], options: Options) => void;
-    progress: (message: Messages['progress'], options: Options) => void;
+  ok: (message: Messages['ok'], options: Options) => void;
+  hash: (message: Messages['hash'], options: Options) => void;
+  invalid: (message: Messages['invalid'], options: Options) => void;
+  problems: (message: Messages['problems'], options: Options) => void;
+  progress: (message: Messages['progress'], options: Options) => void;
 }
 /**
  * @function on

package/types/client/message.d.ts

@@ -3,37 +3,37 @@
  */
 import { StatsError } from 'webpack';
 export interface Invalid {
-    action: 'invalid';
-    payload: {
-        path: string;
-        builtAt: number;
-    };
+  action: 'invalid';
+  payload: {
+    path: string;
+    builtAt: number;
+  };
 }
 export interface Progress {
-    action: 'progress';
-    payload: {
-        value: number;
-        status: string;
-        message: string;
-    };
+  action: 'progress';
+  payload: {
+    value: number;
+    status: string;
+    message: string;
+  };
 }
 export interface Hash {
-    action: 'hash';
-    payload: {
-        hash: string;
-    };
+  action: 'hash';
+  payload: {
+    hash: string;
+  };
 }
 export interface Problems {
-    action: 'problems';
-    payload: {
-        builtAt: number;
-        errors: StatsError[];
-        warnings: StatsError[];
-    };
+  action: 'problems';
+  payload: {
+    builtAt: number;
+    errors: StatsError[];
+    warnings: StatsError[];
+  };
 }
 export interface OK {
-    action: 'ok';
-    payload: {
-        builtAt: number;
-    };
+  action: 'ok';
+  payload: {
+    builtAt: number;
+  };
 }

package/types/client/ui/overlay.d.ts

@@ -4,16 +4,16 @@
  */
 import { StatsError } from 'webpack';
 export default class Overlay {
-    private hidden;
-    private readonly name;
-    private readonly close;
-    private readonly aside;
-    private readonly errorsList;
-    private readonly errorsTitle;
-    private readonly warningsList;
-    private readonly warningsTitle;
-    constructor(name: string);
-    setProblems(type: 'errors' | 'warnings', problems: StatsError[]): void;
-    show(): void;
-    hide(): void;
+  private hidden;
+  private readonly name;
+  private readonly close;
+  private readonly aside;
+  private readonly errorsList;
+  private readonly errorsTitle;
+  private readonly warningsList;
+  private readonly warningsTitle;
+  constructor(name: string);
+  setProblems(type: 'errors' | 'warnings', problems: StatsError[]): void;
+  show(): void;
+  hide(): void;
 }

package/types/client/ui/progress.d.ts

@@ -4,12 +4,12 @@
  * @see https://www.zhangxinxu.com/wordpress/2015/07/svg-circle-loading
  */
 export default class Progress {
-    private timer?;
-    private hidden;
-    private readonly svg;
-    private readonly track;
-    constructor();
-    update(value: number): void;
-    show(): void;
-    hide(): void;
+  private timer?;
+  private hidden;
+  private readonly svg;
+  private readonly track;
+  constructor();
+  update(value: number): void;
+  show(): void;
+  hide(): void;
 }

package/types/client/ui/utils/ansi/enum.d.ts

@@ -2,11 +2,11 @@
  * @module enum
  */
 export declare const enum TokenType {
-    EOS = 0,
-    ESC = 1,
-    OSC = 2,
-    SGR = 3,
-    TEXT = 4,
-    INCESC = 5,
-    UNKNOWN = 6
+  EOS = 0,
+  ESC = 1,
+  OSC = 2,
+  SGR = 3,
+  TEXT = 4,
+  INCESC = 5,
+  UNKNOWN = 6
 }

package/types/client/ui/utils/ansi/index.d.ts

@@ -4,15 +4,15 @@
 import { AnsiBlock, AnsiColor, AnsiStyle, Theme } from './interface';
 export type { AnsiBlock, AnsiStyle };
 export default class Ansi {
-    protected buffer: string;
-    protected style: AnsiStyle;
-    protected colors256: AnsiColor[];
-    protected colors16: AnsiColor[][];
-    constructor(theme?: Theme);
-    private read;
-    private reset;
-    private process;
-    private block;
-    write(text: string, callback: (block: AnsiBlock) => void): void;
-    flush(callback: (block: AnsiBlock) => void): void;
+  protected buffer: string;
+  protected style: AnsiStyle;
+  protected colors256: AnsiColor[];
+  protected colors16: AnsiColor[][];
+  constructor(theme?: Theme);
+  private read;
+  private reset;
+  private process;
+  private block;
+  write(text: string, callback: (block: AnsiBlock) => void): void;
+  flush(callback: (block: AnsiBlock) => void): void;
 }