@kubb/core 5.0.0-beta.15 → 5.0.0-beta.17

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-C1OsqGBJ.cjs");
+const require_PluginDriver = require("./PluginDriver-C5hyNJfM.cjs");
 let node_events = require("node:events");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
@@ -525,7 +525,7 @@ function createAdapter(build) {
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.15";
+var version = "5.0.0-beta.17";
 //#endregion
 //#region src/createStorage.ts
 /**
@@ -564,133 +564,6 @@ function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node = class {
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node(value);
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-		this.#size++;
-	}
-	dequeue() {
-		const current = this.#head;
-		if (!current) return;
-		this.#head = this.#head.next;
-		this.#size--;
-		if (!this.#head) this.#tail = void 0;
-		return current.value;
-	}
-	peek() {
-		if (!this.#head) return;
-		return this.#head.value;
-	}
-	clear() {
-		this.#head = void 0;
-		this.#tail = void 0;
-		this.#size = 0;
-	}
-	get size() {
-		return this.#size;
-	}
-	*[Symbol.iterator]() {
-		let current = this.#head;
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
-	let rejectOnClear = false;
-	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
-	validateConcurrency(concurrency);
-	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve, reject, arguments_) => {
-		const queueItem = { reject };
-		new Promise((internalResolve) => {
-			queueItem.run = internalResolve;
-			queue.enqueue(queueItem);
-		}).then(run.bind(void 0, function_, resolve, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			if (!rejectOnClear) {
-				queue.clear();
-				return;
-			}
-			const abortError = AbortSignal.abort().reason;
-			while (queue.size > 0) queue.dequeue().reject(abortError);
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-//#endregion
 //#region src/FileProcessor.ts
 function joinSources(file) {
 	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).join("\n\n");
@@ -703,7 +576,6 @@ function joinSources(file) {
 */
 var FileProcessor = class {
 	events = new AsyncEventEmitter();
-	#limit = pLimit(16);
 	async parse(file, { parsers, extension } = {}) {
 		const parseExtName = extension?.[file.extname] || void 0;
 		if (!parsers || !file.extname) return joinSources(file);
@@ -711,27 +583,37 @@ var FileProcessor = class {
 		if (!parser) return joinSources(file);
 		return parser.parse(file, { extname: parseExtName });
 	}
-	async run(files, { parsers, mode = "sequential", extension } = {}) {
-		await this.events.emit("start", files);
+	/**
+	* Streams parsed files one at a time as each is processed.
+	*
+	* Unlike `run()`, files are yielded immediately after parsing rather than batched.
+	* Storage writes can begin as soon as the first file is ready, keeping peak
+	* memory proportional to one file at a time instead of the full batch.
+	*/
+	async *stream(files, options = {}) {
 		const total = files.length;
 		let processed = 0;
-		const processOne = async (file) => {
-			const source = await this.parse(file, {
-				extension,
-				parsers
-			});
-			const currentProcessed = ++processed;
-			const percentage = currentProcessed / total * 100;
-			await this.events.emit("update", {
+		for (const file of files) {
+			const source = await this.parse(file, options);
+			processed++;
+			yield {
 				file,
 				source,
-				processed: currentProcessed,
-				percentage,
-				total
-			});
-		};
-		if (mode === "sequential") for (const file of files) await processOne(file);
-		else await Promise.all(files.map((file) => this.#limit(() => processOne(file))));
+				processed,
+				total,
+				percentage: processed / total * 100
+			};
+		}
+	}
+	async run(files, options = {}) {
+		await this.events.emit("start", files);
+		for await (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+			file,
+			source,
+			processed,
+			percentage,
+			total
+		});
 		await this.events.emit("end", files);
 		return files;
 	}
@@ -927,15 +809,40 @@ async function setup(userConfig, options = {}) {
 			logs: [`Running adapter: ${config.adapter.name}`]
 		});
 		driver.adapter = config.adapter;
-		driver.inputNode = await config.adapter.parse(source);
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [
-				`✓ Adapter '${config.adapter.name}' resolved InputNode`,
-				`  • Schemas: ${driver.inputNode.schemas.length}`,
-				`  • Operations: ${driver.inputNode.operations.length}`
-			]
-		});
+		if (config.adapter.count && config.adapter.stream) {
+			const { schemas: schemaCount, operations: operationCount } = await config.adapter.count(source);
+			if (schemaCount > 100) {
+				driver.inputStreamNode = await config.adapter.stream(source);
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [
+						`✓ Adapter '${config.adapter.name}' streaming InputStreamNode`,
+						`  • Schemas: ${schemaCount} (threshold: 100)`,
+						`  • Operations: ${operationCount}`
+					]
+				});
+			} else {
+				driver.inputNode = await config.adapter.parse(source);
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [
+						`✓ Adapter '${config.adapter.name}' resolved InputNode`,
+						`  • Schemas: ${driver.inputNode.schemas.length}`,
+						`  • Operations: ${driver.inputNode.operations.length}`
+					]
+				});
+			}
+		} else {
+			driver.inputNode = await config.adapter.parse(source);
+			await hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [
+					`✓ Adapter '${config.adapter.name}' resolved InputNode`,
+					`  • Schemas: ${driver.inputNode.schemas.length}`,
+					`  • Operations: ${driver.inputNode.operations.length}`
+				]
+			});
+		}
 	}
 	return {
 		config,
@@ -949,15 +856,134 @@ async function setup(userConfig, options = {}) {
 	};
 }
 /**
-* Walks the AST and dispatches nodes to a plugin's direct AST hooks
-* (`schema`, `operation`, `operations`).
+* Single-pass fan-out for streaming mode.
+*
+* Iterates `inputStreamNode.schemas` and `.operations` exactly once, distributing each
+* node to every plugin in parallel. This replaces the N-pass-per-plugin pattern (where
+* each plugin got its own `for await` iterator) with a single parse pass fanned to all
+* plugins — eliminating the N×parse-time overhead for multi-plugin builds.
 *
-* When `include` contains only operation-scoped filters (`tag`, `operationId`, `path`,
-* `method`, `contentType`) and no `schemaName` filter, the function pre-computes the set
-* of top-level schema names transitively reachable from the included operations and skips
-* schemas that fall outside that set. This ensures that component schemas referenced
-* exclusively by excluded operations are not generated.
+* Each plugin still gets independent `plugin:start` / `plugin:end` events and its own
+* timing, but the schema and operation nodes are parsed only once total.
 */
+async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, config, pluginTimings, failedPlugins, flushPendingFiles) {
+	function resolveRendererFor(gen, state) {
+		return gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
+	}
+	const states = entries.map(({ plugin, context, hrStart }) => ({
+		plugin,
+		generatorContext: {
+			...context,
+			resolver: driver.getResolver(plugin.name)
+		},
+		generators: plugin.generators ?? [],
+		hrStart,
+		failed: false,
+		error: void 0
+	}));
+	let schemasProcessed = 0;
+	for await (const node of inputStreamNode.schemas) {
+		for (const state of states) {
+			if (state.failed) continue;
+			try {
+				const { plugin, generatorContext, generators } = state;
+				const { exclude, include, override } = plugin.options;
+				const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+				const options = generatorContext.resolver.resolveOptions(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) continue;
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.schema) continue;
+					await require_PluginDriver.applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRendererFor(gen, state));
+				}
+				await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		}
+		schemasProcessed++;
+		if (schemasProcessed % 50 === 0) await flushPendingFiles();
+	}
+	const collectedOperations = [];
+	for await (const node of inputStreamNode.operations) {
+		collectedOperations.push(node);
+		for (const state of states) {
+			if (state.failed) continue;
+			try {
+				const { plugin, generatorContext, generators } = state;
+				const { exclude, include, override } = plugin.options;
+				const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+				const options = generatorContext.resolver.resolveOptions(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) continue;
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.operation) continue;
+					await require_PluginDriver.applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRendererFor(gen, state));
+				}
+				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		}
+	}
+	for (const state of states) {
+		if (!state.failed) try {
+			const { plugin, generatorContext, generators } = state;
+			const ctx = {
+				...generatorContext,
+				options: plugin.options
+			};
+			for (const gen of generators) {
+				if (!gen.operations) continue;
+				await require_PluginDriver.applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRendererFor(gen, state));
+			}
+			await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+		} catch (caughtError) {
+			state.failed = true;
+			state.error = caughtError;
+		}
+		const duration = getElapsedMs(state.hrStart);
+		pluginTimings.set(state.plugin.name, duration);
+		await hooks.emit("kubb:plugin:end", {
+			plugin: state.plugin,
+			duration,
+			success: !state.failed,
+			...state.failed && state.error ? { error: state.error } : {},
+			config,
+			get files() {
+				return driver.fileManager.files;
+			},
+			upsertFile: (...files) => driver.fileManager.upsert(...files)
+		});
+		if (state.failed && state.error) failedPlugins.add({
+			plugin: state.plugin,
+			error: state.error
+		});
+		await hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
+		});
+	}
+	await flushPendingFiles();
+}
 async function runPluginAstHooks(plugin, context) {
 	const { adapter, inputNode, resolver, driver } = context;
 	const { exclude, include, override } = plugin.options;
@@ -1046,54 +1072,90 @@ async function safeBuild(setupResult) {
 	const parsersMap = /* @__PURE__ */ new Map();
 	for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
 	const fileProcessor = new FileProcessor();
-	fileProcessor.events.on("start", async (processingFiles) => {
-		await hooks.emit("kubb:files:processing:start", { files: processingFiles });
-	});
-	fileProcessor.events.on("update", async ({ file, source, processed, total, percentage }) => {
-		await hooks.emit("kubb:file:processing:update", {
-			file,
-			source,
-			processed,
-			total,
-			percentage,
-			config
-		});
-		if (source) await storage.setItem(file.path, source);
-	});
-	fileProcessor.events.on("end", async (processed) => {
-		await hooks.emit("kubb:files:processing:end", { files: processed });
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`✓ File write process completed for ${processed.length} files`]
-		});
-	});
-	async function flushPendingFiles() {
-		const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
+	async function flushPendingFiles(snapshot) {
+		const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path) && (!snapshot || !snapshot.has(f.path)));
 		if (files.length === 0) return;
 		await hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [`Writing ${files.length} files...`]
 		});
-		await fileProcessor.run(files, {
+		await hooks.emit("kubb:files:processing:start", { files });
+		const stream = fileProcessor.stream(files, {
 			parsers: parsersMap,
-			mode: "parallel",
 			extension: config.output.extension
 		});
-		for (const file of files) writtenPaths.add(file.path);
+		for await (const { file, source, processed, total, percentage } of stream) {
+			await hooks.emit("kubb:file:processing:update", {
+				file,
+				source,
+				processed,
+				total,
+				percentage,
+				config
+			});
+			if (source) await storage.setItem(file.path, source);
+			writtenPaths.add(file.path);
+		}
+		await hooks.emit("kubb:files:processing:end", { files });
+		await hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`✓ File write process completed for ${files.length} files`]
+		});
 	}
 	try {
 		await driver.emitSetupHooks();
-		if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
+		if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
 			config,
 			adapter: driver.adapter,
-			inputNode: driver.inputNode,
+			inputNode: driver.inputNode ?? {
+				kind: "Input",
+				schemas: [],
+				operations: [],
+				meta: driver.inputStreamNode?.meta
+			},
 			getPlugin: driver.getPlugin.bind(driver),
 			get files() {
 				return driver.fileManager.files;
 			},
 			upsertFile: (...files) => driver.fileManager.upsert(...files)
 		});
-		for (const plugin of driver.plugins.values()) {
+		const inputStreamNode = driver.inputStreamNode;
+		if (inputStreamNode) {
+			const streamPluginEntries = [];
+			for (const plugin of driver.plugins.values()) {
+				const context = driver.getContext(plugin);
+				const hrStart = process.hrtime();
+				await hooks.emit("kubb:plugin:start", { plugin });
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
+				});
+				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) streamPluginEntries.push({
+					plugin,
+					context,
+					hrStart
+				});
+				else {
+					const duration = getElapsedMs(hrStart);
+					pluginTimings.set(plugin.name, duration);
+					await hooks.emit("kubb:plugin:end", {
+						plugin,
+						duration,
+						success: true,
+						config,
+						get files() {
+							return driver.fileManager.files;
+						},
+						upsertFile: (...files) => driver.fileManager.upsert(...files)
+					});
+					await hooks.emit("kubb:debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
+					});
+				}
+			}
+			if (streamPluginEntries.length > 0) await runPluginStreamHooks(inputStreamNode, streamPluginEntries, driver, hooks, config, pluginTimings, failedPlugins, flushPendingFiles);
+		} else for (const plugin of driver.plugins.values()) {
 			const context = driver.getContext(plugin);
 			const hrStart = process.hrtime();
 			try {
@@ -1150,6 +1212,7 @@ async function safeBuild(setupResult) {
 					error
 				});
 			}
+			await flushPendingFiles();
 		}
 		await hooks.emit("kubb:plugins:end", {
 			config,