rspack-plugin-mock 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -1,20 +1,103 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"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 _chunkT4AI3L6Rcjs = require('./chunk-T4AI3L6R.cjs');
 
 
 
-var _chunkKE2LVHUPcjs = require('./chunk-KE2LVHUP.cjs');
+var _chunk4GMRSIINcjs = require('./chunk-4GMRSIIN.cjs');
 
 
 
-var _chunk2S4KCTKWcjs = require('./chunk-2S4KCTKW.cjs');
 
+var _chunkZEC4FWWYcjs = require('./chunk-ZEC4FWWY.cjs');
 
+// src/rspack.ts
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _core = require('@rspack/core'); var _core2 = _interopRequireDefault(_core);
+var _utils = require('@pengzhanbo/utils');
+var PLUGIN_NAME = "rspack-plugin-mock";
+var MockServerPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const compilerOptions = compiler.options;
+    const options = resolvePluginOptions2(compiler, this.options);
+    if (_process2.default.env.NODE_ENV !== "production") {
+      const mockCompiler = _chunk4GMRSIINcjs.createMockCompiler.call(void 0, options);
+      const mockMiddleware = _chunk4GMRSIINcjs.createMockMiddleware.call(void 0, mockCompiler, options);
+      const setupMiddlewares = _optionalChain([compilerOptions, 'access', _ => _.devServer, 'optionalAccess', _2 => _2.setupMiddlewares]);
+      const waitServer = _chunkZEC4FWWYcjs.waitingFor.call(void 0, (server) => {
+        _chunkZEC4FWWYcjs.mockWebSocket.call(void 0, mockCompiler, server, options);
+      });
+      compilerOptions.devServer = {
+        ...compilerOptions.devServer,
+        setupMiddlewares: (middlewares, devServer) => {
+          middlewares = _optionalChain([setupMiddlewares, 'optionalCall', _3 => _3(middlewares, devServer)]) || middlewares;
+          const reload = () => {
+            if (_optionalChain([devServer, 'access', _4 => _4.webSocketServer, 'optionalAccess', _5 => _5.clients]))
+              devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
+          };
+          middlewares = mockMiddleware(middlewares, reload) || middlewares;
+          waitServer(() => devServer.server);
+          return middlewares;
+        }
+      };
+      const proxy = _optionalChain([compilerOptions, 'access', _6 => _6.devServer, 'optionalAccess', _7 => _7.proxy]) || [];
+      const wsPrefix = _utils.toArray.call(void 0, options.wsPrefix);
+      if (proxy.length) {
+        compilerOptions.devServer.proxy = proxy.map((item) => {
+          if (typeof item !== "function" && !item.ws) {
+            const onProxyReq = item.onProxyReq;
+            item.onProxyReq = (proxyReq, req, ...args) => {
+              _optionalChain([onProxyReq, 'optionalCall', _8 => _8(proxyReq, req, ...args)]);
+              _chunkZEC4FWWYcjs.rewriteRequest.call(void 0, proxyReq, req);
+            };
+          }
+          return item;
+        }).filter((item) => {
+          if (typeof item !== "function" && item.ws === true && wsPrefix.length) {
+            return !_utils.toArray.call(void 0, item.context).filter(_utils.isString).some((context) => wsPrefix.includes(context));
+          }
+          return true;
+        });
+      }
+      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
+      compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
+    } else if (options.build !== false) {
+      compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => _chunk4GMRSIINcjs.buildMockServer.call(void 0, 
+        options,
+        compilerOptions.output.path || _path2.default.resolve(_process2.default.cwd(), "dist")
+      ));
+    }
+  }
+};
+function resolvePluginOptions2(compiler, options) {
+  const compilerOptions = compiler.options;
+  const alias = _optionalChain([compilerOptions, 'access', _9 => _9.resolve, 'optionalAccess', _10 => _10.alias]) || {};
+  const context = compilerOptions.context;
+  const definePluginInstance = _optionalChain([compilerOptions, 'access', _11 => _11.plugins, 'optionalAccess', _12 => _12.find, 'call', _13 => _13(
+    (plugin) => plugin instanceof _core2.default.DefinePlugin
+  )]);
+  const proxies = (_optionalChain([compilerOptions, 'access', _14 => _14.devServer, 'optionalAccess', _15 => _15.proxy]) || []).flatMap((item) => {
+    if (typeof item !== "function" && item.context && !item.ws) {
+      return item.context;
+    }
+    return [];
+  });
+  return _chunk4GMRSIINcjs.resolvePluginOptions.call(void 0, options, {
+    alias,
+    context,
+    plugins: _utils.toArray.call(void 0, definePluginInstance),
+    proxies
+  });
+}
 
 
 
 
 
-exports.MockServerPlugin = _chunkT4AI3L6Rcjs.MockServerPlugin; exports.createDefineMock = _chunkKE2LVHUPcjs.createDefineMock; exports.createMockCompiler = _chunk2S4KCTKWcjs.createMockCompiler; exports.createMockMiddleware = _chunk2S4KCTKWcjs.createMockMiddleware; exports.defineMock = _chunkKE2LVHUPcjs.defineMock; exports.resolvePluginOptions = _chunkT4AI3L6Rcjs.resolvePluginOptions;
+
+
+exports.MockCompiler = _chunk4GMRSIINcjs.MockCompiler; exports.MockServerPlugin = MockServerPlugin; exports.createMockCompiler = _chunk4GMRSIINcjs.createMockCompiler; exports.createMockMiddleware = _chunk4GMRSIINcjs.createMockMiddleware; exports.mockWebSocket = _chunkZEC4FWWYcjs.mockWebSocket; exports.resolvePluginOptions = resolvePluginOptions2;

package/dist/index.d.cts

@@ -1,11 +1,7 @@
-import { R as ResolvePluginOptions } from './rspack-BcdszmoI.cjs';
-export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-BcdszmoI.cjs';
-export { createDefineMock, defineMock } from './helper.cjs';
-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.cjs';
+import { RspackPluginInstance, Compiler } from '@rspack/core';
+import { M as MockServerPluginOptions } from './types-BgpcN3jm.cjs';
+import { R as ResolvePluginOptions } from './mockWebsocket-Dc9CZBfv.cjs';
+export { a as Middleware, M as MiddlewareOptions, f as MockCompiler, d as MockCompilerOptions, b as MockSocketOptions, S as Server, e as createMockCompiler, c as createMockMiddleware, m as mockWebSocket } from './mockWebsocket-Dc9CZBfv.cjs';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';
@@ -14,47 +10,15 @@ import 'cors';
 import 'formidable';
 import 'ws';
 import 'co-body';
+import 'node:http2';
+import 'node:events';
+import 'node:fs';
 
-interface MockCompilerOptions {
-    alias?: Record<string, false | string | (string | false)[]>;
-    plugins: RspackPluginInstance[];
-    cwd?: string;
-    include: string | string[];
-    exclude: string | string[];
+declare class MockServerPlugin implements RspackPluginInstance {
+    options: MockServerPluginOptions;
+    constructor(options?: MockServerPluginOptions);
+    apply(compiler: Compiler): void;
 }
-declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
-declare class MockCompiler extends EventEmitter {
-    options: MockCompilerOptions;
-    cwd: string;
-    mockWatcher: FSWatcher;
-    moduleType: 'cjs' | 'esm';
-    entryFile: string;
-    outputFile: 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;
-    resolveEntryFile(fileList: string[]): Promise<void>;
-    createCompiler(callback: (e: Error | null, stats?: rspackCore.Stats) => void): 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;
+declare function resolvePluginOptions(compiler: Compiler, options: MockServerPluginOptions): ResolvePluginOptions;
 
-export { type Middleware, type MiddlewareOptions, type Server, createMockCompiler, createMockMiddleware };
+export { MockServerPlugin, resolvePluginOptions };

package/dist/index.d.ts

@@ -1,11 +1,7 @@
-import { R as ResolvePluginOptions } from './rspack-E_yBzR5v.js';
-export { M as MockServerPlugin, r as resolvePluginOptions } from './rspack-E_yBzR5v.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 { RspackPluginInstance, Compiler } from '@rspack/core';
+import { M as MockServerPluginOptions } from './types-BgpcN3jm.js';
+import { R as ResolvePluginOptions } from './mockWebsocket-CPuTAvL0.js';
+export { a as Middleware, M as MiddlewareOptions, f as MockCompiler, d as MockCompilerOptions, b as MockSocketOptions, S as Server, e as createMockCompiler, c as createMockMiddleware, m as mockWebSocket } from './mockWebsocket-CPuTAvL0.js';
 import 'node:buffer';
 import 'node:http';
 import 'node:stream';
@@ -14,47 +10,15 @@ import 'cors';
 import 'formidable';
 import 'ws';
 import 'co-body';
+import 'node:http2';
+import 'node:events';
+import 'node:fs';
 
-interface MockCompilerOptions {
-    alias?: Record<string, false | string | (string | false)[]>;
-    plugins: RspackPluginInstance[];
-    cwd?: string;
-    include: string | string[];
-    exclude: string | string[];
+declare class MockServerPlugin implements RspackPluginInstance {
+    options: MockServerPluginOptions;
+    constructor(options?: MockServerPluginOptions);
+    apply(compiler: Compiler): void;
 }
-declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
-declare class MockCompiler extends EventEmitter {
-    options: MockCompilerOptions;
-    cwd: string;
-    mockWatcher: FSWatcher;
-    moduleType: 'cjs' | 'esm';
-    entryFile: string;
-    outputFile: 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;
-    resolveEntryFile(fileList: string[]): Promise<void>;
-    createCompiler(callback: (e: Error | null, stats?: rspackCore.Stats) => void): 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;
+declare function resolvePluginOptions(compiler: Compiler, options: MockServerPluginOptions): ResolvePluginOptions;
 
-export { type Middleware, type MiddlewareOptions, type Server, createMockCompiler, createMockMiddleware };
+export { MockServerPlugin, resolvePluginOptions };

package/dist/index.js

@@ -1,20 +1,103 @@
 import {
-  MockServerPlugin,
+  MockCompiler,
+  buildMockServer,
+  createMockCompiler,
+  createMockMiddleware,
   resolvePluginOptions
-} from "./chunk-P6DRAHHI.js";
-import {
-  createDefineMock,
-  defineMock
-} from "./chunk-HTOWPFQ7.js";
+} from "./chunk-B5W3PWCX.js";
 import {
-  createMockCompiler,
-  createMockMiddleware
-} from "./chunk-UJAKORAH.js";
+  mockWebSocket,
+  rewriteRequest,
+  waitingFor
+} from "./chunk-EY46RSAC.js";
+
+// src/rspack.ts
+import process from "process";
+import path from "path";
+import rspack from "@rspack/core";
+import { isString, toArray } from "@pengzhanbo/utils";
+var PLUGIN_NAME = "rspack-plugin-mock";
+var MockServerPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const compilerOptions = compiler.options;
+    const options = resolvePluginOptions2(compiler, this.options);
+    if (process.env.NODE_ENV !== "production") {
+      const mockCompiler = createMockCompiler(options);
+      const mockMiddleware = createMockMiddleware(mockCompiler, options);
+      const setupMiddlewares = compilerOptions.devServer?.setupMiddlewares;
+      const waitServer = waitingFor((server) => {
+        mockWebSocket(mockCompiler, server, options);
+      });
+      compilerOptions.devServer = {
+        ...compilerOptions.devServer,
+        setupMiddlewares: (middlewares, devServer) => {
+          middlewares = setupMiddlewares?.(middlewares, devServer) || middlewares;
+          const reload = () => {
+            if (devServer.webSocketServer?.clients)
+              devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
+          };
+          middlewares = mockMiddleware(middlewares, reload) || middlewares;
+          waitServer(() => devServer.server);
+          return middlewares;
+        }
+      };
+      const proxy = compilerOptions.devServer?.proxy || [];
+      const wsPrefix = toArray(options.wsPrefix);
+      if (proxy.length) {
+        compilerOptions.devServer.proxy = proxy.map((item) => {
+          if (typeof item !== "function" && !item.ws) {
+            const onProxyReq = item.onProxyReq;
+            item.onProxyReq = (proxyReq, req, ...args) => {
+              onProxyReq?.(proxyReq, req, ...args);
+              rewriteRequest(proxyReq, req);
+            };
+          }
+          return item;
+        }).filter((item) => {
+          if (typeof item !== "function" && item.ws === true && wsPrefix.length) {
+            return !toArray(item.context).filter(isString).some((context) => wsPrefix.includes(context));
+          }
+          return true;
+        });
+      }
+      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
+      compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
+    } else if (options.build !== false) {
+      compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => buildMockServer(
+        options,
+        compilerOptions.output.path || path.resolve(process.cwd(), "dist")
+      ));
+    }
+  }
+};
+function resolvePluginOptions2(compiler, options) {
+  const compilerOptions = compiler.options;
+  const alias = compilerOptions.resolve?.alias || {};
+  const context = compilerOptions.context;
+  const definePluginInstance = compilerOptions.plugins?.find(
+    (plugin) => plugin instanceof rspack.DefinePlugin
+  );
+  const proxies = (compilerOptions.devServer?.proxy || []).flatMap((item) => {
+    if (typeof item !== "function" && item.context && !item.ws) {
+      return item.context;
+    }
+    return [];
+  });
+  return resolvePluginOptions(options, {
+    alias,
+    context,
+    plugins: toArray(definePluginInstance),
+    proxies
+  });
+}
 export {
+  MockCompiler,
   MockServerPlugin,
-  createDefineMock,
   createMockCompiler,
   createMockMiddleware,
-  defineMock,
-  resolvePluginOptions
+  mockWebSocket,
+  resolvePluginOptions2 as resolvePluginOptions
 };

package/dist/mockWebsocket-CPuTAvL0.d.ts

@@ -0,0 +1,76 @@
+import { RspackPluginInstance, Compiler, RspackOptionsNormalized } from '@rspack/core';
+import { i as LogLevel, M as MockServerPluginOptions, S as ServerBuildOption, c as MockOptions } from './types-BgpcN3jm.js';
+import { Server as Server$1 } from 'node:http';
+import { Http2SecureServer } from 'node:http2';
+import EventEmitter from 'node:events';
+import { FSWatcher } from 'node:fs';
+
+interface Logger {
+    debug: (msg: string, level?: boolean | LogLevel) => void;
+    info: (msg: string, level?: boolean | LogLevel) => void;
+    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)[]>;
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+    plugins: RspackPluginInstance[];
+    context?: string;
+}
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, 'build'>> & ResolvedCompilerOptions & {
+    logger: Logger;
+    build: false | ServerBuildOption;
+};
+
+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 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;
+
+export { type Logger as L, type MiddlewareOptions as M, type ResolvePluginOptions as R, type Server as S, type Middleware as a, type MockSocketOptions as b, createMockMiddleware as c, type MockCompilerOptions as d, createMockCompiler as e, MockCompiler as f, createLogger as g, logLevels as l, mockWebSocket as m };

package/dist/mockWebsocket-Dc9CZBfv.d.cts

@@ -0,0 +1,76 @@
+import { RspackPluginInstance, Compiler, RspackOptionsNormalized } from '@rspack/core';
+import { i as LogLevel, M as MockServerPluginOptions, S as ServerBuildOption, c as MockOptions } from './types-BgpcN3jm.cjs';
+import { Server as Server$1 } from 'node:http';
+import { Http2SecureServer } from 'node:http2';
+import EventEmitter from 'node:events';
+import { FSWatcher } from 'node:fs';
+
+interface Logger {
+    debug: (msg: string, level?: boolean | LogLevel) => void;
+    info: (msg: string, level?: boolean | LogLevel) => void;
+    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)[]>;
+    proxies: (string | ((pathname: string, req: any) => boolean))[];
+    wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+    plugins: RspackPluginInstance[];
+    context?: string;
+}
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, 'build'>> & ResolvedCompilerOptions & {
+    logger: Logger;
+    build: false | ServerBuildOption;
+};
+
+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 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;
+
+export { type Logger as L, type MiddlewareOptions as M, type ResolvePluginOptions as R, type Server as S, type Middleware as a, type MockSocketOptions as b, createMockMiddleware as c, type MockCompilerOptions as d, createMockCompiler as e, MockCompiler as f, createLogger as g, logLevels as l, mockWebSocket as m };