@kubb/core 5.0.0-beta.60 → 5.0.0-beta.62

package/dist/{diagnostics-B-UZnFqP.d.ts → diagnostics-D0G07LHG.d.ts}

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
-import { FileNode, HttpMethod, ImportNode, InputMeta, InputNode, Node, OperationNode, SchemaNode, UserFileNode, Visitor } from "@kubb/ast";
+import { Enforce, FileNode, HttpMethod, ImportNode, InputMeta, InputNode, Macro, Node, OperationNode, SchemaNode, UserFileNode } from "@kubb/ast";
 
 //#region ../../internals/utils/src/asyncEventEmitter.d.ts
 /**
@@ -1137,9 +1137,14 @@ type KubbPluginSetupContext<TFactory extends PluginFactoryOptions = PluginFactor
    */
   setResolver(resolver: Partial<TFactory['resolver']>): void;
   /**
-   * Set the AST transformer to pre-process nodes before they reach generators.
+   * Add a macro that rewrites AST nodes before they reach generators. Macros run in the order they
+   * are added, after any macros from earlier `addMacro` calls.
    */
-  setTransformer(visitor: Visitor): void;
+  addMacro(macro: Macro): void;
+  /**
+   * Replace this plugin's macros with `macros`.
+   */
+  setMacros(macros: ReadonlyArray<Macro>): void;
   /**
    * Set resolved options merged into the normalized plugin's `options`.
    * Call this in `kubb:plugin:setup` to provide options generators need.
@@ -1185,7 +1190,7 @@ type Plugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
    *
    * Dependency constraints always take precedence over `enforce`.
    */
-  enforce?: 'pre' | 'post';
+  enforce?: Enforce;
   /**
    * The options passed by the user when calling the plugin factory.
    */
@@ -1212,7 +1217,7 @@ type NormalizedPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptio
     override: Array<Override<TOptions['resolvedOptions']>>;
   };
   resolver: TOptions['resolver'];
-  transformer?: Visitor;
+  macros?: Array<Macro>;
   generators?: Array<Generator$1>;
   apply?: (config: Config) => boolean;
   version?: string;
@@ -1339,7 +1344,7 @@ declare class KubbDriver {
   get hooks(): AsyncEventEmitter<KubbHooks>;
   /**
    * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
-   * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+   * can configure generators, resolvers, macros and renderers before `buildStart` runs.
    *
    * Call this once from `safeBuild` before the plugin execution loop begins.
    */
@@ -1497,13 +1502,6 @@ type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    * `ctx.resolver.resolveFile({ name: 'pet', extname: '.ts' }, { root, output })`
    */
   resolver: TOptions['resolver'];
-  /**
-   * The AST visitor this plugin registered through `setTransformer` during
-   * `kubb:plugin:setup`, or `undefined` when it never registered one. The driver already
-   * applies the visitor to every schema and operation node before a generator sees it, so
-   * read it here only to inspect or re-run the transformation.
-   */
-  transformer: Visitor | undefined;
   /**
    * Report a warning. Collected as a `warning` diagnostic attributed to the current
    * plugin. It surfaces in the run summary but does not fail the build. For a structured
@@ -2903,4 +2901,4 @@ declare class Diagnostics {
 }
 //#endregion
 export { KubbPluginSetupContext as $, KubbHookStartContext as A, Adapter as At, ParsedFile as B, KubbFilesProcessingEndContext as C, GenerationResult as Ct, KubbGenerationStartContext as D, UserReporter as Dt, KubbGenerationEndContext as E, ReporterName as Et, KubbSuccessContext as F, Generator$1 as G, createKubb as H, KubbWarnContext as I, KubbDriver as J, GeneratorContext as K, PossibleConfig as L, KubbInfoContext as M, AdapterSource as Mt, KubbLifecycleStartContext as N, createAdapter as Nt, KubbHookEndContext as O, createReporter as Ot, KubbPluginsEndContext as P, AsyncEventEmitter as Pt, KubbPluginEndContext as Q, UserConfig as R, KubbFileProcessingUpdate as S, createStorage as St, KubbFilesProcessingUpdateContext as T, ReporterContext as Tt, Parser as U, Kubb$1 as V, defineParser as W, Group as X, Exclude$1 as Y, Include as Z, InputPath as _, defineResolver as _t, DiagnosticLocation as a, Override as at, KubbDiagnosticContext as b, createRenderer as bt, PerformanceDiagnostic as c, definePlugin as ct, SerializedDiagnostic as d, ResolveBannerFile as dt, KubbPluginStartContext as et, UpdateDiagnostic as f, ResolveOptionsContext as ft, InputData as g, ResolverPathParams as gt, Config as h, ResolverFileParams as ht, DiagnosticKind as i, OutputOptions as it, KubbHooks as j, AdapterFactoryOptions as jt, KubbHookLineContext as k, logLevel as kt, ProblemCode as l, BannerMeta as lt, CLIOptions as m, ResolverContext as mt, DiagnosticByCode as n, Output as nt, DiagnosticSeverity as o, Plugin as ot, BuildOutput as p, Resolver as pt, defineGenerator as q, DiagnosticDoc as r, OutputMode as rt, Diagnostics as s, PluginFactoryOptions as st, Diagnostic as t, NormalizedPlugin as tt, ProblemDiagnostic as u, ResolveBannerContext as ut, KubbBuildEndContext as v, Renderer as vt, KubbFilesProcessingStartContext as w, Reporter as wt, KubbErrorContext as x, Storage as xt, KubbBuildStartContext as y, RendererFactory as yt, FileProcessorHooks as z };
-//# sourceMappingURL=diagnostics-B-UZnFqP.d.ts.map
+//# sourceMappingURL=diagnostics-D0G07LHG.d.ts.map

package/dist/index.cjs

@@ -611,7 +611,7 @@ function createAdapter(build) {
 /**
 * Docs major version, derived from the package version so the link tracks the published major.
 */
-const docsMajor = "5.0.0-beta.60".split(".")[0] ?? "5";
+const docsMajor = "5.0.0-beta.62".split(".")[0] ?? "5";
 /**
 * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
 *
@@ -1492,45 +1492,55 @@ function defineResolver(build) {
 //#endregion
 //#region src/Transform.ts
 /**
-* Holds one `Visitor` per plugin, keyed by plugin name. Each plugin's transformer runs in
-* isolation on the original adapter node. `applyTo` is a lookup, not a chain, so plugin A's
-* visitor never sees plugin B's output. When no transformer is registered, `applyTo` returns
-* the original node reference, and the `@kubb/ast` `transform` primitive does the same when
-* its visitor leaves the tree untouched. Callers can compare by identity to detect a no-op.
-*
-* Registration order matches the order setup hooks fire, which the driver has already sorted
-* by `enforce` and dependency edges. The registry does not re-order anything.
+* Holds an ordered list of macros per plugin, keyed by plugin name. Each plugin's macros run in
+* isolation on the original adapter node and are composed into a single `Visitor` that the
+* `@kubb/ast` `transform` primitive applies. `applyTo` is a per-plugin lookup, not a cross-plugin
+* chain, so plugin A's macros never see plugin B's output. When a plugin has no macros, `applyTo`
+* returns the original node reference, and `transform` does the same when the composed visitor
+* leaves the tree untouched, so callers can detect a no-op by identity.
+*
+* Registration order matches the order setup hooks fire, which the driver has already sorted by
+* `enforce` and dependency edges. The registry preserves that order; macro `enforce` only reorders
+* within a single plugin's list.
 */
 var Transform = class {
-	#visitors = /* @__PURE__ */ new Map();
+	#macros = /* @__PURE__ */ new Map();
+	#composed = /* @__PURE__ */ new Map();
 	#memo = /* @__PURE__ */ new Map();
 	/**
-	* Number of plugins with a registered transformer.
+	* Number of plugins with at least one registered macro.
 	*/
 	get size() {
-		return this.#visitors.size;
+		return this.#macros.size;
 	}
 	/**
-	* Records `visitor` as the transformer for `pluginName`. A second call for the same plugin
-	* replaces the first.
+	* Appends `macro` to the plugin's list, after any macros already registered.
 	*/
-	register(pluginName, visitor) {
-		this.#visitors.set(pluginName, visitor);
-		this.#memo.delete(pluginName);
+	add(pluginName, macro) {
+		const list = this.#macros.get(pluginName);
+		if (list) list.push(macro);
+		else this.#macros.set(pluginName, [macro]);
+		this.#invalidate(pluginName);
+	}
+	/**
+	* Replaces the plugin's macro list with `macros`.
+	*/
+	set(pluginName, macros) {
+		this.#macros.set(pluginName, [...macros]);
+		this.#invalidate(pluginName);
 	}
 	/**
-	* Looks up the transformer for `pluginName`. The generator context uses this so plugins can
-	* read their own visitor through `ctx.transformer`.
+	* Looks up the composed visitor for `pluginName`, or `undefined` when the plugin has no macros.
 	*/
 	get(pluginName) {
-		return this.#visitors.get(pluginName);
+		return this.#visitorFor(pluginName);
 	}
 	/**
-	* Runs the plugin's transformer on `node`. Returns the original node reference when the
-	* plugin has no transformer, so callers can compare by identity to detect a no-op.
+	* Runs the plugin's macros on `node`. Returns the original node reference when the plugin has no
+	* macros, so callers can compare by identity to detect a no-op.
 	*/
 	applyTo(pluginName, node) {
-		const visitor = this.#visitors.get(pluginName);
+		const visitor = this.#visitorFor(pluginName);
 		if (!visitor) return node;
 		let memo = this.#memo.get(pluginName);
 		if (!memo) {
@@ -1544,13 +1554,28 @@ var Transform = class {
 		return result;
 	}
 	/**
-	* Clears every registration. Called from the driver's `dispose()` so visitors do not leak
-	* across builds.
+	* Clears every registration. Called from the driver's `dispose()` so macros do not leak across
+	* builds.
 	*/
 	dispose() {
-		this.#visitors.clear();
+		this.#macros.clear();
+		this.#composed.clear();
 		this.#memo.clear();
 	}
+	#invalidate(pluginName) {
+		this.#composed.delete(pluginName);
+		this.#memo.delete(pluginName);
+	}
+	#visitorFor(pluginName) {
+		const macros = this.#macros.get(pluginName);
+		if (!macros || macros.length === 0) return void 0;
+		let composed = this.#composed.get(pluginName);
+		if (!composed) {
+			composed = (0, _kubb_ast.composeMacros)(macros);
+			this.#composed.set(pluginName, composed);
+		}
+		return composed;
+	}
 };
 //#endregion
 //#region src/KubbDriver.ts
@@ -1591,7 +1616,7 @@ var KubbDriver = class {
 	*/
 	#listeners = [];
 	/**
-	* Transform registry. Plugins populate it during `kubb:plugin:setup` via `setTransformer`,
+	* Transform registry. Plugins populate it during `kubb:plugin:setup` via `addMacro`/`setMacros`,
 	* and `#runGenerators` reads it once per `(plugin, node)` pair through `applyTo`.
 	*/
 	#transforms = new Transform();
@@ -1674,7 +1699,7 @@ var KubbDriver = class {
 	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
 	*
 	* The `kubb:plugin:setup` listener wraps the global context in a plugin-specific one so
-	* `addGenerator`, `setResolver`, and `setTransformer` target the right `normalizedPlugin`.
+	* `addGenerator`, `setResolver`, and `setMacros` target the right `normalizedPlugin`.
 	* Every other `KubbHooks` event registers as a pass-through listener that external tooling
 	* can observe via `hooks.on(...)`.
 	*
@@ -1694,8 +1719,11 @@ var KubbDriver = class {
 					setResolver: (resolver) => {
 						this.setPluginResolver(plugin.name, resolver);
 					},
-					setTransformer: (visitor) => {
-						this.#transforms.register(plugin.name, visitor);
+					addMacro: (macro) => {
+						this.#transforms.add(plugin.name, macro);
+					},
+					setMacros: (macros) => {
+						this.#transforms.set(plugin.name, macros);
 					},
 					setOptions: (opts) => {
 						plugin.options = {
@@ -1728,7 +1756,7 @@ var KubbDriver = class {
 	}
 	/**
 	* Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
-	* can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+	* can configure generators, resolvers, macros and renderers before `buildStart` runs.
 	*
 	* Call this once from `safeBuild` before the plugin execution loop begins.
 	*/
@@ -1739,7 +1767,8 @@ var KubbDriver = class {
 			options: {},
 			addGenerator: noop,
 			setResolver: noop,
-			setTransformer: noop,
+			addMacro: noop,
+			setMacros: noop,
 			setOptions: noop,
 			injectFile: noop,
 			updateConfig: noop
@@ -1759,39 +1788,21 @@ var KubbDriver = class {
 	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
 	*/
 	registerGenerator(pluginName, generator) {
-		if (generator.schema) {
-			const schemaHandler = async (node, ctx) => {
+		const register = (event, method) => {
+			if (!method) return;
+			const handler = async (node, ctx) => {
 				if (ctx.plugin.name !== pluginName) return;
-				const result = await generator.schema(node, ctx);
+				const result = await method(node, ctx);
 				await this.dispatch({
 					result,
 					renderer: generator.renderer
 				});
 			};
-			this.#trackListener("kubb:generate:schema", schemaHandler);
-		}
-		if (generator.operation) {
-			const operationHandler = async (node, ctx) => {
-				if (ctx.plugin.name !== pluginName) return;
-				const result = await generator.operation(node, ctx);
-				await this.dispatch({
-					result,
-					renderer: generator.renderer
-				});
-			};
-			this.#trackListener("kubb:generate:operation", operationHandler);
-		}
-		if (generator.operations) {
-			const operationsHandler = async (nodes, ctx) => {
-				if (ctx.plugin.name !== pluginName) return;
-				const result = await generator.operations(nodes, ctx);
-				await this.dispatch({
-					result,
-					renderer: generator.renderer
-				});
-			};
-			this.#trackListener("kubb:generate:operations", operationsHandler);
-		}
+			this.#trackListener(event, handler);
+		};
+		register("kubb:generate:schema", generator.schema);
+		register("kubb:generate:operation", generator.operation);
+		register("kubb:generate:operations", generator.operations);
 		this.#eventGeneratorPlugins.add(pluginName);
 	}
 	/**
@@ -1931,7 +1942,7 @@ var KubbDriver = class {
 	}
 	/**
 	* Streams schemas and operations through every plugin's generators. Each node is run
-	* through the plugin's transformer (from `this.#transforms`) before the generator sees it,
+	* 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
 	* because the two passes share `flushPending` and the FileProcessor's event emitter.
 	* A failing plugin contributes an error diagnostic so the rest of the build continues.
@@ -2235,9 +2246,6 @@ var KubbDriver = class {
 			get resolver() {
 				return driver.getResolver(plugin.name);
 			},
-			get transformer() {
-				return driver.#transforms.get(plugin.name);
-			},
 			warn(message) {
 				report({
 					code: Diagnostics.code.pluginWarning,