0.2.0 - Mid migration

web/node_modules/webpack-dev-server/client/clients/BaseClient.js

@@ -0,0 +1,25 @@
+'use strict';
+/* eslint-disable
+  no-unused-vars
+*/
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+module.exports = /*#__PURE__*/function () {
+  function BaseClient() {
+    _classCallCheck(this, BaseClient);
+  }
+
+  _createClass(BaseClient, null, [{
+    key: "getClientPath",
+    value: function getClientPath(options) {
+      throw new Error('Client needs implementation');
+    }
+  }]);
+
+  return BaseClient;
+}();

web/node_modules/webpack-dev-server/client/clients/SockJSClient.js

@@ -0,0 +1,78 @@
+'use strict';
+/* eslint-disable
+  no-unused-vars
+*/
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var SockJS = require('sockjs-client/dist/sockjs');
+
+var BaseClient = require('./BaseClient');
+
+module.exports = /*#__PURE__*/function (_BaseClient) {
+  _inherits(SockJSClient, _BaseClient);
+
+  var _super = _createSuper(SockJSClient);
+
+  function SockJSClient(url) {
+    var _this;
+
+    _classCallCheck(this, SockJSClient);
+
+    _this = _super.call(this);
+    _this.sock = new SockJS(url);
+
+    _this.sock.onerror = function (err) {// TODO: use logger to log the error event once client and client-src
+      // are reorganized to have the same directory structure
+    };
+
+    return _this;
+  }
+
+  _createClass(SockJSClient, [{
+    key: "onOpen",
+    value: function onOpen(f) {
+      this.sock.onopen = f;
+    }
+  }, {
+    key: "onClose",
+    value: function onClose(f) {
+      this.sock.onclose = f;
+    } // call f with the message string as the first argument
+
+  }, {
+    key: "onMessage",
+    value: function onMessage(f) {
+      this.sock.onmessage = function (e) {
+        f(e.data);
+      };
+    }
+  }], [{
+    key: "getClientPath",
+    value: function getClientPath(options) {
+      return require.resolve('./SockJSClient');
+    }
+  }]);
+
+  return SockJSClient;
+}(BaseClient);

web/node_modules/webpack-dev-server/client/clients/WebsocketClient.js

@@ -0,0 +1,78 @@
+'use strict';
+/* global WebSocket */
+
+/* eslint-disable
+  no-unused-vars
+*/
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var BaseClient = require('./BaseClient');
+
+module.exports = /*#__PURE__*/function (_BaseClient) {
+  _inherits(WebsocketClient, _BaseClient);
+
+  var _super = _createSuper(WebsocketClient);
+
+  function WebsocketClient(url) {
+    var _this;
+
+    _classCallCheck(this, WebsocketClient);
+
+    _this = _super.call(this);
+    _this.client = new WebSocket(url.replace(/^http/, 'ws'));
+
+    _this.client.onerror = function (err) {// TODO: use logger to log the error event once client and client-src
+      // are reorganized to have the same directory structure
+    };
+
+    return _this;
+  }
+
+  _createClass(WebsocketClient, [{
+    key: "onOpen",
+    value: function onOpen(f) {
+      this.client.onopen = f;
+    }
+  }, {
+    key: "onClose",
+    value: function onClose(f) {
+      this.client.onclose = f;
+    } // call f with the message string as the first argument
+
+  }, {
+    key: "onMessage",
+    value: function onMessage(f) {
+      this.client.onmessage = function (e) {
+        f(e.data);
+      };
+    }
+  }], [{
+    key: "getClientPath",
+    value: function getClientPath(options) {
+      return require.resolve('./WebsocketClient');
+    }
+  }]);
+
+  return WebsocketClient;
+}(BaseClient);

web/node_modules/webpack-dev-server/client/index.js

@@ -0,0 +1,176 @@
+'use strict';
+/* global __resourceQuery WorkerGlobalScope self */
+
+/* eslint prefer-destructuring: off */
+
+var stripAnsi = require('strip-ansi');
+
+var socket = require('./socket');
+
+var overlay = require('./overlay');
+
+var _require = require('./utils/log'),
+    log = _require.log,
+    setLogLevel = _require.setLogLevel;
+
+var sendMessage = require('./utils/sendMessage');
+
+var reloadApp = require('./utils/reloadApp');
+
+var createSocketUrl = require('./utils/createSocketUrl');
+
+var status = {
+  isUnloading: false,
+  currentHash: ''
+};
+var options = {
+  hot: false,
+  hotReload: true,
+  liveReload: false,
+  initial: true,
+  useWarningOverlay: false,
+  useErrorOverlay: false,
+  useProgress: false
+};
+var socketUrl = createSocketUrl(__resourceQuery);
+self.addEventListener('beforeunload', function () {
+  status.isUnloading = true;
+});
+
+if (typeof window !== 'undefined') {
+  var qs = window.location.search.toLowerCase();
+  options.hotReload = qs.indexOf('hotreload=false') === -1;
+}
+
+var onSocketMessage = {
+  hot: function hot() {
+    options.hot = true;
+    log.info('[WDS] Hot Module Replacement enabled.');
+  },
+  liveReload: function liveReload() {
+    options.liveReload = true;
+    log.info('[WDS] Live Reloading enabled.');
+  },
+  invalid: function invalid() {
+    log.info('[WDS] App updated. Recompiling...'); // fixes #1042. overlay doesn't clear if errors are fixed but warnings remain.
+
+    if (options.useWarningOverlay || options.useErrorOverlay) {
+      overlay.clear();
+    }
+
+    sendMessage('Invalid');
+  },
+  hash: function hash(_hash) {
+    status.currentHash = _hash;
+  },
+  'still-ok': function stillOk() {
+    log.info('[WDS] Nothing changed.');
+
+    if (options.useWarningOverlay || options.useErrorOverlay) {
+      overlay.clear();
+    }
+
+    sendMessage('StillOk');
+  },
+  'log-level': function logLevel(level) {
+    var hotCtx = require.context('webpack/hot', false, /^\.\/log$/);
+
+    if (hotCtx.keys().indexOf('./log') !== -1) {
+      hotCtx('./log').setLogLevel(level);
+    }
+
+    setLogLevel(level);
+  },
+  overlay: function overlay(value) {
+    if (typeof document !== 'undefined') {
+      if (typeof value === 'boolean') {
+        options.useWarningOverlay = false;
+        options.useErrorOverlay = value;
+      } else if (value) {
+        options.useWarningOverlay = value.warnings;
+        options.useErrorOverlay = value.errors;
+      }
+    }
+  },
+  progress: function progress(_progress) {
+    if (typeof document !== 'undefined') {
+      options.useProgress = _progress;
+    }
+  },
+  'progress-update': function progressUpdate(data) {
+    if (options.useProgress) {
+      log.info("[WDS] ".concat(data.percent, "% - ").concat(data.msg, "."));
+    }
+
+    sendMessage('Progress', data);
+  },
+  ok: function ok() {
+    sendMessage('Ok');
+
+    if (options.useWarningOverlay || options.useErrorOverlay) {
+      overlay.clear();
+    }
+
+    if (options.initial) {
+      return options.initial = false;
+    } // eslint-disable-line no-return-assign
+
+
+    reloadApp(options, status);
+  },
+  'content-changed': function contentChanged() {
+    log.info('[WDS] Content base changed. Reloading...');
+    self.location.reload();
+  },
+  warnings: function warnings(_warnings) {
+    log.warn('[WDS] Warnings while compiling.');
+
+    var strippedWarnings = _warnings.map(function (warning) {
+      return stripAnsi(warning);
+    });
+
+    sendMessage('Warnings', strippedWarnings);
+
+    for (var i = 0; i < strippedWarnings.length; i++) {
+      log.warn(strippedWarnings[i]);
+    }
+
+    if (options.useWarningOverlay) {
+      overlay.showMessage(_warnings);
+    }
+
+    if (options.initial) {
+      return options.initial = false;
+    } // eslint-disable-line no-return-assign
+
+
+    reloadApp(options, status);
+  },
+  errors: function errors(_errors) {
+    log.error('[WDS] Errors while compiling. Reload prevented.');
+
+    var strippedErrors = _errors.map(function (error) {
+      return stripAnsi(error);
+    });
+
+    sendMessage('Errors', strippedErrors);
+
+    for (var i = 0; i < strippedErrors.length; i++) {
+      log.error(strippedErrors[i]);
+    }
+
+    if (options.useErrorOverlay) {
+      overlay.showMessage(_errors);
+    }
+
+    options.initial = false;
+  },
+  error: function error(_error) {
+    log.error(_error);
+  },
+  close: function close() {
+    log.error('[WDS] Disconnected!');
+    sendMessage('Close');
+  }
+};
+socket(socketUrl, onSocketMessage);

web/node_modules/webpack-dev-server/client/live.html

@@ -0,0 +1 @@
+<!DOCTYPE html><html><head><meta http-equiv="X-UA-Compatible" content="IE=edge"/><meta charset="utf-8"/><meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0"/><script type="text/javascript" charset="utf-8" src="/__webpack_dev_server__/live.bundle.js"></script></head><body></body></html>

web/node_modules/webpack-dev-server/client/overlay.js

@@ -0,0 +1,120 @@
+'use strict'; // The error overlay is inspired (and mostly copied) from Create React App (https://github.com/facebookincubator/create-react-app)
+// They, in turn, got inspired by webpack-hot-middleware (https://github.com/glenjamin/webpack-hot-middleware).
+
+var ansiHTML = require('ansi-html');
+
+var _require = require('html-entities'),
+    AllHtmlEntities = _require.AllHtmlEntities;
+
+var entities = new AllHtmlEntities();
+var colors = {
+  reset: ['transparent', 'transparent'],
+  black: '181818',
+  red: 'E36049',
+  green: 'B3CB74',
+  yellow: 'FFD080',
+  blue: '7CAFC2',
+  magenta: '7FACCA',
+  cyan: 'C3C2EF',
+  lightgrey: 'EBE7E3',
+  darkgrey: '6D7891'
+};
+var overlayIframe = null;
+var overlayDiv = null;
+var lastOnOverlayDivReady = null;
+ansiHTML.setColors(colors);
+
+function createOverlayIframe(onIframeLoad) {
+  var iframe = document.createElement('iframe');
+  iframe.id = 'webpack-dev-server-client-overlay';
+  iframe.src = 'about:blank';
+  iframe.style.position = 'fixed';
+  iframe.style.left = 0;
+  iframe.style.top = 0;
+  iframe.style.right = 0;
+  iframe.style.bottom = 0;
+  iframe.style.width = '100vw';
+  iframe.style.height = '100vh';
+  iframe.style.border = 'none';
+  iframe.style.zIndex = 9999999999;
+  iframe.onload = onIframeLoad;
+  return iframe;
+}
+
+function addOverlayDivTo(iframe) {
+  var div = iframe.contentDocument.createElement('div');
+  div.id = 'webpack-dev-server-client-overlay-div';
+  div.style.position = 'fixed';
+  div.style.boxSizing = 'border-box';
+  div.style.left = 0;
+  div.style.top = 0;
+  div.style.right = 0;
+  div.style.bottom = 0;
+  div.style.width = '100vw';
+  div.style.height = '100vh';
+  div.style.backgroundColor = 'rgba(0, 0, 0, 0.85)';
+  div.style.color = '#E8E8E8';
+  div.style.fontFamily = 'Menlo, Consolas, monospace';
+  div.style.fontSize = 'large';
+  div.style.padding = '2rem';
+  div.style.lineHeight = '1.2';
+  div.style.whiteSpace = 'pre-wrap';
+  div.style.overflow = 'auto';
+  iframe.contentDocument.body.appendChild(div);
+  return div;
+}
+
+function ensureOverlayDivExists(onOverlayDivReady) {
+  if (overlayDiv) {
+    // Everything is ready, call the callback right away.
+    onOverlayDivReady(overlayDiv);
+    return;
+  } // Creating an iframe may be asynchronous so we'll schedule the callback.
+  // In case of multiple calls, last callback wins.
+
+
+  lastOnOverlayDivReady = onOverlayDivReady;
+
+  if (overlayIframe) {
+    // We've already created it.
+    return;
+  } // Create iframe and, when it is ready, a div inside it.
+
+
+  overlayIframe = createOverlayIframe(function () {
+    overlayDiv = addOverlayDivTo(overlayIframe); // Now we can talk!
+
+    lastOnOverlayDivReady(overlayDiv);
+  }); // Zalgo alert: onIframeLoad() will be called either synchronously
+  // or asynchronously depending on the browser.
+  // We delay adding it so `overlayIframe` is set when `onIframeLoad` fires.
+
+  document.body.appendChild(overlayIframe);
+} // Successful compilation.
+
+
+function clear() {
+  if (!overlayDiv) {
+    // It is not there in the first place.
+    return;
+  } // Clean up and reset internal state.
+
+
+  document.body.removeChild(overlayIframe);
+  overlayDiv = null;
+  overlayIframe = null;
+  lastOnOverlayDivReady = null;
+} // Compilation with errors (e.g. syntax error or missing modules).
+
+
+function showMessage(messages) {
+  ensureOverlayDivExists(function (div) {
+    // Make it look similar to our terminal.
+    div.innerHTML = "<span style=\"color: #".concat(colors.red, "\">Failed to compile.</span><br><br>").concat(ansiHTML(entities.encode(messages[0])));
+  });
+}
+
+module.exports = {
+  clear: clear,
+  showMessage: showMessage
+};

web/node_modules/webpack-dev-server/client/socket.js

@@ -0,0 +1,52 @@
+'use strict';
+/* global __webpack_dev_server_client__ */
+
+/* eslint-disable
+  camelcase
+*/
+// this SockJSClient is here as a default fallback, in case inline mode
+// is off or the client is not injected. This will be switched to
+// WebsocketClient when it becomes the default
+// important: the path to SockJSClient here is made to work in the 'client'
+// directory, but is updated via the webpack compilation when compiled from
+// the 'client-src' directory
+
+var Client = typeof __webpack_dev_server_client__ !== 'undefined' ? __webpack_dev_server_client__ : // eslint-disable-next-line import/no-unresolved
+require('./clients/SockJSClient');
+var retries = 0;
+var client = null;
+
+var socket = function initSocket(url, handlers) {
+  client = new Client(url);
+  client.onOpen(function () {
+    retries = 0;
+  });
+  client.onClose(function () {
+    if (retries === 0) {
+      handlers.close();
+    } // Try to reconnect.
+
+
+    client = null; // After 10 retries stop trying, to prevent logspam.
+
+    if (retries <= 10) {
+      // Exponentially increase timeout to reconnect.
+      // Respectfully copied from the package `got`.
+      // eslint-disable-next-line no-mixed-operators, no-restricted-properties
+      var retryInMs = 1000 * Math.pow(2, retries) + Math.random() * 100;
+      retries += 1;
+      setTimeout(function () {
+        socket(url, handlers);
+      }, retryInMs);
+    }
+  });
+  client.onMessage(function (data) {
+    var msg = JSON.parse(data);
+
+    if (handlers[msg.type]) {
+      handlers[msg.type](msg.data);
+    }
+  });
+};
+
+module.exports = socket;

web/node_modules/webpack-dev-server/client/utils/createSocketUrl.js

@@ -0,0 +1,88 @@
+'use strict';
+/* global self */
+
+var url = require('url');
+
+var getCurrentScriptSource = require('./getCurrentScriptSource');
+
+function createSocketUrl(resourceQuery, currentLocation) {
+  var urlParts;
+
+  if (typeof resourceQuery === 'string' && resourceQuery !== '') {
+    // If this bundle is inlined, use the resource query to get the correct url.
+    // format is like `?http://0.0.0.0:8096&sockPort=8097&sockHost=localhost`
+    urlParts = url.parse(resourceQuery // strip leading `?` from query string to get a valid URL
+    .substr(1) // replace first `&` with `?` to have a valid query string
+    .replace('&', '?'), true);
+  } else {
+    // Else, get the url from the <script> this file was called with.
+    var scriptHost = getCurrentScriptSource();
+    urlParts = url.parse(scriptHost || '/', true, true);
+  } // Use parameter to allow passing location in unit tests
+
+
+  if (typeof currentLocation === 'string' && currentLocation !== '') {
+    currentLocation = url.parse(currentLocation);
+  } else {
+    currentLocation = self.location;
+  }
+
+  return getSocketUrl(urlParts, currentLocation);
+}
+/*
+ * Gets socket URL based on Script Source/Location
+ * (scriptSrc: URL, location: URL) -> URL
+ */
+
+
+function getSocketUrl(urlParts, loc) {
+  var auth = urlParts.auth,
+      query = urlParts.query;
+  var hostname = urlParts.hostname,
+      protocol = urlParts.protocol,
+      port = urlParts.port;
+
+  if (!port || port === '0') {
+    port = loc.port;
+  } // check ipv4 and ipv6 `all hostname`
+  // why do we need this check?
+  // hostname n/a for file protocol (example, when using electron, ionic)
+  // see: https://github.com/webpack/webpack-dev-server/pull/384
+
+
+  if ((hostname === '0.0.0.0' || hostname === '::') && loc.hostname && loc.protocol.indexOf('http') === 0) {
+    hostname = loc.hostname;
+  } // `hostname` can be empty when the script path is relative. In that case, specifying
+  // a protocol would result in an invalid URL.
+  // When https is used in the app, secure websockets are always necessary
+  // because the browser doesn't accept non-secure websockets.
+
+
+  if (hostname && hostname !== '127.0.0.1' && (loc.protocol === 'https:' || urlParts.hostname === '0.0.0.0')) {
+    protocol = loc.protocol;
+  } // all of these sock url params are optionally passed in through
+  // resourceQuery, so we need to fall back to the default if
+  // they are not provided
+
+
+  var sockHost = query.sockHost || hostname;
+  var sockPath = query.sockPath || '/sockjs-node';
+  var sockPort = query.sockPort || port;
+
+  if (sockPort === 'location') {
+    sockPort = loc.port;
+  }
+
+  return url.format({
+    protocol: protocol,
+    auth: auth,
+    hostname: sockHost,
+    port: sockPort,
+    // If sockPath is provided it'll be passed in via the resourceQuery as a
+    // query param so it has to be parsed out of the querystring in order for the
+    // client to open the socket to the correct location.
+    pathname: sockPath
+  });
+}
+
+module.exports = createSocketUrl;

web/node_modules/webpack-dev-server/client/utils/getCurrentScriptSource.js

@@ -0,0 +1,22 @@
+'use strict';
+
+function getCurrentScriptSource() {
+  // `document.currentScript` is the most accurate way to find the current script,
+  // but is not supported in all browsers.
+  if (document.currentScript) {
+    return document.currentScript.getAttribute('src');
+  } // Fall back to getting all scripts in the document.
+
+
+  var scriptElements = document.scripts || [];
+  var currentScript = scriptElements[scriptElements.length - 1];
+
+  if (currentScript) {
+    return currentScript.getAttribute('src');
+  } // Fail as there was no script to use.
+
+
+  throw new Error('[WDS] Failed to get current script source.');
+}
+
+module.exports = getCurrentScriptSource;

web/node_modules/webpack-dev-server/client/utils/log.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var log = require('loglevel').getLogger('webpack-dev-server');
+
+var INFO = 'info';
+var WARN = 'warn';
+var ERROR = 'error';
+var DEBUG = 'debug';
+var TRACE = 'trace';
+var SILENT = 'silent'; // deprecated
+// TODO: remove these at major released
+// https://github.com/webpack/webpack-dev-server/pull/1825
+
+var WARNING = 'warning';
+var NONE = 'none'; // Set the default log level
+
+log.setDefaultLevel(INFO);
+
+function setLogLevel(level) {
+  switch (level) {
+    case INFO:
+    case WARN:
+    case ERROR:
+    case DEBUG:
+    case TRACE:
+      log.setLevel(level);
+      break;
+    // deprecated
+
+    case WARNING:
+      // loglevel's warning name is different from webpack's
+      log.setLevel('warn');
+      break;
+    // deprecated
+
+    case NONE:
+    case SILENT:
+      log.disableAll();
+      break;
+
+    default:
+      log.error("[WDS] Unknown clientLogLevel '".concat(level, "'"));
+  }
+}
+
+module.exports = {
+  log: log,
+  setLogLevel: setLogLevel
+};

web/node_modules/webpack-dev-server/client/utils/reloadApp.js

@@ -0,0 +1,55 @@
+'use strict';
+/* global WorkerGlobalScope self */
+
+var _require = require('./log'),
+    log = _require.log;
+
+function reloadApp(_ref, _ref2) {
+  var hotReload = _ref.hotReload,
+      hot = _ref.hot,
+      liveReload = _ref.liveReload;
+  var isUnloading = _ref2.isUnloading,
+      currentHash = _ref2.currentHash;
+
+  if (isUnloading || !hotReload) {
+    return;
+  }
+
+  if (hot) {
+    log.info('[WDS] App hot update...');
+
+    var hotEmitter = require('webpack/hot/emitter');
+
+    hotEmitter.emit('webpackHotUpdate', currentHash);
+
+    if (typeof self !== 'undefined' && self.window) {
+      // broadcast update to window
+      self.postMessage("webpackHotUpdate".concat(currentHash), '*');
+    }
+  } // allow refreshing the page only if liveReload isn't disabled
+  else if (liveReload) {
+      var rootWindow = self; // use parent window for reload (in case we're in an iframe with no valid src)
+
+      var intervalId = self.setInterval(function () {
+        if (rootWindow.location.protocol !== 'about:') {
+          // reload immediately if protocol is valid
+          applyReload(rootWindow, intervalId);
+        } else {
+          rootWindow = rootWindow.parent;
+
+          if (rootWindow.parent === rootWindow) {
+            // if parent equals current window we've reached the root which would continue forever, so trigger a reload anyways
+            applyReload(rootWindow, intervalId);
+          }
+        }
+      });
+    }
+
+  function applyReload(rootWindow, intervalId) {
+    clearInterval(intervalId);
+    log.info('[WDS] App updated. Reloading...');
+    rootWindow.location.reload();
+  }
+}
+
+module.exports = reloadApp;

web/node_modules/webpack-dev-server/client/utils/sendMessage.js

@@ -0,0 +1,14 @@
+'use strict';
+/* global __resourceQuery WorkerGlobalScope self */
+// Send messages to the outside, so plugins can consume it.
+
+function sendMsg(type, data) {
+  if (typeof self !== 'undefined' && (typeof WorkerGlobalScope === 'undefined' || !(self instanceof WorkerGlobalScope))) {
+    self.postMessage({
+      type: "webpack".concat(type),
+      data: data
+    }, '*');
+  }
+}
+
+module.exports = sendMsg;