webpack-dev-service 0.7.2 → 0.8.0

package/server/esm/{hot.js → hot/Socket.js}

@@ -1,7 +1,7 @@
 /**
  * @package webpack-dev-service
  * @license MIT
- * @version 0.7.2
+ * @version 0.8.0
  * @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
@@ -11,11 +11,12 @@ import WebSocket, { WebSocketServer } from 'ws';
 import webpack from 'webpack';
 
 /**
- * @module hot
+ * @module Socket
  */
 const WEBSOCKET_RE = /^websocket$/i;
+const { toString } = Object.prototype;
 function isObject(value) {
-  return Object.prototype.toString.call(value) === '[object Object]';
+  return toString.call(value) === '[object Object]';
 }
 function resolveStatsOptions(compiler) {
   const options = {
@@ -72,7 +73,7 @@ function isUpgradable(context, detector) {
 function hasProblems(problems) {
   return !!problems && problems.length > 0;
 }
-class HotServer {
+class Socket {
   constructor(compiler, options) {
     this.name = 'webpack-hot-middleware';
     this.compiler = compiler;
@@ -183,20 +184,5 @@ class HotServer {
     }
   }
 }
-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;
-}
 
-export { hot as default };
+export { Socket };

package/server/esm/hot/index.js

@@ -0,0 +1,34 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.0
+ * @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 { Socket } from './Socket.js';
+
+/**
+ * @module index
+ */
+function hot(compiler, options = {}) {
+  const socket = new Socket(compiler, options);
+  return Object.assign(
+    async (ctx, next) => {
+      if (!socket.upgrade(ctx)) {
+        await next();
+      }
+    },
+    {
+      clients() {
+        return socket.clients();
+      },
+      broadcast(clients, action, payload) {
+        socket.broadcast(clients, action, payload);
+      }
+    }
+  );
+}
+
+export { hot };

package/server/esm/index.js

@@ -1,25 +1,27 @@
 /**
  * @package webpack-dev-service
  * @license MIT
- * @version 0.7.2
+ * @version 0.8.0
  * @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';
+import { compose } from './dev/utils/compose.js';
+import { dev } from './dev/index.js';
+import { hot } from './hot/index.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 devMiddleware = dev(compiler, options);
+  if (options.hot === false) {
+    return devMiddleware;
+  }
+  const hotMiddleware = hot(compiler, options.hot);
+  const middleware = compose(devMiddleware, hotMiddleware);
+  return Object.assign(middleware, devMiddleware, hotMiddleware);
 }
 
 export { server as default };

package/types/server/dev/Files.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @module Files
+ */
+import { Context } from 'koa';
+import { FilesOptions } from './interface';
+/**
+ * @class Files
+ */
+export default class Files {
+  private root;
+  private options;
+  /**
+   * @constructor
+   * @description Create files service.
+   * @param root Files service root.
+   * @param options Files service options.
+   */
+  constructor(root: string, options: FilesOptions);
+  /**
+   * @private
+   * @method isConditionalGET
+   * @description Check if request is conditional GET.
+   * @param context Koa context.
+   */
+  private isConditionalGET;
+  /**
+   * @private
+   * @method isPreconditionFailure
+   * @description Check if request precondition failure.
+   * @param context Koa context.
+   */
+  private isPreconditionFailure;
+  /**
+   * @private
+   * @method isRangeFresh
+   * @description Check if request range fresh.
+   * @param context Koa context.
+   */
+  private isRangeFresh;
+  /**
+   * @private
+   * @method parseRange
+   * @description Parse range.
+   * @param context Koa context.
+   * @param stats File stats.
+   */
+  private parseRange;
+  /**
+   * @private
+   * @method setupHeaders
+   * @description Setup headers
+   * @param context Koa context
+   * @param path File path
+   * @param stats File stats
+   */
+  private setupHeaders;
+  /**
+   * @private
+   * @method readTo
+   * @description Read file.
+   * @param stream Destination stream.
+   * @param path File path.
+   * @param range Read range.
+   * @param end Is destory destination stream after read.
+   */
+  private readTo;
+  /**
+   * @private
+   * @method send
+   * @description Send file.
+   * @param context Koa context.
+   * @param path File path.
+   * @param ranges Read ranges.
+   */
+  private send;
+  /**
+   * @public
+   * @method response
+   * @description Response to koa context.
+   * @param context Koa context.
+   */
+  response(context: Context): Promise<boolean>;
+}

package/types/server/dev/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module index
+ */
+import { Middleware } from 'koa';
+import { Compiler } from 'webpack';
+import { AdditionalMethods, Options } from './interface';
+export { AdditionalMethods, Options };
+export declare function dev(compiler: Compiler, options?: Options): Middleware & AdditionalMethods;

package/types/server/dev/interface.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @module interface
+ */
+/// <reference types="node" />
+import { createReadStream, Stats as FileStats } from 'fs';
+import { Compiler, Configuration, MultiCompiler, MultiStats, Stats, Watching } from 'webpack';
+type IOutputFileSystem = NonNullable<Compiler['outputFileSystem']>;
+interface HeaderFunction {
+  (path: string, stats: FileStats): Record<string, string | string[]>;
+}
+export interface OutputFileSystem extends IOutputFileSystem {
+  createReadStream: typeof createReadStream;
+}
+export type Callback = (stats: Stats | MultiStats | null) => void;
+export interface FilesOptions {
+  etag?: boolean;
+  fs: OutputFileSystem;
+  cacheControl?: string;
+  acceptRanges?: boolean;
+  lastModified?: boolean;
+  headers?: HeaderFunction | Record<string, string | string[]>;
+}
+export interface Options extends Omit<FilesOptions, 'fs'> {
+  stats?: Configuration['stats'];
+  outputFileSystem?: OutputFileSystem;
+  writeToDisk?: boolean | ((targetPath: string) => boolean);
+}
+export interface Context {
+  state: boolean;
+  options: Options;
+  callbacks: Callback[];
+  stats: Stats | MultiStats | null;
+  compiler: Compiler | MultiCompiler;
+  outputFileSystem: OutputFileSystem;
+  logger: ReturnType<Compiler['getInfrastructureLogger']>;
+  watching: Watching | ReturnType<MultiCompiler['watch']>;
+}
+export interface AdditionalMethods {
+  isReady(): boolean;
+  logger: Context['logger'];
+  ready(callback: Callback): void;
+  invalidate(callback: Callback): void;
+  close(callback: (error?: Error | null) => void): void;
+}
+export type InitialContext = Optional<Context, 'watching' | 'outputFileSystem'>;
+export {};

package/types/server/dev/middleware.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module middleware
+ */
+import { Middleware } from 'koa';
+import { Context } from './interface';
+export declare function middleware(context: Context): Middleware;

package/types/server/dev/utils/boundary.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module boundary
+ */
+/**
+ * @function generate
+ * @description Generate a boundary.
+ */
+export declare function generate(): string;

package/types/server/dev/utils/common.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module common
+ */
+/// <reference types="node" />
+import { Stats } from 'fs';
+import { Compiler, MultiCompiler } from 'webpack';
+import { OutputFileSystem } from '../../../server/dev/interface';
+export declare const PLUGIN_NAME = 'webpack-dev-service';
+/**
+ * @function unixify
+ * @description Convert path to unix style.
+ * @param path The path to convert.
+ */
+export declare function unixify(path: string): string;
+/**
+ * @function decodeURI
+ * @description Decode URI component.
+ * @param URI The URI to decode.
+ */
+export declare function decodeURI(URI: string): string | -1;
+/**
+ * @function hasTrailingSlash
+ * @description Check if path has trailing slash.
+ * @param path The path to check.
+ */
+export declare function hasTrailingSlash(path: string): boolean;
+export declare function isString(value: unknown): value is string;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isFunction(value: unknown): value is Function;
+/**
+ * @function isOutRoot
+ * @description Check if path is out of root.
+ * @param path The path to check.
+ * @param root The root path.
+ */
+export declare function isOutRoot(path: string, root: string): boolean;
+export declare function getCompilers(compiler: Compiler | MultiCompiler): Compiler[];
+/**
+ * @function fstat
+ * @description Get file stats.
+ * @param path The file path.
+ */
+export declare function fstat(fs: OutputFileSystem, path: string): Promise<Stats | undefined>;
+export declare function isMultiCompilerMode(compiler: Compiler | MultiCompiler): compiler is MultiCompiler;

package/types/server/dev/utils/compose.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module compose
+ */
+export interface Next {
+  (): Promise<void>;
+}
+export interface Composed<C> {
+  (context: C, next?: Next): Promise<void>;
+}
+export interface Middleware<C> {
+  (context: C, next: Next): Promise<void> | void;
+}
+/**
+ * @function compose
+ * @description 生成融合中间件
+ * @param middlewares 中间件数组
+ */
+export declare function compose<C>(...middlewares: Middleware<C>[]): Composed<C>;

package/types/server/dev/utils/getPaths.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module getPaths
+ */
+import { Context } from '../../../server/dev/interface';
+interface Path {
+  outputPath: string;
+  publicPath: string;
+}
+export declare function getPaths(context: Context, name: string): Promise<Path[]>;
+export {};

package/types/server/dev/utils/http.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @method http
+ */
+/**
+ * @function parseTokens
+ * @description Parse HTTP tokens.
+ * @param value The tokens value string.
+ */
+export declare function parseTokens(value: string): string[];
+/**
+ * @function isETag
+ * @description Check if etag is valid.
+ * @param value The value to check.
+ */
+export declare function isETag(value: string): boolean;
+/**
+ * @function isETagFresh
+ * @description Check if etag is fresh.
+ * @param match The match value.
+ * @param etag The etag value.
+ */
+export declare function isETagFresh(match: string, etag: string): boolean;

package/types/server/dev/utils/ready.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @method ready
+ */
+import { Callback, Context } from '../../../server/dev/interface';
+export declare function ready(context: Context, callback: Callback, name?: string): void;

package/types/server/dev/utils/setupHooks.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module setupHooks
+ */
+import { InitialContext } from '../../../server/dev/interface';
+export declare function setupHooks(context: InitialContext): void;

package/types/server/dev/utils/setupOutputFileSystem.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module setupOutputFileSystem
+ */
+import { InitialContext } from '../../../server/dev/interface';
+export declare function setupOutputFileSystem(context: InitialContext): void;

package/types/server/dev/utils/setupWatching.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module setupWatching
+ */
+import { InitialContext } from '../../../server/dev/interface';
+export declare function setupWatching(context: InitialContext): void;

package/types/server/dev/utils/setupWriteToDisk.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module setupWriteToDisk
+ */
+import { InitialContext } from '../../../server/dev/interface';
+export declare function setupWriteToDisk(context: InitialContext): void;

package/types/server/hot/Socket.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module Socket
+ */
+import { Context } from 'koa';
+import WebSocket from 'ws';
+import { Compiler, StatsCompilation } from 'webpack';
+export interface Options {
+  hmr?: boolean;
+  path?: string;
+  progress?: boolean;
+}
+export declare class Socket {
+  private stats;
+  private readonly compiler;
+  private readonly server;
+  private readonly options;
+  private readonly name;
+  private readonly logger;
+  constructor(compiler: Compiler, options: Options);
+  setupWss(): void;
+  setupHooks(): void;
+  setupPlugins(): void;
+  clients(): Set<WebSocket>;
+  upgrade(context: Context): boolean;
+  broadcast<T>(clients: Set<WebSocket> | WebSocket[], action: string, payload: T): void;
+  broadcastStats(clients: Set<WebSocket> | WebSocket[], stats: StatsCompilation): void;
+}

package/types/server/{hot.d.ts → hot/index.d.ts}

@@ -1,16 +1,13 @@
 /**
- * @module hot
+ * @module index
  */
-import { Middleware } from 'koa';
 import WebSocket from 'ws';
+import { Middleware } from 'koa';
 import { Compiler } from 'webpack';
-export interface Options {
-  hmr?: boolean;
-  path?: string;
-  progress?: boolean;
-}
-export type Instance = {
+import { Options } from './Socket';
+export { Options };
+export interface AdditionalMethods {
   clients(): Set<WebSocket>;
   broadcast<T>(clients: Set<WebSocket> | WebSocket[], action: string, payload: T): void;
-};
-export default function hot(compiler: Compiler, options?: Options): Middleware & Instance;
+}
+export declare function hot(compiler: Compiler, options?: Options): Middleware & AdditionalMethods;

package/types/server/index.d.ts

@@ -3,8 +3,8 @@
  */
 import { Middleware } from 'koa';
 import { Compiler } from 'webpack';
-import { Instance as DevInstance, Options as DevOptions } from './dev';
-import { Instance as HotInstance, Options as HotOptions } from './hot';
+import { AdditionalMethods as DevMethods, Options as DevOptions } from './dev';
+import { AdditionalMethods as HotMethods, Options as HotOptions } from './hot';
 type DisableHotOptions = DevOptions & {
   hot: false;
 };
@@ -12,8 +12,8 @@ type EnableHotOptions = DevOptions & {
   hot?: HotOptions;
 };
 export type Options = EnableHotOptions | DisableHotOptions;
-export type DisableHotMiddleware = Middleware & DevInstance;
-export type EnableHotMiddleware = DisableHotMiddleware & HotInstance;
+export type DisableHotMiddleware = Middleware & DevMethods;
+export type EnableHotMiddleware = DisableHotMiddleware & HotMethods;
 /**
  * @function server
  * @description Create koa dev server middleware.

package/server/cjs/dev.cjs

@@ -1,50 +0,0 @@
-/**
- * @package webpack-dev-service
- * @license MIT
- * @version 0.7.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
- */
-
-'use strict';
-
-const webpackDevMiddleware = require('webpack-dev-middleware');
-
-function _interopDefault(e) {
-  return e && e.__esModule ? e : { default: e };
-}
-
-const webpackDevMiddleware__default = /*#__PURE__*/ _interopDefault(webpackDevMiddleware);
-
-/**
- * @module dev
- */
-function dev(compiler, options) {
-  const middleware = webpackDevMiddleware__default.default(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);
-}
-
-module.exports = dev;

package/server/esm/dev.js

@@ -1,42 +0,0 @@
-/**
- * @package webpack-dev-service
- * @license MIT
- * @version 0.7.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
- */
-
-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);
-}
-
-export { dev as default };

package/types/server/dev.d.ts

@@ -1,17 +0,0 @@
-/**
- * @module dev
- */
-/// <reference types="node" />
-import { AdditionalMethods, ExtendedServerResponse, IncomingMessage, Options as DevOptions } from 'webpack-dev-middleware';
-import { Middleware } from 'koa';
-import { Compiler } from 'webpack';
-import { ServerResponse } from 'http';
-export interface OutgoingMessage extends ServerResponse, ExtendedServerResponse {
-  send(body: any): void;
-  get(field: string): string;
-  status(statusCode: number): void;
-  set(field: string, value: string): void;
-}
-export type Options = DevOptions<IncomingMessage, OutgoingMessage>;
-export type Instance = AdditionalMethods<IncomingMessage, OutgoingMessage>;
-export default function dev(compiler: Compiler, options: Options): Middleware & Instance;