rspack-plugin-mock 1.2.0 → 1.3.0

package/dist/mockWebsocket-qLVAe-RI.d.ts

@@ -1,85 +0,0 @@
-import { LogLevel, MockOptions, MockServerPluginOptions, ServerBuildOption } from "./types-DPzh7nJq.js";
-import EventEmitter from "node:events";
-import { FSWatcher } from "node:fs";
-import { Compiler, RspackOptionsNormalized, RspackPluginInstance } from "@rspack/core";
-import { Server } from "node:http";
-import { Http2SecureServer } from "node:http2";
-
-//#region src/core/logger.d.ts
-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;
-//#endregion
-//#region src/core/mockCompiler.d.ts
-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;
-}
-//#endregion
-//#region src/core/resolvePluginOptions.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))[];
-  plugins: RspackPluginInstance[];
-  context?: string;
-}
-type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, "build">> & ResolvedCompilerOptions & {
-  logger: Logger;
-  build: false | ServerBuildOption;
-};
-//#endregion
-//#region src/core/mockMiddleware.d.ts
-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$1 = SetupMiddlewaresFn extends ((middlewares: any, devServer: infer T) => void) ? T : never;
-//#endregion
-//#region src/core/mockWebsocket.d.ts
-interface MockSocketOptions {
-  wsProxies: (string | ((pathname: string, req: any) => boolean))[];
-  cookiesOptions: MockServerPluginOptions["cookiesOptions"];
-  logger: Logger;
-}
-declare function mockWebSocket(compiler: MockCompiler, httpServer: Server | Http2SecureServer, {
-  wsProxies: proxies,
-  cookiesOptions,
-  logger
-}: MockSocketOptions): void;
-//#endregion
-export { Logger, Middleware, MiddlewareOptions, MockCompiler, MockCompilerOptions, MockSocketOptions, ResolvePluginOptions, Server$1 as Server, createLogger, createMockCompiler, createMockMiddleware, logLevels, mockWebSocket };

package/dist/resolvePluginOptions-Da5uqlBx.cjs

@@ -1,506 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_logger = require('./logger-C0V8Cvvd.cjs');
-const __pengzhanbo_utils = require_chunk.__toESM(require("@pengzhanbo/utils"));
-const node_events = require_chunk.__toESM(require("node:events"));
-const node_path = require_chunk.__toESM(require("node:path"));
-const node_process = require_chunk.__toESM(require("node:process"));
-const __rollup_pluginutils = require_chunk.__toESM(require("@rollup/pluginutils"));
-const chokidar = require_chunk.__toESM(require("chokidar"));
-const fast_glob = require_chunk.__toESM(require("fast-glob"));
-const node_fs = require_chunk.__toESM(require("node:fs"));
-const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
-const picocolors = require_chunk.__toESM(require("picocolors"));
-const node_module = require_chunk.__toESM(require("node:module"));
-const __rspack_core = require_chunk.__toESM(require("@rspack/core"));
-const is_core_module = require_chunk.__toESM(require("is-core-module"));
-const node_url = require_chunk.__toESM(require("node:url"));
-const path_to_regexp = require_chunk.__toESM(require("path-to-regexp"));
-const cors = require_chunk.__toESM(require("cors"));
-
-//#region src/core/createRspackCompiler.ts
-const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-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(picocolors.default.red(name), ...args);
-		};
-		if (err) {
-			logError(err.stack || err);
-			if ("details" in err) logError(err.details);
-			return;
-		}
-		if (stats?.hasErrors()) {
-			const info = stats.toJson();
-			logError(info.errors);
-		}
-		const code = require_logger.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: name$1 } of modules) if (name$1?.startsWith("external")) {
-				const packageName = normalizePackageName(name$1);
-				if (!(0, is_core_module.default)(packageName) && !aliasList.includes(packageName)) externals.push(normalizePackageName(name$1));
-			}
-		}
-		await callback({
-			code,
-			externals
-		});
-	}
-	const compiler = __rspack_core.rspack(rspackOptions, isWatch ? handler : void 0);
-	if (compiler) compiler.outputFileSystem = require_logger.vfs;
-	if (!isWatch) compiler?.run(async (...args) => {
-		await handler(...args);
-		compiler.close(() => {});
-	});
-	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 >= 18.0.0"];
-	if (alias && "@swc/helpers" in alias) delete alias["@swc/helpers"];
-	return {
-		mode: "production",
-		context: cwd,
-		entry: entryFile,
-		watch,
-		target: "node18.0",
-		externalsType: isEsm ? "module" : "commonjs2",
-		resolve: {
-			alias,
-			extensions: [
-				".js",
-				".ts",
-				".cjs",
-				".mjs",
-				".json5",
-				".json"
-			]
-		},
-		plugins,
-		output: {
-			library: { type: !isEsm ? "commonjs2" : "module" },
-			filename: "output.js",
-			path: "/"
-		},
-		experiments: { outputModule: isEsm },
-		optimization: { minimize: !watch },
-		module: { rules: [
-			{
-				test: /\.json5?$/,
-				loader: require$1.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/core/build.ts
-async function buildMockServer(options, outputDir) {
-	const entryFile = node_path.default.resolve(node_process.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
-	const mockFileList = await getMockFileList(options);
-	await writeMockEntryFile(entryFile, mockFileList, options.cwd);
-	const { code, externals } = await transformWithRspack({
-		entryFile,
-		cwd: options.cwd,
-		plugins: options.plugins,
-		alias: options.alias
-	});
-	await node_fs_promises.default.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 = node_path.default.resolve(outputDir, options.build.dist);
-	options.logger.info(`${picocolors.default.green("✓")} generate mock server in ${picocolors.default.cyan(node_path.default.relative(node_process.default.cwd(), dist))}`);
-	if (!node_fs.default.existsSync(dist)) await node_fs_promises.default.mkdir(dist, { recursive: true });
-	for (const { filename, source } of outputList) {
-		await node_fs_promises.default.writeFile(node_path.default.join(dist, filename), source, "utf8");
-		const sourceSize = (source.length / 1024).toFixed(2);
-		const space = filename.length < 24 ? " ".repeat(24 - filename.length) : "";
-		options.logger.info(` ${picocolors.default.green(filename)}${space}${picocolors.default.bold(picocolors.default.dim(`${sourceSize} kB`))}`);
-	}
-}
-function generatePackageJson(options, externals) {
-	const deps = getHostDependencies(options.cwd);
-	const { name, version } = getPluginPackageInfo();
-	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);
-}
-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,
-  transformMockData,
-  transformRawData
-} 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((0, __pengzhanbo_utils.toArray)(wsPrefix))};
-const cookiesOptions = ${JSON.stringify(cookiesOptions)};
-const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
-const priority = ${JSON.stringify(priority)};
-const mockConfig = { 
-  mockData: transformMockData(transformRawData(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}');
-`;
-}
-async function getMockFileList({ cwd, include, exclude }) {
-	const filter = (0, __rollup_pluginutils.createFilter)(include, exclude, { resolve: false });
-	return await (0, fast_glob.default)(include, { cwd }).then((files) => files.filter(filter));
-}
-async function writeMockEntryFile(entryFile, files, cwd) {
-	const importers = [];
-	const exporters = [];
-	for (const [index, filepath] of files.entries()) {
-		const file = require_logger.normalizePath(node_path.default.join(cwd, filepath));
-		importers.push(`import * as m${index} from '${file}'`);
-		exporters.push(`[m${index}, '${filepath}']`);
-	}
-	const code = `${importers.join("\n")}\n\nexport default [\n  ${exporters.join(",\n  ")}\n]`;
-	const dirname = node_path.default.dirname(entryFile);
-	if (!node_fs.default.existsSync(dirname)) await node_fs_promises.default.mkdir(dirname, { recursive: true });
-	await node_fs_promises.default.writeFile(entryFile, code, "utf8");
-}
-function getPluginPackageInfo() {
-	let pkg = {};
-	try {
-		const filepath = node_path.default.join(require_logger.packageDir, "../package.json");
-		if (node_fs.default.existsSync(filepath)) pkg = JSON.parse(node_fs.default.readFileSync(filepath, "utf8"));
-	} catch {}
-	return {
-		name: pkg.name || "rspack-plugin-mock",
-		version: pkg.version || "latest"
-	};
-}
-function getHostDependencies(context) {
-	let pkg = {};
-	try {
-		const content = require_logger.lookupFile(context, ["package.json"]);
-		if (content) pkg = JSON.parse(content);
-	} catch {}
-	return {
-		...pkg.dependencies,
-		...pkg.devDependencies
-	};
-}
-
-//#endregion
-//#region src/core/loadFromCode.ts
-async function loadFromCode({ filepath, code, isESM, cwd }) {
-	filepath = node_path.default.resolve(cwd, filepath);
-	const ext = isESM ? ".mjs" : ".cjs";
-	const filepathTmp = `${filepath}.timestamp-${Date.now()}${ext}`;
-	const file = (0, node_url.pathToFileURL)(filepathTmp).toString();
-	await node_fs.promises.writeFile(filepathTmp, code, "utf8");
-	try {
-		const mod = await import(file);
-		return mod.default || mod;
-	} finally {
-		try {
-			node_fs.default.unlinkSync(filepathTmp);
-		} catch {}
-	}
-}
-
-//#endregion
-//#region src/core/mockCompiler.ts
-function createMockCompiler(options) {
-	return new MockCompiler(options);
-}
-var MockCompiler = class extends node_events.default {
-	cwd;
-	mockWatcher;
-	moduleType = "cjs";
-	entryFile;
-	_mockData = {};
-	fileFilter;
-	watchInfo;
-	compiler;
-	constructor(options) {
-		super();
-		this.options = options;
-		this.cwd = options.cwd || node_process.default.cwd();
-		const { include, exclude } = this.options;
-		this.fileFilter = (0, __rollup_pluginutils.createFilter)(include, exclude, { resolve: false });
-		try {
-			const pkg = require_logger.lookupFile(this.cwd, ["package.json"]);
-			this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
-		} catch {}
-		this.entryFile = node_path.default.resolve(node_process.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
-	}
-	get mockData() {
-		return this._mockData;
-	}
-	async run() {
-		await this.updateMockEntry();
-		this.watchMockFiles();
-		const { plugins, alias } = this.options;
-		const options = {
-			isEsm: this.moduleType === "esm",
-			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.moduleType === "esm",
-					cwd: this.cwd
-				});
-				this._mockData = require_logger.transformMockData(require_logger.transformRawData(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() {
-		const files = await this.getMockFiles();
-		await writeMockEntryFile(this.entryFile, files, this.cwd);
-	}
-	async getMockFiles() {
-		const { include } = this.options;
-		const files = await (0, fast_glob.default)(include, { cwd: this.cwd });
-		return files.filter(this.fileFilter);
-	}
-	watchMockFiles() {
-		const { include } = this.options;
-		const [firstGlob, ...otherGlob] = (0, __pengzhanbo_utils.toArray)(include);
-		const watcher = this.mockWatcher = chokidar.default.watch(firstGlob, {
-			ignoreInitial: true,
-			cwd: this.cwd
-		});
-		if (otherGlob.length > 0) otherGlob.forEach((glob) => watcher.add(glob));
-		watcher.on("add", (filepath) => {
-			if (this.fileFilter(filepath)) {
-				this.watchInfo = {
-					filepath,
-					type: "add"
-				};
-				this.updateMockEntry();
-			}
-		});
-		watcher.on("change", (filepath) => {
-			if (this.fileFilter(filepath)) this.watchInfo = {
-				filepath,
-				type: "change"
-			};
-		});
-		watcher.on("unlink", async (filepath) => {
-			this.watchInfo = {
-				filepath,
-				type: "unlink"
-			};
-			this.updateMockEntry();
-		});
-	}
-};
-
-//#endregion
-//#region src/core/mockMiddleware.ts
-function createMockMiddleware(compiler, options) {
-	return function mockMiddleware(middlewares, reload) {
-		middlewares.unshift(require_logger.baseMiddleware(compiler, options));
-		const corsMiddleware = createCorsMiddleware(compiler, options);
-		if (corsMiddleware) middlewares.unshift(corsMiddleware);
-		if (options.reload) compiler.on("update", () => reload?.());
-		return middlewares;
-	};
-}
-function createCorsMiddleware(compiler, options) {
-	let corsOptions = {};
-	const enabled = options.cors !== false;
-	if (enabled) corsOptions = {
-		...corsOptions,
-		...typeof options.cors === "boolean" ? {} : options.cors
-	};
-	const proxies = options.proxies;
-	return !enabled ? void 0 : function(req, res, next) {
-		const { pathname } = require_logger.urlParse(req.url);
-		if (!pathname || proxies.length === 0 || !proxies.some((context) => require_logger.doesProxyContextMatchUrl(context, req.url, req))) return next();
-		const mockData = compiler.mockData;
-		const mockUrl = Object.keys(mockData).find((key) => (0, path_to_regexp.pathToRegexp)(key).test(pathname));
-		if (!mockUrl) return next();
-		(0, cors.default)(corsOptions)(req, res, next);
-	};
-}
-
-//#endregion
-//#region src/core/resolvePluginOptions.ts
-function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"], exclude = [
-	"**/node_modules/**",
-	"**/.vscode/**",
-	"**/.git/**"
-], reload = false, log = "info", cors: cors$2 = true, formidableOptions = {}, build = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {} }, { alias, context, plugins, proxies }) {
-	const logger = require_logger.createLogger("rspack:mock", (0, __pengzhanbo_utils.isBoolean)(log) ? log ? "info" : "error" : log);
-	prefix = (0, __pengzhanbo_utils.toArray)(prefix);
-	return {
-		prefix,
-		wsPrefix,
-		cwd: cwd || context || node_process.default.cwd(),
-		include,
-		exclude,
-		reload,
-		cors: cors$2,
-		cookiesOptions,
-		log,
-		formidableOptions: {
-			multiples: true,
-			...formidableOptions
-		},
-		bodyParserOptions,
-		priority,
-		build: build ? Object.assign({
-			serverPort: 8080,
-			dist: "mockServer",
-			log: "error"
-		}, typeof build === "object" ? build : {}) : false,
-		alias,
-		plugins,
-		proxies: [...proxies, ...prefix],
-		wsProxies: (0, __pengzhanbo_utils.toArray)(wsPrefix),
-		logger
-	};
-}
-
-//#endregion
-Object.defineProperty(exports, 'MockCompiler', {
-  enumerable: true,
-  get: function () {
-    return MockCompiler;
-  }
-});
-Object.defineProperty(exports, 'buildMockServer', {
-  enumerable: true,
-  get: function () {
-    return buildMockServer;
-  }
-});
-Object.defineProperty(exports, 'createMockCompiler', {
-  enumerable: true,
-  get: function () {
-    return createMockCompiler;
-  }
-});
-Object.defineProperty(exports, 'createMockMiddleware', {
-  enumerable: true,
-  get: function () {
-    return createMockMiddleware;
-  }
-});
-Object.defineProperty(exports, 'resolvePluginOptions', {
-  enumerable: true,
-  get: function () {
-    return resolvePluginOptions;
-  }
-});