@bleedingdev/modern-js-server 3.5.0-ultramodern.97 → 3.5.0-ultramodern.99

package/dist/esm/dev.mjs

@@ -1,40 +1,14 @@
 import { connectMid2HonoMid } from "@modern-js/server-core/node";
-import { API_DIR, SHARED_DIR } from "@modern-js/utils";
-import { getDevOptions, getMockMiddleware, initFileReader, onRepack, startWatcher } from "./helpers/index.mjs";
-const devPlugin = (options, compiler)=>({
+import { API_DIR, SHARED_DIR, logger } from "@modern-js/utils";
+import { getDevOptions, getMockMiddleware, initFileReader, isPathInsideDirectory, onRepack, resolveMockDirectory, startWatcher } from "./helpers/index.mjs";
+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 = 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) onRepack(distDirectory, hooks);
-                });
-                const { watchOptions } = config.server;
-                const watcher = startWatcher({
-                    pwd,
-                    distDir: distDirectory,
-                    apiDir: apiDirectory || API_DIR,
-                    sharedDir: sharedDirectory || 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;
@@ -52,7 +26,7 @@ const devPlugin = (options, compiler)=>({
                         handler: connectMid2HonoMid(middleware)
                     });
                 });
-                const mockMiddleware = await getMockMiddleware(pwd);
+                const mockMiddleware = await getMockMiddleware(pwd, options.config?.dev?.mockDir);
                 middlewares.push({
                     name: 'mock-dev',
                     handler: mockMiddleware
@@ -74,4 +48,60 @@ const devPlugin = (options, compiler)=>({
             });
         }
     });
-export { 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) onRepack(distDir, runtimeServer.hooks);
+        }
+    });
+    const { watchOptions } = config.server;
+    const mockDir = config.dev?.mockDir;
+    const mockPath = resolveMockDirectory(pwd, mockDir);
+    const watcher = startWatcher({
+        pwd,
+        distDir,
+        apiDir: apiDir || API_DIR,
+        sharedDir: sharedDir || SHARED_DIR,
+        mockDir,
+        watchOptions,
+        onChange: (filepath, event)=>{
+            const runtimeServer = getRuntimeServer();
+            if (runtimeServer && !isPathInsideDirectory(filepath, mockPath)) {
+                const fileChangeEvent = {
+                    type: 'file-change',
+                    payload: [
+                        {
+                            filename: filepath,
+                            event
+                        }
+                    ]
+                };
+                Promise.resolve(runtimeServer.hooks.onReset.call({
+                    event: fileChangeEvent
+                })).catch((error)=>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$
+    };
+}
+export { devRuntimeMiddlewarePlugin, setupDevInfra };

package/dist/esm/helpers/index.mjs

@@ -1,42 +1,14 @@
-import { AGGRED_DIR } from "@modern-js/server-core";
-import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR } from "@modern-js/utils";
 import path from "path";
 import dev_tools_watcher, { mergeWatchOptions } from "../dev-tools/watcher/index.mjs";
-import { initOrUpdateMockMiddlewares } from "./mock.mjs";
-import { debug } from "./utils.mjs";
+import { resolveMockDirectory } from "./mock.mjs";
 export * from "./devOptions.mjs";
 export * from "./fileReader.mjs";
 export * from "./mock.mjs";
 export * from "./repack.mjs";
-async function onServerChange({ pwd, filepath, event, server }) {
-    const { mock } = AGGRED_DIR;
-    const mockPath = path.normalize(path.join(pwd, mock));
-    const { hooks } = server;
-    if (filepath.startsWith(mockPath)) {
-        await initOrUpdateMockMiddlewares(pwd);
-        logger.info('Finish update the mock handlers');
-    } else try {
-        const fileChangeEvent = {
-            type: 'file-change',
-            payload: [
-                {
-                    filename: filepath,
-                    event
-                }
-            ]
-        };
-        await hooks.onReset.call({
-            event: fileChangeEvent
-        });
-        debug(`Finish reload server, trigger by ${filepath} ${event}`);
-    } catch (e) {
-        logger.error(e);
-    }
-}
-function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
-    const { mock } = AGGRED_DIR;
+function startWatcher({ pwd, distDir, apiDir, sharedDir, mockDir, watchOptions, onChange }) {
     const defaultWatched = [
-        `${mock}/**/*`,
+        path.join(resolveMockDirectory(pwd, mockDir), '**/*'),
         `${SERVER_DIR}/**/*`,
         `${apiDir}/**`,
         `${sharedDir}/**/*`,
@@ -53,12 +25,7 @@ function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server })
         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/esm/helpers/mock.mjs

@@ -1,10 +1,15 @@
 import node_path from "node:path";
 import { AGGRED_DIR } from "@modern-js/server-core";
 import { connectMockMid2HonoMid } from "@modern-js/server-core/node";
-import { fs } from "@modern-js/utils";
+import { compatibleRequire, fs } from "@modern-js/utils";
 import { match } from "path-to-regexp";
 let mockAPIs = [];
 let mockConfig;
+const resolveMockDirectory = (pwd, mockDir = AGGRED_DIR.mock)=>node_path.resolve(pwd, mockDir);
+const isPathInsideDirectory = (filepath, directory)=>{
+    const relativePath = node_path.relative(directory, node_path.resolve(filepath));
+    return '' === relativePath || '..' !== relativePath && !relativePath.startsWith(`..${node_path.sep}`) && !node_path.isAbsolute(relativePath);
+};
 const parseKey = (key)=>{
     const _blank = ' ';
     const splitted = key.split(_blank).filter(Boolean);
@@ -20,21 +25,22 @@ const parseKey = (key)=>{
         path: key
     };
 };
-const getMockModule = async (pwd)=>{
+const getMockModule = async (pwd, mockDir)=>{
     const exts = [
         '.ts',
         '.js'
     ];
     let mockFilePath = '';
+    const mockDirectory = resolveMockDirectory(pwd, mockDir);
     for (const ext of exts){
-        const maybeMatch = node_path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
+        const maybeMatch = node_path.join(mockDirectory, `index${ext}`);
         if (await fs.pathExists(maybeMatch)) {
             mockFilePath = maybeMatch;
             break;
         }
     }
     if (!mockFilePath) return;
-    const { default: mockHandlers, config } = await import(mockFilePath);
+    const { default: mockHandlers, config } = await compatibleRequire(mockFilePath, false);
     const enable = config?.enable;
     if (false === enable) return;
     if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);
@@ -54,8 +60,8 @@ const getMatched = (request, mockApis)=>{
     });
     return matched;
 };
-async function initOrUpdateMockMiddlewares(pwd) {
-    const mockModule = await getMockModule(pwd);
+async function initOrUpdateMockMiddlewares(pwd, mockDir) {
+    const mockModule = await getMockModule(pwd, mockDir);
     mockConfig = mockModule?.config;
     mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
         const { method, path } = parseKey(key);
@@ -66,8 +72,8 @@ async function initOrUpdateMockMiddlewares(pwd) {
         };
     });
 }
-async function getMockMiddleware(pwd) {
-    await initOrUpdateMockMiddlewares(pwd);
+async function getMockMiddleware(pwd, mockDir) {
+    await initOrUpdateMockMiddlewares(pwd, mockDir);
     const mockMiddleware = async (c, next)=>{
         if ('function' == typeof mockConfig?.enable) {
             const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
@@ -83,4 +89,4 @@ async function getMockMiddleware(pwd) {
     };
     return mockMiddleware;
 }
-export { getMatched, getMockMiddleware, initOrUpdateMockMiddlewares };
+export { getMatched, getMockMiddleware, initOrUpdateMockMiddlewares, isPathInsideDirectory, resolveMockDirectory };

package/dist/esm-node/createDevServer.mjs

@@ -2,7 +2,10 @@ import "node:module";
 import node_path from "node:path";
 import { createServerBase } from "@modern-js/server-core";
 import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
-import { devPlugin } from "./dev.mjs";
+import { logger } from "@modern-js/utils";
+import { devRuntimeMiddlewarePlugin, setupDevInfra } from "./dev.mjs";
+import { createReloadManager } from "./dev-tools/reloadManager.mjs";
+import { createRuntimeServerOptions } from "./dev-tools/runtimeOptions.mjs";
 import { getDevAssetPrefix, getDevOptions } from "./helpers/index.mjs";
 async function createDevServer(options, applyPlugins) {
     const { config, pwd, serverConfigPath, builder } = options;
@@ -21,33 +24,76 @@ async function createDevServer(options, applyPlugins) {
             ...options.plugins || []
         ]
     };
-    const server = createServerBase(prodServerOptions);
-    const devHttpsOption = 'object' == typeof dev && dev.https;
-    const isHttp2 = !!devHttpsOption;
-    let nodeServer;
-    if (devHttpsOption) {
-        const { genHttpsOptions } = await import("./dev-tools/https/index.mjs");
-        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
-        nodeServer = await createNodeServer(server.handle.bind(server), httpsOptions, isHttp2);
-    } else nodeServer = await createNodeServer(server.handle.bind(server));
-    const promise = getDevAssetPrefix(builder);
     let compiler = null;
     builder?.onAfterCreateCompiler((context)=>{
         compiler = context.compiler;
     });
+    const assetPrefixPromise = getDevAssetPrefix(builder);
     const builderDevServer = await builder?.createDevServer({
         runCompile: options.runCompile
     });
-    server.addPlugins([
-        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 loadServerRuntimeConfig(serverConfigPath) || {};
+        const runtimeOptions = createRuntimeServerOptions({
+            ...prodServerOptions,
+            serverConfig: {
+                ...freshServerConfig,
+                ...options.serverConfig
+            },
+            plugins: [
+                ...freshServerConfig.plugins || [],
+                ...options.plugins || []
+            ]
+        }, assetPrefix);
+        const runtimeServer = createServerBase(runtimeOptions);
+        runtimeServer.addPlugins([
+            devRuntimeMiddlewarePlugin({
+                ...options,
+                builderDevServer
+            }, compiler)
+        ]);
+        await applyPlugins(runtimeServer, runtimeOptions, nodeServer);
+        await runtimeServer.init();
+        currentRuntimeServer = runtimeServer;
+        return runtimeServer.handle;
+    };
+    const pendingReloadFiles = new Set();
+    const reloadManager = createReloadManager({
+        build: buildRuntimeServer,
+        onReload: ()=>{
+            const files = Array.from(pendingReloadFiles);
+            pendingReloadFiles.clear();
+            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.mjs");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await createNodeServer(reloadManager.handle, httpsOptions, isHttp2);
+    } else nodeServer = await createNodeServer(reloadManager.handle);
+    reloadManager.setHandle(await buildRuntimeServer());
+    setupDevInfra({
+        config,
+        pwd,
+        distDir,
+        apiDir: options.appContext?.apiDirectory,
+        sharedDir: options.appContext?.sharedDirectory,
+        builder,
+        builderDevServer,
+        compiler,
+        nodeServer,
+        getRuntimeServer: ()=>currentRuntimeServer,
+        onFileChange: (filepath)=>{
+            pendingReloadFiles.add(node_path.relative(pwd, filepath));
+            reloadManager.schedule();
+        },
+        onClose: ()=>reloadManager.close()
+    });
     const afterListen = async ()=>{
         await builderDevServer?.afterListen();
     };

package/dist/esm-node/dev-tools/reloadManager.mjs

@@ -0,0 +1,186 @@
+import "node:module";
+import { logger } from "@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 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 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);
+}
+export { ReloadManager, createReloadManager };

package/dist/esm-node/dev-tools/runtimeOptions.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+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 ?? []
+        ]
+    };
+}
+export { createRuntimeServerOptions };

package/dist/esm-node/dev-tools/watcher/dependencyTree.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import node_path from "node:path";
 import * as __rspack_external_minimatch from "minimatch";
 const defaultIgnores = [
     '**/coverage/**',
@@ -42,8 +43,9 @@ class DependencyTree {
         }
     }
     shouldIgnore(path) {
-        return !path || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
-                path
+        const matchPath = path && node_path.isAbsolute(path) ? node_path.relative(process.cwd(), path) : path;
+        return !matchPath || Boolean(this.ignore.find((rule)=>__rspack_external_minimatch.match([
+                matchPath
             ], rule, {
                 dot: true
             }).length > 0));