rspack-plugin-mock 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { R as ResolvePluginOptions } from './rspack-E_yBzR5v.js';
-export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-E_yBzR5v.js';
+import { L as Logger, R as ResolvePluginOptions } from './rspack-h3uerEgg.js';
+export { M as MockServerPlugin, c as createLogger, l as logLevels, r as resolvePluginOptions } from './rspack-h3uerEgg.js';
 export { createDefineMock, defineMock } from './helper.js';
-import * as rspackCore from '@rspack/core';
 import { Compiler, RspackPluginInstance, RspackOptionsNormalized } from '@rspack/core';
 import EventEmitter from 'node:events';
 import { FSWatcher } from 'node:fs';
-import { a as MockOptions } from './types-C770q3L0.js';
+import { a as MockOptions, M as MockServerPluginOptions, b as MockHttpItem, c as MockWebsocketItem } from './types-C770q3L0.js';
+import { Server as Server$1 } from 'node:http';
+import { Http2SecureServer } from 'node:http2';
 import 'node:buffer';
-import 'node:http';
 import 'node:stream';
 import 'cookies';
 import 'cors';
@@ -21,6 +21,7 @@ interface MockCompilerOptions {
     cwd?: string;
     include: string | string[];
     exclude: string | string[];
+    logger: Logger;
 }
 declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
 declare class MockCompiler extends EventEmitter {
@@ -29,7 +30,6 @@ declare class MockCompiler extends EventEmitter {
     mockWatcher: FSWatcher;
     moduleType: 'cjs' | 'esm';
     entryFile: string;
-    outputFile: string;
     private _mockData;
     private fileFilter;
     private watchInfo?;
@@ -42,8 +42,6 @@ declare class MockCompiler extends EventEmitter {
     updateMockEntry(): Promise<void>;
     getMockFiles(): Promise<string[]>;
     watchMockFiles(): void;
-    resolveEntryFile(fileList: string[]): Promise<void>;
-    createCompiler(callback: (e: Error | null, stats?: rspackCore.Stats) => void): void;
 }
 
 interface MiddlewareOptions {
@@ -57,4 +55,25 @@ type SetupMiddlewaresFn = NonNullable<NonNullable<RspackOptionsNormalized['devSe
 type Middleware = SetupMiddlewaresFn extends (middlewares: (infer T)[], devServer: any) => void ? T : never;
 type Server = SetupMiddlewaresFn extends (middlewares: any, devServer: infer T) => void ? T : never;
 
-export { type Middleware, type MiddlewareOptions, type Server, createMockCompiler, createMockMiddleware };
+interface BaseMiddlewareOptions {
+    formidableOptions: MockServerPluginOptions['formidableOptions'];
+    cookiesOptions: MockServerPluginOptions['cookiesOptions'];
+    bodyParserOptions: MockServerPluginOptions['bodyParserOptions'];
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    logger: Logger;
+    priority: MockServerPluginOptions['priority'];
+}
+declare function baseMiddleware(compiler: MockCompiler, { formidableOptions, bodyParserOptions, proxies, cookiesOptions, logger, priority, }: BaseMiddlewareOptions): Middleware;
+
+interface MockSocketOptions {
+    wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+    cookiesOptions: MockServerPluginOptions['cookiesOptions'];
+    logger: Logger;
+}
+declare function mockWebSocket(compiler: MockCompiler, httpServer: Server$1 | Http2SecureServer, { wsProxies: proxies, cookiesOptions, logger, }: MockSocketOptions): void;
+
+declare function transformRawData(rawData: (readonly [any, string])[]): (MockHttpItem | MockWebsocketItem | MockOptions)[];
+declare function transformMockData(mockList: (MockHttpItem | MockWebsocketItem | MockOptions)[]): Record<string, MockOptions>;
+declare function sortByValidator(mocks: MockOptions): (MockHttpItem | MockWebsocketItem)[];
+
+export { type BaseMiddlewareOptions, Logger, type Middleware, type MiddlewareOptions, type MockSocketOptions, type Server, baseMiddleware, createMockCompiler, createMockMiddleware, mockWebSocket, sortByValidator, transformMockData, transformRawData };

package/dist/index.js

@@ -1,20 +1,34 @@
 import {
   MockServerPlugin,
   resolvePluginOptions
-} from "./chunk-P6DRAHHI.js";
+} from "./chunk-P5FOCSCE.js";
 import {
   createDefineMock,
   defineMock
 } from "./chunk-HTOWPFQ7.js";
 import {
+  baseMiddleware,
+  createLogger,
   createMockCompiler,
-  createMockMiddleware
-} from "./chunk-UJAKORAH.js";
+  createMockMiddleware,
+  logLevels,
+  mockWebSocket,
+  sortByValidator,
+  transformMockData,
+  transformRawData
+} from "./chunk-YSJVV4SH.js";
 export {
   MockServerPlugin,
+  baseMiddleware,
   createDefineMock,
+  createLogger,
   createMockCompiler,
   createMockMiddleware,
   defineMock,
-  resolvePluginOptions
+  logLevels,
+  mockWebSocket,
+  resolvePluginOptions,
+  sortByValidator,
+  transformMockData,
+  transformRawData
 };

package/dist/rsbuild.cjs

@@ -4,11 +4,13 @@
 
 
 
-var _chunk2S4KCTKWcjs = require('./chunk-2S4KCTKW.cjs');
+
+var _chunkI54ZNZWLcjs = require('./chunk-I54ZNZWL.cjs');
 
 // src/rsbuild.ts
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 var _http = require('http');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _utils = require('@pengzhanbo/utils');
 var _core = require('@rspack/core'); var _core2 = _interopRequireDefault(_core);
 var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
@@ -17,65 +19,77 @@ function pluginMockServer(options = {}) {
   return {
     name: "plugin-mock-server",
     setup(api) {
-      if (_process2.default.env.NODE_ENV === "production")
-        return;
-      let port = 3079;
-      api.modifyRsbuildConfig(async (config) => {
-        const defaultPort = (_optionalChain([config, 'access', _ => _.server, 'optionalAccess', _2 => _2.port]) || port) + 1;
-        port = await _portfinder.getPortPromise.call(void 0, { port: defaultPort });
+      const rsbuildConfig = api.getRsbuildConfig();
+      const resolvedOptions = _chunkI54ZNZWLcjs.resolvePluginOptions.call(void 0, options, {
+        proxies: resolveConfigProxies(rsbuildConfig),
+        alias: {},
+        context: api.context.rootPath,
+        plugins: [new _core2.default.DefinePlugin(_optionalChain([rsbuildConfig, 'access', _ => _.source, 'optionalAccess', _2 => _2.define]) || {})]
       });
-      let mockCompiler = null;
-      let resolvedOptions;
-      api.modifyRsbuildConfig(updateServerProxyConfig);
+      if (_process2.default.env.NODE_ENV === "production") {
+        if (resolvedOptions.build) {
+          api.onAfterBuild(async () => {
+            const config = api.getNormalizedConfig();
+            await _chunkI54ZNZWLcjs.buildMockServer.call(void 0, 
+              resolvedOptions,
+              _path2.default.resolve(_process2.default.cwd(), config.output.distPath.root || "dist")
+            );
+          });
+        }
+        return;
+      }
+      const mockCompiler = _chunkI54ZNZWLcjs.createMockCompiler.call(void 0, resolvedOptions);
       api.modifyRsbuildConfig((config) => {
-        config.server ??= {};
-        resolvedOptions = _chunk2S4KCTKWcjs.resolvePluginOptions.call(void 0, options, {
-          proxies: resolveConfigProxies(config, options.wsPrefix || [], port),
-          alias: {},
-          context: api.context.rootPath,
-          plugins: [new _core2.default.DefinePlugin(_optionalChain([config, 'access', _3 => _3.source, 'optionalAccess', _4 => _4.define]) || {})]
-        });
-        mockCompiler = _chunk2S4KCTKWcjs.createMockCompiler.call(void 0, resolvedOptions);
-        const mockMiddleware = _chunk2S4KCTKWcjs.createMockMiddleware.call(void 0, mockCompiler, resolvedOptions);
+        updateServerProxyConfigByHttpMock(config);
+        const mockMiddleware = _chunkI54ZNZWLcjs.createMockMiddleware.call(void 0, mockCompiler, resolvedOptions);
         config.dev ??= {};
         config.dev.setupMiddlewares ??= [];
         config.dev.setupMiddlewares.push((middlewares, server2) => {
           mockMiddleware(middlewares, () => server2.sockWrite("static-changed"));
         });
       });
+      let port = 3079;
+      const shouldMockWs = _utils.toArray.call(void 0, resolvedOptions.wsPrefix).length > 0;
+      if (shouldMockWs) {
+        api.modifyRsbuildConfig(async (config) => {
+          const defaultPort = (_optionalChain([config, 'access', _3 => _3.server, 'optionalAccess', _4 => _4.port]) || port) + 1;
+          port = await _portfinder.getPortPromise.call(void 0, { port: defaultPort });
+          updateServerProxyConfigByWSMock(config, options.wsPrefix || [], port);
+        });
+      }
+      let server;
+      function startMockServer() {
+        mockCompiler.run();
+        if (shouldMockWs) {
+          server = _http.createServer.call(void 0, );
+          _chunkI54ZNZWLcjs.mockWebSocket.call(void 0, mockCompiler, server, resolvedOptions);
+          server.listen(port);
+        }
+      }
+      function close() {
+        mockCompiler.close();
+        _optionalChain([server, 'optionalAccess', _5 => _5.close, 'call', _6 => _6()]);
+      }
       api.onAfterCreateCompiler(({ compiler }) => {
         if ("compilers" in compiler) {
           compiler.compilers.forEach((compiler2) => {
-            _optionalChain([mockCompiler, 'optionalAccess', _5 => _5.updateAlias, 'call', _6 => _6(_optionalChain([compiler2, 'access', _7 => _7.options, 'access', _8 => _8.resolve, 'optionalAccess', _9 => _9.alias]) || {})]);
+            mockCompiler.updateAlias(_optionalChain([compiler2, 'access', _7 => _7.options, 'access', _8 => _8.resolve, 'optionalAccess', _9 => _9.alias]) || {});
           });
         } else {
-          _optionalChain([mockCompiler, 'optionalAccess', _10 => _10.updateAlias, 'call', _11 => _11(_optionalChain([compiler, 'access', _12 => _12.options, 'access', _13 => _13.resolve, 'optionalAccess', _14 => _14.alias]) || {})]);
+          mockCompiler.updateAlias(_optionalChain([compiler, 'access', _10 => _10.options, 'access', _11 => _11.resolve, 'optionalAccess', _12 => _12.alias]) || {});
         }
       });
-      let server;
-      function startMockServer() {
-        if (!mockCompiler)
-          return;
-        mockCompiler.run();
-        server = _http.createServer.call(void 0, );
-        _chunk2S4KCTKWcjs.mockWebSocket.call(void 0, mockCompiler, server, resolvedOptions);
-        server.listen(port);
-      }
-      function close() {
-        _optionalChain([mockCompiler, 'optionalAccess', _15 => _15.close, 'call', _16 => _16()]);
-        _optionalChain([server, 'optionalAccess', _17 => _17.close, 'call', _18 => _18()]);
-      }
       api.onAfterStartDevServer(startMockServer);
       api.onAfterStartProdServer(startMockServer);
       api.onExit(close);
     }
   };
 }
-function updateServerProxyConfig(config) {
-  if (!_optionalChain([config, 'access', _19 => _19.server, 'optionalAccess', _20 => _20.proxy]))
+function updateServerProxyConfigByHttpMock(config) {
+  if (!_optionalChain([config, 'access', _13 => _13.server, 'optionalAccess', _14 => _14.proxy]))
     return;
   const onProxyError = (err, _req, res) => {
-    console.error(_picocolors2.default.red(_optionalChain([err, 'optionalAccess', _21 => _21.stack]) || err.message));
+    console.error(_picocolors2.default.red(_optionalChain([err, 'optionalAccess', _15 => _15.stack]) || err.message));
     res.statusCode = 500;
     res.end();
   };
@@ -88,8 +102,8 @@ function updateServerProxyConfig(config) {
           ...item,
           onError: onError || onProxyError,
           onProxyReq: (proxyReq, req, ...args) => {
-            _optionalChain([onProxyReq, 'optionalCall', _22 => _22(proxyReq, req, ...args)]);
-            _chunk2S4KCTKWcjs.rewriteRequest.call(void 0, proxyReq, req);
+            _optionalChain([onProxyReq, 'optionalCall', _16 => _16(proxyReq, req, ...args)]);
+            _chunkI54ZNZWLcjs.rewriteRequest.call(void 0, proxyReq, req);
           }
         };
       }
@@ -98,8 +112,8 @@ function updateServerProxyConfig(config) {
   } else if ("target" in config.server.proxy) {
     const onProxyReq = config.server.proxy.onProxyReq;
     config.server.proxy.onProxyReq = (proxyReq, req, ...args) => {
-      _optionalChain([onProxyReq, 'optionalCall', _23 => _23(proxyReq, req, ...args)]);
-      _chunk2S4KCTKWcjs.rewriteRequest.call(void 0, proxyReq, req);
+      _optionalChain([onProxyReq, 'optionalCall', _17 => _17(proxyReq, req, ...args)]);
+      _chunkI54ZNZWLcjs.rewriteRequest.call(void 0, proxyReq, req);
     };
     config.server.proxy.onError ??= onProxyError;
   } else if (config.server.proxy) {
@@ -113,17 +127,17 @@ function updateServerProxyConfig(config) {
       proxy[key] = {
         ...rest,
         onProxyReq: (proxyReq, req, ...args) => {
-          _optionalChain([onProxyReq, 'optionalCall', _24 => _24(proxyReq, req, ...args)]);
-          _chunk2S4KCTKWcjs.rewriteRequest.call(void 0, proxyReq, req);
+          _optionalChain([onProxyReq, 'optionalCall', _18 => _18(proxyReq, req, ...args)]);
+          _chunkI54ZNZWLcjs.rewriteRequest.call(void 0, proxyReq, req);
         },
         onError: onError || onProxyError
       };
     });
   }
 }
-function resolveConfigProxies(config, wsPrefix, port) {
+function updateServerProxyConfigByWSMock(config, wsPrefix, port) {
+  config.server ??= {};
   const proxy = config.server.proxy ??= {};
-  const proxies = [];
   const wsTarget = `ws://localhost:${port}`;
   const prefix = _utils.toArray.call(void 0, wsPrefix);
   const has = (context) => typeof context === "string" && prefix.includes(context);
@@ -138,32 +152,19 @@ function resolveConfigProxies(config, wsPrefix, port) {
   }
   if (_utils.isArray.call(void 0, proxy)) {
     for (const item of proxy) {
-      if (typeof item !== "function" && item.context) {
-        if (!item.ws) {
-          proxies.push(..._utils.toArray.call(void 0, item.context));
-        } else {
-          updateProxy(item);
-        }
+      if (typeof item !== "function" && item.context && item.ws) {
+        updateProxy(item);
       }
     }
-    prefix.filter((context) => !used.has(context)).forEach((context) => {
-      proxy.push({ context, target: wsTarget });
-    });
+    prefix.filter((context) => !used.has(context)).forEach((context) => proxy.push({ context, target: wsTarget }));
   } else if ("target" in proxy) {
-    if (!proxy.ws) {
-      proxies.push(..._utils.toArray.call(void 0, proxy.context));
-    } else {
+    if (proxy.ws) {
       updateProxy(proxy);
       const list = config.server.proxy = [proxy];
-      prefix.filter((context) => !used.has(context)).forEach((context) => {
-        list.push({ context, target: wsTarget });
-      });
+      prefix.filter((context) => !used.has(context)).forEach((context) => list.push({ context, target: wsTarget }));
     }
   } else {
-    Object.entries(proxy).forEach(([context, opt]) => {
-      if (typeof opt === "string" || !opt.ws) {
-        proxies.push(context);
-      }
+    Object.entries(proxy).forEach(([, opt]) => {
       if (typeof opt !== "string" && opt.ws) {
         updateProxy(opt);
       }
@@ -172,6 +173,26 @@ function resolveConfigProxies(config, wsPrefix, port) {
       proxy[context] = { target: wsTarget, ws: true };
     });
   }
+}
+function resolveConfigProxies(config) {
+  config.server ??= {};
+  const proxy = config.server.proxy ??= {};
+  const proxies = [];
+  if (_utils.isArray.call(void 0, proxy)) {
+    for (const item of proxy) {
+      if (typeof item !== "function" && item.context && !item.ws) {
+        proxies.push(..._utils.toArray.call(void 0, item.context));
+      }
+    }
+  } else if ("target" in proxy) {
+    if (!proxy.ws)
+      proxies.push(..._utils.toArray.call(void 0, proxy.context));
+  } else {
+    Object.entries(proxy).forEach(([context, opt]) => {
+      if (typeof opt === "string" || !opt.ws)
+        proxies.push(context);
+    });
+  }
   return proxies;
 }
 

package/dist/rsbuild.js

@@ -1,14 +1,16 @@
 import {
+  buildMockServer,
   createMockCompiler,
   createMockMiddleware,
   mockWebSocket,
   resolvePluginOptions,
   rewriteRequest
-} from "./chunk-UJAKORAH.js";
+} from "./chunk-YSJVV4SH.js";
 
 // src/rsbuild.ts
 import process from "process";
 import { createServer } from "http";
+import path from "path";
 import { isArray, toArray } from "@pengzhanbo/utils";
 import rspack from "@rspack/core";
 import color from "picocolors";
@@ -17,25 +19,28 @@ function pluginMockServer(options = {}) {
   return {
     name: "plugin-mock-server",
     setup(api) {
-      if (process.env.NODE_ENV === "production")
-        return;
-      let port = 3079;
-      api.modifyRsbuildConfig(async (config) => {
-        const defaultPort = (config.server?.port || port) + 1;
-        port = await getPortPromise({ port: defaultPort });
+      const rsbuildConfig = api.getRsbuildConfig();
+      const resolvedOptions = resolvePluginOptions(options, {
+        proxies: resolveConfigProxies(rsbuildConfig),
+        alias: {},
+        context: api.context.rootPath,
+        plugins: [new rspack.DefinePlugin(rsbuildConfig.source?.define || {})]
       });
-      let mockCompiler = null;
-      let resolvedOptions;
-      api.modifyRsbuildConfig(updateServerProxyConfig);
+      if (process.env.NODE_ENV === "production") {
+        if (resolvedOptions.build) {
+          api.onAfterBuild(async () => {
+            const config = api.getNormalizedConfig();
+            await buildMockServer(
+              resolvedOptions,
+              path.resolve(process.cwd(), config.output.distPath.root || "dist")
+            );
+          });
+        }
+        return;
+      }
+      const mockCompiler = createMockCompiler(resolvedOptions);
       api.modifyRsbuildConfig((config) => {
-        config.server ??= {};
-        resolvedOptions = resolvePluginOptions(options, {
-          proxies: resolveConfigProxies(config, options.wsPrefix || [], port),
-          alias: {},
-          context: api.context.rootPath,
-          plugins: [new rspack.DefinePlugin(config.source?.define || {})]
-        });
-        mockCompiler = createMockCompiler(resolvedOptions);
+        updateServerProxyConfigByHttpMock(config);
         const mockMiddleware = createMockMiddleware(mockCompiler, resolvedOptions);
         config.dev ??= {};
         config.dev.setupMiddlewares ??= [];
@@ -43,35 +48,44 @@ function pluginMockServer(options = {}) {
           mockMiddleware(middlewares, () => server2.sockWrite("static-changed"));
         });
       });
-      api.onAfterCreateCompiler(({ compiler }) => {
-        if ("compilers" in compiler) {
-          compiler.compilers.forEach((compiler2) => {
-            mockCompiler?.updateAlias(compiler2.options.resolve?.alias || {});
-          });
-        } else {
-          mockCompiler?.updateAlias(compiler.options.resolve?.alias || {});
-        }
-      });
+      let port = 3079;
+      const shouldMockWs = toArray(resolvedOptions.wsPrefix).length > 0;
+      if (shouldMockWs) {
+        api.modifyRsbuildConfig(async (config) => {
+          const defaultPort = (config.server?.port || port) + 1;
+          port = await getPortPromise({ port: defaultPort });
+          updateServerProxyConfigByWSMock(config, options.wsPrefix || [], port);
+        });
+      }
       let server;
       function startMockServer() {
-        if (!mockCompiler)
-          return;
         mockCompiler.run();
-        server = createServer();
-        mockWebSocket(mockCompiler, server, resolvedOptions);
-        server.listen(port);
+        if (shouldMockWs) {
+          server = createServer();
+          mockWebSocket(mockCompiler, server, resolvedOptions);
+          server.listen(port);
+        }
       }
       function close() {
-        mockCompiler?.close();
+        mockCompiler.close();
         server?.close();
       }
+      api.onAfterCreateCompiler(({ compiler }) => {
+        if ("compilers" in compiler) {
+          compiler.compilers.forEach((compiler2) => {
+            mockCompiler.updateAlias(compiler2.options.resolve?.alias || {});
+          });
+        } else {
+          mockCompiler.updateAlias(compiler.options.resolve?.alias || {});
+        }
+      });
       api.onAfterStartDevServer(startMockServer);
       api.onAfterStartProdServer(startMockServer);
       api.onExit(close);
     }
   };
 }
-function updateServerProxyConfig(config) {
+function updateServerProxyConfigByHttpMock(config) {
   if (!config.server?.proxy)
     return;
   const onProxyError = (err, _req, res) => {
@@ -121,9 +135,9 @@ function updateServerProxyConfig(config) {
     });
   }
 }
-function resolveConfigProxies(config, wsPrefix, port) {
+function updateServerProxyConfigByWSMock(config, wsPrefix, port) {
+  config.server ??= {};
   const proxy = config.server.proxy ??= {};
-  const proxies = [];
   const wsTarget = `ws://localhost:${port}`;
   const prefix = toArray(wsPrefix);
   const has = (context) => typeof context === "string" && prefix.includes(context);
@@ -138,32 +152,19 @@ function resolveConfigProxies(config, wsPrefix, port) {
   }
   if (isArray(proxy)) {
     for (const item of proxy) {
-      if (typeof item !== "function" && item.context) {
-        if (!item.ws) {
-          proxies.push(...toArray(item.context));
-        } else {
-          updateProxy(item);
-        }
+      if (typeof item !== "function" && item.context && item.ws) {
+        updateProxy(item);
       }
     }
-    prefix.filter((context) => !used.has(context)).forEach((context) => {
-      proxy.push({ context, target: wsTarget });
-    });
+    prefix.filter((context) => !used.has(context)).forEach((context) => proxy.push({ context, target: wsTarget }));
   } else if ("target" in proxy) {
-    if (!proxy.ws) {
-      proxies.push(...toArray(proxy.context));
-    } else {
+    if (proxy.ws) {
       updateProxy(proxy);
       const list = config.server.proxy = [proxy];
-      prefix.filter((context) => !used.has(context)).forEach((context) => {
-        list.push({ context, target: wsTarget });
-      });
+      prefix.filter((context) => !used.has(context)).forEach((context) => list.push({ context, target: wsTarget }));
     }
   } else {
-    Object.entries(proxy).forEach(([context, opt]) => {
-      if (typeof opt === "string" || !opt.ws) {
-        proxies.push(context);
-      }
+    Object.entries(proxy).forEach(([, opt]) => {
       if (typeof opt !== "string" && opt.ws) {
         updateProxy(opt);
       }
@@ -172,6 +173,26 @@ function resolveConfigProxies(config, wsPrefix, port) {
       proxy[context] = { target: wsTarget, ws: true };
     });
   }
+}
+function resolveConfigProxies(config) {
+  config.server ??= {};
+  const proxy = config.server.proxy ??= {};
+  const proxies = [];
+  if (isArray(proxy)) {
+    for (const item of proxy) {
+      if (typeof item !== "function" && item.context && !item.ws) {
+        proxies.push(...toArray(item.context));
+      }
+    }
+  } else if ("target" in proxy) {
+    if (!proxy.ws)
+      proxies.push(...toArray(proxy.context));
+  } else {
+    Object.entries(proxy).forEach(([context, opt]) => {
+      if (typeof opt === "string" || !opt.ws)
+        proxies.push(context);
+    });
+  }
   return proxies;
 }
 export {

package/dist/{rspack-E_yBzR5v.d.ts → rspack-BB-Jtq4f.d.cts}

@@ -1,5 +1,5 @@
 import { RspackPluginInstance, Compiler } from '@rspack/core';
-import { L as LogLevel, M as MockServerPluginOptions } from './types-C770q3L0.js';
+import { L as LogLevel, M as MockServerPluginOptions, S as ServerBuildOption } from './types-C770q3L0.cjs';
 
 interface Logger {
     debug: (msg: string, level?: boolean | LogLevel) => void;
@@ -7,6 +7,8 @@ interface Logger {
     warn: (msg: string, level?: boolean | LogLevel) => void;
     error: (msg: string, level?: boolean | LogLevel) => void;
 }
+declare const logLevels: Record<LogLevel, number>;
+declare function createLogger(prefix: string, defaultLevel?: LogLevel): Logger;
 
 interface ResolvedCompilerOptions {
     alias: Record<string, false | string | (string | false)[]>;
@@ -15,8 +17,9 @@ interface ResolvedCompilerOptions {
     plugins: RspackPluginInstance[];
     context?: string;
 }
-type ResolvePluginOptions = Required<MockServerPluginOptions> & ResolvedCompilerOptions & {
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, 'build'>> & ResolvedCompilerOptions & {
     logger: Logger;
+    build: false | ServerBuildOption;
 };
 
 declare class MockServerPlugin implements RspackPluginInstance {
@@ -26,4 +29,4 @@ declare class MockServerPlugin implements RspackPluginInstance {
 }
 declare function resolvePluginOptions(compiler: Compiler, options: MockServerPluginOptions): ResolvePluginOptions;
 
-export { MockServerPlugin as M, type ResolvePluginOptions as R, resolvePluginOptions as r };
+export { type Logger as L, MockServerPlugin as M, type ResolvePluginOptions as R, createLogger as c, logLevels as l, resolvePluginOptions as r };

package/dist/{rspack-BcdszmoI.d.cts → rspack-h3uerEgg.d.ts}

@@ -1,5 +1,5 @@
 import { RspackPluginInstance, Compiler } from '@rspack/core';
-import { L as LogLevel, M as MockServerPluginOptions } from './types-C770q3L0.cjs';
+import { L as LogLevel, M as MockServerPluginOptions, S as ServerBuildOption } from './types-C770q3L0.js';
 
 interface Logger {
     debug: (msg: string, level?: boolean | LogLevel) => void;
@@ -7,6 +7,8 @@ interface Logger {
     warn: (msg: string, level?: boolean | LogLevel) => void;
     error: (msg: string, level?: boolean | LogLevel) => void;
 }
+declare const logLevels: Record<LogLevel, number>;
+declare function createLogger(prefix: string, defaultLevel?: LogLevel): Logger;
 
 interface ResolvedCompilerOptions {
     alias: Record<string, false | string | (string | false)[]>;
@@ -15,8 +17,9 @@ interface ResolvedCompilerOptions {
     plugins: RspackPluginInstance[];
     context?: string;
 }
-type ResolvePluginOptions = Required<MockServerPluginOptions> & ResolvedCompilerOptions & {
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, 'build'>> & ResolvedCompilerOptions & {
     logger: Logger;
+    build: false | ServerBuildOption;
 };
 
 declare class MockServerPlugin implements RspackPluginInstance {
@@ -26,4 +29,4 @@ declare class MockServerPlugin implements RspackPluginInstance {
 }
 declare function resolvePluginOptions(compiler: Compiler, options: MockServerPluginOptions): ResolvePluginOptions;
 
-export { MockServerPlugin as M, type ResolvePluginOptions as R, resolvePluginOptions as r };
+export { type Logger as L, MockServerPlugin as M, type ResolvePluginOptions as R, createLogger as c, logLevels as l, resolvePluginOptions as r };

package/dist/rspack.cjs

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunkT4AI3L6Rcjs = require('./chunk-T4AI3L6R.cjs');
-require('./chunk-2S4KCTKW.cjs');
+var _chunkOYBMX3GQcjs = require('./chunk-OYBMX3GQ.cjs');
+require('./chunk-I54ZNZWL.cjs');
 
 
 
-exports.MockServerPlugin = _chunkT4AI3L6Rcjs.MockServerPlugin; exports.resolvePluginOptions = _chunkT4AI3L6Rcjs.resolvePluginOptions;
+exports.MockServerPlugin = _chunkOYBMX3GQcjs.MockServerPlugin; exports.resolvePluginOptions = _chunkOYBMX3GQcjs.resolvePluginOptions;

package/dist/rspack.d.cts

@@ -1,6 +1,6 @@
 import '@rspack/core';
 import './types-C770q3L0.cjs';
-export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-BcdszmoI.cjs';
+export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-BB-Jtq4f.cjs';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';

package/dist/rspack.d.ts

@@ -1,6 +1,6 @@
 import '@rspack/core';
 import './types-C770q3L0.js';
-export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-E_yBzR5v.js';
+export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-h3uerEgg.js';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';

package/dist/rspack.js

@@ -1,8 +1,8 @@
 import {
   MockServerPlugin,
   resolvePluginOptions
-} from "./chunk-P6DRAHHI.js";
-import "./chunk-UJAKORAH.js";
+} from "./chunk-P5FOCSCE.js";
+import "./chunk-YSJVV4SH.js";
 export {
   MockServerPlugin,
   resolvePluginOptions