@modern-js/server 3.5.0 → 3.6.0

package/dist/cjs/createDevServer.js

@@ -43,7 +43,10 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const server_core_namespaceObject = require("@modern-js/server-core");
 const node_namespaceObject = require("@modern-js/server-core/node");
+const utils_namespaceObject = require("@modern-js/utils");
 const external_dev_js_namespaceObject = require("./dev.js");
+const reloadManager_js_namespaceObject = require("./dev-tools/reloadManager.js");
+const runtimeOptions_js_namespaceObject = require("./dev-tools/runtimeOptions.js");
 const index_js_namespaceObject = require("./helpers/index.js");
 async function createDevServer(options, applyPlugins) {
     const { config, pwd, serverConfigPath, builder } = options;
@@ -62,33 +65,76 @@ async function createDevServer(options, applyPlugins) {
             ...options.plugins || []
         ]
     };
-    const server = (0, server_core_namespaceObject.createServerBase)(prodServerOptions);
-    const devHttpsOption = 'object' == typeof dev && dev.https;
-    const isHttp2 = !!devHttpsOption;
-    let nodeServer;
-    if (devHttpsOption) {
-        const { genHttpsOptions } = await import("./dev-tools/https/index.js");
-        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
-        nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server), httpsOptions, isHttp2);
-    } else nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server));
-    const promise = (0, index_js_namespaceObject.getDevAssetPrefix)(builder);
     let compiler = null;
     builder?.onAfterCreateCompiler((context)=>{
         compiler = context.compiler;
     });
+    const assetPrefixPromise = (0, index_js_namespaceObject.getDevAssetPrefix)(builder);
     const builderDevServer = await builder?.createDevServer({
         runCompile: options.runCompile
     });
-    server.addPlugins([
-        (0, external_dev_js_namespaceObject.devPlugin)({
-            ...options,
-            builderDevServer
-        }, compiler)
-    ]);
-    const assetPrefix = await promise;
-    if (assetPrefix) prodServerOptions.config.output.assetPrefix = assetPrefix;
-    await applyPlugins(server, prodServerOptions, nodeServer);
-    await server.init();
+    const assetPrefix = await assetPrefixPromise;
+    let currentRuntimeServer;
+    let nodeServer;
+    const buildRuntimeServer = async ()=>{
+        const freshServerConfig = await (0, node_namespaceObject.loadServerRuntimeConfig)(serverConfigPath) || {};
+        const runtimeOptions = (0, runtimeOptions_js_namespaceObject.createRuntimeServerOptions)({
+            ...prodServerOptions,
+            serverConfig: {
+                ...freshServerConfig,
+                ...options.serverConfig
+            },
+            plugins: [
+                ...freshServerConfig.plugins || [],
+                ...options.plugins || []
+            ]
+        }, assetPrefix);
+        const runtimeServer = (0, server_core_namespaceObject.createServerBase)(runtimeOptions);
+        runtimeServer.addPlugins([
+            (0, external_dev_js_namespaceObject.devRuntimeMiddlewarePlugin)({
+                ...options,
+                builderDevServer
+            }, compiler)
+        ]);
+        await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
+        await runtimeServer.init();
+        currentRuntimeServer = runtimeServer;
+        return runtimeServer.handle;
+    };
+    const pendingReloadFiles = new Set();
+    const reloadManager = (0, reloadManager_js_namespaceObject.createReloadManager)({
+        build: buildRuntimeServer,
+        onReload: ()=>{
+            const files = Array.from(pendingReloadFiles);
+            pendingReloadFiles.clear();
+            utils_namespaceObject.logger.info(files.length > 0 ? `Server runtime reloaded (${files.join(', ')})` : 'Server runtime reloaded');
+        }
+    });
+    const devHttpsOption = 'object' == typeof dev && dev.https;
+    const isHttp2 = !!devHttpsOption;
+    if (devHttpsOption) {
+        const { genHttpsOptions } = await import("./dev-tools/https/index.js");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await (0, node_namespaceObject.createNodeServer)(reloadManager.handle, httpsOptions, isHttp2);
+    } else nodeServer = await (0, node_namespaceObject.createNodeServer)(reloadManager.handle);
+    reloadManager.setHandle(await buildRuntimeServer());
+    (0, external_dev_js_namespaceObject.setupDevInfra)({
+        config,
+        pwd,
+        distDir,
+        apiDir: options.appContext?.apiDirectory,
+        sharedDir: options.appContext?.sharedDirectory,
+        builder,
+        builderDevServer,
+        compiler,
+        nodeServer,
+        getRuntimeServer: ()=>currentRuntimeServer,
+        onFileChange: (filepath)=>{
+            pendingReloadFiles.add(external_node_path_default().relative(pwd, filepath));
+            reloadManager.schedule();
+        },
+        onClose: ()=>reloadManager.close()
+    });
     const afterListen = async ()=>{
         await builderDevServer?.afterListen();
     };

package/dist/cjs/dev-tools/reloadManager.js

@@ -0,0 +1,226 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    ReloadManager: ()=>ReloadManager,
+    createReloadManager: ()=>createReloadManager
+});
+const utils_namespaceObject = require("@modern-js/utils");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+const DEFAULT_DEBOUNCE_MS = 300;
+const notReadyHandle = ()=>new Response('Dev server is starting…', {
+        status: 503,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8'
+        }
+    });
+var _current = /*#__PURE__*/ new WeakMap(), _build = /*#__PURE__*/ new WeakMap(), _debounceMs = /*#__PURE__*/ new WeakMap(), _onReload = /*#__PURE__*/ new WeakMap(), _onError = /*#__PURE__*/ new WeakMap(), _onReloadError = /*#__PURE__*/ new WeakMap(), _debounceTimer = /*#__PURE__*/ new WeakMap(), _running = /*#__PURE__*/ new WeakMap(), _pending = /*#__PURE__*/ new WeakMap(), _runningPromise = /*#__PURE__*/ new WeakMap(), _closed = /*#__PURE__*/ new WeakMap(), _runLoop = /*#__PURE__*/ new WeakSet(), _reportBuildError = /*#__PURE__*/ new WeakSet(), _reportReloadCallbackError = /*#__PURE__*/ new WeakSet();
+class ReloadManager {
+    setHandle(handle) {
+        _class_private_field_set(this, _current, handle);
+    }
+    get handle() {
+        return (request, ...args)=>_class_private_field_get(this, _current).call(this, request, ...args);
+    }
+    get currentHandle() {
+        return _class_private_field_get(this, _current);
+    }
+    get isReloading() {
+        return _class_private_field_get(this, _running);
+    }
+    schedule() {
+        if (_class_private_field_get(this, _closed)) return;
+        if (_class_private_field_get(this, _debounceTimer)) clearTimeout(_class_private_field_get(this, _debounceTimer));
+        _class_private_field_set(this, _debounceTimer, setTimeout(()=>{
+            _class_private_field_set(this, _debounceTimer, null);
+            this.reloadNow();
+        }, _class_private_field_get(this, _debounceMs)));
+    }
+    async reloadNow() {
+        if (_class_private_field_get(this, _closed)) return;
+        if (_class_private_field_get(this, _running)) {
+            _class_private_field_set(this, _pending, true);
+            return _class_private_field_get(this, _runningPromise) ?? Promise.resolve();
+        }
+        _class_private_field_set(this, _running, true);
+        _class_private_field_set(this, _runningPromise, _class_private_method_get(this, _runLoop, runLoop).call(this));
+        try {
+            await _class_private_field_get(this, _runningPromise);
+        } finally{
+            _class_private_field_set(this, _running, false);
+            _class_private_field_set(this, _runningPromise, null);
+        }
+    }
+    close() {
+        _class_private_field_set(this, _closed, true);
+        _class_private_field_set(this, _pending, false);
+        if (_class_private_field_get(this, _debounceTimer)) {
+            clearTimeout(_class_private_field_get(this, _debounceTimer));
+            _class_private_field_set(this, _debounceTimer, null);
+        }
+    }
+    constructor(options){
+        _class_private_method_init(this, _runLoop);
+        _class_private_method_init(this, _reportBuildError);
+        _class_private_method_init(this, _reportReloadCallbackError);
+        _class_private_field_init(this, _current, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _build, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _debounceMs, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onReload, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onError, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _onReloadError, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _debounceTimer, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _running, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _pending, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _runningPromise, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _closed, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _debounceTimer, null);
+        _class_private_field_set(this, _running, false);
+        _class_private_field_set(this, _pending, false);
+        _class_private_field_set(this, _runningPromise, null);
+        _class_private_field_set(this, _closed, false);
+        _class_private_field_set(this, _current, options.initialHandle ?? notReadyHandle);
+        _class_private_field_set(this, _build, options.build);
+        _class_private_field_set(this, _debounceMs, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+        _class_private_field_set(this, _onReload, options.onReload);
+        _class_private_field_set(this, _onError, options.onError);
+        _class_private_field_set(this, _onReloadError, options.onReloadError);
+    }
+}
+async function runLoop() {
+    var _this, _this1;
+    do {
+        _class_private_field_set(this, _pending, false);
+        let next;
+        try {
+            next = await _class_private_field_get(this, _build).call(this);
+        } catch (error) {
+            _class_private_method_get(this, _reportBuildError, reportBuildError).call(this, error);
+            continue;
+        }
+        if (_class_private_field_get(this, _closed)) return;
+        _class_private_field_set(this, _current, next);
+        try {
+            null == (_this = _class_private_field_get(_this1 = this, _onReload)) || _this.call(_this1, next);
+        } catch (callbackError) {
+            _class_private_method_get(this, _reportReloadCallbackError, reportReloadCallbackError).call(this, callbackError);
+        }
+    }while (_class_private_field_get(this, _pending) && !_class_private_field_get(this, _closed));
+}
+function reportBuildError(error) {
+    if (_class_private_field_get(this, _onError)) _class_private_field_get(this, _onError).call(this, error);
+    else utils_namespaceObject.logger.error(`[dev-server] runtime reload build failed, keep serving previous handle:\n${error instanceof Error ? error.stack ?? error.message : error}`);
+}
+function reportReloadCallbackError(error) {
+    if (_class_private_field_get(this, _onReloadError)) _class_private_field_get(this, _onReloadError).call(this, error);
+    else utils_namespaceObject.logger.warn(`[dev-server] onReload callback failed after a successful swap (handle is already active):\n${error instanceof Error ? error.stack ?? error.message : error}`);
+}
+function createReloadManager(options) {
+    return new ReloadManager(options);
+}
+exports.ReloadManager = __webpack_exports__.ReloadManager;
+exports.createReloadManager = __webpack_exports__.createReloadManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ReloadManager",
+    "createReloadManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev-tools/runtimeOptions.js

@@ -0,0 +1,73 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__);
+function createRuntimeServerOptions(base, assetPrefix) {
+    const baseConfig = base.config ?? {};
+    const baseOutput = baseConfig.output ?? {};
+    const baseServerConfig = base.serverConfig ?? {};
+    return {
+        ...base,
+        config: {
+            ...baseConfig,
+            output: {
+                ...baseOutput,
+                ...assetPrefix ? {
+                    assetPrefix
+                } : {}
+            }
+        },
+        serverConfig: {
+            ...baseServerConfig,
+            middlewares: [
+                ...baseServerConfig.middlewares ?? []
+            ],
+            renderMiddlewares: [
+                ...baseServerConfig.renderMiddlewares ?? []
+            ],
+            ...baseServerConfig.plugins ? {
+                plugins: [
+                    ...baseServerConfig.plugins
+                ]
+            } : {}
+        },
+        plugins: [
+            ...base.plugins ?? []
+        ]
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    createRuntimeServerOptions: ()=>createRuntimeServerOptions
+});
+exports.createRuntimeServerOptions = __webpack_exports__.createRuntimeServerOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRuntimeServerOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev.js

@@ -1,5 +1,14 @@
 "use strict";
 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, getters, values)=>{
         var define = (defs, kind)=>{
@@ -28,45 +37,23 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    devPlugin: ()=>devPlugin
+    devRuntimeMiddlewarePlugin: ()=>devRuntimeMiddlewarePlugin,
+    setupDevInfra: ()=>setupDevInfra
 });
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const server_core_namespaceObject = require("@modern-js/server-core");
 const node_namespaceObject = require("@modern-js/server-core/node");
 const utils_namespaceObject = require("@modern-js/utils");
 const index_js_namespaceObject = require("./helpers/index.js");
-const devPlugin = (options, compiler)=>({
+const devRuntimeMiddlewarePlugin = (options, compiler)=>({
         name: '@modern-js/plugin-dev',
         setup (api) {
-            const { config, pwd, builder, builderDevServer } = options;
-            const closeCb = [];
+            const { pwd, builderDevServer } = options;
             const dev = (0, index_js_namespaceObject.getDevOptions)(options.dev);
             api.onPrepare(async ()=>{
-                const { middlewares: builderMiddlewares, close, connectWebSocket } = builderDevServer || {};
-                close && closeCb.push(close);
-                const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.getServerContext();
-                connectWebSocket && nodeServer && connectWebSocket({
-                    server: nodeServer
-                });
-                const hooks = api.getHooks();
-                builder?.onDevCompileDone(({ stats })=>{
-                    if ('server' !== stats.toJson({
-                        all: false
-                    }).name) (0, index_js_namespaceObject.onRepack)(distDirectory, hooks);
-                });
-                const { watchOptions } = config.server;
-                const watcher = (0, index_js_namespaceObject.startWatcher)({
-                    pwd,
-                    distDir: distDirectory,
-                    apiDir: apiDirectory || utils_namespaceObject.API_DIR,
-                    sharedDir: sharedDirectory || utils_namespaceObject.SHARED_DIR,
-                    watchOptions,
-                    server: serverBase
-                });
-                closeCb.push(watcher.close.bind(watcher));
-                closeCb.length > 0 && nodeServer?.on('close', ()=>{
-                    closeCb.forEach((cb)=>{
-                        cb();
-                    });
-                });
+                const { middlewares: builderMiddlewares } = builderDevServer || {};
+                const { middlewares } = api.getServerContext();
                 const before = [];
                 const after = [];
                 const { setupMiddlewares = [] } = dev;
@@ -106,9 +93,65 @@ const devPlugin = (options, compiler)=>({
             });
         }
     });
-exports.devPlugin = __webpack_exports__.devPlugin;
+function setupDevInfra({ config, pwd, distDir, apiDir, sharedDir, builder, builderDevServer, getRuntimeServer, onFileChange, onClose, nodeServer }) {
+    const { close, connectWebSocket } = builderDevServer || {};
+    const closeCb = [];
+    close && closeCb.push(close);
+    connectWebSocket && nodeServer && connectWebSocket({
+        server: nodeServer
+    });
+    builder?.onDevCompileDone(({ stats })=>{
+        if ('server' !== stats.toJson({
+            all: false
+        }).name) {
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer) (0, index_js_namespaceObject.onRepack)(distDir, runtimeServer.hooks);
+        }
+    });
+    const { watchOptions } = config.server;
+    const mockPath = external_node_path_default().normalize(external_node_path_default().join(pwd, server_core_namespaceObject.AGGRED_DIR.mock));
+    const watcher = (0, index_js_namespaceObject.startWatcher)({
+        pwd,
+        distDir,
+        apiDir: apiDir || utils_namespaceObject.API_DIR,
+        sharedDir: sharedDir || utils_namespaceObject.SHARED_DIR,
+        watchOptions,
+        onChange: (filepath, event)=>{
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer && !filepath.startsWith(mockPath)) {
+                const fileChangeEvent = {
+                    type: 'file-change',
+                    payload: [
+                        {
+                            filename: filepath,
+                            event
+                        }
+                    ]
+                };
+                Promise.resolve(runtimeServer.hooks.onReset.call({
+                    event: fileChangeEvent
+                })).catch((error)=>utils_namespaceObject.logger.error(error));
+            }
+            onFileChange(filepath, event);
+        }
+    });
+    closeCb.push(watcher.close.bind(watcher));
+    onClose && closeCb.push(onClose);
+    const close$ = ()=>{
+        closeCb.forEach((cb)=>{
+            cb();
+        });
+    };
+    closeCb.length > 0 && nodeServer?.on('close', close$);
+    return {
+        close: close$
+    };
+}
+exports.devRuntimeMiddlewarePlugin = __webpack_exports__.devRuntimeMiddlewarePlugin;
+exports.setupDevInfra = __webpack_exports__.setupDevInfra;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "devPlugin"
+    "devRuntimeMiddlewarePlugin",
+    "setupDevInfra"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/helpers/index.js

@@ -15,9 +15,6 @@ var __webpack_modules__ = {
     "./repack" (module) {
         module.exports = require("./repack.js");
     },
-    "./utils" (module) {
-        module.exports = require("./utils.js");
-    },
     "@modern-js/server-core" (module) {
         module.exports = require("@modern-js/server-core");
     },
@@ -81,61 +78,35 @@ var __webpack_exports__ = {};
     var _modern_js_utils__rspack_import_2 = __webpack_require__("@modern-js/utils");
     var _dev_tools_watcher__rspack_import_3 = __webpack_require__("../dev-tools/watcher");
     var _dev_tools_watcher__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(_dev_tools_watcher__rspack_import_3);
-    var _mock__rspack_import_4 = __webpack_require__("./mock");
-    var _utils__rspack_import_5 = __webpack_require__("./utils");
-    var _repack__rspack_import_6 = __webpack_require__("./repack");
+    var _repack__rspack_import_4 = __webpack_require__("./repack");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _repack__rspack_import_6)if ([
+    for(const __rspack_import_key in _repack__rspack_import_4)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_repack__rspack_import_6[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_repack__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _devOptions__rspack_import_7 = __webpack_require__("./devOptions");
+    var _devOptions__rspack_import_5 = __webpack_require__("./devOptions");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _devOptions__rspack_import_7)if ([
+    for(const __rspack_import_key in _devOptions__rspack_import_5)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_devOptions__rspack_import_7[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_devOptions__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _fileReader__rspack_import_8 = __webpack_require__("./fileReader");
+    var _fileReader__rspack_import_6 = __webpack_require__("./fileReader");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _fileReader__rspack_import_8)if ([
+    for(const __rspack_import_key in _fileReader__rspack_import_6)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_fileReader__rspack_import_8[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_fileReader__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _mock__rspack_import_7 = __webpack_require__("./mock");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _mock__rspack_import_4)if ([
+    for(const __rspack_import_key in _mock__rspack_import_7)if ([
         "startWatcher",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_mock__rspack_import_4[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_mock__rspack_import_7[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    async function onServerChange({ pwd, filepath, event, server }) {
-        const { mock } = _modern_js_server_core__rspack_import_1.AGGRED_DIR;
-        const mockPath = path__rspack_import_0_default().normalize(path__rspack_import_0_default().join(pwd, mock));
-        const { hooks } = server;
-        if (filepath.startsWith(mockPath)) {
-            await (0, _mock__rspack_import_4.initOrUpdateMockMiddlewares)(pwd);
-            _modern_js_utils__rspack_import_2.logger.info('Finish update the mock handlers');
-        } else try {
-            const fileChangeEvent = {
-                type: 'file-change',
-                payload: [
-                    {
-                        filename: filepath,
-                        event
-                    }
-                ]
-            };
-            await hooks.onReset.call({
-                event: fileChangeEvent
-            });
-            (0, _utils__rspack_import_5.debug)(`Finish reload server, trigger by ${filepath} ${event}`);
-        } catch (e) {
-            _modern_js_utils__rspack_import_2.logger.error(e);
-        }
-    }
-    function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+    function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, onChange }) {
         const { mock } = _modern_js_server_core__rspack_import_1.AGGRED_DIR;
         const defaultWatched = [
             `${mock}/**/*`,
@@ -155,12 +126,7 @@ var __webpack_exports__ = {};
             if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
             watcher.updateDepTree();
             watcher.cleanDepCache(filepath);
-            onServerChange({
-                pwd,
-                filepath,
-                event,
-                server
-            });
+            onChange(filepath, event);
         });
         return watcher;
     }

package/dist/cjs/helpers/mock.js

@@ -78,7 +78,7 @@ const getMockModule = async (pwd)=>{
         }
     }
     if (!mockFilePath) return;
-    const { default: mockHandlers, config } = await import(mockFilePath);
+    const { default: mockHandlers, config } = await (0, utils_namespaceObject.compatibleRequire)(mockFilePath, false);
     const enable = config?.enable;
     if (false === enable) return;
     if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);