webpack-dev-service 0.10.0 → 0.10.1

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

@@ -0,0 +1,227 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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 hash = require('./hash.cjs');
+const parseRange = require('range-parser');
+
+function _interopDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+
+const parseRange__default = /*#__PURE__*/ _interopDefault(parseRange);
+
+/**
+ * @module http
+ */
+/**
+ * @function isETag
+ * @description Check if etag is valid.
+ * @param value The value to check.
+ */
+function isETag(value) {
+  return /^(?:W\/)?"[\s\S]+"$/.test(value);
+}
+/**
+ * @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 isRangeFresh
+ * @description Check if request range fresh.
+ * @param context Koa context.
+ */
+function isRangeFresh(context) {
+  const { request, response } = context;
+  const ifRange = request.get('If-Range');
+  // No If-Range.
+  if (!ifRange) {
+    return true;
+  }
+  // If-Range as etag.
+  if (isETag(ifRange)) {
+    const etag = response.get('ETag');
+    return !!(etag && isETagFresh(ifRange, etag));
+  }
+  // If-Range as modified date.
+  const lastModified = response.get('Last-Modified');
+  return Date.parse(lastModified) <= Date.parse(ifRange);
+}
+/**
+ * @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;
+  });
+}
+/**
+ * @function decodeURI
+ * @description Decode URI component.
+ * @param URI The URI to decode.
+ */
+function decodeURI(URI) {
+  try {
+    return decodeURIComponent(URI);
+  } catch (_a) {
+    return -1;
+  }
+}
+/**
+ * @function isConditionalGET
+ * @description Check if request is conditional GET.
+ * @param context Koa context.
+ */
+function isConditionalGET(context) {
+  const { request } = context;
+  return !!(
+    request.get('If-Match') ||
+    request.get('If-None-Match') ||
+    request.get('If-Modified-Since') ||
+    request.get('If-Unmodified-Since')
+  );
+}
+/**
+ * @function isPreconditionFailure
+ * @description Check if request precondition failure.
+ * @param context Koa context.
+ */
+function isPreconditionFailure({ request, response }) {
+  // If-Match.
+  const match = request.get('If-Match');
+  // Check if request match.
+  if (match) {
+    // Etag.
+    const etag = response.get('ETag');
+    return !etag || match === '*' || !isETagFresh(match, etag);
+  }
+  // If-Unmodified-Since.
+  const unmodifiedSince = Date.parse(request.get('If-Unmodified-Since'));
+  // Check if request unmodified.
+  if (!Number.isNaN(unmodifiedSince)) {
+    // Last-Modified.
+    const lastModified = Date.parse(response.get('Last-Modified'));
+    return Number.isNaN(lastModified) || lastModified > unmodifiedSince;
+  }
+  // Check precondition passed.
+  return false;
+}
+/**
+ * @function parseRanges
+ * @description Parse ranges.
+ * @param context Koa context.
+ * @param stats File stats.
+ */
+function parseRanges(context, stats) {
+  const { size } = stats;
+  // Range support.
+  if (/^bytes$/i.test(context.response.get('Accept-Ranges'))) {
+    const range = context.request.get('Range');
+    // Range fresh.
+    if (range && isRangeFresh(context)) {
+      // Parse range -1 -2 or [].
+      const parsed = parseRange__default.default(size, range, { combine: true });
+      // -1 signals an unsatisfiable range.
+      // -2 signals a malformed header string.
+      if (parsed === -1 || parsed === -2) {
+        return parsed;
+      }
+      // Ranges ok, support multiple ranges.
+      if (parsed.type === 'bytes') {
+        // Set 206 status.
+        context.status = 206;
+        const { length } = parsed;
+        // Multiple ranges.
+        if (length > 1) {
+          // Content-Length.
+          let contentLength = 0;
+          // Ranges.
+          const ranges = [];
+          // Range boundary.
+          const boundary = `<${hash.generate()}>`;
+          // Range suffix.
+          const suffix = `\r\n--${boundary}--\r\n`;
+          // Multipart Content-Type.
+          const contentType = `Content-Type: ${context.type}`;
+          // Override Content-Type.
+          context.type = `multipart/byteranges; boundary=${boundary}`;
+          // Map ranges.
+          for (let index = 0; index < length; index++) {
+            const { start, end } = parsed[index];
+            // The first prefix boundary no \r\n.
+            const head = index > 0 ? '\r\n' : '';
+            const contentRange = `Content-Range: bytes ${start}-${end}/${size}`;
+            const prefix = `${head}--${boundary}\r\n${contentType}\r\n${contentRange}\r\n\r\n`;
+            // Compute Content-Length
+            contentLength += end - start + 1 + Buffer.byteLength(prefix);
+            // Cache range.
+            ranges.push({ start, end, prefix });
+          }
+          // The last add suffix boundary.
+          ranges[length - 1].suffix = suffix;
+          // Compute Content-Length.
+          contentLength += Buffer.byteLength(suffix);
+          // Set Content-Length.
+          context.length = contentLength;
+          // Return ranges.
+          return ranges;
+        } else {
+          const [{ start, end }] = parsed;
+          // Set Content-Length.
+          context.length = end - start + 1;
+          // Set Content-Range.
+          context.set('Content-Range', `bytes ${start}-${end}/${size}`);
+          // Return ranges.
+          return parsed;
+        }
+      }
+    }
+  }
+  // Set Content-Length.
+  context.length = size;
+  // Return ranges.
+  return [{ start: 0, end: Math.max(size - 1) }];
+}
+
+exports.decodeURI = decodeURI;
+exports.isConditionalGET = isConditionalGET;
+exports.isPreconditionFailure = isPreconditionFailure;
+exports.parseRanges = parseRanges;

package/cjs/server/dev/utils/path.cjs

@@ -0,0 +1,46 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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 path
+ */
+/**
+ * @function unixify
+ * @description Convert path to unix style.
+ * @param path The path to convert.
+ */
+function unixify(path) {
+  return path.replace(/\\/g, '/');
+}
+/**
+ * @function hasTrailingSlash
+ * @description Check if path has trailing slash.
+ * @param path The path to check.
+ */
+function hasTrailingSlash(path) {
+  return /\/$/.test(path);
+}
+/**
+ * @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);
+}
+
+exports.hasTrailingSlash = hasTrailingSlash;
+exports.isOutRoot = isOutRoot;
+exports.unixify = unixify;

package/cjs/server/dev/utils/paths.cjs

@@ -0,0 +1,59 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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');
+
+/**
+ * @module paths
+ */
+function getOutputPath(compilation) {
+  // The `output.path` is always present and always absolute.
+  const { path } = compilation.outputOptions;
+  // Get the path.
+  return compilation.getPath(path ? path : '');
+}
+function getPublicPath(compilation) {
+  const { publicPath } = compilation.outputOptions;
+  const path = compilation.getPath(publicPath ? publicPath : '');
+  // Get the path.
+  try {
+    return new url.URL(path).pathname;
+  } catch (_a) {
+    return path;
+  }
+}
+function getStats(stats) {
+  if (isMultiStatsMode(stats)) {
+    return stats.stats;
+  }
+  // Return the stats.
+  return [stats];
+}
+function isMultiStatsMode(stats) {
+  return 'stats' in stats;
+}
+function getPaths(stats) {
+  const paths = [];
+  const childStats = getStats(stats);
+  // Get the paths.
+  for (const { compilation } of childStats) {
+    paths.push([
+      // Output path.
+      getOutputPath(compilation),
+      // Public path.
+      getPublicPath(compilation)
+    ]);
+  }
+  // Return the paths.
+  return paths;
+}
+
+exports.getPaths = getPaths;

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

@@ -0,0 +1,23 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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 ready
+ */
+function ready({ stats, callbacks }, callback) {
+  if (stats) {
+    callback(stats);
+  } else {
+    callbacks.push(callback);
+  }
+}
+
+exports.ready = ready;

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

@@ -0,0 +1,106 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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 utils = require('../../utils.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 (utils.isString(statsOptions)) {
+    return { preset: statsOptions };
+  } else if (utils.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) {
+    if (utils.isMultiCompilerMode(compiler)) {
+      return {
+        children: compiler.compilers.map(() => {
+          return normalizeStatsOptions(stats);
+        })
+      };
+    }
+    return normalizeStatsOptions(stats);
+  }
+  if (utils.isMultiCompilerMode(compiler)) {
+    return {
+      children: compiler.compilers.map(({ options }) => {
+        return normalizeStatsOptions(options.stats);
+      })
+    };
+  }
+  return normalizeStatsOptions(compiler.options.stats);
+}
+function setupHooks(context) {
+  const { hooks } = context.compiler;
+  const statsOptions = getStatsOptions(context);
+  const invalid = () => {
+    // We are now in invalid state.
+    context.stats = null;
+    // Log compilation starting.
+    context.logger.log('compilation starting...');
+  };
+  const {
+    onCompilerDone = (stats, statsOptions) => {
+      const printedStats = stats.toString(statsOptions);
+      // Avoid extra empty line when `stats: 'none'`.
+      if (printedStats) {
+        context.logger.info(printedStats);
+      }
+    }
+  } = context.options;
+  const done = stats => {
+    // We are now on valid state
+    context.stats = stats;
+    // Do the stuff in nextTick, because bundle may be invalidated if a change happened while compiling.
+    process.nextTick(() => {
+      const { stats } = context;
+      // Check if still in valid state.
+      if (stats) {
+        // Call onCompilerDone.
+        onCompilerDone(stats, statsOptions);
+        // Callbacks.
+        const { callbacks } = context;
+        // Clear callbacks.
+        context.callbacks = [];
+        // Call callbacks.
+        for (const callback of callbacks) {
+          callback(stats);
+        }
+        // Log compilation finished.
+        context.logger.log('compilation finished');
+      }
+    });
+  };
+  hooks.done.tap(utils.PLUGIN_NAME, done);
+  hooks.invalid.tap(utils.PLUGIN_NAME, invalid);
+  hooks.watchRun.tap(utils.PLUGIN_NAME, invalid);
+}
+
+exports.setupHooks = setupHooks;

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

@@ -0,0 +1,31 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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 utils = require('../../utils.cjs');
+const memfs = require('memfs');
+
+/**
+ * @module setupOutputFileSystem
+ */
+function createMemfs() {
+  const volume = new memfs.Volume();
+  return memfs.createFsFromVolume(volume);
+}
+function setupOutputFileSystem(context) {
+  const { fs = createMemfs() } = context.options;
+  const compilers = utils.getCompilers(context.compiler);
+  for (const compiler of compilers) {
+    compiler.outputFileSystem = fs;
+  }
+  context.fs = fs;
+}
+
+exports.setupOutputFileSystem = setupOutputFileSystem;

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

@@ -0,0 +1,43 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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 utils = require('../../utils.cjs');
+
+/**
+ * @module setupWatching
+ */
+function getWatching({ compiler, logger }) {
+  const isMulti = utils.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;

package/cjs/server/dev/utils/setupWriteToDisk.cjs

@@ -0,0 +1,54 @@
+/**
+ * @package webpack-dev-service
+ * @license MIT
+ * @version 0.10.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');
+const fs = require('fs');
+const utils = require('../../utils.cjs');
+
+/**
+ * @module setupWriteToDisk
+ */
+function getCompilerName({ options: { name } }) {
+  return name ? `compiler "${name}": ` : '';
+}
+function isAllowWrite(targetPath, filter) {
+  return utils.isFunction(filter) ? filter(targetPath) : filter === true;
+}
+function setupWriteToDisk(context) {
+  const { logger, options } = context;
+  const { writeToDisk: filter } = options;
+  const compilers = utils.getCompilers(context.compiler);
+  for (const compiler of compilers) {
+    compiler.hooks.assetEmitted.tapAsync(utils.PLUGIN_NAME, (_file, { targetPath, content }, callback) => {
+      if (!isAllowWrite(targetPath, filter)) {
+        return callback();
+      }
+      const dir = path.dirname(targetPath);
+      const name = getCompilerName(compiler);
+      return fs.mkdir(dir, { recursive: true }, error => {
+        if (error) {
+          logger.error(`${name}unable to write "${dir}" directory to disk:\n${error}`);
+          return callback(error);
+        }
+        fs.writeFile(targetPath, content, error => {
+          if (error) {
+            logger.error(`${name}unable to write "${targetPath}" asset to disk:\n${error}`);
+            return callback(error);
+          }
+          logger.log(`${name}asset written to disk: "${targetPath}"`);
+          return callback();
+        });
+      });
+    });
+  }
+}
+
+exports.setupWriteToDisk = setupWriteToDisk;