rspack-plugin-mock 0.1.0 → 0.3.0

package/dist/helper.d.cts

@@ -1,5 +1,5 @@
-import { a as MockHttpItem, b as MockWebsocketItem, c as MockOptions } from './types-DhT3pRJ3.cjs';
-export { B as BodyParserOptions, E as ExtraRequest, F as FormidableFile, i as LogLevel, L as LogType, f as Method, d as MockMatchPriority, e as MockMatchSpecialPriority, g as MockRequest, h as MockResponse, M as MockServerPluginOptions, R as ResponseBody, S as ServerBuildOption, W as WebSocketSetupContext } from './types-DhT3pRJ3.cjs';
+import { b as MockHttpItem, c as MockWebsocketItem, a as MockOptions } from './types-C770q3L0.cjs';
+export { B as BodyParserOptions, E as ExtraRequest, F as FormidableFile, L as LogLevel, i as LogType, f as Method, d as MockMatchPriority, e as MockMatchSpecialPriority, g as MockRequest, h as MockResponse, M as MockServerPluginOptions, R as ResponseBody, S as ServerBuildOption, W as WebSocketSetupContext } from './types-C770q3L0.cjs';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';

package/dist/helper.d.ts

@@ -1,5 +1,5 @@
-import { a as MockHttpItem, b as MockWebsocketItem, c as MockOptions } from './types-DhT3pRJ3.js';
-export { B as BodyParserOptions, E as ExtraRequest, F as FormidableFile, i as LogLevel, L as LogType, f as Method, d as MockMatchPriority, e as MockMatchSpecialPriority, g as MockRequest, h as MockResponse, M as MockServerPluginOptions, R as ResponseBody, S as ServerBuildOption, W as WebSocketSetupContext } from './types-DhT3pRJ3.js';
+import { b as MockHttpItem, c as MockWebsocketItem, a as MockOptions } from './types-C770q3L0.js';
+export { B as BodyParserOptions, E as ExtraRequest, F as FormidableFile, L as LogLevel, i as LogType, f as Method, d as MockMatchPriority, e as MockMatchSpecialPriority, g as MockRequest, h as MockResponse, M as MockServerPluginOptions, R as ResponseBody, S as ServerBuildOption, W as WebSocketSetupContext } from './types-C770q3L0.js';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';

package/dist/index.cjs

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunk4BGDHRTOcjs = require('./chunk-4BGDHRTO.cjs');
+var _chunkOYBMX3GQcjs = require('./chunk-OYBMX3GQ.cjs');
 
 
 
@@ -9,7 +9,6 @@ var _chunkKE2LVHUPcjs = require('./chunk-KE2LVHUP.cjs');
 
 
 
-var _chunkG53QRHGVcjs = require('./chunk-G53QRHGV.cjs');
 
 
 
@@ -17,4 +16,19 @@ var _chunkG53QRHGVcjs = require('./chunk-G53QRHGV.cjs');
 
 
 
-exports.MockServerPlugin = _chunk4BGDHRTOcjs.MockServerPlugin; exports.createDefineMock = _chunkKE2LVHUPcjs.createDefineMock; exports.createManuallyMockMiddleware = _chunkG53QRHGVcjs.createManuallyMockMiddleware; exports.createMockMiddleware = _chunkG53QRHGVcjs.createMockMiddleware; exports.defineMock = _chunkKE2LVHUPcjs.defineMock; exports.resolveMiddleOptions = _chunk4BGDHRTOcjs.resolveMiddleOptions;
+var _chunkI54ZNZWLcjs = require('./chunk-I54ZNZWL.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.MockServerPlugin = _chunkOYBMX3GQcjs.MockServerPlugin; exports.baseMiddleware = _chunkI54ZNZWLcjs.baseMiddleware; exports.createDefineMock = _chunkKE2LVHUPcjs.createDefineMock; exports.createLogger = _chunkI54ZNZWLcjs.createLogger; exports.createMockCompiler = _chunkI54ZNZWLcjs.createMockCompiler; exports.createMockMiddleware = _chunkI54ZNZWLcjs.createMockMiddleware; exports.defineMock = _chunkKE2LVHUPcjs.defineMock; exports.logLevels = _chunkI54ZNZWLcjs.logLevels; exports.mockWebSocket = _chunkI54ZNZWLcjs.mockWebSocket; exports.resolvePluginOptions = _chunkOYBMX3GQcjs.resolvePluginOptions; exports.sortByValidator = _chunkI54ZNZWLcjs.sortByValidator; exports.transformMockData = _chunkI54ZNZWLcjs.transformMockData; exports.transformRawData = _chunkI54ZNZWLcjs.transformRawData;

package/dist/index.d.cts

@@ -1,12 +1,79 @@
-export { d as Middleware, a as MiddlewareOptions, M as MockServerPlugin, S as Server, c as createManuallyMockMiddleware, b as createMockMiddleware, r as resolveMiddleOptions } from './rspack-BI-Ifj4a.cjs';
+import { L as Logger, R as ResolvePluginOptions } from './rspack-BB-Jtq4f.cjs';
+export { M as MockServerPlugin, c as createLogger, l as logLevels, r as resolvePluginOptions } from './rspack-BB-Jtq4f.cjs';
 export { createDefineMock, defineMock } from './helper.cjs';
-import '@rspack/core';
-import './types-DhT3pRJ3.cjs';
+import { Compiler, RspackPluginInstance, RspackOptionsNormalized } from '@rspack/core';
+import EventEmitter from 'node:events';
+import { FSWatcher } from 'node:fs';
+import { a as MockOptions, M as MockServerPluginOptions, b as MockHttpItem, c as MockWebsocketItem } from './types-C770q3L0.cjs';
+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';
 import 'formidable';
 import 'ws';
 import 'co-body';
+
+interface MockCompilerOptions {
+    alias?: Record<string, false | string | (string | false)[]>;
+    plugins: RspackPluginInstance[];
+    cwd?: string;
+    include: string | string[];
+    exclude: string | string[];
+    logger: Logger;
+}
+declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
+declare class MockCompiler extends EventEmitter {
+    options: MockCompilerOptions;
+    cwd: string;
+    mockWatcher: FSWatcher;
+    moduleType: 'cjs' | 'esm';
+    entryFile: string;
+    private _mockData;
+    private fileFilter;
+    private watchInfo?;
+    compiler?: Compiler | null;
+    constructor(options: MockCompilerOptions);
+    get mockData(): Record<string, MockOptions>;
+    run(): Promise<void>;
+    close(): void;
+    updateAlias(alias: Record<string, false | string | (string | false)[]>): void;
+    updateMockEntry(): Promise<void>;
+    getMockFiles(): Promise<string[]>;
+    watchMockFiles(): void;
+}
+
+interface MiddlewareOptions {
+    alias: Record<string, false | string | (string | false)[]>;
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    context?: string;
+    plugins: RspackPluginInstance[];
+}
+declare function createMockMiddleware(compiler: MockCompiler, options: ResolvePluginOptions): (middlewares: Middleware[], reload?: () => void) => Middleware[];
+type SetupMiddlewaresFn = NonNullable<NonNullable<RspackOptionsNormalized['devServer']>['setupMiddlewares']>;
+type Middleware = SetupMiddlewaresFn extends (middlewares: (infer T)[], devServer: any) => void ? T : never;
+type Server = SetupMiddlewaresFn extends (middlewares: any, devServer: infer T) => void ? T : never;
+
+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.d.ts

@@ -1,12 +1,79 @@
-export { d as Middleware, a as MiddlewareOptions, M as MockServerPlugin, S as Server, c as createManuallyMockMiddleware, b as createMockMiddleware, r as resolveMiddleOptions } from './rspack-Db7drzDm.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 '@rspack/core';
-import './types-DhT3pRJ3.js';
+import { Compiler, RspackPluginInstance, RspackOptionsNormalized } from '@rspack/core';
+import EventEmitter from 'node:events';
+import { FSWatcher } from 'node:fs';
+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';
 import 'formidable';
 import 'ws';
 import 'co-body';
+
+interface MockCompilerOptions {
+    alias?: Record<string, false | string | (string | false)[]>;
+    plugins: RspackPluginInstance[];
+    cwd?: string;
+    include: string | string[];
+    exclude: string | string[];
+    logger: Logger;
+}
+declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
+declare class MockCompiler extends EventEmitter {
+    options: MockCompilerOptions;
+    cwd: string;
+    mockWatcher: FSWatcher;
+    moduleType: 'cjs' | 'esm';
+    entryFile: string;
+    private _mockData;
+    private fileFilter;
+    private watchInfo?;
+    compiler?: Compiler | null;
+    constructor(options: MockCompilerOptions);
+    get mockData(): Record<string, MockOptions>;
+    run(): Promise<void>;
+    close(): void;
+    updateAlias(alias: Record<string, false | string | (string | false)[]>): void;
+    updateMockEntry(): Promise<void>;
+    getMockFiles(): Promise<string[]>;
+    watchMockFiles(): void;
+}
+
+interface MiddlewareOptions {
+    alias: Record<string, false | string | (string | false)[]>;
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    context?: string;
+    plugins: RspackPluginInstance[];
+}
+declare function createMockMiddleware(compiler: MockCompiler, options: ResolvePluginOptions): (middlewares: Middleware[], reload?: () => void) => Middleware[];
+type SetupMiddlewaresFn = NonNullable<NonNullable<RspackOptionsNormalized['devServer']>['setupMiddlewares']>;
+type Middleware = SetupMiddlewaresFn extends (middlewares: (infer T)[], devServer: any) => void ? T : never;
+type Server = SetupMiddlewaresFn extends (middlewares: any, devServer: infer T) => void ? T : never;
+
+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,
-  resolveMiddleOptions
-} from "./chunk-B56QNVSS.js";
+  resolvePluginOptions
+} from "./chunk-P5FOCSCE.js";
 import {
   createDefineMock,
   defineMock
 } from "./chunk-HTOWPFQ7.js";
 import {
-  createManuallyMockMiddleware,
-  createMockMiddleware
-} from "./chunk-5MGZAMDI.js";
+  baseMiddleware,
+  createLogger,
+  createMockCompiler,
+  createMockMiddleware,
+  logLevels,
+  mockWebSocket,
+  sortByValidator,
+  transformMockData,
+  transformRawData
+} from "./chunk-YSJVV4SH.js";
 export {
   MockServerPlugin,
+  baseMiddleware,
   createDefineMock,
-  createManuallyMockMiddleware,
+  createLogger,
+  createMockCompiler,
   createMockMiddleware,
   defineMock,
-  resolveMiddleOptions
+  logLevels,
+  mockWebSocket,
+  resolvePluginOptions,
+  sortByValidator,
+  transformMockData,
+  transformRawData
 };

package/dist/rsbuild.cjs

@@ -1,121 +1,200 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
-var _chunkG53QRHGVcjs = require('./chunk-G53QRHGV.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);
+var _portfinder = require('portfinder');
 function pluginMockServer(options = {}) {
   return {
     name: "plugin-mock-server",
     setup(api) {
-      if (_process2.default.env.NODE_ENV === "production")
-        return;
-      api.modifyRsbuildConfig((config) => {
-        if (!_optionalChain([config, 'access', _ => _.server, 'optionalAccess', _2 => _2.proxy]))
-          return;
-        const onProxyError = (err, req, res) => {
-          console.error(_optionalChain([err, 'optionalAccess', _3 => _3.stack]) || err);
-          res.statusCode = 500;
-          res.end();
-        };
-        if (_utils.isArray.call(void 0, config.server.proxy)) {
-          config.server.proxy = config.server.proxy.map((item) => {
-            if (typeof item !== "function" && !item.ws) {
-              const onProxyReq = item.onProxyReq;
-              const onError = item.onError;
-              return {
-                ...item,
-                onError: onError || onProxyError,
-                onProxyReq: (proxyReq, req, ...args) => {
-                  _optionalChain([onProxyReq, 'optionalCall', _4 => _4(proxyReq, req, ...args)]);
-                  _chunkG53QRHGVcjs.rewriteRequest.call(void 0, proxyReq, req);
-                }
-              };
-            }
-            return item;
-          });
-        } else if ("target" in config.server.proxy) {
-          const onProxyReq = config.server.proxy.onProxyReq;
-          config.server.proxy.onProxyReq = (proxyReq, req, ...args) => {
-            _optionalChain([onProxyReq, 'optionalCall', _5 => _5(proxyReq, req, ...args)]);
-            _chunkG53QRHGVcjs.rewriteRequest.call(void 0, proxyReq, req);
-          };
-          config.server.proxy.onError ??= onProxyError;
-        } else if (config.server.proxy) {
-          const proxy = config.server.proxy;
-          Object.keys(proxy).forEach((key) => {
-            const target = proxy[key];
-            const options2 = typeof target === "string" ? { target } : target;
-            if (options2.ws)
-              return;
-            const { onProxyReq, onError, ...rest } = options2;
-            proxy[key] = {
-              ...rest,
-              onProxyReq: (proxyReq, req, ...args) => {
-                _optionalChain([onProxyReq, 'optionalCall', _6 => _6(proxyReq, req, ...args)]);
-                _chunkG53QRHGVcjs.rewriteRequest.call(void 0, proxyReq, req);
-              },
-              onError: onError || onProxyError
-            };
-          });
-        }
+      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 compilerRun;
-      let compilerClose;
-      let compilerUpdateAlias;
-      api.modifyRsbuildConfig((config) => {
-        const proxy = _optionalChain([config, 'access', _7 => _7.server, 'optionalAccess', _8 => _8.proxy]) || [];
-        const proxies = [];
-        if (_utils.isArray.call(void 0, proxy)) {
-          for (const item of proxy) {
-            if (typeof item !== "function" && !item.ws && item.context) {
-              proxies.push(..._utils.toArray.call(void 0, item.context));
-            }
-          }
-        } else if ("target" in proxy) {
-          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);
-            }
+      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")
+            );
           });
         }
-        const { mockMiddleware, run, close, updateAlias } = _chunkG53QRHGVcjs.createManuallyMockMiddleware.call(void 0, {
-          plugins: [new _core2.default.DefinePlugin(_optionalChain([config, 'access', _9 => _9.source, 'optionalAccess', _10 => _10.define]) || {})],
-          alias: {},
-          proxies,
-          context: api.context.rootPath
-        }, options);
-        compilerRun = run;
-        compilerClose = close;
-        compilerUpdateAlias = updateAlias;
+        return;
+      }
+      const mockCompiler = _chunkI54ZNZWLcjs.createMockCompiler.call(void 0, resolvedOptions);
+      api.modifyRsbuildConfig((config) => {
+        updateServerProxyConfigByHttpMock(config);
+        const mockMiddleware = _chunkI54ZNZWLcjs.createMockMiddleware.call(void 0, mockCompiler, resolvedOptions);
         config.dev ??= {};
         config.dev.setupMiddlewares ??= [];
-        config.dev.setupMiddlewares.push((middlewares) => {
-          mockMiddleware(middlewares);
+        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 (compilerUpdateAlias) {
-          if ("compilers" in compiler) {
-            compiler.compilers.forEach((compiler2) => {
-              _optionalChain([compilerUpdateAlias, 'optionalCall', _11 => _11(_optionalChain([compiler2, 'access', _12 => _12.options, 'access', _13 => _13.resolve, 'optionalAccess', _14 => _14.alias]) || {})]);
-            });
-          } else {
-            _optionalChain([compilerUpdateAlias, 'optionalCall', _15 => _15(_optionalChain([compiler, 'access', _16 => _16.options, 'access', _17 => _17.resolve, 'optionalAccess', _18 => _18.alias]) || {})]);
-          }
+        if ("compilers" in compiler) {
+          compiler.compilers.forEach((compiler2) => {
+            mockCompiler.updateAlias(_optionalChain([compiler2, 'access', _7 => _7.options, 'access', _8 => _8.resolve, 'optionalAccess', _9 => _9.alias]) || {});
+          });
+        } else {
+          mockCompiler.updateAlias(_optionalChain([compiler, 'access', _10 => _10.options, 'access', _11 => _11.resolve, 'optionalAccess', _12 => _12.alias]) || {});
         }
       });
-      api.onAfterStartDevServer(() => _optionalChain([compilerRun, 'optionalCall', _19 => _19()]));
-      api.onAfterStartProdServer(() => _optionalChain([compilerRun, 'optionalCall', _20 => _20()]));
-      api.onExit(() => _optionalChain([compilerClose, 'optionalCall', _21 => _21()]));
+      api.onAfterStartDevServer(startMockServer);
+      api.onAfterStartProdServer(startMockServer);
+      api.onExit(close);
     }
   };
 }
+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', _15 => _15.stack]) || err.message));
+    res.statusCode = 500;
+    res.end();
+  };
+  if (_utils.isArray.call(void 0, config.server.proxy)) {
+    config.server.proxy = config.server.proxy.map((item) => {
+      if (typeof item !== "function" && !item.ws) {
+        const onProxyReq = item.onProxyReq;
+        const onError = item.onError;
+        return {
+          ...item,
+          onError: onError || onProxyError,
+          onProxyReq: (proxyReq, req, ...args) => {
+            _optionalChain([onProxyReq, 'optionalCall', _16 => _16(proxyReq, req, ...args)]);
+            _chunkI54ZNZWLcjs.rewriteRequest.call(void 0, proxyReq, req);
+          }
+        };
+      }
+      return item;
+    });
+  } else if ("target" in config.server.proxy) {
+    const onProxyReq = config.server.proxy.onProxyReq;
+    config.server.proxy.onProxyReq = (proxyReq, req, ...args) => {
+      _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) {
+    const proxy = config.server.proxy;
+    Object.keys(proxy).forEach((key) => {
+      const target = proxy[key];
+      const options = typeof target === "string" ? { target } : target;
+      if (options.ws)
+        return;
+      const { onProxyReq, onError, ...rest } = options;
+      proxy[key] = {
+        ...rest,
+        onProxyReq: (proxyReq, req, ...args) => {
+          _optionalChain([onProxyReq, 'optionalCall', _18 => _18(proxyReq, req, ...args)]);
+          _chunkI54ZNZWLcjs.rewriteRequest.call(void 0, proxyReq, req);
+        },
+        onError: onError || onProxyError
+      };
+    });
+  }
+}
+function updateServerProxyConfigByWSMock(config, wsPrefix, port) {
+  config.server ??= {};
+  const proxy = config.server.proxy ??= {};
+  const wsTarget = `ws://localhost:${port}`;
+  const prefix = _utils.toArray.call(void 0, wsPrefix);
+  const has = (context) => typeof context === "string" && prefix.includes(context);
+  const used = /* @__PURE__ */ new Set();
+  function updateProxy(item) {
+    if (_utils.isArray.call(void 0, item.context)) {
+      item.context = item.context.filter(has);
+    } else if (has(item.context)) {
+      used.add(item.context);
+      item.target = wsTarget;
+    }
+  }
+  if (_utils.isArray.call(void 0, proxy)) {
+    for (const item of proxy) {
+      if (typeof item !== "function" && item.context && item.ws) {
+        updateProxy(item);
+      }
+    }
+    prefix.filter((context) => !used.has(context)).forEach((context) => proxy.push({ context, target: wsTarget }));
+  } else if ("target" in proxy) {
+    if (proxy.ws) {
+      updateProxy(proxy);
+      const list = config.server.proxy = [proxy];
+      prefix.filter((context) => !used.has(context)).forEach((context) => list.push({ context, target: wsTarget }));
+    }
+  } else {
+    Object.entries(proxy).forEach(([, opt]) => {
+      if (typeof opt !== "string" && opt.ws) {
+        updateProxy(opt);
+      }
+    });
+    prefix.filter((context) => !used.has(context)).forEach((context) => {
+      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;
+}
 
 
 exports.pluginMockServer = pluginMockServer;

package/dist/rsbuild.d.cts

@@ -1,5 +1,5 @@
 import { RsbuildPlugin } from '@rsbuild/core';
-import { M as MockServerPluginOptions } from './types-DhT3pRJ3.cjs';
+import { M as MockServerPluginOptions } from './types-C770q3L0.cjs';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';

package/dist/rsbuild.d.ts

@@ -1,5 +1,5 @@
 import { RsbuildPlugin } from '@rsbuild/core';
-import { M as MockServerPluginOptions } from './types-DhT3pRJ3.js';
+import { M as MockServerPluginOptions } from './types-C770q3L0.js';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';