rspack-plugin-mock 1.3.0 → 2.0.0

package/dist/options-Bd0PSZeT.js

@@ -0,0 +1,446 @@
+import { a as processRawData, c as normalizePath, f as getPackageDepList, i as processMockData, l as vfs, m as createMatcher, p as getPackageDeps, u as createLogger } from "./ws-BcLCWVaK.js";
+import { createRequire } from "node:module";
+import { attemptAsync, isBoolean, isPlainObject, toArray, uniq } from "@pengzhanbo/utils";
+import path from "node:path";
+import process from "node:process";
+import * as rspackCore from "@rspack/core";
+import fs, { promises } from "node:fs";
+import fsp from "node:fs/promises";
+import ansis from "ansis";
+import { glob } from "tinyglobby";
+import isCore from "is-core-module";
+import { loadPackageJSONSync } from "local-pkg";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import EventEmitter from "node:events";
+import chokidar from "chokidar";
+//#region src/compiler/createRspackCompiler.ts
+const require = createRequire(import.meta.url);
+function createCompiler(options, callback) {
+	const rspackOptions = resolveRspackOptions(options);
+	const isWatch = rspackOptions.watch === true;
+	async function handler(err, stats) {
+		const name = "[rspack:mock]";
+		const logError = (...args) => {
+			if (stats) stats.compilation.getLogger(name).error(...args);
+			else console.error(ansis.red(name), ...args);
+		};
+		if (err) {
+			logError(err.stack || err);
+			if ("details" in err) logError(err.details);
+			return;
+		}
+		if (stats?.hasErrors()) logError(stats.toJson().errors);
+		const code = vfs.readFileSync("/output.js", "utf-8");
+		const externals = [];
+		if (!isWatch) {
+			const modules = stats?.toJson().modules || [];
+			const aliasList = Object.keys(options.alias || {}).map((key) => key.replace(/\$$/g, ""));
+			for (const { name } of modules) if (name?.startsWith("external")) {
+				const packageName = normalizePackageName(name);
+				if (!isCore(packageName) && !aliasList.includes(packageName)) externals.push(normalizePackageName(name));
+			}
+		}
+		await callback({
+			code,
+			externals
+		});
+	}
+	const compiler = rspackCore.rspack(rspackOptions);
+	compiler.outputFileSystem = vfs;
+	if (!isWatch) compiler.run(async (...args) => {
+		await handler(...args);
+		compiler.close(() => {});
+	});
+	else compiler.watch({}, handler);
+	return compiler;
+}
+function transformWithRspack(options) {
+	return new Promise((resolve) => {
+		createCompiler({
+			...options,
+			watch: false
+		}, (result) => {
+			resolve(result);
+		});
+	});
+}
+function normalizePackageName(name) {
+	const filepath = name.replace("external ", "").slice(1, -1);
+	const [scope, packageName] = filepath.split("/");
+	if (filepath[0] === "@") return `${scope}/${packageName}`;
+	return scope;
+}
+function resolveRspackOptions({ cwd, isEsm = true, entryFile, plugins, alias, watch = false }) {
+	const targets = ["node >= 20.0.0"];
+	if (alias && "@swc/helpers" in alias) delete alias["@swc/helpers"];
+	const externals = getPackageDepList(cwd);
+	const externalPattern = new RegExp(`^(${externals.join("|")})($|/)`, "i");
+	return {
+		mode: "production",
+		context: cwd,
+		entry: entryFile,
+		watch,
+		target: `node${(process.versions.node || "").replace(/\.\d+$/, "")}`,
+		externalsType: isEsm ? "module" : "commonjs2",
+		externals: [externalPattern],
+		resolve: {
+			alias,
+			extensions: [
+				".js",
+				".ts",
+				".cjs",
+				".mjs",
+				".json5",
+				".json"
+			]
+		},
+		plugins,
+		output: {
+			library: { type: !isEsm ? "commonjs2" : "module" },
+			filename: "output.js",
+			module: isEsm,
+			path: "/"
+		},
+		optimization: { minimize: !watch },
+		node: {
+			__dirname: false,
+			__filename: false
+		},
+		module: { rules: [
+			{
+				test: /\.json5?$/,
+				loader: require.resolve("#json5-loader"),
+				type: "javascript/auto"
+			},
+			{
+				test: /\.[cm]?js$/,
+				use: [{
+					loader: "builtin:swc-loader",
+					options: {
+						jsc: { parser: { syntax: "ecmascript" } },
+						env: { targets }
+					}
+				}]
+			},
+			{
+				test: /\.[cm]?ts$/,
+				use: [{
+					loader: "builtin:swc-loader",
+					options: {
+						jsc: { parser: { syntax: "typescript" } },
+						env: { targets }
+					}
+				}]
+			}
+		] }
+	};
+}
+//#endregion
+//#region src/compiler/loadFromCode.ts
+async function loadFromCode({ filepath, code, isESM, cwd }) {
+	filepath = path.resolve(cwd, filepath);
+	const ext = isESM ? ".mjs" : ".cjs";
+	const filepathTmp = `${filepath}.${getHash(code)}${ext}`;
+	await promises.writeFile(filepathTmp, code, "utf8");
+	const [, mod] = await attemptAsync(importDefault, String(pathToFileURL(filepathTmp)));
+	await attemptAsync(promises.unlink, filepathTmp);
+	return mod;
+}
+async function importDefault(filepath) {
+	const mod = await import(filepath);
+	return mod.default || mod;
+}
+function getHash(str) {
+	return createHash("md5").update(str).digest("hex");
+}
+//#endregion
+//#region src/compiler/mockCompiler.ts
+function createMockCompiler(options) {
+	return new MockCompiler(options);
+}
+var MockCompiler = class extends EventEmitter {
+	cwd;
+	mockWatcher;
+	entryFile;
+	deps = [];
+	isESM = false;
+	_mockData = {};
+	watchInfo;
+	compiler;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.cwd = options.cwd || process.cwd();
+		try {
+			const pkg = loadPackageJSONSync(this.cwd);
+			this.isESM = pkg?.type === "module";
+		} catch {}
+		this.entryFile = path.resolve(process.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+	}
+	get mockData() {
+		return this._mockData;
+	}
+	async run() {
+		const { include, exclude } = this.options;
+		const { pattern, ignore, isMatch } = createMatcher(include, exclude);
+		const files = await glob(pattern, {
+			ignore,
+			cwd: path.join(this.cwd, this.options.dir)
+		});
+		this.deps = files.map((file) => normalizePath(file));
+		this.updateMockEntry();
+		this.watchMockFiles(isMatch);
+		const { plugins, alias } = this.options;
+		const options = {
+			isEsm: this.isESM,
+			cwd: this.cwd,
+			plugins,
+			entryFile: this.entryFile,
+			alias,
+			watch: true
+		};
+		this.compiler = createCompiler(options, async ({ code }) => {
+			try {
+				const result = await loadFromCode({
+					filepath: "mock.bundle.js",
+					code,
+					isESM: this.isESM,
+					cwd: this.cwd
+				});
+				this._mockData = processMockData(processRawData(result));
+				this.emit("update", this.watchInfo || {});
+			} catch (e) {
+				this.options.logger.error(e.stack || e.message);
+			}
+		});
+	}
+	close() {
+		this.mockWatcher.close();
+		this.compiler?.close(() => {});
+		this.emit("close");
+	}
+	updateAlias(alias) {
+		this.options.alias = {
+			...this.options.alias,
+			...alias
+		};
+	}
+	async updateMockEntry() {
+		await writeMockEntryFile(this.entryFile, this.deps, this.cwd, this.options.dir);
+	}
+	watchMockFiles(isMatch) {
+		const watcher = this.mockWatcher = chokidar.watch(this.options.dir, {
+			ignoreInitial: true,
+			cwd: this.cwd,
+			ignored: (filepath, stats) => {
+				if (filepath.includes("node_modules")) return true;
+				return !!stats?.isFile() && !isMatch(filepath);
+			}
+		});
+		watcher.on("add", (filepath) => {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) {
+				this.watchInfo = {
+					filepath,
+					type: "add"
+				};
+				this.deps = uniq([...this.deps, filepath]);
+				this.updateMockEntry();
+			}
+		});
+		watcher.on("change", (filepath) => {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) this.watchInfo = {
+				filepath,
+				type: "change"
+			};
+		});
+		watcher.on("unlink", async (filepath) => {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) {
+				this.watchInfo = {
+					filepath,
+					type: "unlink"
+				};
+				this.deps = this.deps.filter((dep) => dep !== filepath);
+				this.updateMockEntry();
+			}
+		});
+	}
+};
+//#endregion
+//#region package.json
+var name = "rspack-plugin-mock";
+var version = "2.0.0";
+//#endregion
+//#region src/build/packageJson.ts
+function generatePackageJson(options, externals) {
+	const deps = getPackageDeps(options.context);
+	const exclude = [
+		name,
+		"connect",
+		"cors"
+	];
+	const mockPkg = {
+		name: "mock-server",
+		type: "module",
+		scripts: { start: "node index.js" },
+		dependencies: {
+			connect: "^3.7.0",
+			[name]: `^${version}`,
+			cors: "^2.8.5"
+		}
+	};
+	externals.filter((dep) => !exclude.includes(dep)).forEach((dep) => {
+		mockPkg.dependencies[dep] = deps[dep] || "latest";
+	});
+	return JSON.stringify(mockPkg, null, 2);
+}
+//#endregion
+//#region src/build/serverEntryCode.ts
+function generatorServerEntryCode({ proxies, wsPrefix, cookiesOptions, bodyParserOptions, priority, build }) {
+	const { serverPort, log } = build;
+	return `import { createServer } from 'node:http';
+import connect from 'connect';
+import corsMiddleware from 'cors';
+import { 
+  baseMiddleware,
+  createLogger,
+  mockWebSocket,
+  processMockData,
+  processRawData
+} from 'rspack-plugin-mock/server';
+import rawData from './mock-data.js';
+
+const app = connect();
+const server = createServer(app);
+const logger = createLogger('mock-server', '${log}');
+const proxies = ${JSON.stringify(proxies)};
+const wsProxies = ${JSON.stringify(toArray(wsPrefix))};
+const cookiesOptions = ${JSON.stringify(cookiesOptions)};
+const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
+const priority = ${JSON.stringify(priority)};
+const mockConfig = { 
+  mockData: processMockData(processRawData(rawData)),
+  on: () => {},
+};
+
+mockWebSocket(mockConfig, server, { wsProxies, cookiesOptions, logger });
+
+app.use(corsMiddleware());
+app.use(baseMiddleware(mockConfig, {
+  formidableOptions: { multiples: true },
+  proxies,
+  priority,
+  cookiesOptions,
+  bodyParserOptions,
+  logger,
+}));
+
+server.listen(${serverPort});
+
+console.log('listen: http://localhost:${serverPort}');
+`;
+}
+//#endregion
+//#region src/build/writeEntryFile.ts
+async function writeMockEntryFile(entryFile, files, cwd, dir) {
+	const importers = [];
+	const exporters = [];
+	for (const [index, filepath] of files.entries()) {
+		const relative = normalizePath(path.join(dir, filepath));
+		const file = normalizePath(path.join(cwd, relative));
+		importers.push(`import * as m${index} from '${file}'`);
+		exporters.push(`[m${index}, '${relative}']`);
+	}
+	const code = `${importers.join("\n")}\n\nexport default [\n  ${exporters.join(",\n  ")}\n]`;
+	const dirname = path.dirname(entryFile);
+	if (!fs.existsSync(dirname)) await fsp.mkdir(dirname, { recursive: true });
+	await fsp.writeFile(entryFile, code, "utf8");
+}
+//#endregion
+//#region src/build/generate.ts
+async function buildMockServer(options, outputDir) {
+	const entryFile = path.resolve(process.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+	const { pattern, ignore } = createMatcher(options.include, options.exclude);
+	await writeMockEntryFile(entryFile, await glob(pattern, {
+		ignore,
+		cwd: path.join(options.cwd, options.dir)
+	}), options.cwd, options.dir);
+	const { code, externals } = await transformWithRspack({
+		entryFile,
+		cwd: options.cwd,
+		plugins: options.plugins,
+		alias: options.alias
+	});
+	await fsp.unlink(entryFile);
+	const outputList = [
+		{
+			filename: "mock-data.js",
+			source: code
+		},
+		{
+			filename: "index.js",
+			source: generatorServerEntryCode(options)
+		},
+		{
+			filename: "package.json",
+			source: generatePackageJson(options, externals)
+		}
+	];
+	const dist = path.resolve(outputDir, options.build.dist);
+	options.logger.info(`${ansis.green("✓")} generate mock server in ${ansis.cyan(path.relative(process.cwd(), dist))}`);
+	if (!fs.existsSync(dist)) await fsp.mkdir(dist, { recursive: true });
+	for (const { filename, source } of outputList) {
+		await fsp.writeFile(path.join(dist, filename), source, "utf8");
+		const sourceSize = (source.length / 1024).toFixed(2);
+		const space = filename.length < 24 ? " ".repeat(24 - filename.length) : "";
+		options.logger.info(` ${ansis.green(filename)}${space}${ansis.bold.dim(`${sourceSize} kB`)}`);
+	}
+}
+//#endregion
+//#region src/options.ts
+function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, dir = "mock", include = ["**/*.mock.{js,ts,cjs,mjs,json,json5}"], exclude = [], reload = false, log = "info", cors = true, formidableOptions = {}, build = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {} }, { alias, context, plugins, proxies: rawProxies }) {
+	const logger = createLogger("rspack:mock", isBoolean(log) ? log ? "info" : "error" : log);
+	const proxies = [...toArray(prefix), ...rawProxies];
+	const wsProxies = toArray(wsPrefix);
+	if (!proxies.length && !wsProxies.length) logger.warn(`No proxy was configured, mock server will not work. See ${ansis.cyan("https://vite-plugin-mock-dev-server.netlify.app/guide/usage")}`);
+	const enabled = !!cors;
+	let corsOptions = {};
+	if (enabled && isPlainObject(cors)) corsOptions = {
+		...corsOptions,
+		...cors
+	};
+	return {
+		prefix,
+		wsPrefix,
+		cwd: cwd || context || process.cwd(),
+		dir,
+		include,
+		exclude,
+		reload,
+		cors: enabled ? corsOptions : false,
+		cookiesOptions,
+		log,
+		formidableOptions: {
+			multiples: true,
+			...formidableOptions
+		},
+		bodyParserOptions,
+		priority,
+		build: build ? {
+			serverPort: 8080,
+			dist: "mockServer",
+			log: "error",
+			...typeof build === "object" ? build : {}
+		} : false,
+		alias,
+		plugins,
+		proxies,
+		wsProxies,
+		logger
+	};
+}
+//#endregion
+export { buildMockServer as n, createMockCompiler as r, resolvePluginOptions as t };

package/dist/{rsbuild.d.mts → rsbuild.d.ts}

@@ -1,4 +1,4 @@
-import { _ as WebSocketSetupContext, a as LogType, c as MockMatchPriority, d as MockRequest, f as MockResponse, g as ServerBuildOption, h as ResponseBody, i as LogLevel, l as MockMatchSpecialPriority, m as MockWebsocketItem, n as ExtraRequest, o as Method, p as MockServerPluginOptions, r as FormidableFile, s as MockHttpItem, t as BodyParserOptions, u as MockOptions } from "./types-Bt_OTa7I.mjs";
+import { _ as WebSocketSetupContext, a as LogType, c as MockMatchPriority, d as MockRequest, f as MockResponse, g as ServerBuildOption, h as ResponseBody, i as LogLevel, l as MockMatchSpecialPriority, m as MockWebsocketItem, n as ExtraRequest, o as Method, p as MockServerPluginOptions, r as FormidableFile, s as MockHttpItem, t as BodyParserOptions, u as MockOptions } from "./types-GT6M6WuI.js";
 import { RsbuildPlugin } from "@rsbuild/core";
 
 //#region src/rsbuild.d.ts

package/dist/rsbuild.js

@@ -0,0 +1,92 @@
+import { n as baseMiddleware, r as rewriteRequest, t as mockWebSocket } from "./ws-BcLCWVaK.js";
+import { n as buildMockServer, r as createMockCompiler, t as resolvePluginOptions } from "./options-Bd0PSZeT.js";
+import { isArray, objectEntries, toArray } from "@pengzhanbo/utils";
+import path from "node:path";
+import process from "node:process";
+import rspack from "@rspack/core";
+import ansis from "ansis";
+import { Socket } from "node:net";
+//#region src/rsbuild.ts
+function pluginMockServer(options = {}) {
+	return {
+		name: "plugin-mock-server",
+		setup(api) {
+			const rsbuildConfig = api.getRsbuildConfig();
+			const resolvedOptions = resolvePluginOptions(options, {
+				proxies: resolveConfigProxies(rsbuildConfig),
+				alias: {},
+				context: api.context.rootPath,
+				plugins: [new rspack.DefinePlugin(rsbuildConfig.source?.define || {})]
+			});
+			if (api.context.action === "build") {
+				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.onAfterCreateCompiler(({ compiler }) => {
+				if ("compilers" in compiler) compiler.compilers.forEach((compiler) => {
+					mockCompiler.updateAlias(compiler.options.resolve?.alias || {});
+				});
+				else mockCompiler.updateAlias(compiler.options.resolve?.alias || {});
+			});
+			api.modifyRsbuildConfig((config) => updateServerProxyConfigByHttpMock(config));
+			function initMockServer(server) {
+				server.middlewares.use(baseMiddleware(mockCompiler, resolvedOptions));
+				if (resolvedOptions.reload && api.context.action === "dev") mockCompiler.on("update", () => server.sockWrite("static-changed"));
+				if (toArray(resolvedOptions.wsPrefix).length > 0) mockWebSocket(mockCompiler, server.httpServer, resolvedOptions);
+				mockCompiler.run();
+			}
+			api.onBeforeStartDevServer(({ server }) => initMockServer(server));
+			api.onBeforeStartPreviewServer(({ server }) => initMockServer(server));
+			api.onExit(() => mockCompiler.close());
+		}
+	};
+}
+function onProxyError(err, _req, res) {
+	console.error(ansis.red(err?.stack || err.message));
+	if (!(res instanceof Socket)) res.statusCode = 500;
+	res.end();
+}
+function wrapProxyOptions(options) {
+	const { on, ...rest } = options;
+	return {
+		...rest,
+		on: {
+			...on,
+			proxyReq: (proxyReq, req, ...args) => {
+				on?.proxyReq?.(proxyReq, req, ...args);
+				rewriteRequest(proxyReq, req);
+			},
+			error: on?.error || onProxyError
+		}
+	};
+}
+function updateServerProxyConfigByHttpMock(config) {
+	if (!config.server?.proxy) return;
+	if (isArray(config.server.proxy)) config.server.proxy = config.server.proxy.map((item) => item.ws ? item : wrapProxyOptions(item));
+	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;
+			proxy[key] = wrapProxyOptions(options);
+		});
+	}
+}
+function resolveConfigProxies(config) {
+	config.server ??= {};
+	const proxy = config.server.proxy ??= {};
+	const proxies = [];
+	if (isArray(proxy)) {
+		for (const item of proxy) if (item.pathFilter && !item.ws) proxies.push(...toArray(item.pathFilter));
+	} else objectEntries(proxy).forEach(([pathFilter, opt]) => {
+		if (typeof opt === "string" || !opt.ws) proxies.push(pathFilter);
+	});
+	return proxies;
+}
+//#endregion
+export { pluginMockServer };

package/dist/{server-4ETytB7L.d.mts → server-_doRwsZm.d.ts}

@@ -1,11 +1,12 @@
-import { g as ServerBuildOption, i as LogLevel, m as MockWebsocketItem, p as MockServerPluginOptions, s as MockHttpItem, u as MockOptions } from "./types-Bt_OTa7I.mjs";
-import { Compiler, RspackOptionsNormalized, RspackPluginInstance } from "@rspack/core";
+import { g as ServerBuildOption, i as LogLevel, m as MockWebsocketItem, p as MockServerPluginOptions, s as MockHttpItem, u as MockOptions } from "./types-GT6M6WuI.js";
+import { Compiler, RspackPluginInstance } from "@rspack/core";
 import { Matcher } from "picomatch";
 import Debug from "debug";
-import "memfs";
 import EventEmitter from "node:events";
 import { FSWatcher } from "chokidar";
-import { Server } from "node:http";
+import { CorsOptions } from "cors";
+import * as http$1 from "node:http";
+import http, { Server } from "node:http";
 import { Http2SecureServer } from "node:http2";
 
 //#region src/utils/logger.d.ts
@@ -21,10 +22,11 @@ declare function createLogger(prefix: string, defaultLevel?: LogLevel): Logger;
 //#region src/options.d.ts
 interface ResolvedCompilerOptions {
   alias: Record<string, false | string | (string | false)[]>;
-  proxies: (string | ((pathname: string, req: any) => boolean))[];
-  wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+  proxies: (string | ((pathname: string, req: http.IncomingMessage) => boolean))[];
+  wsProxies: (string | ((pathname: string, req: http.IncomingMessage) => boolean))[];
   plugins: RspackPluginInstance[];
   context?: string;
+  cors: false | CorsOptions;
 }
 type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, "build">> & ResolvedCompilerOptions & {
   logger: Logger;
@@ -40,8 +42,8 @@ declare function sortByValidator(mocks: MockOptions): (MockHttpItem | MockWebsoc
 declare class MockCompiler extends EventEmitter {
   options: ResolvePluginOptions;
   cwd: string;
-  mockWatcher: FSWatcher;
-  entryFile: string;
+  mockWatcher!: FSWatcher;
+  entryFile!: string;
   deps: string[];
   isESM: boolean;
   private _mockData;
@@ -56,14 +58,11 @@ declare class MockCompiler extends EventEmitter {
   watchMockFiles(isMatch: Matcher): void;
 }
 //#endregion
-//#region src/core/types.d.ts
-type SetupMiddlewaresFn = NonNullable<NonNullable<RspackOptionsNormalized["devServer"]>["setupMiddlewares"]>;
-type Middleware = SetupMiddlewaresFn extends ((middlewares: (infer T)[], devServer: any) => void) ? T : never;
-//#endregion
 //#region src/core/mockMiddleware.d.ts
 interface BaseMiddlewareOptions extends Pick<MockServerPluginOptions, "formidableOptions" | "cookiesOptions" | "bodyParserOptions" | "priority"> {
   proxies: (string | ((pathname: string, req: any) => boolean))[];
   logger: Logger;
+  cors: false | CorsOptions;
 }
 declare function baseMiddleware(compiler: MockCompiler, {
   formidableOptions,
@@ -71,8 +70,9 @@ declare function baseMiddleware(compiler: MockCompiler, {
   proxies,
   cookiesOptions,
   logger,
-  priority
-}: BaseMiddlewareOptions): Middleware;
+  priority,
+  cors: corsOptions
+}: BaseMiddlewareOptions): (req: http$1.IncomingMessage, res: http$1.ServerResponse, next: (err?: any) => void) => void;
 //#endregion
 //#region src/core/ws.d.ts
 interface MockSocketOptions {
@@ -80,7 +80,7 @@ interface MockSocketOptions {
   cookiesOptions: MockServerPluginOptions["cookiesOptions"];
   logger: Logger;
 }
-declare function mockWebSocket(compiler: MockCompiler, httpServer: Server | Http2SecureServer, {
+declare function mockWebSocket(compiler: MockCompiler, httpServer: Server | Http2SecureServer | null, {
   wsProxies: proxies,
   cookiesOptions,
   logger

package/dist/{server.d.mts → server.d.ts}

@@ -1,3 +1,2 @@
-import "./types-Bt_OTa7I.mjs";
-import { a as processMockData, c as Logger, i as baseMiddleware, l as createLogger, n as mockWebSocket, o as processRawData, r as BaseMiddlewareOptions, s as sortByValidator, t as MockSocketOptions, u as logLevels } from "./server-4ETytB7L.mjs";
+import { a as processMockData, c as Logger, i as baseMiddleware, l as createLogger, n as mockWebSocket, o as processRawData, r as BaseMiddlewareOptions, s as sortByValidator, t as MockSocketOptions, u as logLevels } from "./server-_doRwsZm.js";
 export { BaseMiddlewareOptions, Logger, MockSocketOptions, baseMiddleware, createLogger, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };

package/dist/server.js

@@ -0,0 +1,2 @@
+import { a as processRawData, d as logLevels, i as processMockData, n as baseMiddleware, o as sortByValidator, t as mockWebSocket, u as createLogger } from "./ws-BcLCWVaK.js";
+export { baseMiddleware, createLogger, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };

package/dist/{types-Bt_OTa7I.d.mts → types-GT6M6WuI.d.ts}

@@ -1,16 +1,16 @@
 import { Readable } from "node:stream";
+import crypto from "node:crypto";
 import { CorsOptions } from "cors";
 import { Options } from "co-body";
 import formidable from "formidable";
 import http, { IncomingMessage, ServerResponse } from "node:http";
-import crypto from "node:crypto";
 import { Buffer } from "node:buffer";
 import { WebSocketServer } from "ws";
 
 //#region src/cookies/Keygrip.d.ts
 declare class Keygrip {
-  private algorithm;
-  private encoding;
+  private algorithm!;
+  private encoding!;
   private keys;
   constructor(keys: string[], algorithm?: string, encoding?: crypto.BinaryToTextEncoding);
   sign(data: string, key?: string): string;