@kubb/core 5.0.0-beta.18 → 5.0.0-beta.19

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-Bc-k8EUQ.cjs");
+const require_PluginDriver = require("./PluginDriver-DXp767s2.cjs");
 let node_events = require("node:events");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
@@ -69,9 +69,12 @@ var AsyncEventEmitter = class {
 	* await emitter.emit('build', 'petstore')
 	* ```
 	*/
-	async emit(eventName, ...eventArgs) {
+	emit(eventName, ...eventArgs) {
 		const listeners = this.#emitter.listeners(eventName);
 		if (listeners.length === 0) return;
+		return this.#emitAll(eventName, listeners, eventArgs);
+	}
+	async #emitAll(eventName, listeners, eventArgs) {
 		for (const listener of listeners) try {
 			await listener(...eventArgs);
 		} catch (err) {
@@ -245,6 +248,19 @@ async function clean(path) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+/** Returns `true` when `result` is a thenable `Promise`.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve(1)) // true
+* isPromise(42)                 // false
+* ```
+*/
+function isPromise(result) {
+	return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -525,7 +541,7 @@ function createAdapter(build) {
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.18";
+var version = "5.0.0-beta.19";
 //#endregion
 //#region src/createStorage.ts
 /**
@@ -566,7 +582,14 @@ function createStorage(build) {
 //#endregion
 //#region src/FileProcessor.ts
 function joinSources(file) {
-	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).join("\n\n");
+	const sources = file.sources;
+	if (sources.length === 0) return "";
+	const parts = [];
+	for (const source of sources) {
+		const s = (0, _kubb_ast.extractStringsFromNodes)(source.nodes);
+		if (s) parts.push(s);
+	}
+	return parts.join("\n\n");
 }
 /**
 * Converts a single file to a string using the registered parsers.
@@ -576,25 +599,19 @@ function joinSources(file) {
 */
 var FileProcessor = class {
 	events = new AsyncEventEmitter();
-	async parse(file, { parsers, extension } = {}) {
+	parse(file, { parsers, extension } = {}) {
 		const parseExtName = extension?.[file.extname] || void 0;
 		if (!parsers || !file.extname) return joinSources(file);
 		const parser = parsers.get(file.extname);
 		if (!parser) return joinSources(file);
 		return parser.parse(file, { extname: parseExtName });
 	}
-	/**
-	* 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 = {}) {
+	*stream(files, options = {}) {
 		const total = files.length;
+		if (total === 0) return;
 		let processed = 0;
 		for (const file of files) {
-			const source = await this.parse(file, options);
+			const source = this.parse(file, options);
 			processed++;
 			yield {
 				file,
@@ -607,7 +624,7 @@ var FileProcessor = class {
 	}
 	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", {
+		for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
 			file,
 			source,
 			processed,
@@ -881,18 +898,9 @@ async function setup(userConfig, options = {}) {
 						`  • 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 {
+		}
+		if (!driver.inputStreamNode) {
 			driver.inputNode = await config.adapter.parse(source);
 			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
@@ -928,84 +936,101 @@ async function setup(userConfig, options = {}) {
 * 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) {
+async function runPluginStreamHooks({ entries, driver, pluginTimings, failedPlugins }) {
+	const inputStreamNode = driver.inputStreamNode;
 	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
+	const states = entries.map(({ plugin, context, hrStart }) => {
+		const { exclude, include, override } = plugin.options;
+		const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+		const hasInclude = Array.isArray(include) && include.length > 0;
+		const hasOverride = Array.isArray(override) && override.length > 0;
+		return {
+			plugin,
+			generatorContext: {
+				...context,
+				resolver: driver.getResolver(plugin.name)
+			},
+			generators: plugin.generators ?? [],
+			hrStart,
+			failed: false,
+			error: void 0,
+			optionsAreStatic: !hasExclude && !hasInclude && !hasOverride
+		};
+	});
+	async function dispatchSchema(state, node) {
+		if (state.failed) return;
+		try {
+			const { plugin, generatorContext, generators } = state;
+			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+			const { exclude, include, override } = plugin.options;
+			const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+				options: plugin.options,
+				exclude,
+				include,
+				override
+			});
+			if (options === null) return;
+			const ctx = {
+				...generatorContext,
+				options
+			};
+			for (const gen of generators) {
+				if (!gen.schema) continue;
+				const raw = gen.schema(transformedNode, ctx);
+				const applied = require_PluginDriver.applyHookResult({
+					result: isPromise(raw) ? await raw : raw,
+					driver,
+					rendererFactory: resolveRendererFor(gen, state)
 				});
-				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;
+				if (isPromise(applied)) await applied;
 			}
+			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
+	async function dispatchOperation(state, node) {
+		if (state.failed) return;
+		try {
+			const { plugin, generatorContext, generators } = state;
+			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+			const { exclude, include, override } = plugin.options;
+			const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+				options: plugin.options,
+				exclude,
+				include,
+				override
+			});
+			if (options === null) return;
+			const ctx = {
+				...generatorContext,
+				options
+			};
+			for (const gen of generators) {
+				if (!gen.operation) continue;
+				const raw = gen.operation(transformedNode, ctx);
+				const applied = require_PluginDriver.applyHookResult({
+					result: isPromise(raw) ? await raw : raw,
+					driver,
+					rendererFactory: resolveRendererFor(gen, state)
 				});
-				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;
+				if (isPromise(applied)) await applied;
 			}
+			await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+		} catch (caughtError) {
+			state.failed = true;
+			state.error = caughtError;
 		}
 	}
+	for await (const node of inputStreamNode.schemas) await Promise.all(states.map((state) => dispatchSchema(state, node)));
+	const collectedOperations = [];
+	for await (const node of inputStreamNode.operations) {
+		collectedOperations.push(node);
+		await Promise.all(states.map((state) => dispatchOperation(state, node)));
+	}
 	for (const state of states) {
 		if (!state.failed) try {
 			const { plugin, generatorContext, generators } = state;
@@ -1015,7 +1040,11 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
 			};
 			for (const gen of generators) {
 				if (!gen.operations) continue;
-				await require_PluginDriver.applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRendererFor(gen, state));
+				await require_PluginDriver.applyHookResult({
+					result: await gen.operations(collectedOperations, ctx),
+					driver,
+					rendererFactory: resolveRendererFor(gen, state)
+				});
 			}
 			await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
 		} catch (caughtError) {
@@ -1024,12 +1053,12 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
 		}
 		const duration = getElapsedMs(state.hrStart);
 		pluginTimings.set(state.plugin.name, duration);
-		await hooks.emit("kubb:plugin:end", {
+		await driver.hooks.emit("kubb:plugin:end", {
 			plugin: state.plugin,
 			duration,
 			success: !state.failed,
 			...state.failed && state.error ? { error: state.error } : {},
-			config,
+			config: driver.config,
 			get files() {
 				return driver.fileManager.files;
 			},
@@ -1039,13 +1068,22 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
 			plugin: state.plugin,
 			error: state.error
 		});
-		await hooks.emit("kubb:debug", {
+		await driver.hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
 		});
 	}
-	await flushPendingFiles();
 }
+/**
+* Walks the AST and dispatches nodes to a plugin's direct AST hooks
+* (`schema`, `operation`, `operations`).
+*
+* 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.
+*/
 async function runPluginAstHooks(plugin, context) {
 	const { adapter, inputNode, resolver, driver } = context;
 	const { exclude, include, override } = plugin.options;
@@ -1068,13 +1106,15 @@ async function runPluginAstHooks(plugin, context) {
 	]);
 	const hasOperationBasedIncludes = include?.some(({ type }) => operationFilterTypes.has(type)) ?? false;
 	const hasSchemaNameIncludes = include?.some(({ type }) => type === "schemaName") ?? false;
-	let allowedSchemaNames;
-	if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-		options: plugin.options,
-		exclude,
-		include,
-		override
-	}) !== null), inputNode.schemas);
+	const allowedSchemaNames = (() => {
+		if (!hasOperationBasedIncludes || hasSchemaNameIncludes) return void 0;
+		return (0, _kubb_ast.collectUsedSchemaNames)(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
+			options: plugin.options,
+			exclude,
+			include,
+			override
+		}) !== null), inputNode.schemas);
+	})();
 	await (0, _kubb_ast.walk)(inputNode, {
 		depth: "shallow",
 		async schema(node) {
@@ -1092,7 +1132,11 @@ async function runPluginAstHooks(plugin, context) {
 				options
 			};
 			await Promise.all(generators.filter((gen) => gen.schema).map(async (gen) => {
-				return require_PluginDriver.applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
+				return require_PluginDriver.applyHookResult({
+					result: await gen.schema(transformedNode, ctx),
+					driver,
+					rendererFactory: resolveRenderer(gen)
+				});
 			}));
 			await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
 		},
@@ -1104,17 +1148,20 @@ async function runPluginAstHooks(plugin, context) {
 				include,
 				override
 			});
-			if (options !== null) {
-				collectedOperations.push(transformedNode);
-				const ctx = {
-					...generatorContext,
-					options
-				};
-				await Promise.all(generators.filter((gen) => gen.operation).map(async (gen) => {
-					return require_PluginDriver.applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
-				}));
-				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-			}
+			if (options === null) return;
+			collectedOperations.push(transformedNode);
+			const ctx = {
+				...generatorContext,
+				options
+			};
+			await Promise.all(generators.filter((gen) => gen.operation).map(async (gen) => {
+				return require_PluginDriver.applyHookResult({
+					result: await gen.operation(transformedNode, ctx),
+					driver,
+					rendererFactory: resolveRenderer(gen)
+				});
+			}));
+			await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
 		}
 	});
 	if (collectedOperations.length > 0) {
@@ -1124,7 +1171,11 @@ async function runPluginAstHooks(plugin, context) {
 		};
 		for (const gen of generators) {
 			if (!gen.operations) continue;
-			await require_PluginDriver.applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+			await require_PluginDriver.applyHookResult({
+				result: await gen.operations(collectedOperations, ctx),
+				driver,
+				rendererFactory: resolveRenderer(gen)
+			});
 		}
 		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
 	}
@@ -1141,8 +1192,8 @@ 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();
-		async function flushPendingFiles(snapshot) {
-			const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path) && (!snapshot || !snapshot.has(f.path)));
+		async function flushPendingFiles() {
+			const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
 			if (files.length === 0) return;
 			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
@@ -1153,7 +1204,7 @@ async function safeBuild(setupResult) {
 				parsers: parsersMap,
 				extension: config.output.extension
 			});
-			for await (const { file, source, processed, total, percentage } of stream) {
+			for (const { file, source, processed, total, percentage } of stream) {
 				await hooks.emit("kubb:file:processing:update", {
 					file,
 					source,
@@ -1188,8 +1239,7 @@ async function safeBuild(setupResult) {
 				},
 				upsertFile: (...files) => driver.fileManager.upsert(...files)
 			});
-			const inputStreamNode = driver.inputStreamNode;
-			if (inputStreamNode) {
+			if (driver.inputStreamNode) {
 				const streamPluginEntries = [];
 				for (const plugin of driver.plugins.values()) {
 					const context = driver.getContext(plugin);
@@ -1199,31 +1249,40 @@ async function safeBuild(setupResult) {
 						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", {
+					if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) {
+						streamPluginEntries.push({
 							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)})`]
+							context,
+							hrStart
 						});
+						continue;
 					}
+					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({
+						entries: streamPluginEntries,
+						driver,
+						pluginTimings,
+						failedPlugins
+					});
+					await flushPendingFiles();
 				}
-				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();