@kubb/core 5.0.0-beta.102 → 5.0.0-beta.104

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_usingCtx = require("./usingCtx-CZyLSqds.cjs");
+const require_usingCtx = require("./usingCtx-BYOZEkiy.cjs");
 let node_async_hooks = require("node:async_hooks");
 let node_util = require("node:util");
 let node_crypto = require("node:crypto");
@@ -151,7 +151,7 @@ function randomCliColor(text) {
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.102";
+var version = "5.0.0-beta.104";
 //#endregion
 //#region src/constants.ts
 /**
@@ -847,28 +847,24 @@ var Resolver = class Resolver {
 	* schemas (`targetName`) import the emitted name. Names and paths go through the top-level
 	* `name` and `file`, so import entries follow the plugin's conventions, and a per-call
 	* `name` override wins over both.
+	*
+	* The subtree scan runs through `collectImportedRefNames`, which memoizes by node identity, so a
+	* schema shared across the ts, zod, and faker plugins is walked once and every plugin's resolver
+	* reads the same ref set instead of re-scanning it per plugin.
 	*/
 	imports(options) {
 		const { node, root, output, group, extname = ".ts", name } = options;
 		const resolveName = name ?? ((schemaName) => this.name(schemaName));
-		const seen = /* @__PURE__ */ new Set();
-		return (0, _kubb_ast.collectSync)(node, { schema: (schemaNode) => {
-			const schemaRef = (0, _kubb_ast.narrowSchema)(schemaNode, "ref");
-			if (!schemaRef?.ref) return null;
-			const schemaName = (0, _kubb_ast.resolveRefName)(schemaRef);
-			if (!schemaName || seen.has(schemaName)) return null;
-			seen.add(schemaName);
-			return _kubb_ast.ast.factory.createImport({
-				name: [resolveName(schemaName)],
-				path: this.file({
-					name: schemaName,
-					extname,
-					root,
-					output,
-					group
-				}).path
-			});
-		} });
+		return (0, _kubb_ast.collectImportedRefNames)(node).map((schemaName) => _kubb_ast.ast.factory.createImport({
+			name: [resolveName(schemaName)],
+			path: this.file({
+				name: schemaName,
+				extname,
+				root,
+				output,
+				group
+			}).path
+		}));
 	}
 	/**
 	* Folds each `override` over `base`, left to right, and returns a new resolver with helpers
@@ -1483,6 +1479,7 @@ var KubbDriver = class {
 				updateBuffer.push(item);
 			},
 			end: async (files) => {
+				updateBuffer.sort((a, b) => a.processed - b.processed);
 				await hooks.callHook("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
 					...item,
 					config
@@ -1591,16 +1588,20 @@ var KubbDriver = class {
 		}));
 	}
 	/**
-	* Runs schemas and operations through every plugin's generators. Each node is run
-	* through the plugin's macros (from `this.#transforms`) before the generator sees it,
-	* so plugins stay isolated and the hot path stays per-node. Schemas run before operations
-	* so file output stays deterministic across runs.
-	* A failing plugin contributes an error diagnostic so the rest of the build continues.
-	* Every plugin also contributes a `timing` diagnostic.
+	* Runs schemas and operations through every plugin's generators. The walk is node-outer: each
+	* schema is visited once and each operation once, and the node fans out to the matching
+	* generators of every plugin in dependency order. A per-node cache (`createNodeCache`) is created
+	* once per node and shared by all of that node's plugins, so node-derived work is computed once
+	* and reused instead of recomputed per plugin. Each node still runs through the plugin's macros
+	* (from `this.#transforms`) and its exclude/include/override filters before that plugin's
+	* generator sees it, so plugins stay isolated. Schemas run before operations so file output
+	* stays deterministic across runs. A generator with a `match` predicate that resolves `false`
+	* for a node is skipped for that node, without calling `schema`/`operation`.
 	*
-	* Plugins are processed one at a time, in full, so `kubb:plugin:end` fires as each one
-	* completes rather than all at once at the end. That ordering drives the CLI's
-	* `Plugins N/M` counter.
+	* A failing plugin is dropped from the remaining walk, contributes an error diagnostic, and no
+	* longer aborts the other plugins. `kubb:plugin:end` and each plugin's `timing` diagnostic fire
+	* in dependency order once the walk finishes, driving the CLI's `Plugins N/M` counter. The
+	* `operations` batch fires once per plugin after the single operation walk.
 	*
 	* When `this.inputNode` is `null`, every entry still gets a `kubb:plugin:end` so
 	* post-plugin listeners (the barrel writer and friends) complete.
@@ -1638,105 +1639,133 @@ var KubbDriver = class {
 			}) !== null);
 			allowedSchemaNamesByPlugin.set(plugin.name, (0, _kubb_ast.collectUsedSchemaNames)(includedOps, schemas));
 		}
-		for (const { plugin, context, hrStart } of entries) {
+		const states = entries.map(({ plugin, context, hrStart }) => {
 			const generatorContext = {
 				...context,
 				resolver: this.getResolver(plugin.name)
 			};
 			const { exclude, include, override } = plugin.options;
-			const optionsAreStatic = !exclude?.length && !include?.length && !override?.length;
-			const allowedSchemaNames = allowedSchemaNamesByPlugin.get(plugin.name) ?? null;
 			const generators = plugin.generators ?? [];
-			const schemaGenerators = generators.filter((generator) => generator.schema);
-			const operationGenerators = generators.filter((generator) => generator.operation);
-			const operationsGenerators = generators.filter((generator) => generator.operations);
-			let error = null;
-			const resolveForPlugin = (node) => {
-				const transformedNode = transforms.applyTo(plugin.name, node);
-				if (optionsAreStatic) return {
-					transformedNode,
-					options: plugin.options
-				};
-				const options = generatorContext.resolver.default.options(transformedNode, {
-					options: plugin.options,
-					exclude,
-					include,
-					override
-				});
-				if (options === null) return null;
-				return {
-					transformedNode,
-					options
-				};
+			return {
+				plugin,
+				hrStart,
+				generatorContext,
+				exclude,
+				include,
+				override,
+				optionsAreStatic: !exclude?.length && !include?.length && !override?.length,
+				allowedSchemaNames: allowedSchemaNamesByPlugin.get(plugin.name) ?? null,
+				schemaGenerators: generators.filter((generator) => generator.schema),
+				operationGenerators: generators.filter((generator) => generator.operation),
+				operationsGenerators: generators.filter((generator) => generator.operations),
+				pluginOperations: [],
+				error: null
 			};
-			if (schemaGenerators.length) for (const node of schemas) {
-				if (error) break;
+		});
+		const resolveForPlugin = (state, node) => {
+			const transformedNode = transforms.applyTo(state.plugin.name, node);
+			if (state.optionsAreStatic) return {
+				transformedNode,
+				options: state.plugin.options
+			};
+			const options = state.generatorContext.resolver.default.options(transformedNode, {
+				options: state.plugin.options,
+				exclude: state.exclude,
+				include: state.include,
+				override: state.override
+			});
+			if (options === null) return null;
+			return {
+				transformedNode,
+				options
+			};
+		};
+		for (const node of schemas) {
+			const cache = require_usingCtx.createNodeCache();
+			for (const state of states) {
+				if (state.error || !state.schemaGenerators.length) continue;
 				try {
-					const resolved = resolveForPlugin(node);
+					const resolved = resolveForPlugin(state, node);
 					if (!resolved) continue;
 					const { transformedNode, options } = resolved;
-					if (allowedSchemaNames !== null && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) continue;
+					if (state.allowedSchemaNames !== null && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) continue;
 					const ctx = {
-						...generatorContext,
-						options
+						...state.generatorContext,
+						options,
+						cache
 					};
-					for (const generator of schemaGenerators) await this.dispatch({
-						result: await generator.schema(transformedNode, ctx),
-						renderer: generator.renderer
-					});
+					for (const generator of state.schemaGenerators) {
+						if (!(generator.match ? await generator.match(transformedNode, ctx) : true)) continue;
+						await this.dispatch({
+							result: await generator.schema(transformedNode, ctx),
+							renderer: generator.renderer
+						});
+					}
 					await this.hooks.callHook("kubb:generate:schema", transformedNode, ctx);
 				} catch (caughtError) {
-					error = require_usingCtx.toError(caughtError);
+					state.error = require_usingCtx.toError(caughtError);
 				}
 			}
-			const pluginOperations = [];
-			if (operationGenerators.length || operationsGenerators.length) for (const node of operations) {
-				if (error) break;
+		}
+		for (const node of operations) {
+			const cache = require_usingCtx.createNodeCache();
+			for (const state of states) {
+				if (state.error || !state.operationGenerators.length && !state.operationsGenerators.length) continue;
 				try {
-					const resolved = resolveForPlugin(node);
+					const resolved = resolveForPlugin(state, node);
 					if (!resolved) continue;
-					pluginOperations.push(resolved.transformedNode);
-					if (operationGenerators.length) {
+					state.pluginOperations.push(resolved.transformedNode);
+					if (state.operationGenerators.length) {
 						const ctx = {
-							...generatorContext,
-							options: resolved.options
+							...state.generatorContext,
+							options: resolved.options,
+							cache
 						};
-						for (const generator of operationGenerators) await this.dispatch({
-							result: await generator.operation(resolved.transformedNode, ctx),
-							renderer: generator.renderer
-						});
+						for (const generator of state.operationGenerators) {
+							if (!(generator.match ? await generator.match(resolved.transformedNode, ctx) : true)) continue;
+							await this.dispatch({
+								result: await generator.operation(resolved.transformedNode, ctx),
+								renderer: generator.renderer
+							});
+						}
 						await this.hooks.callHook("kubb:generate:operation", resolved.transformedNode, ctx);
 					}
 				} catch (caughtError) {
-					error = require_usingCtx.toError(caughtError);
+					state.error = require_usingCtx.toError(caughtError);
 				}
 			}
-			if (!error && operationsGenerators.length) try {
+		}
+		for (const state of states) {
+			if (state.error || !state.operationsGenerators.length) continue;
+			try {
 				const ctx = {
-					...generatorContext,
-					options: plugin.options
+					...state.generatorContext,
+					options: state.plugin.options,
+					cache: require_usingCtx.createNodeCache()
 				};
-				for (const generator of operationsGenerators) await this.dispatch({
-					result: await generator.operations(pluginOperations, ctx),
+				for (const generator of state.operationsGenerators) await this.dispatch({
+					result: await generator.operations(state.pluginOperations, ctx),
 					renderer: generator.renderer
 				});
-				await this.hooks.callHook("kubb:generate:operations", pluginOperations, ctx);
+				await this.hooks.callHook("kubb:generate:operations", state.pluginOperations, ctx);
 			} catch (caughtError) {
-				error = require_usingCtx.toError(caughtError);
+				state.error = require_usingCtx.toError(caughtError);
 			}
-			const duration = getElapsedMs(hrStart);
+		}
+		for (const state of states) {
+			const duration = getElapsedMs(state.hrStart);
 			await this.#emitPluginEnd({
-				plugin,
+				plugin: state.plugin,
 				duration,
-				success: !error,
-				error: error ?? void 0
+				success: !state.error,
+				error: state.error ?? void 0
 			});
-			if (error) diagnostics.push({
-				...Diagnostics.from(error),
-				plugin: plugin.name
+			if (state.error) diagnostics.push({
+				...Diagnostics.from(state.error),
+				plugin: state.plugin.name
 			});
 			diagnostics.push(Diagnostics.performance({
-				plugin: plugin.name,
+				plugin: state.plugin.name,
 				duration
 			}));
 		}