webpack-dev-service 0.7.2 → 0.8.1

package/server/esm/dev/middleware.js

@@ -0,0 +1,67 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 Files from './Files.js';
+import { decodeURI } from './utils/common.js';
+import { getPaths } from './utils/getPaths.js';
+
+/**
+ * @module middleware
+ */
+const cache = new WeakMap();
+async function getFilesInstances(context, name) {
+  const cached = cache.get(context.compiler);
+  if (cached != null) {
+    return cached;
+  }
+  const { options } = context;
+  const instances = [];
+  const paths = await getPaths(context, name);
+  for (const { outputPath, publicPath } of paths) {
+    instances.push({
+      publicPath,
+      files: new Files(outputPath, {
+        etag: options.etag,
+        headers: options.headers,
+        fs: context.outputFileSystem,
+        acceptRanges: options.acceptRanges,
+        cacheControl: options.cacheControl,
+        lastModified: options.lastModified
+      })
+    });
+  }
+  return instances;
+}
+function middleware(context) {
+  return async (ctx, next) => {
+    const path = decodeURI(ctx.path);
+    // Path -1 or null byte(s)
+    if (path === -1 || path.includes('\0')) {
+      return ctx.throw(400);
+    }
+    let respond = false;
+    const instances = await getFilesInstances(context, path);
+    for (const { files, publicPath } of instances) {
+      if (path.startsWith(publicPath)) {
+        ctx.path = path.slice(publicPath.length);
+        respond = await files.response(ctx);
+        if (respond) {
+          return;
+        } else {
+          ctx.path = path;
+        }
+      }
+    }
+    if (!respond) {
+      await next();
+    }
+  };
+}
+
+export { middleware };

package/server/esm/dev/utils/boundary.js

@@ -0,0 +1,40 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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
+ */
+
+/**
+ * @module boundary
+ */
+// prettier-ignore
+const CHARS = [
+    // 0-9
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    // A-M
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    // N-Z
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    // a-m
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    // n-z
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
+];
+/**
+ * @function generate
+ * @description Generate a boundary.
+ */
+function generate() {
+  let boundary = '';
+  // Create boundary.
+  for (let i = 0; i < 38; i++) {
+    boundary += CHARS[Math.floor(Math.random() * 62)];
+  }
+  // Return boundary.
+  return boundary;
+}
+
+export { generate };

package/server/esm/dev/utils/common.js

@@ -0,0 +1,98 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 { relative, isAbsolute } from 'path';
+
+/**
+ * @module common
+ */
+const { toString } = Object.prototype;
+const PLUGIN_NAME = 'webpack-dev-service';
+/**
+ * @function unixify
+ * @description Convert path to unix style.
+ * @param path The path to convert.
+ */
+function unixify(path) {
+  return path.replace(/\\/g, '/');
+}
+/**
+ * @function decodeURI
+ * @description Decode URI component.
+ * @param URI The URI to decode.
+ */
+function decodeURI(URI) {
+  try {
+    return decodeURIComponent(URI);
+  } catch (_a) {
+    return -1;
+  }
+}
+/**
+ * @function hasTrailingSlash
+ * @description Check if path has trailing slash.
+ * @param path The path to check.
+ */
+function hasTrailingSlash(path) {
+  return /\/$/.test(path);
+}
+function isString(value) {
+  return toString.call(value) === '[object String]';
+}
+function isBoolean(value) {
+  return toString.call(value) === '[object Boolean]';
+}
+function isFunction(value) {
+  return typeof value === 'function';
+}
+/**
+ * @function isOutRoot
+ * @description Check if path is out of root.
+ * @param path The path to check.
+ * @param root The root path.
+ */
+function isOutRoot(path, root) {
+  path = relative(root, path);
+  return /\.\.(?:[\\/]|$)/.test(path) || isAbsolute(path);
+}
+function getCompilers(compiler) {
+  if (isMultiCompilerMode(compiler)) {
+    return compiler.compilers;
+  }
+  return [compiler];
+}
+/**
+ * @function fstat
+ * @description Get file stats.
+ * @param path The file path.
+ */
+function fstat(fs, path) {
+  return new Promise((resolve, reject) => {
+    fs.stat(path, (error, stats) => {
+      error ? reject(error) : resolve(stats);
+    });
+  });
+}
+function isMultiCompilerMode(compiler) {
+  return 'compilers' in compiler;
+}
+
+export {
+  PLUGIN_NAME,
+  decodeURI,
+  fstat,
+  getCompilers,
+  hasTrailingSlash,
+  isBoolean,
+  isFunction,
+  isMultiCompilerMode,
+  isOutRoot,
+  isString,
+  unixify
+};

package/server/esm/dev/utils/compose.js

@@ -0,0 +1,56 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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
+ */
+
+/**
+ * @module compose
+ */
+/**
+ * @function dispatch
+ * @param middlewares 中间件数组
+ * @param index 要执行的中间件索引
+ * @param stack 调用栈信息
+ * @param context 执行上下文
+ * @param [next] 下一个中间件
+ */
+async function dispatch(middlewares, index, stack, context, next) {
+  if (index <= stack.index) {
+    throw new Error('next() called multiple times');
+  }
+  stack.index = index;
+  const { length } = middlewares;
+  if (index <= length) {
+    if (index < length) {
+      const middleware = middlewares[index];
+      await middleware(context, () => {
+        return dispatch(middlewares, index + 1, stack, context, next);
+      });
+    } else if (next) {
+      await next();
+    }
+  }
+}
+/**
+ * @function compose
+ * @description 生成融合中间件
+ * @param middlewares 中间件数组
+ */
+function compose(...middlewares) {
+  /**
+   * @function middleware
+   * @description 融合中间件
+   * @param context 执行上下文
+   * @param [next] 下一个中间件
+   */
+  return (context, next) => {
+    const stack = { index: -1 };
+    return dispatch(middlewares, 0, stack, context, next);
+  };
+}
+
+export { compose };

package/server/esm/dev/utils/getPaths.js

@@ -0,0 +1,69 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 { URL } from 'url';
+import { ready } from './ready.js';
+
+/**
+ * @module getPaths
+ */
+const cache = new WeakMap();
+function getOutputPath(compilation) {
+  const { path } = compilation.outputOptions;
+  return compilation.getPath(path != null ? path : '');
+}
+function getPublicPath(compilation) {
+  const { publicPath } = compilation.outputOptions;
+  const path = compilation.getPath(publicPath != null ? publicPath : '');
+  try {
+    return new URL(path).pathname;
+  } catch (_a) {
+    return path;
+  }
+}
+function getStats(stats) {
+  if (stats == null) {
+    return [];
+  }
+  if (isMultiStatsMode(stats)) {
+    return stats.stats;
+  }
+  return [stats];
+}
+function isMultiStatsMode(stats) {
+  return 'stats' in stats;
+}
+function getPaths(context, name) {
+  return new Promise(resolve => {
+    const { compiler } = context;
+    const paths = cache.get(compiler);
+    if (paths != null) {
+      resolve(paths);
+    } else {
+      ready(
+        context,
+        stats => {
+          const paths = [];
+          const childStats = getStats(stats);
+          for (const { compilation } of childStats) {
+            // The `output.path` is always present and always absolute
+            const outputPath = getOutputPath(compilation);
+            const publicPath = getPublicPath(compilation);
+            paths.push({ outputPath, publicPath });
+          }
+          cache.set(compiler, paths);
+          resolve(paths);
+        },
+        name
+      );
+    }
+  });
+}
+
+export { getPaths };

package/server/esm/dev/utils/http.js

@@ -0,0 +1,65 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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
+ */
+
+/**
+ * @method http
+ */
+/**
+ * @function parseTokens
+ * @description Parse HTTP tokens.
+ * @param value The tokens value string.
+ */
+function parseTokens(value) {
+  let end = 0;
+  let start = 0;
+  let tokens = [];
+  // Gather tokens.
+  for (let i = 0, length = value.length; i < length; i++) {
+    switch (value.charCodeAt(i)) {
+      case 0x20:
+        // ' '.
+        if (start === end) {
+          start = end = i + 1;
+        }
+        break;
+      case 0x2c:
+        // ','.
+        tokens.push(value.substring(start, end));
+        start = end = i + 1;
+        break;
+      default:
+        end = i + 1;
+        break;
+    }
+  }
+  // Final token.
+  tokens.push(value.substring(start, end));
+  return tokens;
+}
+/**
+ * @function isETag
+ * @description Check if etag is valid.
+ * @param value The value to check.
+ */
+function isETag(value) {
+  return /^(?:W\/)?"[\s\S]+"$/.test(value);
+}
+/**
+ * @function isETagFresh
+ * @description Check if etag is fresh.
+ * @param match The match value.
+ * @param etag The etag value.
+ */
+function isETagFresh(match, etag) {
+  return parseTokens(match).some(match => {
+    return match === etag || match === 'W/' + etag || 'W/' + match === etag;
+  });
+}
+
+export { isETag, isETagFresh, parseTokens };

package/server/esm/dev/utils/ready.js

@@ -0,0 +1,24 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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
+ */
+
+/**
+ * @method ready
+ */
+function ready(context, callback, name) {
+  if (context.state) {
+    callback(context.stats);
+  } else {
+    context.callbacks.push(callback);
+    if (name) {
+      context.logger.info(`wait until bundle finished: ${name}`);
+    }
+  }
+}
+
+export { ready };

package/server/esm/dev/utils/setupHooks.js

@@ -0,0 +1,87 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 supportsColor from 'supports-color';
+import { PLUGIN_NAME, isMultiCompilerMode, isString, isBoolean } from './common.js';
+
+/**
+ * @module setupHooks
+ */
+function normalizeStatsOptions(statsOptions) {
+  if (statsOptions == null) {
+    return { preset: 'normal' };
+  } else if (isString(statsOptions)) {
+    return { preset: statsOptions };
+  } else if (isBoolean(statsOptions)) {
+    return statsOptions ? { preset: 'normal' } : { preset: 'none' };
+  }
+  if (statsOptions.colors == null) {
+    const { stdout, stderr } = supportsColor;
+    statsOptions.colors = stdout !== false && stderr !== false;
+  }
+  return statsOptions;
+}
+function getStatsOptions(context) {
+  const { compiler } = context;
+  const { stats } = context.options;
+  if (stats != null) {
+    if (!isMultiCompilerMode(compiler)) {
+      return normalizeStatsOptions(stats);
+    }
+    return {
+      children: compiler.compilers.map(() => normalizeStatsOptions(stats))
+    };
+  }
+  if (!isMultiCompilerMode(compiler)) {
+    return normalizeStatsOptions(compiler.options.stats);
+  }
+  return {
+    children: compiler.compilers.map(({ options }) => normalizeStatsOptions(options.stats))
+  };
+}
+function setupHooks(context) {
+  function invalid() {
+    if (context.state) {
+      context.logger.log('Compilation starting...');
+    }
+    // We are now in invalid state
+    context.stats = null;
+    context.state = false;
+  }
+  function done(stats) {
+    // We are now on valid state
+    context.state = true;
+    context.stats = stats;
+    // Do the stuff in nextTick, because bundle may be invalidated if a change happened while compiling
+    process.nextTick(() => {
+      const { state } = context;
+      // Check if still in valid state
+      if (state) {
+        const { logger, callbacks } = context;
+        logger.log('Compilation finished');
+        context.callbacks = [];
+        for (const callback of callbacks) {
+          callback(stats);
+        }
+        const statsOptions = getStatsOptions(context);
+        const printedStats = stats.toString(statsOptions);
+        // Avoid extra empty line when `stats: 'none'`
+        if (printedStats) {
+          logger.log(printedStats);
+        }
+      }
+    });
+  }
+  const { hooks } = context.compiler;
+  hooks.done.tap(PLUGIN_NAME, done);
+  hooks.invalid.tap(PLUGIN_NAME, invalid);
+  hooks.watchRun.tap(PLUGIN_NAME, invalid);
+}
+
+export { setupHooks };

package/server/esm/dev/utils/setupOutputFileSystem.js

@@ -0,0 +1,62 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 { Volume, createFsFromVolume } from 'memfs';
+import { getCompilers, isFunction, isMultiCompilerMode } from './common.js';
+
+/**
+ * @module setupOutputFileSystem
+ */
+function createMemfs() {
+  const volume = new Volume();
+  return createFsFromVolume(volume);
+}
+function hasReadStream(fs) {
+  return isFunction(fs.createReadStream);
+}
+function getOutputFileSystem({ options, compiler }) {
+  if (options.outputFileSystem) {
+    return options.outputFileSystem;
+  }
+  if (options.writeToDisk !== true) {
+    return createMemfs();
+  }
+  if (isMultiCompilerMode(compiler)) {
+    const { compilers } = compiler;
+    for (const compiler of compilers) {
+      if ('devServer' in compiler) {
+        if (compiler.outputFileSystem) {
+          return compiler.outputFileSystem;
+        }
+      }
+    }
+    if (compiler.outputFileSystem) {
+      return compiler.outputFileSystem;
+    }
+    for (const compiler of compilers) {
+      if (compiler.outputFileSystem) {
+        return compiler.outputFileSystem;
+      }
+    }
+  }
+  return createMemfs();
+}
+function setupOutputFileSystem(context) {
+  const compilers = getCompilers(context.compiler);
+  const outputFileSystem = getOutputFileSystem(context);
+  if (!hasReadStream(outputFileSystem)) {
+    throw new Error('Compiler outputFileSystem must support createReadStream');
+  }
+  for (const compiler of compilers) {
+    compiler.outputFileSystem = outputFileSystem;
+  }
+  context.outputFileSystem = outputFileSystem;
+}
+
+export { setupOutputFileSystem };

package/server/esm/dev/utils/setupWatching.js

@@ -0,0 +1,41 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 { isMultiCompilerMode } from './common.js';
+
+/**
+ * @module setupWatching
+ */
+function getWatching({ compiler, logger }) {
+  const isMulti = isMultiCompilerMode(compiler);
+  if (!isMulti && compiler.watching) {
+    return compiler.watching;
+  }
+  const errorHandler = error => {
+    if (error) {
+      // For example - `writeToDisk` can throw an error and right now it is ends watching.
+      // We can improve that and keep watching active, but it is require API on webpack side.
+      // Let's implement that in webpack@5 because it is rare case.
+      logger.error(error);
+    }
+  };
+  if (!isMulti) {
+    const { watchOptions } = compiler.options;
+    return compiler.watch(watchOptions, errorHandler);
+  }
+  const watchOptions = compiler.compilers.map(({ options }) => {
+    return options.watchOptions;
+  });
+  return compiler.watch(watchOptions, errorHandler);
+}
+function setupWatching(context) {
+  context.watching = getWatching(context);
+}
+
+export { setupWatching };

package/server/esm/dev/utils/setupWriteToDisk.js

@@ -0,0 +1,60 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.8.1
+ * @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 { dirname } from 'path';
+import { mkdir, writeFile } from 'fs';
+import { getCompilers, PLUGIN_NAME, isFunction } from './common.js';
+
+/**
+ * @module setupWriteToDisk
+ */
+const assetEmitted = Symbol('assetEmitted');
+function getCompilerName({ options: { name } }) {
+  return name ? `Child "${name}": ` : '';
+}
+function isAllowWrite(targetPath, filter) {
+  return filter && isFunction(filter) ? filter(targetPath) : true;
+}
+function setupWriteToDisk(context) {
+  const { logger, options } = context;
+  const { writeToDisk: filter } = options;
+  const compilers = getCompilers(context.compiler);
+  for (const compiler of compilers) {
+    const { hooks } = compiler;
+    hooks.emit.tap(PLUGIN_NAME, () => {
+      if (!compiler[assetEmitted]) {
+        hooks.assetEmitted.tapAsync(PLUGIN_NAME, (_file, { targetPath, content }, callback) => {
+          if (!isAllowWrite(targetPath, filter)) {
+            return callback();
+          }
+          const dir = dirname(targetPath);
+          const name = getCompilerName(compiler);
+          return mkdir(dir, { recursive: true }, mkdirError => {
+            if (mkdirError) {
+              logger.error(`${name}Unable to write "${dir}" directory to disk:\n${mkdirError}`);
+              return callback(mkdirError);
+            }
+            writeFile(targetPath, content, writeFileError => {
+              if (writeFileError) {
+                logger.error(`${name}Unable to write "${targetPath}" asset to disk:\n${writeFileError}`);
+                return callback(writeFileError);
+              }
+              logger.log(`${name}Asset written to disk: "${targetPath}"`);
+              return callback();
+            });
+          });
+        });
+        // Set asset emitted to true
+        compiler[assetEmitted] = true;
+      }
+    });
+  }
+}
+
+export { setupWriteToDisk };