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

package/dist/index.cjs

@@ -150,48 +150,8 @@ function randomCliColor(text) {
 	return (0, node_util.styleText)(randomColors[index] ?? "white", text);
 }
 //#endregion
-//#region ../../internals/utils/src/promise.ts
-/**
-* Wraps `factory` with a keyed cache backed by the provided store.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
-*/
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
-}
-//#endregion
 //#region package.json
-var version = "5.0.0-beta.100";
+var version = "5.0.0-beta.102";
 //#endregion
 //#region src/constants.ts
 /**
@@ -1288,6 +1248,38 @@ const ENFORCE_ORDER = {
 	post: 1
 };
 const enforceWeight = (plugin) => plugin.enforce ? ENFORCE_ORDER[plugin.enforce] : 0;
+/**
+* The options bag a `NormalizedPlugin` starts with before a plugin refines it: a directory output
+* at the plugin root and empty filter lists.
+*/
+function defaultPluginOptions() {
+	return {
+		output: {
+			path: ".",
+			mode: "directory"
+		},
+		exclude: [],
+		override: []
+	};
+}
+/**
+* Fills in the `output`, `exclude`, and `override` a `NormalizedPlugin` needs from a plugin's raw
+* options, running `output` through `normalizeOutput`. Idempotent, so the driver can apply it after
+* `setOptions` has already run without disturbing an already-normalized bag.
+*/
+function normalizePluginOptions(rawOptions, pluginName) {
+	const options = {
+		...defaultPluginOptions(),
+		...rawOptions ?? {}
+	};
+	const group = "group" in options ? options.group : void 0;
+	options.output = normalizeOutput({
+		output: options.output,
+		group,
+		pluginName
+	});
+	return options;
+}
 var KubbDriver = class {
 	config;
 	options;
@@ -1309,13 +1301,6 @@ var KubbDriver = class {
 	fileManager = new require_usingCtx.FileManager();
 	plugins = /* @__PURE__ */ new Map();
 	/**
-	* Tracks which plugins have generators registered via `addGenerator()` (hook-based path).
-	* Used by the build loop to decide whether to emit generator hooks for a given plugin.
-	*/
-	#hookGeneratorPlugins = /* @__PURE__ */ new Set();
-	#resolvers = /* @__PURE__ */ new Map();
-	#defaultResolvers = /* @__PURE__ */ new Map();
-	/**
 	* Removers for every listener the driver added (plugin, generator) so `dispose()` can detach
 	* them in one pass. External `hooks.hook(...)` listeners are not tracked.
 	*/
@@ -1343,15 +1328,8 @@ var KubbDriver = class {
 				dependencies: rawPlugin.dependencies,
 				enforce: rawPlugin.enforce,
 				hooks: rawPlugin.hooks,
-				options: rawPlugin.options ?? {
-					output: {
-						path: ".",
-						mode: "directory"
-					},
-					exclude: [],
-					override: []
-				},
-				resolver: this.#getDefaultResolver(rawPlugin.name)
+				options: rawPlugin.options ?? defaultPluginOptions(),
+				resolver: createResolver({ pluginName: rawPlugin.name })
 			};
 		}));
 		for (const plugin of normalized) {
@@ -1460,46 +1438,30 @@ var KubbDriver = class {
 		}
 	}
 	/**
-	* Registers a generator for the given plugin on the shared hook emitter.
+	* Appends a generator to its owning plugin so the generate loop can call it directly.
 	*
-	* The generator's `schema`, `operation`, and `operations` methods are registered as
-	* listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
-	* respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
-	* so that generators from different plugins do not cross-fire.
-	*
-	* The renderer comes from `generator.renderer`. Set `generator.renderer = null` (or leave it
-	* unset) to opt out of rendering.
+	* The generator's `schema`, `operation`, and `operations` methods run per node during the AST
+	* walk in `#runGenerators`, and their result is routed through `dispatch`. Because a generator is
+	* bound to a plugin, generators from different plugins never cross-fire without a name check. The
+	* renderer comes from `generator.renderer`; set it to `null` (or leave it unset) to opt out of
+	* rendering.
 	*
 	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
 	*/
 	registerGenerator(pluginName, generator) {
-		const wrap = (method) => {
-			if (!method) return void 0;
-			return async (node, ctx) => {
-				if (ctx.plugin.name !== pluginName) return;
-				const result = await method(node, ctx);
-				await this.dispatch({
-					result,
-					renderer: generator.renderer
-				});
-			};
-		};
-		this.#unhooks.push(this.hooks.addHooks({
-			"kubb:generate:schema": wrap(generator.schema),
-			"kubb:generate:operation": wrap(generator.operation),
-			"kubb:generate:operations": wrap(generator.operations)
-		}));
-		this.#hookGeneratorPlugins.add(pluginName);
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) return;
+		plugin.generators = plugin.generators ? [...plugin.generators, generator] : [generator];
 	}
 	/**
 	* Returns `true` when at least one generator was registered for the given plugin
 	* via `addGenerator()` in `kubb:plugin:setup`.
 	*
-	* Used by the build loop to decide whether to walk the AST and emit generator hooks
+	* Used by the build loop to decide whether to walk the AST and run the generators
 	* for a plugin.
 	*/
 	hasHookGenerators(pluginName) {
-		return this.#hookGeneratorPlugins.has(pluginName);
+		return (this.plugins.get(pluginName)?.generators?.length ?? 0) > 0;
 	}
 	/**
 	* Runs the full plugin pipeline. Returns the diagnostics collected so far even
@@ -1534,12 +1496,16 @@ var KubbDriver = class {
 				const outputRoot = (0, node_path.resolve)(config.root, config.output.path);
 				await this.#parseInput();
 				await this.setupHooks();
-				if (this.adapter && this.inputNode) await hooks.callHook("kubb:build:start", Object.assign({
-					config,
-					adapter: this.adapter,
-					meta: this.inputNode.meta,
-					getPlugin: this.getPlugin.bind(this)
-				}, this.#filesPayload()));
+				for (const plugin of this.plugins.values()) plugin.options = normalizePluginOptions(plugin.options, plugin.name);
+				if (this.adapter && this.inputNode) {
+					const buildStartContext = this.#withFiles({
+						config,
+						adapter: this.adapter,
+						meta: this.inputNode.meta,
+						getPlugin: this.getPlugin.bind(this)
+					});
+					await hooks.callHook("kubb:build:start", buildStartContext);
+				}
 				const generatorPlugins = [];
 				for (const plugin of this.plugins.values()) {
 					const context = this.getContext(plugin);
@@ -1584,7 +1550,7 @@ var KubbDriver = class {
 					});
 				}
 				diagnostics.push(...await this.#runGenerators(generatorPlugins));
-				await hooks.callHook("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+				await hooks.callHook("kubb:plugins:end", this.#withFiles({ config }));
 				await fileManager.write(fileManager.files, {
 					storage: config.storage,
 					parsers: parsersMap
@@ -1603,23 +1569,26 @@ var KubbDriver = class {
 			}
 		});
 	}
-	#filesPayload() {
-		const driver = this;
+	/**
+	* Widens `extra` with the files present at emit time and a bound `upsertFile`, the shape every
+	* file-carrying hook context shares. Building it here in one place keeps the `files` and
+	* `upsertFile` keys from being dropped by a stray spread at the call site.
+	*/
+	#withFiles(extra) {
 		return {
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
+			...extra,
+			files: this.fileManager.files,
+			upsertFile: (...files) => this.fileManager.upsert(...files)
 		};
 	}
 	#emitPluginEnd({ plugin, duration, success, error }) {
-		return this.hooks.callHook("kubb:plugin:end", Object.assign({
+		return this.hooks.callHook("kubb:plugin:end", this.#withFiles({
 			plugin,
 			duration,
 			success,
 			...error ? { error } : {},
 			config: this.config
-		}, this.#filesPayload()));
+		}));
 	}
 	/**
 	* Runs schemas and operations through every plugin's generators. Each node is run
@@ -1656,9 +1625,6 @@ var KubbDriver = class {
 		}
 		const transforms = this.#transforms;
 		const { schemas, operations } = this.inputNode;
-		const emitsSchemaHook = this.hooks.listenerCount("kubb:generate:schema") > 0;
-		const emitsOperationHook = this.hooks.listenerCount("kubb:generate:operation") > 0;
-		const emitsOperationsHook = this.hooks.listenerCount("kubb:generate:operations") > 0;
 		const allowedSchemaNamesByPlugin = /* @__PURE__ */ new Map();
 		for (const { plugin } of entries) {
 			const { exclude, include, override } = plugin.options;
@@ -1680,6 +1646,10 @@ var KubbDriver = class {
 			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);
@@ -1699,44 +1669,57 @@ var KubbDriver = class {
 					options
 				};
 			};
-			if (emitsSchemaHook) for (const node of schemas) {
+			if (schemaGenerators.length) for (const node of schemas) {
 				if (error) break;
 				try {
 					const resolved = resolveForPlugin(node);
 					if (!resolved) continue;
 					const { transformedNode, options } = resolved;
 					if (allowedSchemaNames !== null && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) continue;
-					await this.hooks.callHook("kubb:generate:schema", transformedNode, {
+					const ctx = {
 						...generatorContext,
 						options
+					};
+					for (const generator of schemaGenerators) 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);
 				}
 			}
-			if (emitsOperationHook) for (const node of operations) {
+			const pluginOperations = [];
+			if (operationGenerators.length || operationsGenerators.length) for (const node of operations) {
 				if (error) break;
 				try {
 					const resolved = resolveForPlugin(node);
 					if (!resolved) continue;
-					await this.hooks.callHook("kubb:generate:operation", resolved.transformedNode, {
-						...generatorContext,
-						options: resolved.options
-					});
+					pluginOperations.push(resolved.transformedNode);
+					if (operationGenerators.length) {
+						const ctx = {
+							...generatorContext,
+							options: resolved.options
+						};
+						for (const generator of operationGenerators) 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);
 				}
 			}
-			if (!error && emitsOperationsHook) try {
+			if (!error && operationsGenerators.length) try {
 				const ctx = {
 					...generatorContext,
 					options: plugin.options
 				};
-				const pluginOperations = operations.reduce((acc, node) => {
-					const resolved = resolveForPlugin(node);
-					if (resolved) acc.push(resolved.transformedNode);
-					return acc;
-				}, []);
+				for (const generator of operationsGenerators) await this.dispatch({
+					result: await generator.operations(pluginOperations, ctx),
+					renderer: generator.renderer
+				});
 				await this.hooks.callHook("kubb:generate:operations", pluginOperations, ctx);
 			} catch (caughtError) {
 				error = require_usingCtx.toError(caughtError);
@@ -1798,10 +1781,7 @@ var KubbDriver = class {
 	dispose() {
 		for (const unhook of this.#unhooks) unhook();
 		this.#unhooks.length = 0;
-		this.#hookGeneratorPlugins.clear();
 		this.#transforms.dispose();
-		this.#resolvers.clear();
-		this.#defaultResolvers.clear();
 		this.fileManager.dispose();
 		this.inputNode = null;
 		this.#adapterSource = null;
@@ -1809,21 +1789,17 @@ var KubbDriver = class {
 	[Symbol.dispose]() {
 		this.dispose();
 	}
-	#getDefaultResolver = memoize(this.#defaultResolvers, (pluginName) => createResolver({ pluginName }));
 	/**
-	* Merges `partial` with the plugin's default resolver and stores the result.
-	* Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
-	* get the up-to-date resolver without going through `getResolver()`.
+	* Merges `partial` onto a fresh default resolver and stores the result on `plugin.resolver`,
+	* which is the single source `getResolver` and `getPlugin(name).resolver` both read.
 	*/
 	setPluginResolver(pluginName, partial) {
-		const defaultResolver = this.#getDefaultResolver(pluginName);
-		const merged = Resolver.merge(defaultResolver, partial);
-		this.#resolvers.set(pluginName, merged);
 		const plugin = this.plugins.get(pluginName);
-		if (plugin) plugin.resolver = merged;
+		if (!plugin) return;
+		plugin.resolver = Resolver.merge(createResolver({ pluginName }), partial);
 	}
 	getResolver(pluginName) {
-		return this.#resolvers.get(pluginName) ?? this.#getDefaultResolver(pluginName);
+		return this.plugins.get(pluginName)?.resolver ?? createResolver({ pluginName });
 	}
 	getContext(plugin) {
 		const driver = this;
@@ -2153,6 +2129,69 @@ var Kubb = class {
 			_usingCtx$1.d();
 		}
 	}
+	/**
+	* Run one build and its output passes end to end, emitting the surrounding `kubb:generation:*`
+	* hooks. Never throws on a build error: the outcome comes back in {@link GenerateResult} so the
+	* host decides how failures surface. Telemetry and progress narration stay with the host, which
+	* reads the result and subscribes to the `kubb:*` hooks.
+	*
+	* @example
+	* ```ts
+	* const result = await createKubb(config, { hooks }).generate()
+	* if (!result.success) process.exitCode = 1
+	* ```
+	*/
+	async generate(options = {}) {
+		const { hooks, config } = this;
+		const hrStart = process.hrtime();
+		await hooks.callHook("kubb:generation:start", { config });
+		await hooks.callHook("kubb:setup:start");
+		await this.setup();
+		await hooks.callHook("kubb:setup:end");
+		const { files, diagnostics, storage } = await this.safeBuild();
+		for (const diagnostic of diagnostics) {
+			if (!Diagnostics.isProblem(diagnostic)) continue;
+			if (diagnostic.code === Diagnostics.code.unknown) {
+				await hooks.callHook("kubb:error", { error: diagnostic.cause ?? new Error(diagnostic.message) });
+				continue;
+			}
+			await Diagnostics.emit(hooks, diagnostic);
+		}
+		if (Diagnostics.hasError(diagnostics)) {
+			await hooks.callHook("kubb:generation:end", {
+				config,
+				storage,
+				diagnostics,
+				filesCreated: files.length,
+				status: "failed",
+				hrStart
+			});
+			return {
+				success: false,
+				files,
+				diagnostics
+			};
+		}
+		const outputDiagnostics = options.processOutput ? await options.processOutput({
+			config,
+			outputPath: (0, node_path.resolve)(config.root, config.output.path)
+		}) : [];
+		const finalDiagnostics = [...diagnostics, ...outputDiagnostics];
+		const failed = Diagnostics.hasError(outputDiagnostics);
+		await hooks.callHook("kubb:generation:end", {
+			config,
+			storage,
+			diagnostics: finalDiagnostics,
+			filesCreated: files.length,
+			status: failed ? "failed" : "success",
+			hrStart
+		});
+		return {
+			success: !failed,
+			files,
+			diagnostics: finalDiagnostics
+		};
+	}
 	dispose() {
 		this.#driver?.dispose();
 	}