@kubb/core 5.0.0-beta.36 → 5.0.0-beta.38

package/dist/index.js

@@ -1,26 +1,10 @@
 import "./chunk-C0LytTxp.js";
-import { a as FileManager, c as DEFAULT_BANNER, d as logLevel, f as URLPath, i as FileProcessor, l as DEFAULT_EXTENSION, m as BuildError, o as defineResolver, p as AsyncEventEmitter, r as _usingCtx, s as definePlugin, t as KubbDriver, u as DEFAULT_STUDIO_URL } from "./KubbDriver-DrG5-FFe.js";
+import { _ as URLPath, a as defineResolver, c as Diagnostics, d as isProblemDiagnostic, f as isUpdateDiagnostic, g as logLevel, h as diagnosticCode, i as FileManager, l as diagnosticCatalog, m as DEFAULT_STUDIO_URL, n as _usingCtx, o as definePlugin, p as narrowDiagnostic, r as FileProcessor, s as DiagnosticError, t as KubbDriver, u as isPerformanceDiagnostic, v as AsyncEventEmitter, y as BuildError } from "./KubbDriver-CyNF-NIb.js";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import * as ast from "@kubb/ast";
-import { version } from "node:process";
 //#region ../../internals/utils/src/fs.ts
 /**
-* Resolves to `true` when the file or directory at `path` exists.
-* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
-*
-* @example
-* ```ts
-* if (await exists('./kubb.config.ts')) {
-*   const content = await read('./kubb.config.ts')
-* }
-* ```
-*/
-async function exists(path) {
-	if (typeof Bun !== "undefined") return Bun.file(path).exists();
-	return access(path).then(() => true, () => false);
-}
-/**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
 * Skips the write when the trimmed content is empty or identical to what is already on disk.
 * Creates any missing parent directories automatically.
@@ -105,14 +89,11 @@ function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region package.json
-var version$1 = "5.0.0-beta.36";
-//#endregion
 //#region src/createStorage.ts
 /**
 * Defines a custom storage backend. The builder receives user options and
 * returns a `Storage` implementation. Kubb ships with filesystem and
-* in-memory storages — reach for this when you need to write generated files
+* in-memory storages, reach for this when you need to write generated files
 * elsewhere (cloud storage, a database, a remote API).
 *
 * @example In-memory storage (the built-in implementation)
@@ -229,7 +210,7 @@ const fsStorage = createStorage(() => ({
 /**
 * Builds a `Storage` view scoped to the file paths produced by the current build.
 * Reads delegate to the underlying `storage` so source bytes stay where they were
-* written; writes register the key so subsequent reads and `getKeys` are scoped
+* written. Writes register the key so subsequent reads and `getKeys` are scoped
 * to this build's output.
 */
 function createSourcesView(storage) {
@@ -270,8 +251,8 @@ function resolveConfig(userConfig) {
 		output: {
 			format: false,
 			lint: false,
-			extension: DEFAULT_EXTENSION,
-			defaultBanner: DEFAULT_BANNER,
+			extension: { ".ts": ".ts" },
+			defaultBanner: "simple",
 			...userConfig.output
 		},
 		storage: userConfig.storage ?? fsStorage(),
@@ -282,21 +263,6 @@ function resolveConfig(userConfig) {
 		plugins: userConfig.plugins ?? []
 	};
 }
-/**
-* Returns a snapshot of the current runtime environment.
-*
-* Useful for attaching context to debug logs and error reports so that
-* issues can be reproduced without manual information gathering.
-*/
-function getDiagnosticInfo() {
-	return {
-		nodeVersion: version,
-		KubbVersion: version$1,
-		platform: process.platform,
-		arch: process.arch,
-		cwd: process.cwd()
-	};
-}
 function isInputPath(config) {
 	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
@@ -311,7 +277,7 @@ function isInputPath(config) {
 * ```ts
 * const kubb = createKubb(userConfig)
 * kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
-* const { files, failedPlugins } = await kubb.safeBuild()
+* const { files, diagnostics } = await kubb.safeBuild()
 * ```
 */
 var Kubb = class {
@@ -343,26 +309,8 @@ var Kubb = class {
 		const config = resolveConfig(this.#userConfig);
 		const driver = new KubbDriver(config, { hooks: this.hooks });
 		const storage = createSourcesView(config.storage);
-		await this.hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: this.#configLogs(config)
-		});
-		if (isInputPath(this.#userConfig) && !new URLPath(this.#userConfig.input.path).isURL) try {
-			await exists(this.#userConfig.input.path);
-			await this.hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ Input file validated: ${this.#userConfig.input.path}`]
-			});
-		} catch (caughtError) {
-			throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${this.#userConfig.input.path}`, { cause: caughtError });
-		}
-		if (config.output.clean) {
-			await this.hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
-			});
-			await config.storage.clear(resolve(config.root, config.output.path));
-		}
+		this.hooks.setMaxListeners(Math.max(10, config.plugins.length * 4));
+		if (config.output.clean) await config.storage.clear(resolve(config.root, config.output.path));
 		await driver.setup();
 		this.#config = config;
 		this.#driver = driver;
@@ -374,10 +322,9 @@ var Kubb = class {
 	*/
 	async build() {
 		const out = await this.safeBuild();
-		if (out.error) throw out.error;
-		if (out.failedPlugins.size > 0) {
-			const errors = [...out.failedPlugins].map(({ error }) => error);
-			throw new BuildError(`Build Error with ${out.failedPlugins.size} failed plugins`, { errors });
+		if (Diagnostics.hasError(out.diagnostics)) {
+			const errors = out.diagnostics.filter(isProblemDiagnostic).filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.cause ?? new DiagnosticError(diagnostic));
+			throw new BuildError(`Build failed with ${errors.length} ${errors.length === 1 ? "error" : "errors"}`, { errors });
 		}
 		return out;
 	}
@@ -392,14 +339,12 @@ var Kubb = class {
 			const cleanup = _usingCtx$1.u(this);
 			const driver = cleanup.driver;
 			const storage = cleanup.storage;
-			const { failedPlugins, pluginTimings, error } = await driver.run({ storage });
+			const { diagnostics } = await driver.run({ storage });
 			return {
-				failedPlugins,
+				diagnostics,
 				files: driver.fileManager.files,
 				driver,
-				pluginTimings,
-				storage,
-				...error ? { error } : {}
+				storage
 			};
 		} catch (_) {
 			_usingCtx$1.e = _;
@@ -413,24 +358,6 @@ var Kubb = class {
 	[Symbol.dispose]() {
 		this.dispose();
 	}
-	#configLogs(config) {
-		const u = this.#userConfig;
-		const diag = getDiagnosticInfo();
-		return [
-			"Configuration:",
-			`  • Name: ${u.name || "unnamed"}`,
-			`  • Root: ${u.root || process.cwd()}`,
-			`  • Output: ${u.output?.path || "not specified"}`,
-			`  • Plugins: ${u.plugins?.length || 0}`,
-			"Output Settings:",
-			`  • Storage: ${config.storage.name}`,
-			`  • Formatter: ${u.output?.format || "none"}`,
-			`  • Linter: ${u.output?.lint || "none"}`,
-			`Running adapter: ${config.adapter?.name || "none"}`,
-			"Environment:",
-			Object.entries(diag).map(([key, value]) => `  • ${key}: ${value}`).join("\n")
-		];
-	}
 };
 /**
 * Constructs a {@link Kubb} build orchestrator from a user config. Equivalent
@@ -456,13 +383,54 @@ function createKubb(userConfig, options = {}) {
 	return new Kubb(userConfig, options);
 }
 //#endregion
+//#region src/createReporter.ts
+/**
+* Defines a reporter. When the definition has a `flush`, the returned reporter buffers each value
+* `report` returns and hands the array to `flush` once, then clears it. Without a `flush`, nothing
+* is buffered. Wiring the reporter onto the run's events is the host's job, so the reporter only
+* ever deals with a {@link GenerationResult}.
+*
+* @example
+* ```ts
+* import { createReporter, Diagnostics } from '@kubb/core'
+*
+* export const jsonReporter = createReporter({
+*   name: 'json',
+*   report(result) {
+*     return { status: Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success', diagnostics: result.diagnostics }
+*   },
+*   flush(context, reports) {
+*     process.stdout.write(`${JSON.stringify(reports, null, 2)}\n`)
+*   },
+* })
+* ```
+*/
+function createReporter(reporter) {
+	const flush = reporter.flush;
+	if (!flush) return {
+		name: reporter.name,
+		report: reporter.report
+	};
+	const reports = [];
+	return {
+		name: reporter.name,
+		async report(result, context) {
+			reports.push(await reporter.report(result, context));
+		},
+		async flush(context) {
+			await flush(context, reports);
+			reports.length = 0;
+		}
+	};
+}
+//#endregion
 //#region src/createRenderer.ts
 /**
 * Defines a renderer factory. Renderers turn the generator's return value
 * (JSX, a template string, a tree of any shape) into `FileNode`s that get
 * written to disk.
 *
-* Use this to support output formats beyond JSX — for instance, a Handlebars
+* Use this to support output formats beyond JSX, for instance, a Handlebars
 * renderer, a string-template renderer, or a renderer that writes binary
 * files. Plugins and generators pick the renderer to use via the `renderer`
 * field on `defineGenerator`.
@@ -506,7 +474,7 @@ function createRenderer(factory) {
 * The returned object is the input as-is, but with `this` types preserved so
 * `schema`/`operation`/`operations` methods are correctly typed against the
 * plugin's `PluginFactoryOptions`. Renderer elements and `FileNode[]` returns
-* are both handled by the runtime — pick whichever style fits.
+* are both handled by the runtime, so pick whichever style fits.
 *
 * @example JSX-based schema generator
 * ```tsx
@@ -688,6 +656,6 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-export { AsyncEventEmitter, FileManager, FileProcessor, KubbDriver, URLPath, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
+export { AsyncEventEmitter, DiagnosticError, Diagnostics, FileManager, FileProcessor, KubbDriver, URLPath, ast, createAdapter, createKubb, createRenderer, createReporter, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, diagnosticCatalog, diagnosticCode, fsStorage, isInputPath, isPerformanceDiagnostic, isProblemDiagnostic, isUpdateDiagnostic, logLevel, memoryStorage, narrowDiagnostic };
 
 //# sourceMappingURL=index.js.map