Mail

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/WDSSocket.js

@@ -0,0 +1,32 @@
+/* global __webpack_dev_server_client__ */
+
+const getSocketUrlParts = require('./utils/getSocketUrlParts.js');
+const getUrlFromParts = require('./utils/getUrlFromParts');
+const getWDSMetadata = require('./utils/getWDSMetadata');
+
+/**
+ * Initializes a socket server for HMR for webpack-dev-server.
+ * @param {function(*): void} messageHandler A handler to consume Webpack compilation messages.
+ * @param {string} [resourceQuery] Webpack's `__resourceQuery` string.
+ * @returns {void}
+ */
+function initWDSSocket(messageHandler, resourceQuery) {
+  if (typeof __webpack_dev_server_client__ !== 'undefined') {
+    let SocketClient = __webpack_dev_server_client__;
+    if (typeof __webpack_dev_server_client__.default !== 'undefined') {
+      SocketClient = __webpack_dev_server_client__.default;
+    }
+
+    const wdsMeta = getWDSMetadata(SocketClient);
+    const urlParts = getSocketUrlParts(resourceQuery, wdsMeta);
+
+    const connection = new SocketClient(getUrlFromParts(urlParts, wdsMeta));
+
+    connection.onMessage(function onSocketMessage(data) {
+      const message = JSON.parse(data);
+      messageHandler(message);
+    });
+  }
+}
+
+module.exports = { init: initWDSSocket };

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/WHMEventSource.js

@@ -0,0 +1,31 @@
+/**
+ * The hard-coded singleton key for webpack-hot-middleware's client instance.
+ *
+ * [Ref](https://github.com/webpack-contrib/webpack-hot-middleware/blob/cb29abb9dde435a1ac8e9b19f82d7d36b1093198/client.js#L152)
+ */
+const singletonKey = '__webpack_hot_middleware_reporter__';
+
+/**
+ * Initializes a socket server for HMR for webpack-hot-middleware.
+ * @param {function(*): void} messageHandler A handler to consume Webpack compilation messages.
+ * @returns {void}
+ */
+function initWHMEventSource(messageHandler) {
+  const client = window[singletonKey];
+
+  client.useCustomOverlay({
+    showProblems: function showProblems(type, data) {
+      const error = {
+        data: data,
+        type: type,
+      };
+
+      messageHandler(error);
+    },
+    clear: function clear() {
+      messageHandler({ type: 'ok' });
+    },
+  });
+}
+
+module.exports = { init: initWHMEventSource };

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/WPSSocket.js

@@ -0,0 +1,51 @@
+/* global ʎɐɹɔosǝʌɹǝs */
+const { ClientSocket } = require('webpack-plugin-serve/lib/client/ClientSocket');
+
+/**
+ * Initializes a socket server for HMR for webpack-plugin-serve.
+ * @param {function(*): void} messageHandler A handler to consume Webpack compilation messages.
+ * @returns {void}
+ */
+function initWPSSocket(messageHandler) {
+  /**
+   * The hard-coded options injection key from webpack-plugin-serve.
+   *
+   * [Ref](https://github.com/shellscape/webpack-plugin-serve/blob/aeb49f14e900802c98df4a4607a76bc67b1cffdf/lib/index.js#L258)
+   * @type {Object | undefined}
+   */
+  let options;
+  try {
+    options = ʎɐɹɔosǝʌɹǝs;
+  } catch (e) {
+    // Bail out because this indicates the plugin is not included
+    return;
+  }
+
+  const { address, client = {}, secure } = options;
+  const protocol = secure ? 'wss' : 'ws';
+  const socket = new ClientSocket(client, protocol + '://' + (client.address || address) + '/wps');
+
+  socket.addEventListener('message', function listener(message) {
+    const { action, data } = JSON.parse(message.data);
+
+    switch (action) {
+      case 'done': {
+        messageHandler({ type: 'ok' });
+        break;
+      }
+      case 'problems': {
+        if (data.errors.length) {
+          messageHandler({ type: 'errors', data: data.errors });
+        } else if (data.warnings.length) {
+          messageHandler({ type: 'warnings', data: data.warnings });
+        }
+        break;
+      }
+      default: {
+        // Do nothing
+      }
+    }
+  });
+}
+
+module.exports = { init: initWPSSocket };

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/utils/getCurrentScriptSource.js

@@ -0,0 +1,30 @@
+/**
+ * Gets the source (i.e. host) of the script currently running.
+ * @returns {string}
+ */
+function getCurrentScriptSource() {
+  // `document.currentScript` is the most accurate way to get the current running script,
+  // but is not supported in all browsers (most notably, IE).
+  if ('currentScript' in document) {
+    // In some cases, `document.currentScript` would be `null` even if the browser supports it:
+    // e.g. asynchronous chunks on Firefox.
+    // We should not fallback to the list-approach as it would not be safe.
+    if (document.currentScript == null) return;
+    return document.currentScript.getAttribute('src');
+  }
+  // Fallback to getting all scripts running in the document,
+  // and finding the last one injected.
+  else {
+    const scriptElementsWithSrc = Array.prototype.filter.call(
+      document.scripts || [],
+      function (elem) {
+        return elem.getAttribute('src');
+      }
+    );
+    if (!scriptElementsWithSrc.length) return;
+    const currentScript = scriptElementsWithSrc[scriptElementsWithSrc.length - 1];
+    return currentScript.getAttribute('src');
+  }
+}
+
+module.exports = getCurrentScriptSource;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/utils/getSocketUrlParts.js

@@ -0,0 +1,141 @@
+const getCurrentScriptSource = require('./getCurrentScriptSource.js');
+
+/**
+ * @typedef {Object} SocketUrlParts
+ * @property {string} [auth]
+ * @property {string} hostname
+ * @property {string} [protocol]
+ * @property {string} pathname
+ * @property {string} [port]
+ */
+
+/**
+ * Parse current location and Webpack's `__resourceQuery` into parts that can create a valid socket URL.
+ * @param {string} [resourceQuery] The Webpack `__resourceQuery` string.
+ * @param {import('./getWDSMetadata').WDSMetaObj} [metadata] The parsed WDS metadata object.
+ * @returns {SocketUrlParts} The parsed URL parts.
+ * @see https://webpack.js.org/api/module-variables/#__resourcequery-webpack-specific
+ */
+function getSocketUrlParts(resourceQuery, metadata) {
+  if (typeof metadata === 'undefined') {
+    metadata = {};
+  }
+
+  /** @type {SocketUrlParts} */
+  let urlParts = {};
+
+  // If the resource query is available,
+  // parse it and ignore everything we received from the script host.
+  if (resourceQuery) {
+    const parsedQuery = {};
+    const searchParams = new URLSearchParams(resourceQuery.slice(1));
+    searchParams.forEach(function (value, key) {
+      parsedQuery[key] = value;
+    });
+
+    urlParts.hostname = parsedQuery.sockHost;
+    urlParts.pathname = parsedQuery.sockPath;
+    urlParts.port = parsedQuery.sockPort;
+
+    // Make sure the protocol from resource query has a trailing colon
+    if (parsedQuery.sockProtocol) {
+      urlParts.protocol = parsedQuery.sockProtocol + ':';
+    }
+  } else {
+    const scriptSource = getCurrentScriptSource();
+
+    let url = {};
+    try {
+      // The placeholder `baseURL` with `window.location.href`,
+      // is to allow parsing of path-relative or protocol-relative URLs,
+      // and will have no effect if `scriptSource` is a fully valid URL.
+      url = new URL(scriptSource, window.location.href);
+    } catch (e) {
+      // URL parsing failed, do nothing.
+      // We will still proceed to see if we can recover using `resourceQuery`
+    }
+
+    // Parse authentication credentials in case we need them
+    if (url.username) {
+      // Since HTTP basic authentication does not allow empty username,
+      // we only include password if the username is not empty.
+      // Result: <username> or <username>:<password>
+      urlParts.auth = url.username;
+      if (url.password) {
+        urlParts.auth += ':' + url.password;
+      }
+    }
+
+    // `file://` URLs has `'null'` origin
+    if (url.origin !== 'null') {
+      urlParts.hostname = url.hostname;
+    }
+
+    urlParts.protocol = url.protocol;
+    urlParts.port = url.port;
+  }
+
+  if (!urlParts.pathname) {
+    if (metadata.version === 4) {
+      // This is hard-coded in WDS v4
+      urlParts.pathname = '/ws';
+    } else {
+      // This is hard-coded in WDS v3
+      urlParts.pathname = '/sockjs-node';
+    }
+  }
+
+  // Check for IPv4 and IPv6 host addresses that correspond to any/empty.
+  // This is important because `hostname` can be empty for some hosts,
+  // such as 'about:blank' or 'file://' URLs.
+  const isEmptyHostname =
+    urlParts.hostname === '0.0.0.0' || urlParts.hostname === '[::]' || !urlParts.hostname;
+  // We only re-assign the hostname if it is empty,
+  // and if we are using HTTP/HTTPS protocols.
+  if (
+    isEmptyHostname &&
+    window.location.hostname &&
+    window.location.protocol.indexOf('http') === 0
+  ) {
+    urlParts.hostname = window.location.hostname;
+  }
+
+  // We only re-assign `protocol` when `protocol` is unavailable,
+  // or if `hostname` is available and is empty,
+  // since otherwise we risk creating an invalid URL.
+  // We also do this when no sockProtocol was passed to the config and 'https' is used,
+  // as it mandates the use of secure sockets.
+  if (
+    !urlParts.protocol ||
+    (urlParts.hostname &&
+      (isEmptyHostname || (!resourceQuery && window.location.protocol === 'https:')))
+  ) {
+    urlParts.protocol = window.location.protocol;
+  }
+
+  // We only re-assign port when it is not available
+  if (!urlParts.port) {
+    urlParts.port = window.location.port;
+  }
+
+  if (!urlParts.hostname || !urlParts.pathname) {
+    throw new Error(
+      [
+        '[React Refresh] Failed to get an URL for the socket connection.',
+        "This usually means that the current executed script doesn't have a `src` attribute set.",
+        'You should either specify the socket path parameters under the `devServer` key in your Webpack config, or use the `overlay` option.',
+        'https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/main/docs/API.md#overlay',
+      ].join('\n')
+    );
+  }
+
+  return {
+    auth: urlParts.auth,
+    hostname: urlParts.hostname,
+    pathname: urlParts.pathname,
+    protocol: urlParts.protocol,
+    port: urlParts.port || undefined,
+  };
+}
+
+module.exports = getSocketUrlParts;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/utils/getUrlFromParts.js

@@ -0,0 +1,35 @@
+/**
+ * Create a valid URL from parsed URL parts.
+ * @param {import('./getSocketUrlParts').SocketUrlParts} urlParts The parsed URL parts.
+ * @param {import('./getWDSMetadata').WDSMetaObj} [metadata] The parsed WDS metadata object.
+ * @returns {string} The generated URL.
+ */
+function urlFromParts(urlParts, metadata) {
+  if (typeof metadata === 'undefined') {
+    metadata = {};
+  }
+
+  let fullProtocol = 'http:';
+  if (urlParts.protocol) {
+    fullProtocol = urlParts.protocol;
+  }
+  if (metadata.enforceWs) {
+    fullProtocol = fullProtocol.replace(/^(?:http|.+-extension|file)/i, 'ws');
+  }
+
+  fullProtocol = fullProtocol + '//';
+
+  let fullHost = urlParts.hostname;
+  if (urlParts.auth) {
+    const fullAuth = urlParts.auth.split(':').map(encodeURIComponent).join(':') + '@';
+    fullHost = fullAuth + fullHost;
+  }
+  if (urlParts.port) {
+    fullHost = fullHost + ':' + urlParts.port;
+  }
+
+  const url = new URL(urlParts.pathname, fullProtocol + fullHost);
+  return url.href;
+}
+
+module.exports = urlFromParts;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/sockets/utils/getWDSMetadata.js

@@ -0,0 +1,44 @@
+/**
+ * @typedef {Object} WDSMetaObj
+ * @property {boolean} enforceWs
+ * @property {number} version
+ */
+
+/**
+ * Derives WDS metadata from a compatible socket client.
+ * @param {Function} SocketClient A WDS socket client (SockJS/WebSocket).
+ * @returns {WDSMetaObj} The parsed WDS metadata object.
+ */
+function getWDSMetadata(SocketClient) {
+  let enforceWs = false;
+  if (
+    typeof SocketClient.name !== 'undefined' &&
+    SocketClient.name !== null &&
+    SocketClient.name.toLowerCase().includes('websocket')
+  ) {
+    enforceWs = true;
+  }
+
+  let version;
+  // WDS versions <=3.5.0
+  if (!('onMessage' in SocketClient.prototype)) {
+    version = 3;
+  } else {
+    // WDS versions >=3.5.0 <4
+    if (
+      'getClientPath' in SocketClient ||
+      Object.getPrototypeOf(SocketClient).name === 'BaseClient'
+    ) {
+      version = 3;
+    } else {
+      version = 4;
+    }
+  }
+
+  return {
+    enforceWs: enforceWs,
+    version: version,
+  };
+}
+
+module.exports = getWDSMetadata;