WIP - add extractor, generate snippet_data

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

@@ -0,0 +1,82 @@
+'use strict';
+/* global self */
+
+var url = require('url');
+
+var querystring = require('querystring');
+
+var getCurrentScriptSource = require('./getCurrentScriptSource');
+
+function createSocketUrl(resourceQuery) {
+  var urlParts;
+
+  if (typeof resourceQuery === 'string' && resourceQuery !== '') {
+    // If this bundle is inlined, use the resource query to get the correct url.
+    urlParts = url.parse(resourceQuery.substr(1));
+  } else {
+    // Else, get the url from the <script> this file was called with.
+    var scriptHost = getCurrentScriptSource(); // eslint-disable-next-line no-useless-escape
+
+    scriptHost = scriptHost.replace(/\/[^\/]+$/, '');
+    urlParts = url.parse(scriptHost || '/', false, true);
+  }
+
+  if (!urlParts.port || urlParts.port === '0') {
+    urlParts.port = self.location.port;
+  }
+
+  var _urlParts = urlParts,
+      auth = _urlParts.auth,
+      path = _urlParts.path;
+  var _urlParts2 = urlParts,
+      hostname = _urlParts2.hostname,
+      protocol = _urlParts2.protocol; // 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
+
+  var isAnyHostname = (hostname === '0.0.0.0' || hostname === '::') && self.location.hostname && // eslint-disable-next-line no-bitwise
+  !!~self.location.protocol.indexOf('http');
+
+  if (isAnyHostname) {
+    hostname = self.location.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 && (self.location.protocol === 'https:' || urlParts.hostname === '0.0.0.0')) {
+    protocol = self.location.protocol;
+  } // default values of the sock url if they are not provided
+
+
+  var sockHost = hostname;
+  var sockPath = '/sockjs-node';
+  var sockPort = urlParts.port; // eslint-disable-next-line no-undefined
+
+  var shouldParsePath = path !== null && path !== undefined && path !== '/';
+
+  if (shouldParsePath) {
+    var parsedQuery = querystring.parse(path); // 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
+
+    sockHost = parsedQuery.sockHost || sockHost;
+    sockPath = parsedQuery.sockPath || sockPath;
+    sockPort = parsedQuery.sockPort || sockPort;
+  }
+
+  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;

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;

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
+};

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;

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;