@rspack/plugin-react-refresh 1.5.0 → 1.5.2

package/README.md

@@ -217,6 +217,21 @@ new ReactRefreshPlugin({
 });
 ```
 
+### reloadOnRuntimeErrors
+
+- Type: `boolean`
+- Default: `false`
+
+Config the plugin whether trigger a full page reload when an unrecoverable runtime error is encountered.
+
+Currently, only module factory undefined error is considered as unrecoverable runtime error.
+
+```js
+new ReactRefreshPlugin({
+  reloadOnRuntimeErrors: true,
+});
+```
+
 ## Credits
 
 Thanks to the [react-refresh-webpack-plugin](https://github.com/pmmmwh/react-refresh-webpack-plugin) created by [@pmmmwh](https://github.com/pmmmwh), which inspires implement this plugin.

package/client/overlay/index.js

@@ -240,7 +240,12 @@ function render() {
  */
 function cleanup() {
   // Clean up and reset all internal state.
-  document.body.removeChild(iframeRoot);
+  try {
+    document.body.removeChild(iframeRoot);
+  } catch (e) {
+    // In case user render react app directly to body， will trigger `NotFoundError` when recovery from an Error
+    // https://developer.mozilla.org/en-US/docs/Web/API/Node/removeChild#exceptions
+  }
   scheduledRenderFn = null;
   root = null;
   iframeRoot = null;

package/client/reactRefresh.js

@@ -14,7 +14,13 @@ function refresh(moduleId, webpackHot) {
     if (typeof __react_refresh_test__ !== 'undefined') {
       testMode = __react_refresh_test__;
     }
-    RefreshUtils.executeRuntime(exports, moduleId, webpackHot, errorOverlay, testMode);
+    RefreshUtils.executeRuntime(
+      exports,
+      moduleId,
+      webpackHot,
+      errorOverlay,
+      testMode,
+    );
   };
   if (typeof Promise !== 'undefined' && currentExports instanceof Promise) {
     currentExports.then(fn);

package/client/refreshUtils.js

@@ -209,6 +209,7 @@ function shouldInvalidateReactRefreshBoundary(prevExports, nextExports) {
 }
 
 var enqueueUpdate = createDebounceUpdate();
+
 function executeRuntime(
   moduleExports,
   moduleId,
@@ -245,6 +246,15 @@ function executeRuntime(
          * @returns {void}
          */
         function hotErrorHandler(error) {
+          console.error(error);
+          if (
+            __reload_on_runtime_errors__ &&
+            isUnrecoverableRuntimeError(error)
+          ) {
+            location.reload();
+            return;
+          }
+
           if (typeof refreshOverlay !== 'undefined' && refreshOverlay) {
             refreshOverlay.handleRuntimeError(error);
           }
@@ -287,6 +297,10 @@ function executeRuntime(
   }
 }
 
+function isUnrecoverableRuntimeError(error) {
+  return error.message.startsWith('RuntimeError: factory is undefined');
+}
+
 module.exports = Object.freeze({
   enqueueUpdate: enqueueUpdate,
   executeRuntime: executeRuntime,

package/dist/index.d.ts

@@ -3,7 +3,10 @@ import type { NormalizedPluginOptions, PluginOptions } from './options';
 export type { PluginOptions };
 declare class ReactRefreshRspackPlugin {
     options: NormalizedPluginOptions;
-    static deprecated_runtimePaths: string[];
+    /**
+     * @deprecated
+     */
+    static get deprecated_runtimePaths(): string[];
     static loader: string;
     constructor(options?: PluginOptions);
     apply(compiler: Compiler): void;

package/dist/index.js

@@ -1,116 +1,255 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ReactRefreshRspackPlugin: ()=>ReactRefreshRspackPlugin,
+    default: ()=>src
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const d = (object, property, defaultValue)=>{
+    if (void 0 === object[property] && void 0 !== defaultValue) object[property] = defaultValue;
+    return object[property];
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactRefreshRspackPlugin = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const options_1 = require("./options");
-const paths_1 = require("./paths");
-const getAdditionalEntries_1 = require("./utils/getAdditionalEntries");
-const getSocketIntegration_1 = require("./utils/getSocketIntegration");
-const getIntegrationEntry_1 = require("./utils/getIntegrationEntry");
+const normalizeOverlay = (options)=>{
+    const defaultOverlay = {
+        entry: external_node_path_default().join(__dirname, '../client/errorOverlayEntry.js'),
+        module: external_node_path_default().join(__dirname, '../client/overlay/index.js'),
+        sockIntegration: 'wds'
+    };
+    if (!options) return false;
+    if (void 0 === options || true === options) return defaultOverlay;
+    options.entry = options.entry ?? defaultOverlay.entry;
+    options.module = options.module ?? defaultOverlay.module;
+    options.sockIntegration = options.sockIntegration ?? defaultOverlay.sockIntegration;
+    return options;
+};
+function normalizeOptions(options) {
+    d(options, 'exclude', /node_modules/i);
+    d(options, 'include', /\.([cm]js|[jt]sx?|flow)$/i);
+    d(options, 'library');
+    d(options, 'forceEnable', false);
+    d(options, 'injectLoader', true);
+    d(options, 'injectEntry', true);
+    d(options, 'reloadOnRuntimeErrors', false);
+    options.overlay = normalizeOverlay(options.overlay);
+    return options;
+}
+const reactRefreshPath = external_node_path_default().join(__dirname, '../client/reactRefresh.js');
+const reactRefreshEntryPath = external_node_path_default().join(__dirname, '../client/reactRefreshEntry.js');
+const refreshUtilsPath = external_node_path_default().join(__dirname, '../client/refreshUtils.js');
+let refreshRuntimeDirPath;
+function getRefreshRuntimeDirPath() {
+    if (!refreshRuntimeDirPath) refreshRuntimeDirPath = external_node_path_default().dirname(require.resolve('react-refresh', {
+        paths: [
+            reactRefreshPath
+        ]
+    }));
+    return refreshRuntimeDirPath;
+}
+const getRefreshRuntimePaths = ()=>[
+        reactRefreshEntryPath,
+        reactRefreshPath,
+        refreshUtilsPath,
+        getRefreshRuntimeDirPath()
+    ];
+const external_node_querystring_namespaceObject = require("node:querystring");
+var external_node_querystring_default = /*#__PURE__*/ __webpack_require__.n(external_node_querystring_namespaceObject);
+function getAdditionalEntries({ devServer, options }) {
+    const resourceQuery = {};
+    if (devServer) {
+        const { client, https, http2, sockHost, sockPath, sockPort } = devServer;
+        let { host, path, port } = devServer;
+        let protocol = https || http2 ? 'https' : 'http';
+        if (sockHost) host = sockHost;
+        if (sockPath) path = sockPath;
+        if (sockPort) port = sockPort;
+        if (client && null != client.webSocketURL) {
+            let parsedUrl = client.webSocketURL;
+            if ('string' == typeof parsedUrl) parsedUrl = new URL(parsedUrl);
+            let auth;
+            if (parsedUrl.username) {
+                auth = parsedUrl.username;
+                if (parsedUrl.password) auth += `:${parsedUrl.password}`;
+            }
+            if (null != parsedUrl.hostname) host = [
+                null != auth && auth,
+                parsedUrl.hostname
+            ].filter(Boolean).join('@');
+            if (null != parsedUrl.pathname) path = parsedUrl.pathname;
+            if (null != parsedUrl.port) port = [
+                '0',
+                'auto'
+            ].includes(String(parsedUrl.port)) ? void 0 : parsedUrl.port;
+            if (null != parsedUrl.protocol) protocol = 'auto' !== parsedUrl.protocol ? parsedUrl.protocol.replace(':', '') : 'ws';
+        }
+        if (host) resourceQuery.sockHost = host;
+        if (path) resourceQuery.sockPath = path;
+        if (port) resourceQuery.sockPort = port;
+        resourceQuery.sockProtocol = protocol;
+    }
+    if (options.overlay) {
+        const { sockHost, sockPath, sockPort, sockProtocol } = options.overlay;
+        if (sockHost) resourceQuery.sockHost = sockHost;
+        if (sockPath) resourceQuery.sockPath = sockPath;
+        if (sockPort) resourceQuery.sockPort = sockPort;
+        if (sockProtocol) resourceQuery.sockProtocol = sockProtocol;
+    }
+    const queryString = external_node_querystring_default().stringify(resourceQuery, void 0, void 0, {
+        encodeURIComponent (str) {
+            return str;
+        }
+    });
+    const prependEntries = [
+        reactRefreshEntryPath
+    ];
+    const overlayEntries = [
+        false !== options.overlay && options.overlay?.entry && `${require.resolve(options.overlay.entry)}${queryString ? `?${queryString}` : ''}`
+    ].filter(Boolean);
+    return {
+        prependEntries,
+        overlayEntries
+    };
+}
+function getIntegrationEntry(integrationType) {
+    let resolvedEntry;
+    switch(integrationType){
+        case 'whm':
+            resolvedEntry = 'webpack-hot-middleware/client';
+            break;
+    }
+    return resolvedEntry;
+}
+function getSocketIntegration(integrationType) {
+    let resolvedSocketIntegration;
+    switch(integrationType){
+        case 'wds':
+            resolvedSocketIntegration = external_node_path_default().join(__dirname, './sockets/WDSSocket.js');
+            break;
+        case 'whm':
+            resolvedSocketIntegration = external_node_path_default().join(__dirname, './sockets/WHMEventSource.js');
+            break;
+        default:
+            resolvedSocketIntegration = require.resolve(integrationType);
+            break;
+    }
+    return resolvedSocketIntegration;
+}
 function addEntry(entry, compiler) {
     new compiler.webpack.EntryPlugin(compiler.context, entry, {
-        name: undefined,
+        name: void 0
     }).apply(compiler);
 }
 function addSocketEntry(sockIntegration, compiler) {
-    const integrationEntry = (0, getIntegrationEntry_1.getIntegrationEntry)(sockIntegration);
-    if (integrationEntry) {
-        addEntry(integrationEntry, compiler);
-    }
+    const integrationEntry = getIntegrationEntry(sockIntegration);
+    if (integrationEntry) addEntry(integrationEntry, compiler);
 }
 const PLUGIN_NAME = 'ReactRefreshRspackPlugin';
 class ReactRefreshRspackPlugin {
-    constructor(options = {}) {
-        this.options = (0, options_1.normalizeOptions)(options);
+    options;
+    static get deprecated_runtimePaths() {
+        return getRefreshRuntimePaths();
+    }
+    static loader = 'builtin:react-refresh-loader';
+    constructor(options = {}){
+        this.options = normalizeOptions(options);
     }
     apply(compiler) {
-        if (
-        // Webpack do not set process.env.NODE_ENV, so we need to check for mode.
-        // Ref: https://github.com/webpack/webpack/issues/7074
-        (compiler.options.mode !== 'development' ||
-            // We also check for production process.env.NODE_ENV,
-            // in case it was set and mode is non-development (e.g. 'none')
-            (process.env.NODE_ENV && process.env.NODE_ENV === 'production')) &&
-            !this.options.forceEnable) {
-            return;
-        }
-        const addEntries = (0, getAdditionalEntries_1.getAdditionalEntries)({
+        if (('development' !== compiler.options.mode || process.env.NODE_ENV && 'production' === process.env.NODE_ENV) && !this.options.forceEnable) return;
+        const addEntries = getAdditionalEntries({
             devServer: compiler.options.devServer,
-            options: this.options,
+            options: this.options
         });
-        if (this.options.injectEntry) {
-            for (const entry of addEntries.prependEntries) {
-                addEntry(entry, compiler);
-            }
-        }
-        if (this.options.overlay !== false &&
-            this.options.overlay.sockIntegration) {
-            addSocketEntry(this.options.overlay.sockIntegration, compiler);
-        }
-        for (const entry of addEntries.overlayEntries) {
-            addEntry(entry, compiler);
-        }
+        if (this.options.injectEntry) for (const entry of addEntries.prependEntries)addEntry(entry, compiler);
+        if (false !== this.options.overlay && this.options.overlay.sockIntegration) addSocketEntry(this.options.overlay.sockIntegration, compiler);
+        for (const entry of addEntries.overlayEntries)addEntry(entry, compiler);
         new compiler.webpack.ProvidePlugin({
-            $ReactRefreshRuntime$: paths_1.reactRefreshPath,
+            $ReactRefreshRuntime$: reactRefreshPath
         }).apply(compiler);
-        if (this.options.injectLoader) {
-            compiler.options.module.rules.unshift({
-                test: this.options.test,
-                // biome-ignore lint: exists
-                include: this.options.include,
-                exclude: {
-                    // biome-ignore lint: exists
-                    or: [this.options.exclude, [...paths_1.runtimePaths]].filter(Boolean),
-                },
-                resourceQuery: this.options.resourceQuery,
-                dependency: {
-                    // `new URL("static/sdk.js", import.meta.url)` the sdk.js is an asset module
-                    // we shoudn't inject react refresh for asset module
-                    not: ['url'],
-                },
-                use: ReactRefreshRspackPlugin.loader,
-            });
-        }
+        if (this.options.injectLoader) compiler.options.module.rules.unshift({
+            test: this.options.test,
+            include: this.options.include,
+            exclude: {
+                or: [
+                    this.options.exclude,
+                    [
+                        ...getRefreshRuntimePaths()
+                    ]
+                ].filter(Boolean)
+            },
+            resourceQuery: this.options.resourceQuery,
+            dependency: {
+                not: [
+                    'url'
+                ]
+            },
+            use: ReactRefreshRspackPlugin.loader
+        });
         const definedModules = {
-            // For Multiple Instance Mode
-            __react_refresh_library__: JSON.stringify(compiler.webpack.Template.toIdentifier(this.options.library ||
-                compiler.options.output.uniqueName ||
-                compiler.options.output.library)),
+            __react_refresh_library__: JSON.stringify(compiler.webpack.Template.toIdentifier(this.options.library || compiler.options.output.uniqueName || compiler.options.output.library)),
+            __reload_on_runtime_errors__: this.options.reloadOnRuntimeErrors
         };
         const providedModules = {
-            __react_refresh_utils__: paths_1.refreshUtilsPath,
+            __react_refresh_utils__: refreshUtilsPath
         };
-        if (this.options.overlay === false) {
-            // Stub errorOverlay module so their calls can be erased
+        if (false === this.options.overlay) {
             definedModules.__react_refresh_error_overlay__ = false;
             definedModules.__react_refresh_socket__ = false;
-        }
-        else {
-            if (this.options.overlay.module) {
-                providedModules.__react_refresh_error_overlay__ = require.resolve(this.options.overlay.module);
-            }
-            if (this.options.overlay.sockIntegration) {
-                providedModules.__react_refresh_socket__ = (0, getSocketIntegration_1.getSocketIntegration)(this.options.overlay.sockIntegration);
-            }
+        } else {
+            if (this.options.overlay.module) providedModules.__react_refresh_error_overlay__ = require.resolve(this.options.overlay.module);
+            if (this.options.overlay.sockIntegration) providedModules.__react_refresh_socket__ = getSocketIntegration(this.options.overlay.sockIntegration);
         }
         new compiler.webpack.DefinePlugin(definedModules).apply(compiler);
         new compiler.webpack.ProvidePlugin(providedModules).apply(compiler);
-        const refreshPath = node_path_1.default.dirname(require.resolve('react-refresh'));
         compiler.options.resolve.alias = {
-            'react-refresh': refreshPath,
-            ...compiler.options.resolve.alias,
+            'react-refresh': getRefreshRuntimeDirPath(),
+            ...compiler.options.resolve.alias
         };
-        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (_, runtimeRequirements) => {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (_, runtimeRequirements)=>{
                 runtimeRequirements.add(compiler.rspack.RuntimeGlobals.moduleCache);
             });
         });
     }
 }
-exports.ReactRefreshRspackPlugin = ReactRefreshRspackPlugin;
-ReactRefreshRspackPlugin.deprecated_runtimePaths = paths_1.runtimePaths;
-ReactRefreshRspackPlugin.loader = 'builtin:react-refresh-loader';
-exports.default = ReactRefreshRspackPlugin;
+const src = ReactRefreshRspackPlugin;
+exports.ReactRefreshRspackPlugin = __webpack_exports__.ReactRefreshRspackPlugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ReactRefreshRspackPlugin",
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/options.d.ts

@@ -75,6 +75,11 @@ export type PluginOptions = {
      * @default true
      */
     injectEntry?: boolean;
+    /**
+     * Whether to reload the page on runtime errors. E.g: undefined module factory
+     * @default false
+     */
+    reloadOnRuntimeErrors?: boolean;
 };
 export interface NormalizedPluginOptions extends Required<PluginOptions> {
     overlay: false | OverlayOptions;

package/dist/paths.d.ts

@@ -1,5 +1,5 @@
 export declare const reactRefreshPath: string;
 export declare const reactRefreshEntryPath: string;
 export declare const refreshUtilsPath: string;
-export declare const refreshRuntimeDirPath: string;
-export declare const runtimePaths: string[];
+export declare function getRefreshRuntimeDirPath(): string;
+export declare const getRefreshRuntimePaths: () => string[];

package/dist/sockets/WDSSocket.js

@@ -1,42 +1,63 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = init;
-/**
- * The following code is modified based on
- * https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/f1c8b9a44198449093ca95f85af5df97925e1cfc/sockets/WDSSocket.js
- *
- * MIT Licensed
- * Author Michael Mok
- * Copyright (c) 2019 Michael Mok
- * https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/0b960573797bf38926937994c481e4fec9ed8aa6/LICENSE
- */
-const getSocketUrlParts_1 = __importDefault(require("./utils/getSocketUrlParts"));
-const getUrlFromParts_1 = __importDefault(require("./utils/getUrlFromParts"));
-const getWDSMetadata_1 = __importDefault(require("./utils/getWDSMetadata"));
-/**
- * Initializes a socket server for HMR for webpack-dev-server.
- * @param messageHandler A handler to consume Webpack compilation messages.
- * @param resourceQuery Webpack's `__resourceQuery` string.
- * @returns
- */
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    init: ()=>init
+});
+const getSocketUrlParts_js_namespaceObject = require("./utils/getSocketUrlParts.js");
+var getSocketUrlParts_js_default = /*#__PURE__*/ __webpack_require__.n(getSocketUrlParts_js_namespaceObject);
+const getUrlFromParts_js_namespaceObject = require("./utils/getUrlFromParts.js");
+var getUrlFromParts_js_default = /*#__PURE__*/ __webpack_require__.n(getUrlFromParts_js_namespaceObject);
+const getWDSMetadata_js_namespaceObject = require("./utils/getWDSMetadata.js");
+var getWDSMetadata_js_default = /*#__PURE__*/ __webpack_require__.n(getWDSMetadata_js_namespaceObject);
 function init(messageHandler, resourceQuery) {
-    if (typeof __webpack_dev_server_client__ !== 'undefined') {
+    if ('undefined' != typeof __webpack_dev_server_client__) {
         let SocketClient;
-        if ('default' in __webpack_dev_server_client__) {
-            SocketClient = __webpack_dev_server_client__.default;
-        }
-        else {
-            SocketClient = __webpack_dev_server_client__;
-        }
-        const wdsMeta = (0, getWDSMetadata_1.default)(SocketClient);
-        const urlParts = (0, getSocketUrlParts_1.default)(resourceQuery, wdsMeta);
-        const connection = new SocketClient((0, getUrlFromParts_1.default)(urlParts, wdsMeta));
-        connection.onMessage(function onSocketMessage(data) {
+        SocketClient = 'default' in __webpack_dev_server_client__ ? __webpack_dev_server_client__.default : __webpack_dev_server_client__;
+        const wdsMeta = getWDSMetadata_js_default()(SocketClient);
+        const urlParts = getSocketUrlParts_js_default()(resourceQuery, wdsMeta);
+        const connection = new SocketClient(getUrlFromParts_js_default()(urlParts, wdsMeta));
+        connection.onMessage(function(data) {
             const message = JSON.parse(data);
             messageHandler(message);
         });
     }
 }
+exports.init = __webpack_exports__.init;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "init"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/sockets/WHMEventSource.js

@@ -1,34 +1,52 @@
 "use strict";
-/**
- * The following code is modified based on
- * https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/f770d3962c388da01eeda7079bff5f40c93992d2/sockets/WHMEventSource.js
- *
- * MIT Licensed
- * Author Michael Mok
- * Copyright (c) 2019 Michael Mok
- * https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/f770d3962c388da01eeda7079bff5f40c93992d2/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = init;
-/**
- * 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)
- */
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    init: ()=>init
+});
 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 init(messageHandler) {
     const client = window[singletonKey];
     client.useCustomOverlay({
-        showProblems(type, data) {
-            messageHandler({ type, data });
-        },
-        clear() {
-            messageHandler({ type: 'ok' });
+        showProblems (type, data) {
+            messageHandler({
+                type,
+                data
+            });
         },
+        clear () {
+            messageHandler({
+                type: 'ok'
+            });
+        }
     });
 }
+exports.init = __webpack_exports__.init;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "init"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/sockets/utils/getCurrentScriptSource.js

@@ -1,22 +1,45 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getCurrentScriptSource;
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>getCurrentScriptSource
+});
 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;
+        if (null == document.currentScript) return;
         return document.currentScript.getAttribute('src');
     }
-    // Fallback to getting all scripts running in the document,
-    // and finding the last one injected.
-    const scriptElementsWithSrc = Array.prototype.filter.call(document.scripts || [], (elem) => elem.getAttribute('src'));
-    if (!scriptElementsWithSrc.length)
-        return;
+    const scriptElementsWithSrc = Array.prototype.filter.call(document.scripts || [], (elem)=>elem.getAttribute('src'));
+    if (!scriptElementsWithSrc.length) return;
     const currentScript = scriptElementsWithSrc[scriptElementsWithSrc.length - 1];
     return currentScript.getAttribute('src');
 }
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/sockets/utils/getSocketUrlParts.js

@@ -1,108 +1,87 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getSocketUrlParts;
-const getCurrentScriptSource_1 = __importDefault(require("./getCurrentScriptSource"));
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>getSocketUrlParts
+});
+const external_getCurrentScriptSource_js_namespaceObject = require("./getCurrentScriptSource.js");
+var external_getCurrentScriptSource_js_default = /*#__PURE__*/ __webpack_require__.n(external_getCurrentScriptSource_js_namespaceObject);
 function getSocketUrlParts(resourceQuery, metadata = {}) {
     const 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((value, key) => {
+        searchParams.forEach((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 = (0, getCurrentScriptSource_1.default)();
+        if (parsedQuery.sockProtocol) urlParts.protocol = `${parsedQuery.sockProtocol}:`;
+    } else {
+        const scriptSource = external_getCurrentScriptSource_js_default()();
         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.
-            // biome-ignore lint: reason
             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
+        } catch (e) {}
         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;
+            if (url.password) urlParts.auth += `:${url.password}`;
         }
+        if ('null' !== url.origin) 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 'https' is used as it mandates the use of secure sockets.
-    if (!urlParts.protocol ||
-        (urlParts.hostname &&
-            (isEmptyHostname || 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 Rspack config, or use the `overlay` option.',
-            'https://www.rspack.dev/guide/tech/react#fast-refresh',
-        ].join('\n'));
-    }
+    if (!urlParts.pathname) if (4 === metadata.version) urlParts.pathname = '/ws';
+    else urlParts.pathname = '/sockjs-node';
+    const isEmptyHostname = '0.0.0.0' === urlParts.hostname || '[::]' === urlParts.hostname || !urlParts.hostname;
+    if (isEmptyHostname && window.location.hostname && 0 === window.location.protocol.indexOf('http')) urlParts.hostname = window.location.hostname;
+    if (!urlParts.protocol || urlParts.hostname && (isEmptyHostname || 'https:' === window.location.protocol)) urlParts.protocol = window.location.protocol;
+    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.\nThis usually means that the current executed script doesn't have a `src` attribute set.\nYou should either specify the socket path parameters under the `devServer` key in your Rspack config, or use the `overlay` option.\nhttps://www.rspack.dev/guide/tech/react#fast-refresh");
     return {
         auth: urlParts.auth,
         hostname: urlParts.hostname,
         pathname: urlParts.pathname,
         protocol: urlParts.protocol,
-        port: urlParts.port || undefined,
+        port: urlParts.port || void 0
     };
 }
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/sockets/utils/getUrlFromParts.js

@@ -1,29 +1,49 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = urlFromParts;
-/**
- * Create a valid URL from parsed URL parts.
- * @param urlParts The parsed URL parts.
- * @param metadata The parsed WDS metadata object.
- * @returns The generated URL.
- */
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>urlFromParts
+});
 function urlFromParts(urlParts, metadata = {}) {
     let fullProtocol = 'http:';
-    if (urlParts.protocol) {
-        fullProtocol = urlParts.protocol;
-    }
-    if (metadata.enforceWs) {
-        fullProtocol = fullProtocol.replace(/^(?:http|.+-extension|file)/i, 'ws');
-    }
+    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}`;
-    }
+    if (urlParts.port) fullHost = `${fullHost}:${urlParts.port}`;
     const url = new URL(urlParts.pathname, fullProtocol + fullHost);
     return url.href;
 }
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/sockets/utils/getWDSMetadata.js

@@ -1,30 +1,45 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getWDSMetadata;
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>getWDSMetadata
+});
 function getWDSMetadata(SocketClient) {
     let enforceWs = false;
-    if (typeof SocketClient.name !== 'undefined' &&
-        SocketClient.name !== null &&
-        SocketClient.name.toLowerCase().includes('websocket')) {
-        enforceWs = true;
-    }
+    if (void 0 !== SocketClient.name && null !== SocketClient.name && 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;
-        }
-    }
+    version = 'onMessage' in SocketClient.prototype ? 'getClientPath' in SocketClient || 'BaseClient' === Object.getPrototypeOf(SocketClient).name ? 3 : 4 : 3;
     return {
         enforceWs: enforceWs,
-        version: version,
+        version: version
     };
 }
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/exports/index.d.mts

@@ -1,4 +1,4 @@
-import { ReactRefreshRspackPlugin, type PluginOptions } from '../dist/index.js';
+import { type PluginOptions, ReactRefreshRspackPlugin } from '../dist/index.js';
 
 export type { PluginOptions };
 export { ReactRefreshRspackPlugin };

package/exports/index.mjs

@@ -1,5 +1,9 @@
 // ES modules wrapper
-import { ReactRefreshRspackPlugin } from '../dist/index.js';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { ReactRefreshRspackPlugin } = require('../dist/index.js');
+
 // default export will be deprecated in next major version
 export default ReactRefreshRspackPlugin;
 export { ReactRefreshRspackPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/plugin-react-refresh",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "repository": "https://github.com/rspack-contrib/rspack-plugin-react-refresh",
   "license": "MIT",
   "description": "React refresh plugin for Rspack",
@@ -32,10 +32,12 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
-    "@rslib/core": "^0.11.0",
-    "@rspack/core": "1.4.11",
+    "@rslib/core": "^0.15.1",
+    "@rspack/core": "^1.5.8",
     "@types/jest": "29.5.14",
     "@types/node": "^22.17.0",
+    "bumpp": "^10.2.3",
+    "cac": "^6.7.14",
     "cross-env": "^10.0.0",
     "execa": "9.6.0",
     "fs-extra": "11.3.0",
@@ -68,11 +70,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsc -b ./tsconfig.build.json",
-    "dev": "tsc -b -w",
+    "build": "rslib build",
+    "dev": "rslib build -w",
     "lint": "biome check .",
     "lint:write": "biome check . --write",
     "test": "jest --colors",
-    "release": "node ./scripts/release.mjs"
+    "release": "node ./scripts/release.mjs",
+    "bump": "npx bumpp --no-push --no-tag --no-commit"
   }
 }

package/dist/options.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeOptions = normalizeOptions;
-const d = (object, property, defaultValue) => {
-    // TODO: should we also add default for null?
-    if (typeof object[property] === 'undefined' &&
-        typeof defaultValue !== 'undefined') {
-        object[property] = defaultValue;
-    }
-    return object[property];
-};
-const normalizeOverlay = (options) => {
-    const defaultOverlay = {
-        entry: require.resolve('../client/errorOverlayEntry.js'),
-        module: require.resolve('../client/overlay/index.js'),
-        sockIntegration: 'wds',
-    };
-    if (!options) {
-        return false;
-    }
-    if (typeof options === 'undefined' || options === true) {
-        return defaultOverlay;
-    }
-    options.entry = options.entry ?? defaultOverlay.entry;
-    options.module = options.module ?? defaultOverlay.module;
-    options.sockIntegration =
-        options.sockIntegration ?? defaultOverlay.sockIntegration;
-    return options;
-};
-function normalizeOptions(options) {
-    d(options, 'exclude', /node_modules/i);
-    d(options, 'include', /\.([cm]js|[jt]sx?|flow)$/i);
-    d(options, 'library');
-    d(options, 'forceEnable', false);
-    d(options, 'injectLoader', true);
-    d(options, 'injectEntry', true);
-    options.overlay = normalizeOverlay(options.overlay);
-    return options;
-}

package/dist/paths.js

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runtimePaths = exports.refreshRuntimeDirPath = exports.refreshUtilsPath = exports.reactRefreshEntryPath = exports.reactRefreshPath = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-exports.reactRefreshPath = require.resolve('../client/reactRefresh.js');
-exports.reactRefreshEntryPath = require.resolve('../client/reactRefreshEntry.js');
-exports.refreshUtilsPath = require.resolve('../client/refreshUtils.js');
-exports.refreshRuntimeDirPath = node_path_1.default.dirname(require.resolve('react-refresh', {
-    paths: [exports.reactRefreshPath],
-}));
-exports.runtimePaths = [
-    exports.reactRefreshEntryPath,
-    exports.reactRefreshPath,
-    exports.refreshUtilsPath,
-    exports.refreshRuntimeDirPath,
-];

package/dist/utils/getAdditionalEntries.js

@@ -1,88 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAdditionalEntries = getAdditionalEntries;
-const node_querystring_1 = __importDefault(require("node:querystring"));
-const paths_1 = require("../paths");
-function getAdditionalEntries({ devServer, options, }) {
-    const resourceQuery = {};
-    if (devServer) {
-        const { client, https, http2, sockHost, sockPath, sockPort } = devServer;
-        let { host, path, port } = devServer;
-        let protocol = https || http2 ? 'https' : 'http';
-        if (sockHost)
-            host = sockHost;
-        if (sockPath)
-            path = sockPath;
-        if (sockPort)
-            port = sockPort;
-        if (client && client.webSocketURL != null) {
-            let parsedUrl = client.webSocketURL;
-            if (typeof parsedUrl === 'string')
-                parsedUrl = new URL(parsedUrl);
-            let auth;
-            if (parsedUrl.username) {
-                auth = parsedUrl.username;
-                if (parsedUrl.password) {
-                    auth += `:${parsedUrl.password}`;
-                }
-            }
-            if (parsedUrl.hostname != null) {
-                host = [auth != null && auth, parsedUrl.hostname]
-                    .filter(Boolean)
-                    .join('@');
-            }
-            if (parsedUrl.pathname != null) {
-                path = parsedUrl.pathname;
-            }
-            if (parsedUrl.port != null) {
-                port = !['0', 'auto'].includes(String(parsedUrl.port))
-                    ? parsedUrl.port
-                    : undefined;
-            }
-            if (parsedUrl.protocol != null) {
-                protocol =
-                    parsedUrl.protocol !== 'auto'
-                        ? parsedUrl.protocol.replace(':', '')
-                        : 'ws';
-            }
-        }
-        if (host)
-            resourceQuery.sockHost = host;
-        if (path)
-            resourceQuery.sockPath = path;
-        if (port)
-            resourceQuery.sockPort = port;
-        resourceQuery.sockProtocol = protocol;
-    }
-    if (options.overlay) {
-        const { sockHost, sockPath, sockPort, sockProtocol } = options.overlay;
-        if (sockHost)
-            resourceQuery.sockHost = sockHost;
-        if (sockPath)
-            resourceQuery.sockPath = sockPath;
-        if (sockPort)
-            resourceQuery.sockPort = sockPort;
-        if (sockProtocol)
-            resourceQuery.sockProtocol = sockProtocol;
-    }
-    // We don't need to URI encode the resourceQuery as it will be parsed by Webpack
-    const queryString = node_querystring_1.default.stringify(resourceQuery, undefined, undefined, {
-        encodeURIComponent(str) {
-            return str;
-        },
-    });
-    const prependEntries = [
-        // React-refresh runtime
-        paths_1.reactRefreshEntryPath,
-    ];
-    const overlayEntries = [
-        // Error overlay runtime
-        options.overlay !== false &&
-            options.overlay?.entry &&
-            `${require.resolve(options.overlay.entry)}${queryString ? `?${queryString}` : ''}`,
-    ].filter(Boolean);
-    return { prependEntries, overlayEntries };
-}

package/dist/utils/getIntegrationEntry.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIntegrationEntry = getIntegrationEntry;
-/**
- * Gets entry point of a supported socket integration.
- * @param integrationType A valid socket integration type or a path to a module.
- * @returns Path to the resolved integration entry point.
- */
-function getIntegrationEntry(integrationType) {
-    let resolvedEntry;
-    switch (integrationType) {
-        case 'whm': {
-            resolvedEntry = 'webpack-hot-middleware/client';
-            break;
-        }
-    }
-    return resolvedEntry;
-}

package/dist/utils/getSocketIntegration.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSocketIntegration = getSocketIntegration;
-function getSocketIntegration(integrationType) {
-    let resolvedSocketIntegration;
-    switch (integrationType) {
-        case 'wds': {
-            resolvedSocketIntegration = require.resolve('../sockets/WDSSocket');
-            break;
-        }
-        case 'whm': {
-            resolvedSocketIntegration = require.resolve('../sockets/WHMEventSource');
-            break;
-        }
-        default: {
-            resolvedSocketIntegration = require.resolve(integrationType);
-            break;
-        }
-    }
-    return resolvedSocketIntegration;
-}