rspack-plugin-mock 0.1.0

package/dist/chunk-HTOWPFQ7.js

@@ -0,0 +1,20 @@
+// src/core/defineMock.ts
+import { isArray } from "@pengzhanbo/utils";
+function defineMock(config) {
+  return config;
+}
+function createDefineMock(transformer) {
+  const define = (config) => {
+    if (isArray(config))
+      config = config.map((item) => transformer(item) || item);
+    else
+      config = transformer(config) || config;
+    return config;
+  };
+  return define;
+}
+
+export {
+  defineMock,
+  createDefineMock
+};

package/dist/chunk-KE2LVHUP.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/core/defineMock.ts
+var _utils = require('@pengzhanbo/utils');
+function defineMock(config) {
+  return config;
+}
+function createDefineMock(transformer) {
+  const define = (config) => {
+    if (_utils.isArray.call(void 0, config))
+      config = config.map((item) => transformer(item) || item);
+    else
+      config = transformer(config) || config;
+    return config;
+  };
+  return define;
+}
+
+
+
+
+exports.defineMock = defineMock; exports.createDefineMock = createDefineMock;

package/dist/helper.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkKE2LVHUPcjs = require('./chunk-KE2LVHUP.cjs');
+
+
+
+exports.createDefineMock = _chunkKE2LVHUPcjs.createDefineMock; exports.defineMock = _chunkKE2LVHUPcjs.defineMock;

package/dist/helper.d.cts

@@ -0,0 +1,72 @@
+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 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';
+
+/**
+ * mock config Type helper
+ *
+ * mock配置 类型帮助函数
+ * @param config see config docs:
+ * {@link https://vite-plugin-mock-dev-server.netlify.app/en/guide/mock-config en-US DOC} |
+ * {@link https://vite-plugin-mock-dev-server.netlify.app/guide/mock-config zh-CN DOC}
+ *
+ * @example
+ * Mock Http Request
+ * ```ts
+ * export default defineMock({
+ *   url: '/api/example',
+ *   method: ['GET', 'POST'],
+ *   body: { a: 1 },
+ * })
+ * ```
+ * ```ts
+ * export default defineMock({
+ *   url: '/api/example',
+ *   method: 'GET',
+ *   body: ({ query }) => ({ a: 1, b: query.b }),
+ * })
+ * ```
+ * @example
+ * Mock WebSocket
+ * ```ts
+ * export default defineMock({
+ *   url: '/socket.io',
+ *   ws: true,
+ *   setup(wss) {
+ *     wss.on('connection', (ws) => {
+ *       ws.on('message', (rawData) => console.log(rawData))
+ *       ws.send('data')
+ *     })
+ *   },
+ * })
+ * ```
+ */
+declare function defineMock(config: MockHttpItem): MockHttpItem;
+declare function defineMock(config: MockWebsocketItem): MockWebsocketItem;
+declare function defineMock(config: MockOptions): MockOptions;
+/**
+ * Return a custom defineMock function to support preprocessing of mock config.
+ *
+ * 返回一个自定义的 defineMock 函数，用于支持对 mock config 的预处理。
+ * @param transformer preprocessing function
+ * @example
+ * ```ts
+ * const definePostMock = createDefineMock((mock) => {
+ *   mock.url = '/api/post/' + mock.url
+ * })
+ * export default definePostMock({
+ *   url: 'list',
+ *   body: [{ title: '1' }, { title: '2' }],
+ * })
+ * ```
+ */
+declare function createDefineMock(transformer: (mock: MockHttpItem | MockWebsocketItem) => MockHttpItem | MockWebsocketItem | void): typeof defineMock;
+
+export { MockHttpItem, MockOptions, MockWebsocketItem, createDefineMock, defineMock };

package/dist/helper.d.ts

@@ -0,0 +1,72 @@
+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 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';
+
+/**
+ * mock config Type helper
+ *
+ * mock配置 类型帮助函数
+ * @param config see config docs:
+ * {@link https://vite-plugin-mock-dev-server.netlify.app/en/guide/mock-config en-US DOC} |
+ * {@link https://vite-plugin-mock-dev-server.netlify.app/guide/mock-config zh-CN DOC}
+ *
+ * @example
+ * Mock Http Request
+ * ```ts
+ * export default defineMock({
+ *   url: '/api/example',
+ *   method: ['GET', 'POST'],
+ *   body: { a: 1 },
+ * })
+ * ```
+ * ```ts
+ * export default defineMock({
+ *   url: '/api/example',
+ *   method: 'GET',
+ *   body: ({ query }) => ({ a: 1, b: query.b }),
+ * })
+ * ```
+ * @example
+ * Mock WebSocket
+ * ```ts
+ * export default defineMock({
+ *   url: '/socket.io',
+ *   ws: true,
+ *   setup(wss) {
+ *     wss.on('connection', (ws) => {
+ *       ws.on('message', (rawData) => console.log(rawData))
+ *       ws.send('data')
+ *     })
+ *   },
+ * })
+ * ```
+ */
+declare function defineMock(config: MockHttpItem): MockHttpItem;
+declare function defineMock(config: MockWebsocketItem): MockWebsocketItem;
+declare function defineMock(config: MockOptions): MockOptions;
+/**
+ * Return a custom defineMock function to support preprocessing of mock config.
+ *
+ * 返回一个自定义的 defineMock 函数，用于支持对 mock config 的预处理。
+ * @param transformer preprocessing function
+ * @example
+ * ```ts
+ * const definePostMock = createDefineMock((mock) => {
+ *   mock.url = '/api/post/' + mock.url
+ * })
+ * export default definePostMock({
+ *   url: 'list',
+ *   body: [{ title: '1' }, { title: '2' }],
+ * })
+ * ```
+ */
+declare function createDefineMock(transformer: (mock: MockHttpItem | MockWebsocketItem) => MockHttpItem | MockWebsocketItem | void): typeof defineMock;
+
+export { MockHttpItem, MockOptions, MockWebsocketItem, createDefineMock, defineMock };

package/dist/helper.js

@@ -0,0 +1,8 @@
+import {
+  createDefineMock,
+  defineMock
+} from "./chunk-HTOWPFQ7.js";
+export {
+  createDefineMock,
+  defineMock
+};

package/dist/index.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk4BGDHRTOcjs = require('./chunk-4BGDHRTO.cjs');
+
+
+
+var _chunkKE2LVHUPcjs = require('./chunk-KE2LVHUP.cjs');
+
+
+
+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;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+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';
+export { createDefineMock, defineMock } from './helper.cjs';
+import '@rspack/core';
+import './types-DhT3pRJ3.cjs';
+import 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+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';
+export { createDefineMock, defineMock } from './helper.js';
+import '@rspack/core';
+import './types-DhT3pRJ3.js';
+import 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  MockServerPlugin,
+  resolveMiddleOptions
+} from "./chunk-B56QNVSS.js";
+import {
+  createDefineMock,
+  defineMock
+} from "./chunk-HTOWPFQ7.js";
+import {
+  createManuallyMockMiddleware,
+  createMockMiddleware
+} from "./chunk-5MGZAMDI.js";
+export {
+  MockServerPlugin,
+  createDefineMock,
+  createManuallyMockMiddleware,
+  createMockMiddleware,
+  defineMock,
+  resolveMiddleOptions
+};

package/dist/json5-loader.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/json5-loader.ts
+var _json5 = require('json5'); var _json52 = _interopRequireDefault(_json5);
+var json5Loader = function(content) {
+  if (!content)
+    return "export default {}";
+  return `export default ${JSON.stringify(_json52.default.parse(content))}`;
+};
+var json5_loader_default = json5Loader;
+
+
+exports.default = json5_loader_default;

package/dist/json5-loader.d.cts

@@ -0,0 +1,5 @@
+import { LoaderDefinitionFunction } from '@rspack/core';
+
+declare const json5Loader: LoaderDefinitionFunction;
+
+export { json5Loader as default };

package/dist/json5-loader.d.ts

@@ -0,0 +1,5 @@
+import { LoaderDefinitionFunction } from '@rspack/core';
+
+declare const json5Loader: LoaderDefinitionFunction;
+
+export { json5Loader as default };

package/dist/json5-loader.js

@@ -0,0 +1,11 @@
+// src/json5-loader.ts
+import JSON5 from "json5";
+var json5Loader = function(content) {
+  if (!content)
+    return "export default {}";
+  return `export default ${JSON.stringify(JSON5.parse(content))}`;
+};
+var json5_loader_default = json5Loader;
+export {
+  json5_loader_default as default
+};

package/dist/rsbuild.cjs

@@ -0,0 +1,121 @@
+"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');
+
+// src/rsbuild.ts
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _utils = require('@pengzhanbo/utils');
+var _core = require('@rspack/core'); var _core2 = _interopRequireDefault(_core);
+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
+            };
+          });
+        }
+      });
+      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);
+            }
+          });
+        }
+        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;
+        config.dev ??= {};
+        config.dev.setupMiddlewares ??= [];
+        config.dev.setupMiddlewares.push((middlewares) => {
+          mockMiddleware(middlewares);
+        });
+      });
+      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]) || {})]);
+          }
+        }
+      });
+      api.onAfterStartDevServer(() => _optionalChain([compilerRun, 'optionalCall', _19 => _19()]));
+      api.onAfterStartProdServer(() => _optionalChain([compilerRun, 'optionalCall', _20 => _20()]));
+      api.onExit(() => _optionalChain([compilerClose, 'optionalCall', _21 => _21()]));
+    }
+  };
+}
+
+
+exports.pluginMockServer = pluginMockServer;

package/dist/rsbuild.d.cts

@@ -0,0 +1,14 @@
+import { RsbuildPlugin } from '@rsbuild/core';
+import { M as MockServerPluginOptions } from './types-DhT3pRJ3.cjs';
+import 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';
+
+declare function pluginMockServer(options?: MockServerPluginOptions): RsbuildPlugin;
+
+export { pluginMockServer };

package/dist/rsbuild.d.ts

@@ -0,0 +1,14 @@
+import { RsbuildPlugin } from '@rsbuild/core';
+import { M as MockServerPluginOptions } from './types-DhT3pRJ3.js';
+import 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';
+
+declare function pluginMockServer(options?: MockServerPluginOptions): RsbuildPlugin;
+
+export { pluginMockServer };

package/dist/rsbuild.js

@@ -0,0 +1,121 @@
+import {
+  createManuallyMockMiddleware,
+  rewriteRequest
+} from "./chunk-5MGZAMDI.js";
+
+// src/rsbuild.ts
+import process from "process";
+import { isArray, toArray } from "@pengzhanbo/utils";
+import rspack from "@rspack/core";
+function pluginMockServer(options = {}) {
+  return {
+    name: "plugin-mock-server",
+    setup(api) {
+      if (process.env.NODE_ENV === "production")
+        return;
+      api.modifyRsbuildConfig((config) => {
+        if (!config.server?.proxy)
+          return;
+        const onProxyError = (err, req, res) => {
+          console.error(err?.stack || err);
+          res.statusCode = 500;
+          res.end();
+        };
+        if (isArray(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) => {
+                  onProxyReq?.(proxyReq, req, ...args);
+                  rewriteRequest(proxyReq, req);
+                }
+              };
+            }
+            return item;
+          });
+        } else if ("target" in config.server.proxy) {
+          const onProxyReq = config.server.proxy.onProxyReq;
+          config.server.proxy.onProxyReq = (proxyReq, req, ...args) => {
+            onProxyReq?.(proxyReq, req, ...args);
+            rewriteRequest(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) => {
+                onProxyReq?.(proxyReq, req, ...args);
+                rewriteRequest(proxyReq, req);
+              },
+              onError: onError || onProxyError
+            };
+          });
+        }
+      });
+      let compilerRun;
+      let compilerClose;
+      let compilerUpdateAlias;
+      api.modifyRsbuildConfig((config) => {
+        const proxy = config.server?.proxy || [];
+        const proxies = [];
+        if (isArray(proxy)) {
+          for (const item of proxy) {
+            if (typeof item !== "function" && !item.ws && item.context) {
+              proxies.push(...toArray(item.context));
+            }
+          }
+        } else if ("target" in proxy) {
+          proxies.push(...toArray(proxy.context));
+        } else {
+          Object.entries(proxy).forEach(([context, opt]) => {
+            if (typeof opt === "string" || !opt.ws) {
+              proxies.push(context);
+            }
+          });
+        }
+        const { mockMiddleware, run, close, updateAlias } = createManuallyMockMiddleware({
+          plugins: [new rspack.DefinePlugin(config.source?.define || {})],
+          alias: {},
+          proxies,
+          context: api.context.rootPath
+        }, options);
+        compilerRun = run;
+        compilerClose = close;
+        compilerUpdateAlias = updateAlias;
+        config.dev ??= {};
+        config.dev.setupMiddlewares ??= [];
+        config.dev.setupMiddlewares.push((middlewares) => {
+          mockMiddleware(middlewares);
+        });
+      });
+      api.onAfterCreateCompiler(({ compiler }) => {
+        if (compilerUpdateAlias) {
+          if ("compilers" in compiler) {
+            compiler.compilers.forEach((compiler2) => {
+              compilerUpdateAlias?.(compiler2.options.resolve?.alias || {});
+            });
+          } else {
+            compilerUpdateAlias?.(compiler.options.resolve?.alias || {});
+          }
+        }
+      });
+      api.onAfterStartDevServer(() => compilerRun?.());
+      api.onAfterStartProdServer(() => compilerRun?.());
+      api.onExit(() => compilerClose?.());
+    }
+  };
+}
+export {
+  pluginMockServer
+};

package/dist/rspack-BI-Ifj4a.d.cts

@@ -0,0 +1,28 @@
+import { RspackPluginInstance, RspackOptionsNormalized, Compiler } from '@rspack/core';
+import { M as MockServerPluginOptions } from './types-DhT3pRJ3.cjs';
+
+interface MiddlewareOptions {
+    alias: Record<string, false | string | (string | false)[]>;
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    context?: string;
+    plugins: RspackPluginInstance[];
+}
+declare function createManuallyMockMiddleware({ alias, proxies, context, plugins }: MiddlewareOptions, pluginOptions: MockServerPluginOptions): {
+    mockMiddleware: (middlewares: Middleware[]) => Middleware[];
+    run: () => Promise<void>;
+    close: () => void;
+    updateAlias: (alias: Record<string, false | string | (string | false)[]>) => void;
+};
+declare function createMockMiddleware(middlewareOptions: MiddlewareOptions, pluginOptions: MockServerPluginOptions): (middlewares: Middleware[]) => 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;
+
+declare class MockServerPlugin implements RspackPluginInstance {
+    options: MockServerPluginOptions;
+    constructor(options?: MockServerPluginOptions);
+    apply(compiler: Compiler): void;
+}
+declare function resolveMiddleOptions(compiler: Compiler): MiddlewareOptions;
+
+export { MockServerPlugin as M, type Server as S, type MiddlewareOptions as a, createMockMiddleware as b, createManuallyMockMiddleware as c, type Middleware as d, resolveMiddleOptions as r };

package/dist/rspack-Db7drzDm.d.ts

@@ -0,0 +1,28 @@
+import { RspackPluginInstance, RspackOptionsNormalized, Compiler } from '@rspack/core';
+import { M as MockServerPluginOptions } from './types-DhT3pRJ3.js';
+
+interface MiddlewareOptions {
+    alias: Record<string, false | string | (string | false)[]>;
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    context?: string;
+    plugins: RspackPluginInstance[];
+}
+declare function createManuallyMockMiddleware({ alias, proxies, context, plugins }: MiddlewareOptions, pluginOptions: MockServerPluginOptions): {
+    mockMiddleware: (middlewares: Middleware[]) => Middleware[];
+    run: () => Promise<void>;
+    close: () => void;
+    updateAlias: (alias: Record<string, false | string | (string | false)[]>) => void;
+};
+declare function createMockMiddleware(middlewareOptions: MiddlewareOptions, pluginOptions: MockServerPluginOptions): (middlewares: Middleware[]) => 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;
+
+declare class MockServerPlugin implements RspackPluginInstance {
+    options: MockServerPluginOptions;
+    constructor(options?: MockServerPluginOptions);
+    apply(compiler: Compiler): void;
+}
+declare function resolveMiddleOptions(compiler: Compiler): MiddlewareOptions;
+
+export { MockServerPlugin as M, type Server as S, type MiddlewareOptions as a, createMockMiddleware as b, createManuallyMockMiddleware as c, type Middleware as d, resolveMiddleOptions as r };

package/dist/rspack.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk4BGDHRTOcjs = require('./chunk-4BGDHRTO.cjs');
+require('./chunk-G53QRHGV.cjs');
+
+
+
+exports.MockServerPlugin = _chunk4BGDHRTOcjs.MockServerPlugin; exports.resolveMiddleOptions = _chunk4BGDHRTOcjs.resolveMiddleOptions;

package/dist/rspack.d.cts

@@ -0,0 +1,11 @@
+import '@rspack/core';
+import './types-DhT3pRJ3.cjs';
+export { M as MockServerPlugin, r as resolveMiddleOptions } from './rspack-BI-Ifj4a.cjs';
+import 'node:buffer';
+import 'node:http';
+import 'node:stream';
+import 'cookies';
+import 'cors';
+import 'formidable';
+import 'ws';
+import 'co-body';