piral-cli-webpack5 1.0.0-pre.1960 → 1.0.1-beta.5640

package/src/webpack-hot-middleware/client.js

@@ -0,0 +1,306 @@
+/*eslint-env browser*/
+/*global __resourceQuery __webpack_public_path__*/
+
+var options = {
+  path: '/__webpack_hmr',
+  timeout: 20 * 1000,
+  overlay: true,
+  reload: false,
+  log: true,
+  warn: true,
+  name: '',
+  autoConnect: true,
+  overlayStyles: {},
+  overlayWarnings: false,
+  ansiColors: {},
+};
+if (__resourceQuery) {
+  var querystring = require('querystring');
+  var overrides = querystring.parse(__resourceQuery.slice(1));
+  setOverrides(overrides);
+}
+
+if (typeof window === 'undefined') {
+  // do nothing
+} else if (typeof window.EventSource === 'undefined') {
+  console.warn(
+    "webpack-hot-middleware's client requires EventSource to work. " +
+      'You should include a polyfill if you want to support this browser: ' +
+      'https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events#Tools'
+  );
+} else {
+  if (options.autoConnect) {
+    connect();
+  }
+}
+
+/* istanbul ignore next */
+function setOptionsAndConnect(overrides) {
+  setOverrides(overrides);
+  connect();
+}
+
+function setOverrides(overrides) {
+  if (overrides.autoConnect)
+    options.autoConnect = overrides.autoConnect == 'true';
+  if (overrides.path) options.path = overrides.path;
+  if (overrides.timeout) options.timeout = overrides.timeout;
+  if (overrides.overlay) options.overlay = overrides.overlay !== 'false';
+  if (overrides.reload) options.reload = overrides.reload !== 'false';
+  if (overrides.noInfo && overrides.noInfo !== 'false') {
+    options.log = false;
+  }
+  if (overrides.name) {
+    options.name = overrides.name;
+  }
+  if (overrides.quiet && overrides.quiet !== 'false') {
+    options.log = false;
+    options.warn = false;
+  }
+
+  if (overrides.dynamicPublicPath) {
+    options.path = __webpack_public_path__ + options.path;
+  }
+
+  if (overrides.ansiColors)
+    options.ansiColors = JSON.parse(overrides.ansiColors);
+  if (overrides.overlayStyles)
+    options.overlayStyles = JSON.parse(overrides.overlayStyles);
+
+  if (overrides.overlayWarnings) {
+    options.overlayWarnings = overrides.overlayWarnings == 'true';
+  }
+}
+
+function EventSourceWrapper() {
+  var source;
+  var lastActivity = new Date();
+  var listeners = [];
+
+  init();
+  var timer = setInterval(function() {
+    if (new Date() - lastActivity > options.timeout) {
+      handleDisconnect();
+    }
+  }, options.timeout / 2);
+
+  function init() {
+    source = new window.EventSource(options.path);
+    source.onopen = handleOnline;
+    source.onerror = handleDisconnect;
+    source.onmessage = handleMessage;
+  }
+
+  function handleOnline() {
+    if (options.log) console.log('[HMR] connected');
+    lastActivity = new Date();
+  }
+
+  function handleMessage(event) {
+    lastActivity = new Date();
+    for (var i = 0; i < listeners.length; i++) {
+      listeners[i](event);
+    }
+  }
+
+  function handleDisconnect() {
+    clearInterval(timer);
+    source.close();
+    setTimeout(init, options.timeout);
+  }
+
+  return {
+    addMessageListener: function(fn) {
+      listeners.push(fn);
+    },
+  };
+}
+
+function getEventSourceWrapper() {
+  if (!window.__whmEventSourceWrapper) {
+    window.__whmEventSourceWrapper = {};
+  }
+  if (!window.__whmEventSourceWrapper[options.path]) {
+    // cache the wrapper for other entries loaded on
+    // the same page with the same options.path
+    window.__whmEventSourceWrapper[options.path] = EventSourceWrapper();
+  }
+  return window.__whmEventSourceWrapper[options.path];
+}
+
+function connect() {
+  getEventSourceWrapper().addMessageListener(handleMessage);
+
+  function handleMessage(event) {
+    if (event.data == '\uD83D\uDC93') {
+      return;
+    }
+    try {
+      processMessage(JSON.parse(event.data));
+    } catch (ex) {
+      if (options.warn) {
+        console.warn('Invalid HMR message: ' + event.data + '\n' + ex);
+      }
+    }
+  }
+}
+
+// the reporter needs to be a singleton on the page
+// in case the client is being used by multiple bundles
+// we only want to report once.
+// all the errors will go to all clients
+var singletonKey = '__webpack_hot_middleware_reporter__';
+var reporter;
+if (typeof window !== 'undefined') {
+  if (!window[singletonKey]) {
+    window[singletonKey] = createReporter();
+  }
+  reporter = window[singletonKey];
+}
+
+function createReporter() {
+  var strip = require('strip-ansi');
+
+  var overlay;
+  if (typeof document !== 'undefined' && options.overlay) {
+    overlay = require('./client-overlay')({
+      ansiColors: options.ansiColors,
+      overlayStyles: options.overlayStyles,
+    });
+  }
+
+  var styles = {
+    errors: 'color: #ff0000;',
+    warnings: 'color: #999933;',
+  };
+  var previousProblems = null;
+  function log(type, obj) {
+    var newProblems = obj[type]
+      .map(function(msg) {
+        return strip(msg);
+      })
+      .join('\n');
+    if (previousProblems == newProblems) {
+      return;
+    } else {
+      previousProblems = newProblems;
+    }
+
+    var style = styles[type];
+    var name = obj.name ? "'" + obj.name + "' " : '';
+    var title = '[HMR] bundle ' + name + 'has ' + obj[type].length + ' ' + type;
+    // NOTE: console.warn or console.error will print the stack trace
+    // which isn't helpful here, so using console.log to escape it.
+    if (console.group && console.groupEnd) {
+      console.group('%c' + title, style);
+      console.log('%c' + newProblems, style);
+      console.groupEnd();
+    } else {
+      console.log(
+        '%c' + title + '\n\t%c' + newProblems.replace(/\n/g, '\n\t'),
+        style + 'font-weight: bold;',
+        style + 'font-weight: normal;'
+      );
+    }
+  }
+
+  return {
+    cleanProblemsCache: function() {
+      previousProblems = null;
+    },
+    problems: function(type, obj) {
+      if (options.warn) {
+        log(type, obj);
+      }
+      if (overlay) {
+        if (options.overlayWarnings || type === 'errors') {
+          overlay.showProblems(type, obj[type]);
+          return false;
+        }
+        overlay.clear();
+      }
+      return true;
+    },
+    success: function() {
+      if (overlay) overlay.clear();
+    },
+    useCustomOverlay: function(customOverlay) {
+      overlay = customOverlay;
+    },
+  };
+}
+
+var processUpdate = require('./process-update');
+
+var customHandler;
+var subscribeAllHandler;
+function processMessage(obj) {
+  switch (obj.action) {
+    case 'building':
+      if (options.log) {
+        console.log(
+          '[HMR] bundle ' +
+            (obj.name ? "'" + obj.name + "' " : '') +
+            'rebuilding'
+        );
+      }
+      break;
+    case 'built':
+      if (options.log) {
+        console.log(
+          '[HMR] bundle ' +
+            (obj.name ? "'" + obj.name + "' " : '') +
+            'rebuilt in ' +
+            obj.time +
+            'ms'
+        );
+      }
+    // fall through
+    case 'sync':
+      if (obj.name && options.name && obj.name !== options.name) {
+        return;
+      }
+      var applyUpdate = true;
+      if (obj.errors.length > 0) {
+        if (reporter) reporter.problems('errors', obj);
+        applyUpdate = false;
+      } else if (obj.warnings.length > 0) {
+        if (reporter) {
+          var overlayShown = reporter.problems('warnings', obj);
+          applyUpdate = overlayShown;
+        }
+      } else {
+        if (reporter) {
+          reporter.cleanProblemsCache();
+          reporter.success();
+        }
+      }
+      if (applyUpdate) {
+        processUpdate(obj.hash, obj.modules, options);
+      }
+      break;
+    default:
+      if (customHandler) {
+        customHandler(obj);
+      }
+  }
+
+  if (subscribeAllHandler) {
+    subscribeAllHandler(obj);
+  }
+}
+
+if (module) {
+  module.exports = {
+    subscribeAll: function subscribeAll(handler) {
+      subscribeAllHandler = handler;
+    },
+    subscribe: function subscribe(handler) {
+      customHandler = handler;
+    },
+    useCustomOverlay: function useCustomOverlay(customOverlay) {
+      if (reporter) reporter.useCustomOverlay(customOverlay);
+    },
+    setOptionsAndConnect: setOptionsAndConnect,
+  };
+}

package/src/webpack-hot-middleware/helpers.js

@@ -0,0 +1,9 @@
+var parse = require('url').parse;
+
+exports.pathMatch = function(url, path) {
+  try {
+    return parse(url).pathname === path;
+  } catch (e) {
+    return false;
+  }
+};

package/src/webpack-hot-middleware/middleware.js

@@ -0,0 +1,175 @@
+module.exports = webpackHotMiddleware;
+
+var helpers = require('./helpers');
+var pathMatch = helpers.pathMatch;
+
+function webpackHotMiddleware(compiler, opts) {
+  opts = opts || {};
+  opts.log =
+    typeof opts.log == 'undefined' ? console.log.bind(console) : opts.log;
+  opts.path = opts.path || '/__webpack_hmr';
+  opts.heartbeat = opts.heartbeat || 10 * 1000;
+
+  var eventStream = createEventStream(opts.heartbeat);
+  var latestStats = null;
+  var closed = false;
+
+  if (compiler.hooks) {
+    compiler.hooks.invalid.tap('webpack-hot-middleware', onInvalid);
+    compiler.hooks.done.tap('webpack-hot-middleware', onDone);
+  } else {
+    compiler.plugin('invalid', onInvalid);
+    compiler.plugin('done', onDone);
+  }
+  function onInvalid() {
+    if (closed) return;
+    latestStats = null;
+    if (opts.log) opts.log('webpack building...');
+    eventStream.publish({ action: 'building' });
+  }
+  function onDone(statsResult) {
+    if (closed) return;
+    // Keep hold of latest stats so they can be propagated to new clients
+    latestStats = statsResult;
+    publishStats('built', latestStats, eventStream, opts.log);
+  }
+  var middleware = function (req, res, next) {
+    if (closed) return next();
+    if (!pathMatch(req.url, opts.path)) return next();
+    eventStream.handler(req, res);
+    if (latestStats) {
+      // Explicitly not passing in `log` fn as we don't want to log again on
+      // the server
+      publishStats('sync', latestStats, eventStream);
+    }
+  };
+  middleware.publish = function (payload) {
+    if (closed) return;
+    eventStream.publish(payload);
+  };
+  middleware.close = function () {
+    if (closed) return;
+    // Can't remove compiler plugins, so we just set a flag and noop if closed
+    // https://github.com/webpack/tapable/issues/32#issuecomment-350644466
+    closed = true;
+    eventStream.close();
+    eventStream = null;
+  };
+  return middleware;
+}
+
+function createEventStream(heartbeat) {
+  var clientId = 0;
+  var clients = {};
+  function everyClient(fn) {
+    Object.keys(clients).forEach(function (id) {
+      fn(clients[id]);
+    });
+  }
+  var interval = setInterval(function heartbeatTick() {
+    everyClient(function (client) {
+      client.write('data: \uD83D\uDC93\n\n');
+    });
+  }, heartbeat).unref();
+  return {
+    close: function () {
+      clearInterval(interval);
+      everyClient(function (client) {
+        if (!client.finished) client.end();
+      });
+      clients = {};
+    },
+    handler: function (req, res) {
+      var headers = {
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'text/event-stream;charset=utf-8',
+        'Cache-Control': 'no-cache, no-transform',
+        // While behind nginx, event stream should not be buffered:
+        // http://nginx.org/docs/http/ngx_http_proxy_module.html#proxy_buffering
+        'X-Accel-Buffering': 'no',
+      };
+
+      var isHttp1 = !(parseInt(req.httpVersion) >= 2);
+      if (isHttp1) {
+        req.socket.setKeepAlive(true);
+        Object.assign(headers, {
+          Connection: 'keep-alive',
+        });
+      }
+
+      res.writeHead(200, headers);
+      res.write('\n');
+      var id = clientId++;
+      clients[id] = res;
+      req.on('close', function () {
+        if (!res.finished) res.end();
+        delete clients[id];
+      });
+    },
+    publish: function (payload) {
+      everyClient(function (client) {
+        client.write('data: ' + JSON.stringify(payload) + '\n\n');
+      });
+    },
+  };
+}
+
+function publishStats(action, statsResult, eventStream, log) {
+  var stats = statsResult.toJson({
+    all: false,
+    cached: true,
+    children: true,
+    modules: true,
+    timings: true,
+    hash: true,
+  });
+  // For multi-compiler, stats will be an object with a 'children' array of stats
+  var bundles = extractBundles(stats);
+  bundles.forEach(function (stats) {
+    var name = stats.name || '';
+
+    // Fallback to compilation name in case of 1 bundle (if it exists)
+    if (bundles.length === 1 && !name && statsResult.compilation) {
+      name = statsResult.compilation.name || '';
+    }
+
+    if (log) {
+      log(
+        'webpack built ' +
+          (name ? name + ' ' : '') +
+          stats.hash +
+          ' in ' +
+          stats.time +
+          'ms'
+      );
+    }
+    eventStream.publish({
+      name: name,
+      action: action,
+      time: stats.time,
+      hash: stats.hash,
+      warnings: stats.warnings || [],
+      errors: stats.errors || [],
+      modules: buildModuleMap(stats.modules),
+    });
+  });
+}
+
+function extractBundles(stats) {
+  // Stats has modules, single bundle
+  if (stats.modules) return [stats];
+
+  // Stats has children, multiple bundles
+  if (stats.children && stats.children.length) return stats.children;
+
+  // Not sure, assume single
+  return [stats];
+}
+
+function buildModuleMap(modules) {
+  var map = {};
+  modules.forEach(function (module) {
+    map[module.id] = module.name;
+  });
+  return map;
+}

package/src/webpack-hot-middleware/process-update.js

@@ -0,0 +1,157 @@
+/**
+ * Based heavily on https://github.com/webpack/webpack/blob/
+ *  c0afdf9c6abc1dd70707c594e473802a566f7b6e/hot/only-dev-server.js
+ * Original copyright Tobias Koppers @sokra (MIT license)
+ */
+
+/* global window __webpack_hash__ */
+
+if (!module.hot) {
+  throw new Error('[HMR] Hot Module Replacement is disabled.');
+}
+
+var hmrDocsUrl = 'https://webpack.js.org/concepts/hot-module-replacement/'; // eslint-disable-line max-len
+
+var lastHash;
+var failureStatuses = { abort: 1, fail: 1 };
+var applyOptions = {
+  ignoreUnaccepted: true,
+  ignoreDeclined: true,
+  ignoreErrored: true,
+  onUnaccepted: function (data) {
+    console.warn(
+      'Ignored an update to unaccepted module ' + data.chain.join(' -> ')
+    );
+  },
+  onDeclined: function (data) {
+    console.warn(
+      'Ignored an update to declined module ' + data.chain.join(' -> ')
+    );
+  },
+  onErrored: function (data) {
+    console.error(data.error);
+    console.warn(
+      'Ignored an error while updating module ' +
+        data.moduleId +
+        ' (' +
+        data.type +
+        ')'
+    );
+  },
+};
+
+function upToDate(hash) {
+  if (hash) lastHash = hash;
+  return lastHash == __webpack_hash__;
+}
+
+module.exports = function (hash, moduleMap, options) {
+  var reload = options.reload;
+  if (!upToDate(hash) && module.hot.status() == 'idle') {
+    if (options.log) console.log('[HMR] Checking for updates on the server...');
+    check();
+  }
+
+  function check() {
+    var cb = function (err, updatedModules) {
+      if (err) return handleError(err);
+
+      if (!updatedModules || !updatedModules.length) {
+        if (options.warn) {
+          console.warn('[HMR] Cannot find update (Full reload needed)');
+          console.warn('[HMR] (Probably because of restarting the server)');
+        }
+        performReload();
+        return null;
+      }
+
+      var applyCallback = function (applyErr, renewedModules) {
+        if (applyErr) return handleError(applyErr);
+
+        if (!upToDate()) check();
+
+        logUpdates(updatedModules, renewedModules);
+      };
+
+      var applyResult = module.hot.apply(applyOptions, applyCallback);
+      // webpack 2 promise
+      if (applyResult && applyResult.then) {
+        // HotModuleReplacement.runtime.js refers to the result as `outdatedModules`
+        applyResult.then(function (outdatedModules) {
+          applyCallback(null, outdatedModules);
+        });
+        applyResult.catch(applyCallback);
+      }
+    };
+
+    var result = module.hot.check(false, cb);
+    // webpack 2 promise
+    if (result && result.then) {
+      result.then(function (updatedModules) {
+        cb(null, updatedModules);
+      });
+      result.catch(cb);
+    }
+  }
+
+  function logUpdates(updatedModules, renewedModules) {
+    var unacceptedModules = updatedModules.filter(function (moduleId) {
+      return renewedModules && renewedModules.indexOf(moduleId) < 0;
+    });
+
+    if (unacceptedModules.length > 0) {
+      if (options.warn) {
+        console.warn(
+          "[HMR] The following modules couldn't be hot updated: " +
+            '(Full reload needed)\n' +
+            'This is usually because the modules which have changed ' +
+            '(and their parents) do not know how to hot reload themselves. ' +
+            'See ' +
+            hmrDocsUrl +
+            ' for more details.'
+        );
+        unacceptedModules.forEach(function (moduleId) {
+          console.warn('[HMR]  - ' + (moduleMap[moduleId] || moduleId));
+        });
+      }
+      performReload();
+      return;
+    }
+
+    if (options.log) {
+      if (!renewedModules || renewedModules.length === 0) {
+        console.log('[HMR] Nothing hot updated.');
+      } else {
+        console.log('[HMR] Updated modules:');
+        renewedModules.forEach(function (moduleId) {
+          console.log('[HMR]  - ' + (moduleMap[moduleId] || moduleId));
+        });
+      }
+
+      if (upToDate()) {
+        console.log('[HMR] App is up to date.');
+      }
+    }
+  }
+
+  function handleError(err) {
+    if (module.hot.status() in failureStatuses) {
+      if (options.warn) {
+        console.warn('[HMR] Cannot check for update (Full reload needed)');
+        console.warn('[HMR] ' + (err.stack || err.message));
+      }
+      performReload();
+      return;
+    }
+    if (options.warn) {
+      console.warn('[HMR] Update check failed: ' + (err.stack || err.message));
+    }
+  }
+
+  function performReload() {
+    if (reload) {
+      if (options.warn) console.warn('[HMR] Reloading page');
+      window.location.reload();
+    }
+  }
+};

package/lib/configs/HotModuleServerPlugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HotModuleServerPlugin.js","sourceRoot":"","sources":["../../src/configs/HotModuleServerPlugin.ts"],"names":[],"mappings":";;;AAEA,MAAa,qBAAqB;IAChC,YAAoB,OAAe;QAAf,YAAO,GAAP,OAAO,CAAQ;IAAG,CAAC;IAEvC,KAAK,CAAC,QAAkB;QACtB,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QACnC,MAAM,GAAG,GAAG,OAAO,EAAE,CAAC;QACtB,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;QACrD,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IACrC,CAAC;CACF;AATD,sDASC"}

package/lib/configs/SheetLoader.d.ts

@@ -1 +0,0 @@
-export default function SheetLoader(): Promise<void>;

package/lib/configs/SheetLoader.js

@@ -1,27 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-function SheetLoader() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const callback = this.async();
-        const stylesheet = [
-            `var d=document`,
-            `var e=d.createElement("link")`,
-            `e.type="text/css"`,
-            `e.rel="stylesheet"`,
-            `e.href=__webpack_public_path__ + ${JSON.stringify('main.css')}`,
-            `d.head.appendChild(e)`,
-        ].join(';');
-        callback(undefined, stylesheet);
-    });
-}
-exports.default = SheetLoader;
-//# sourceMappingURL=SheetLoader.js.map

package/lib/configs/SheetLoader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SheetLoader.js","sourceRoot":"","sources":["../../src/configs/SheetLoader.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,SAA8B,WAAW;;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC9B,MAAM,UAAU,GAAG;YACjB,gBAAgB;YAChB,+BAA+B;YAC/B,mBAAmB;YACnB,oBAAoB;YACpB,oCAAoC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE;YAChE,uBAAuB;SACxB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACZ,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAClC,CAAC;CAAA;AAXD,8BAWC"}

package/lib/configs/common.d.ts

@@ -1,6 +0,0 @@
-import { RuleSetRule } from 'webpack';
-export declare const extensions: string[];
-export declare function getVariables(): Record<string, string>;
-export declare function getHmrEntry(hmrPort: number): [] | [string];
-export declare function getPlugins(plugins: Array<any>, showProgress: boolean, production: boolean, hmrPort?: number): any[];
-export declare function getRules(baseDir: string, production: boolean, pilet: boolean): Array<RuleSetRule>;