webpack-dev-service 0.7.2 → 0.8.1

package/server/cjs/dev/index.cjs

@@ -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
+ */
+
+'use strict';
+
+const ready = require('./utils/ready.cjs');
+const middleware = require('./middleware.cjs');
+const common = require('./utils/common.cjs');
+const setupHooks = require('./utils/setupHooks.cjs');
+const setupWatching = require('./utils/setupWatching.cjs');
+const setupWriteToDisk = require('./utils/setupWriteToDisk.cjs');
+const setupOutputFileSystem = require('./utils/setupOutputFileSystem.cjs');
+
+/**
+ * @module index
+ */
+function setup(compiler, options) {
+  const context = {
+    options,
+    compiler,
+    stats: null,
+    state: false,
+    callbacks: [],
+    logger: compiler.getInfrastructureLogger(common.PLUGIN_NAME)
+  };
+  setupHooks.setupHooks(context);
+  if (options.writeToDisk) {
+    setupWriteToDisk.setupWriteToDisk(context);
+  }
+  setupOutputFileSystem.setupOutputFileSystem(context);
+  setupWatching.setupWatching(context);
+  return context;
+}
+function dev(compiler, options = {}) {
+  const context = setup(compiler, options);
+  return Object.assign(middleware.middleware(context), {
+    isReady() {
+      return context.state;
+    },
+    get logger() {
+      return context.logger;
+    },
+    ready(callback) {
+      ready.ready(context, callback);
+    },
+    invalidate(callback) {
+      ready.ready(context, callback);
+      context.watching.invalidate();
+    },
+    close(callback) {
+      context.watching.close(callback);
+    }
+  });
+}
+
+exports.dev = dev;

package/server/cjs/dev/middleware.cjs

@@ -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
+ */
+
+'use strict';
+
+const Files = require('./Files.cjs');
+const common = require('./utils/common.cjs');
+const getPaths = require('./utils/getPaths.cjs');
+
+/**
+ * @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.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 = common.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();
+    }
+  };
+}
+
+exports.middleware = middleware;

package/server/cjs/dev/utils/boundary.cjs

@@ -0,0 +1,42 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+/**
+ * @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;
+}
+
+exports.generate = generate;

package/server/cjs/dev/utils/common.cjs

@@ -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
+ */
+
+'use strict';
+
+const path = require('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$1, root) {
+  path$1 = path.relative(root, path$1);
+  return /\.\.(?:[\\/]|$)/.test(path$1) || path.isAbsolute(path$1);
+}
+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;
+}
+
+exports.PLUGIN_NAME = PLUGIN_NAME;
+exports.decodeURI = decodeURI;
+exports.fstat = fstat;
+exports.getCompilers = getCompilers;
+exports.hasTrailingSlash = hasTrailingSlash;
+exports.isBoolean = isBoolean;
+exports.isFunction = isFunction;
+exports.isMultiCompilerMode = isMultiCompilerMode;
+exports.isOutRoot = isOutRoot;
+exports.isString = isString;
+exports.unixify = unixify;

package/server/cjs/dev/utils/compose.cjs

@@ -0,0 +1,58 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+/**
+ * @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);
+  };
+}
+
+exports.compose = compose;

package/server/cjs/dev/utils/getPaths.cjs

@@ -0,0 +1,71 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+const url = require('url');
+const ready = require('./ready.cjs');
+
+/**
+ * @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.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.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
+      );
+    }
+  });
+}
+
+exports.getPaths = getPaths;

package/server/cjs/dev/utils/http.cjs

@@ -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
+ */
+
+'use strict';
+
+/**
+ * @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;
+  });
+}
+
+exports.isETag = isETag;
+exports.isETagFresh = isETagFresh;
+exports.parseTokens = parseTokens;

package/server/cjs/dev/utils/ready.cjs

@@ -0,0 +1,26 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+/**
+ * @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}`);
+    }
+  }
+}
+
+exports.ready = ready;

package/server/cjs/dev/utils/setupHooks.cjs

@@ -0,0 +1,95 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+const supportsColor = require('supports-color');
+const common = require('./common.cjs');
+
+function _interopDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+
+const supportsColor__default = /*#__PURE__*/ _interopDefault(supportsColor);
+
+/**
+ * @module setupHooks
+ */
+function normalizeStatsOptions(statsOptions) {
+  if (statsOptions == null) {
+    return { preset: 'normal' };
+  } else if (common.isString(statsOptions)) {
+    return { preset: statsOptions };
+  } else if (common.isBoolean(statsOptions)) {
+    return statsOptions ? { preset: 'normal' } : { preset: 'none' };
+  }
+  if (statsOptions.colors == null) {
+    const { stdout, stderr } = supportsColor__default.default;
+    statsOptions.colors = stdout !== false && stderr !== false;
+  }
+  return statsOptions;
+}
+function getStatsOptions(context) {
+  const { compiler } = context;
+  const { stats } = context.options;
+  if (stats != null) {
+    if (!common.isMultiCompilerMode(compiler)) {
+      return normalizeStatsOptions(stats);
+    }
+    return {
+      children: compiler.compilers.map(() => normalizeStatsOptions(stats))
+    };
+  }
+  if (!common.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(common.PLUGIN_NAME, done);
+  hooks.invalid.tap(common.PLUGIN_NAME, invalid);
+  hooks.watchRun.tap(common.PLUGIN_NAME, invalid);
+}
+
+exports.setupHooks = setupHooks;

package/server/cjs/dev/utils/setupOutputFileSystem.cjs

@@ -0,0 +1,64 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+const memfs = require('memfs');
+const common = require('./common.cjs');
+
+/**
+ * @module setupOutputFileSystem
+ */
+function createMemfs() {
+  const volume = new memfs.Volume();
+  return memfs.createFsFromVolume(volume);
+}
+function hasReadStream(fs) {
+  return common.isFunction(fs.createReadStream);
+}
+function getOutputFileSystem({ options, compiler }) {
+  if (options.outputFileSystem) {
+    return options.outputFileSystem;
+  }
+  if (options.writeToDisk !== true) {
+    return createMemfs();
+  }
+  if (common.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 = common.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;
+}
+
+exports.setupOutputFileSystem = setupOutputFileSystem;

package/server/cjs/dev/utils/setupWatching.cjs

@@ -0,0 +1,43 @@
+/**
+ * @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
+ */
+
+'use strict';
+
+const common = require('./common.cjs');
+
+/**
+ * @module setupWatching
+ */
+function getWatching({ compiler, logger }) {
+  const isMulti = common.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);
+}
+
+exports.setupWatching = setupWatching;