0.2.0 - Mid migration

web/node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ErrorOverlayEntry.js

@@ -0,0 +1,86 @@
+/* global __react_refresh_error_overlay__, __react_refresh_init_socket__, __resourceQuery */
+
+const errorEventHandlers = require('./utils/errorEventHandlers');
+const formatWebpackErrors = require('./utils/formatWebpackErrors');
+
+// Setup error states
+let isHotReload = false;
+let hasRuntimeErrors = false;
+
+/**
+ * Try dismissing the compile error overlay.
+ * This will also reset runtime error records (if any),
+ * because we have new source to evaluate.
+ * @returns {void}
+ */
+function tryDismissErrorOverlay() {
+  __react_refresh_error_overlay__.clearCompileError();
+  __react_refresh_error_overlay__.clearRuntimeErrors(!hasRuntimeErrors);
+  hasRuntimeErrors = false;
+}
+
+/**
+ * A function called after a compile success signal is received from Webpack.
+ * @returns {void}
+ */
+function handleCompileSuccess() {
+  isHotReload = true;
+
+  if (isHotReload) {
+    tryDismissErrorOverlay();
+  }
+}
+
+/**
+ * A function called after a compile errored signal is received from Webpack.
+ * @param {string} errors
+ * @returns {void}
+ */
+function handleCompileErrors(errors) {
+  isHotReload = true;
+
+  const formattedErrors = formatWebpackErrors(errors);
+
+  // Only show the first error
+  __react_refresh_error_overlay__.showCompileError(formattedErrors[0]);
+}
+
+/**
+ * Handles compilation messages from Webpack.
+ * Integrates with a compile error overlay.
+ * @param {*} message A Webpack HMR message sent via WebSockets.
+ * @returns {void}
+ */
+function compileMessageHandler(message) {
+  switch (message.type) {
+    case 'ok':
+    case 'still-ok':
+    case 'warnings': {
+      // TODO: Implement handling for warnings
+      handleCompileSuccess();
+      break;
+    }
+    case 'errors': {
+      handleCompileErrors(message.data);
+      break;
+    }
+    default: {
+      // Do nothing.
+    }
+  }
+}
+
+// Only register if we're in non-production mode and if window is defined
+if (process.env.NODE_ENV !== 'production' && typeof window !== 'undefined') {
+  // Registers handlers for compile errors
+  __react_refresh_init_socket__(compileMessageHandler, __resourceQuery);
+  // Registers handlers for runtime errors
+  errorEventHandlers.error(function handleError(error) {
+    hasRuntimeErrors = true;
+    __react_refresh_error_overlay__.handleRuntimeError(error);
+  });
+  errorEventHandlers.unhandledRejection(function handleUnhandledPromiseRejection(error) {
+    hasRuntimeErrors = true;
+    __react_refresh_error_overlay__.handleRuntimeError(error);
+  });
+}

web/node_modules/@pmmmwh/react-refresh-webpack-plugin/client/LegacyWDSSocketEntry.js

@@ -0,0 +1,31 @@
+const SockJS = require('sockjs-client/dist/sockjs');
+const safeThis = require('./utils/safeThis');
+
+/**
+ * A SockJS client adapted for use with webpack-dev-server.
+ * @constructor
+ * @param {string} url The socket URL.
+ */
+function SockJSClient(url) {
+  this.socket = new SockJS(url);
+}
+
+/**
+ * Creates a handler to handle socket close events.
+ * @param {function(): void} fn
+ */
+SockJSClient.prototype.onClose = function onClose(fn) {
+  this.socket.onclose = fn;
+};
+
+/**
+ * Creates a handler to handle socket message events.
+ * @param {function(*): void} fn
+ */
+SockJSClient.prototype.onMessage = function onMessage(fn) {
+  this.socket.onmessage = function onMessageHandler(event) {
+    fn(event.data);
+  };
+};
+
+safeThis.__webpack_dev_server_client__ = SockJSClient;

web/node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js

@@ -0,0 +1,13 @@
+const safeThis = require('./utils/safeThis');
+
+if (process.env.NODE_ENV !== 'production' && typeof safeThis !== 'undefined') {
+  // Only inject the runtime if it hasn't been injected
+  if (!safeThis.__reactRefreshInjected) {
+    const RefreshRuntime = require('react-refresh/runtime');
+    // Inject refresh runtime into global scope
+    RefreshRuntime.injectIntoGlobalHook(safeThis);
+
+    // Mark the runtime as injected to prevent double-injection
+    safeThis.__reactRefreshInjected = true;
+  }
+}

web/node_modules/@pmmmwh/react-refresh-webpack-plugin/client/utils/errorEventHandlers.js

@@ -0,0 +1,96 @@
+/**
+ * @callback EventCallback
+ * @param {string | Error | null} context
+ * @returns {void}
+ */
+/**
+ * @callback EventHandler
+ * @param {Event} event
+ * @returns {void}
+ */
+
+/**
+ * A function that creates an event handler for the `error` event.
+ * @param {EventCallback} callback A function called to handle the error context.
+ * @returns {EventHandler} A handler for the `error` event.
+ */
+function createErrorHandler(callback) {
+  return function errorHandler(event) {
+    if (!event || !event.error) {
+      return callback(null);
+    }
+    if (event.error instanceof Error) {
+      return callback(event.error);
+    }
+    // A non-error was thrown, we don't have a trace. :(
+    // Look in your browser's devtools for more information
+    return callback(new Error(event.error));
+  };
+}
+
+/**
+ * A function that creates an event handler for the `unhandledrejection` event.
+ * @param {EventCallback} callback A function called to handle the error context.
+ * @returns {EventHandler} A handler for the `unhandledrejection` event.
+ */
+function createRejectionHandler(callback) {
+  return function rejectionHandler(event) {
+    if (!event || !event.reason) {
+      return callback(new Error('Unknown'));
+    }
+    if (event.reason instanceof Error) {
+      return callback(event.reason);
+    }
+    // A non-error was rejected, we don't have a trace :(
+    // Look in your browser's devtools for more information
+    return callback(new Error(event.reason));
+  };
+}
+
+/**
+ * Creates a handler that registers an EventListener on window for a valid type
+ * and calls a callback when the event fires.
+ * @param {string} eventType A valid DOM event type.
+ * @param {function(EventCallback): EventHandler} createHandler A function that creates an event handler.
+ * @returns {register} A function that registers the EventListener given a callback.
+ */
+function createWindowEventHandler(eventType, createHandler) {
+  /**
+   * @type {EventHandler | null} A cached event handler function.
+   */
+  let eventHandler = null;
+
+  /**
+   * Unregisters an EventListener if it has been registered.
+   * @returns {void}
+   */
+  function unregister() {
+    if (eventHandler === null) {
+      return;
+    }
+    window.removeEventListener(eventType, eventHandler);
+    eventHandler = null;
+  }
+
+  /**
+   * Registers an EventListener if it hasn't been registered.
+   * @param {EventCallback} callback A function called after the event handler to handle its context.
+   * @returns {unregister | void} A function to unregister the registered EventListener if registration is performed.
+   */
+  function register(callback) {
+    if (eventHandler !== null) {
+      return;
+    }
+    eventHandler = createHandler(callback);
+    window.addEventListener(eventType, eventHandler);
+
+    return unregister;
+  }
+
+  return register;
+}
+
+module.exports = {
+  error: createWindowEventHandler('error', createErrorHandler),
+  unhandledRejection: createWindowEventHandler('unhandledrejection', createRejectionHandler),
+};

web/node_modules/@pmmmwh/react-refresh-webpack-plugin/client/utils/formatWebpackErrors.js

@@ -0,0 +1,95 @@
+/**
+ * @typedef {Object} WebpackErrorObj
+ * @property {string} moduleIdentifier
+ * @property {string} moduleName
+ * @property {string} message
+ */
+
+const friendlySyntaxErrorLabel = 'Syntax error:';
+
+/**
+ * Checks if the error message is for a syntax error.
+ * @param {string} message The raw Webpack error message.
+ * @returns {boolean} Whether the error message is for a syntax error.
+ */
+function isLikelyASyntaxError(message) {
+  return message.indexOf(friendlySyntaxErrorLabel) !== -1;
+}
+
+/**
+ * Cleans up Webpack error messages.
+ *
+ * This implementation is based on the one from [create-react-app](https://github.com/facebook/create-react-app/blob/edc671eeea6b7d26ac3f1eb2050e50f75cf9ad5d/packages/react-dev-utils/formatWebpackMessages.js).
+ * @param {string} message The raw Webpack error message.
+ * @returns {string} The formatted Webpack error message.
+ */
+function formatMessage(message) {
+  let lines = message.split('\n');
+
+  // Strip Webpack-added headers off errors/warnings
+  // https://github.com/webpack/webpack/blob/master/lib/ModuleError.js
+  lines = lines.filter(function (line) {
+    return !/Module [A-z ]+\(from/.test(line);
+  });
+
+  // Remove leading newline
+  if (lines.length > 2 && lines[1].trim() === '') {
+    lines.splice(1, 1);
+  }
+
+  // Remove duplicated newlines
+  lines = lines.filter(function (line, index, arr) {
+    return index === 0 || line.trim() !== '' || line.trim() !== arr[index - 1].trim();
+  });
+
+  // Clean up the file name
+  lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, '$1');
+
+  // Cleans up verbose "module not found" messages for files and packages.
+  if (lines[1] && lines[1].indexOf('Module not found: ') === 0) {
+    lines = [
+      lines[0],
+      lines[1]
+        .replace('Error: ', '')
+        .replace('Module not found: Cannot find file:', 'Cannot find file:'),
+    ];
+  }
+
+  message = lines.join('\n');
+
+  // Clean up syntax errors
+  message = message.replace('SyntaxError:', friendlySyntaxErrorLabel);
+
+  // Internal stacks are generally useless, so we strip them -
+  // except the stacks containing `webpack:`,
+  // because they're normally from user code generated by webpack.
+  message = message.replace(/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm, ''); // at ... ...:x:y
+  message = message.replace(/^\s*at\s((?!webpack:).)*<anonymous>[\s)]*(\n|$)/gm, ''); // at ... <anonymous>
+  message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, ''); // at <anonymous>
+
+  return message.trim();
+}
+
+/**
+ * Formats Webpack error messages into a more readable format.
+ * @param {Array<string | WebpackErrorObj>} errors An array of Webpack error messages.
+ * @returns {string[]} The formatted Webpack error messages.
+ */
+function formatWebpackErrors(errors) {
+  let formattedErrors = errors.map(function (errorObjOrMessage) {
+    // Webpack 5 compilation errors are in the form of descriptor objects,
+    // so we have to join pieces to get the format we want.
+    if (typeof errorObjOrMessage === 'object') {
+      return formatMessage([errorObjOrMessage.moduleName, errorObjOrMessage.message].join('\n'));
+    }
+    // Webpack 4 compilation errors are strings
+    return formatMessage(errorObjOrMessage);
+  });
+  if (formattedErrors.some(isLikelyASyntaxError)) {
+    // If there are any syntax errors, show just them.
+    formattedErrors = formattedErrors.filter(isLikelyASyntaxError);
+  }
+  return formattedErrors;
+}
+
+module.exports = formatWebpackErrors;

web/node_modules/@pmmmwh/react-refresh-webpack-plugin/client/utils/safeThis.js

@@ -0,0 +1,19 @@
+/* global globalThis */
+/*
+  This file is copied from `core-js`.
+  https://github.com/zloirock/core-js/blob/master/packages/core-js/internals/global.js
+
+  MIT License
+  Author: Denis Pushkarev (@zloirock)
+*/
+
+const check = function (it) {
+  return it && it.Math == Math && it;
+};
+
+module.exports =
+  check(typeof globalThis == 'object' && globalThis) ||
+  check(typeof window == 'object' && window) ||
+  check(typeof self == 'object' && self) ||
+  check(typeof global == 'object' && global) ||
+  Function('return this')();