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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { $ as PluginName, A as Kubb, At as DiagnosticKind, B as Filter, Bt as Adapter, C as KubbWarnContext, Ct as ReporterContext, D as CreateKubbOptions, Dt as logLevel, E as UserConfig, Et as createReporter, F as KubbDriver, Ft as ProblemCode, G as KubbPluginStartContext, H as Include, Ht as AdapterSource, I as FileManagerHooks, It as ProblemDiagnostic, J as OutputMode, K as NormalizedPlugin, L as Parser, Lt as SerializedDiagnostic, M as Generator, Mt as DiagnosticSeverity, N as GeneratorContext, Nt as Diagnostics, O as GenerateOptions, Ot as Diagnostic, P as defineGenerator, Pt as PerformanceDiagnostic, Q as PluginFactoryOptions, R as defineParser, Rt as UpdateDiagnostic, S as KubbSuccessContext, St as Reporter, T as PostGenerateCommand, Tt as UserReporter, U as KubbPluginEndContext, Ut as createAdapter, V as Group, Vt as AdapterFactoryOptions, W as KubbPluginSetupContext, X as Override, Y as OutputOptions, Z as Plugin, _ as KubbHookStartContext, _t as RendererFactory, a as KubbBuildEndContext, at as ResolveFileOptions, b as KubbLifecycleStartContext, bt as createStorage, c as KubbErrorContext, ct as ResolvePathOptions, d as KubbFilesProcessingStartContext, dt as ResolverFile, et as ResolvePluginOptions, f as KubbFilesProcessingUpdateContext, ft as ResolverFileParams, g as KubbHookLineContext, gt as Renderer, h as KubbHookEndContext, ht as ResolverPathParams, i as Input, it as ResolveBannerFile, j as createKubb, jt as DiagnosticLocation, k as GenerateResult, kt as DiagnosticDoc, l as KubbFileProcessingUpdate, lt as Resolver, m as KubbGenerationStartContext, mt as ResolverPatch, n as CLIOptions, nt as BannerMeta, o as KubbBuildStartContext, ot as ResolveImportsOptions, p as KubbGenerationEndContext, pt as ResolverFilePathParams, q as Output, r as Config, rt as ResolveBannerContext, s as KubbDiagnosticContext, st as ResolveOptionsContext, t as BuildOutput, tt as definePlugin, u as KubbFilesProcessingEndContext, ut as ResolverDefault, v as KubbHooks, vt as createRenderer, w as PossibleConfig, wt as ReporterName, x as KubbPluginsEndContext, xt as GenerationResult, y as KubbInfoContext, yt as Storage, z as Exclude, zt as Hookable } from "./types-B14Ba9P7.js";
+import { $ as PluginFactoryOptions, A as Kubb, At as DiagnosticDoc, B as Exclude, Bt as Hookable, C as KubbWarnContext, Ct as Reporter, D as CreateKubbOptions, Dt as createReporter, E as UserConfig, Et as UserReporter, F as NodeCache, Ft as PerformanceDiagnostic, G as KubbPluginSetupContext, H as Group, Ht as AdapterFactoryOptions, I as KubbDriver, It as ProblemCode, J as Output, K as KubbPluginStartContext, L as FileManagerHooks, Lt as ProblemDiagnostic, M as Generator, Mt as DiagnosticLocation, N as GeneratorContext, Nt as DiagnosticSeverity, O as GenerateOptions, Ot as logLevel, P as defineGenerator, Pt as Diagnostics, Q as Plugin, R as Parser, Rt as SerializedDiagnostic, S as KubbSuccessContext, St as GenerationResult, T as PostGenerateCommand, Tt as ReporterName, U as Include, Ut as AdapterSource, V as Filter, Vt as Adapter, W as KubbPluginEndContext, Wt as createAdapter, X as OutputOptions, Y as OutputMode, Z as Override, _ as KubbHookStartContext, _t as Renderer, a as KubbBuildEndContext, at as ResolveBannerFile, b as KubbLifecycleStartContext, bt as Storage, c as KubbErrorContext, ct as ResolveOptionsContext, d as KubbFilesProcessingStartContext, dt as ResolverDefault, et as PluginName, f as KubbFilesProcessingUpdateContext, ft as ResolverFile, g as KubbHookLineContext, gt as ResolverPathParams, h as KubbHookEndContext, ht as ResolverPatch, i as Input, it as ResolveBannerContext, j as createKubb, jt as DiagnosticKind, k as GenerateResult, kt as Diagnostic, l as KubbFileProcessingUpdate, lt as ResolvePathOptions, m as KubbGenerationStartContext, mt as ResolverFilePathParams, n as CLIOptions, nt as definePlugin, o as KubbBuildStartContext, ot as ResolveFileOptions, p as KubbGenerationEndContext, pt as ResolverFileParams, q as NormalizedPlugin, r as Config, rt as BannerMeta, s as KubbDiagnosticContext, st as ResolveImportsOptions, t as BuildOutput, tt as ResolvePluginOptions, u as KubbFilesProcessingEndContext, ut as Resolver, v as KubbHooks, vt as RendererFactory, w as PossibleConfig, wt as ReporterContext, x as KubbPluginsEndContext, xt as createStorage, y as KubbInfoContext, yt as createRenderer, z as defineParser, zt as UpdateDiagnostic } from "./types-D116CBzm.js";
 //#region src/applyConfigDefaults.d.ts
 type ApplyConfigDefaultsOptions<TOutput> = {
   defaultAdapter: Adapter;
@@ -183,5 +183,5 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  */
 declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
-export { type Adapter, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileManagerHooks, type Filter, type GenerateOptions, type GenerateResult, type GenerationResult, type Generator, type GeneratorContext, type Group, Hookable, type Include, Input, type InputKind, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, type PluginName, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type SerializedDiagnostic, type Storage, type UpdateDiagnostic, UserConfig, type UserReporter, applyConfigDefaults, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fileReporter, fsStorage, getInputKind, jsonReporter, logLevel, memoryStorage };
+export { type Adapter, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileManagerHooks, type Filter, type GenerateOptions, type GenerateResult, type GenerationResult, type Generator, type GeneratorContext, type Group, Hookable, type Include, Input, type InputKind, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NodeCache, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, type PluginName, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type SerializedDiagnostic, type Storage, type UpdateDiagnostic, UserConfig, type UserReporter, applyConfigDefaults, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fileReporter, fsStorage, getInputKind, jsonReporter, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,11 +1,11 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { a as isPathInside, c as write, d as toError, f as camelCase, i as clean, l as BuildError, n as FileManager, o as toFilePath, r as Hookable, s as toPosixPath, t as _usingCtx, u as getErrorMessage } from "./usingCtx-BNggxUEL.js";
+import { a as clean, c as toPosixPath, d as getErrorMessage, f as toError, i as Hookable, l as write, n as createNodeCache, o as isPathInside, p as camelCase, r as FileManager, s as toFilePath, t as _usingCtx, u as BuildError } from "./usingCtx-C24YU3KM.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { stripVTControlCharacters, styleText } from "node:util";
 import { hash } from "node:crypto";
 import { access, glob, readFile, rm } from "node:fs/promises";
 import path, { join, relative, resolve } from "node:path";
-import { ast, collectSync, collectUsedSchemaNames, composeMacros, narrowSchema, operationDef, resolveRefName, schemaDef, transform } from "@kubb/ast";
+import { ast, collectImportedRefNames, collectUsedSchemaNames, composeMacros, operationDef, schemaDef, transform } from "@kubb/ast";
 import process$1 from "node:process";
 //#region src/createAdapter.ts
 /**
@@ -149,7 +149,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
 /**
@@ -845,28 +845,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 collectSync(node, { schema: (schemaNode) => {
-			const schemaRef = narrowSchema(schemaNode, "ref");
-			if (!schemaRef?.ref) return null;
-			const schemaName = resolveRefName(schemaRef);
-			if (!schemaName || seen.has(schemaName)) return null;
-			seen.add(schemaName);
-			return ast.factory.createImport({
-				name: [resolveName(schemaName)],
-				path: this.file({
-					name: schemaName,
-					extname,
-					root,
-					output,
-					group
-				}).path
-			});
-		} });
+		return collectImportedRefNames(node).map((schemaName) => 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
@@ -1481,6 +1477,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
@@ -1589,16 +1586,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.
@@ -1636,105 +1637,133 @@ var KubbDriver = class {
 			}) !== null);
 			allowedSchemaNamesByPlugin.set(plugin.name, 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 = 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 = toError(caughtError);
+					state.error = toError(caughtError);
 				}
 			}
-			const pluginOperations = [];
-			if (operationGenerators.length || operationsGenerators.length) for (const node of operations) {
-				if (error) break;
+		}
+		for (const node of operations) {
+			const cache = 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 = toError(caughtError);
+					state.error = 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: 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 = toError(caughtError);
+				state.error = 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
 			}));
 		}