@kubb/core 5.11.3 → 5.11.5

package/dist/{Hookable-Ce-Xu-KB.js → Hookable-7Kv_oj72.js}

@@ -1,8 +1,9 @@
 import "node:module";
 import { satisfies } from "verkit";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path, { dirname, isAbsolute, relative, resolve } from "node:path";
+import { glob, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path, { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync as existsSync$1 } from "node:fs";
 import { stripVTControlCharacters, styleText } from "node:util";
 import { ast, collectImportedRefNames, collectUsedSchemaNames, extractStringsFromNodes } from "@kubb/ast";
 //#region \0rolldown/runtime.js
@@ -13,7 +14,7 @@ var __name = (target, value) => __defProp(target, "name", {
 });
 //#endregion
 //#region package.json
-var version = "5.11.3";
+var version = "5.11.5";
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -190,9 +191,26 @@ async function write(path, data, options = {}) {
 		stored: stored ?? "",
 		source: trimmed
 	})) return null;
+	await writeRaw(resolved, content);
+	if (options.sanity) {
+		const savedData = await read(resolved);
+		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return content;
+}
+/**
+* Writes UTF-8 content verbatim, including empty files and surrounding whitespace.
+* Uses Bun.write under Bun and creates missing parent directories under either runtime.
+*
+* @example
+* await writeRaw('./cache/output.ts', '  // keep these bytes\n\n')
+*/
+async function writeRaw(path, content) {
+	const resolved = resolve(path);
 	if (runtime.isBun) {
 		await Bun.write(resolved, content);
-		return content;
+		return;
 	}
 	try {
 		await writeFile(resolved, content, { encoding: "utf-8" });
@@ -201,12 +219,29 @@ async function write(path, data, options = {}) {
 		await mkdir(dirname(resolved), { recursive: true });
 		await writeFile(resolved, content, { encoding: "utf-8" });
 	}
-	if (options.sanity) {
-		const savedData = await readFile(resolved, { encoding: "utf-8" });
-		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
-		return savedData;
+}
+/**
+* Lists non-hidden regular files below `directory` as relative POSIX paths, excluding directories and symlinks.
+* Uses Bun.Glob under Bun because its Node glob compatibility API lacks directory-entry support.
+*
+* @example
+* for await (const path of listFiles('./src')) console.log(path)
+*/
+async function* listFiles(directory) {
+	const cwd = resolve(directory);
+	if (runtime.isBun) {
+		yield* new Bun.Glob("**/*").scan({
+			cwd,
+			dot: false,
+			onlyFiles: true,
+			followSymlinks: false
+		});
+		return;
 	}
-	return content;
+	for await (const entry of glob("**/*", {
+		cwd,
+		withFileTypes: true
+	})) if (entry.isFile()) yield toPosixPath(relative(cwd, join(entry.parentPath, entry.name)));
 }
 /**
 * Converts a filesystem path to use POSIX (`/`) separators.
@@ -579,13 +614,15 @@ function serialize(diagnostic) {
 * with `at`, `fix`, the first cause, and `Learn more` for an error, and one row for a warning.
 * `verbose` adds the full stack.
 */
-function format(diagnostic, { audience = "agent", verbose = false, width = 0 } = {}) {
+function format(diagnostic, { audience = "agent", verbose = false, width = 0, position } = {}) {
 	const { code, severity, message } = diagnostic;
 	const problem = Diagnostics.isProblem(diagnostic) ? diagnostic : void 0;
 	const human = audience === "human";
 	const paint = human ? styleText : (_format, text) => text;
 	const [firstLine = "", ...rest] = message.split("\n");
 	const pointer = problem?.location && "pointer" in problem.location ? problem.location.pointer : void 0;
+	const at = position ? `${position.file}:${position.line}:${position.column}` : void 0;
+	const where = at ?? pointer;
 	const help = problem ? getHelp(problem) : void 0;
 	const causes = problem ? getCauses(problem) : [];
 	const crash = problem ? crashCodes.has(problem.code) : false;
@@ -595,7 +632,7 @@ function format(diagnostic, { audience = "agent", verbose = false, width = 0 } =
 		const row = (label, value) => {
 			if (value) details.push(`  ${label}: ${value}`);
 		};
-		row("at", pointer);
+		row("at", at && pointer ? `${at} (${pointer})` : pointer);
 		if (problem && severity !== "info") row("why", Diagnostics.explain(problem.code).cause);
 		row("fix", help);
 		for (const cause of causes) row("caused by", cause);
@@ -605,24 +642,25 @@ function format(diagnostic, { audience = "agent", verbose = false, width = 0 } =
 		return [`${severity} ${code}${problem?.plugin ? ` [${problem.plugin}]` : ""}: ${firstLine}`, ...details];
 	}
 	const left = `${paint(severityStyle[severity], severityIcon[severity])} ${paint("bold", firstLine)}`;
-	const gap = Math.max(2, width - stripVTControlCharacters(left).length - code.length);
-	const headline = `${left}${" ".repeat(gap)}${paint("dim", code)}`;
+	const gap = width - stripVTControlCharacters(left).length - code.length;
+	const headline = width && gap < 2 ? [left, `${" ".repeat(Math.max(0, width - code.length))}${paint("dim", code)}`] : [`${left}${" ".repeat(Math.max(2, gap))}${paint("dim", code)}`];
 	const frame = rest.filter((line) => line.trim()).map((line) => `  ${paint("dim", line)}`);
 	const label = (name) => paint("dim", name.length < 4 ? name.padEnd(4) : `${name} `);
-	const rows = [["at", pointer && paint("cyan", pointer)], ["fix", help]];
+	const rows = [["at", where && paint("cyan", where)], ["fix", help]];
 	if (severity !== "error") {
 		const first = rows.find(([, value]) => value);
 		return [
-			headline,
+			...headline,
 			...frame,
 			...first ? [`  ${label(first[0])} ${first[1]}`] : []
 		];
 	}
 	rows.push(["caused by", causes[0]], ["report", problem?.issues && paint("cyan", problem.issues)]);
-	const details = [...frame, ...rows.flatMap(([name, value]) => value ? [`  ${label(name)} ${value}`] : [])];
+	const codeFrame = (position?.frame ?? []).map((line) => `    ${line}`);
+	const details = [...frame, ...rows.flatMap(([name, value]) => value ? [`  ${label(name)} ${value}`, ...name === "at" ? codeFrame : []] : [])];
 	if (frames?.length) details.push(`  ${paint("dim", "stack")}`, ...frames);
 	if (code !== diagnosticCode.unknown) details.push(`  ${paint("dim", "↳ Learn more")}  ${paint("cyan", Diagnostics.docsUrl(code).replace(/^https:\/\//, ""))}`);
-	return [headline, ...details];
+	return [...headline, ...details];
 }
 //#endregion
 //#region src/Diagnostics.ts
@@ -674,6 +712,7 @@ const failedCode = {
 	parser: diagnosticCode.parserFailed
 };
 const docsByCode = new Map(Object.values(diagnosticCatalog).map((doc) => [doc.code, doc]));
+const reporterKey = Symbol.for("kubb.diagnostics.reporter");
 const countKey = {
 	error: "errors",
 	warning: "warnings",
@@ -683,13 +722,13 @@ const countKey = {
 * Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
 * that lets deep code report a diagnostic without threading a callback.
 *
-* The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
+* The sink lives in a single `AsyncLocalStorage` on `globalThis`, shared by every copy of `@kubb/core`.
 * `Diagnostics.scope` activates it for a run, so anything inside that run (the
 * adapter parse, a generator) reports through `Diagnostics.report` and lands
 * in the same run.
 */
 var Diagnostics = class Diagnostics {
-	static #reporterStorage = new AsyncLocalStorage();
+	static #reporterStorage = globalThis[reporterKey] ??= new AsyncLocalStorage();
 	/**
 	* The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
 	*/
@@ -1032,7 +1071,7 @@ function defineExtension(definition) {
 					return Object.assign(build(options), {
 						name: meta.name,
 						meta,
-						options
+						options: raw
 					});
 				}
 			});
@@ -1527,7 +1566,8 @@ var Resolver = class Resolver {
 	#resolvePath({ baseName, tag, path: groupPath, root, output, group }) {
 		if (output.mode !== "directory") return path.resolve(root, output.path);
 		const outputDir = path.resolve(root, output.path);
-		const result = group && (groupPath || tag) ? path.resolve(outputDir, Resolver.#resolveGroupDir(group, group.type === "path" ? groupPath : tag), baseName) : path.resolve(outputDir, baseName);
+		const groupValue = group?.type === "path" ? groupPath : tag;
+		const result = group && groupValue ? path.resolve(outputDir, Resolver.#resolveGroupDir(group, groupValue), baseName) : path.resolve(outputDir, baseName);
 		assertInside({
 			target: result,
 			parent: outputDir,
@@ -1768,10 +1808,7 @@ function runParser(parser, print) {
 * Reads a `copy` file and prints it through the parser's `copy` hook, or verbatim with `banner`/`footer` when there is none.
 */
 async function parseCopy(file, parser) {
-	let content;
-	try {
-		content = await readFile(file.copy, "utf8");
-	} catch (err) {
+	const content = await readFile(file.copy, "utf8").catch((err) => {
 		throw new Diagnostics.Error({
 			code: Diagnostics.code.pluginFailed,
 			severity: "error",
@@ -1779,7 +1816,7 @@ async function parseCopy(file, parser) {
 			help: "Check that the file a plugin copies into the output exists and is readable.",
 			cause: toError(err)
 		});
-	}
+	});
 	if (parser?.copy) return runParser(parser, () => parser.parse(ast.factory.createFile(parser.copy(file, content))));
 	return [
 		file.banner,
@@ -1793,9 +1830,9 @@ function mergeFile(a, b) {
 		banner: b.banner,
 		footer: b.footer,
 		copy: b.copy ?? a.copy,
-		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
-		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
-		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
+		sources: [...a.sources, ...b.sources],
+		imports: [...a.imports, ...b.imports],
+		exports: [...a.exports, ...b.exports]
 	};
 }
 function isIndexPath(path) {
@@ -1804,17 +1841,49 @@ function isIndexPath(path) {
 function compareFiles(a, b) {
 	return a.path.length - b.path.length || Number(isIndexPath(a.path)) - Number(isIndexPath(b.path));
 }
-function isUnchanged({ stored, source, key, manifest }) {
-	if (stored === null) return false;
-	if (matchesStored({
+/**
+* Writes `source` to `file.path` unless the storage already holds it, either verbatim or, per the
+* manifest, as what the output passes make of it. Checking here rather than in a driver gives a
+* storage writing to S3 or a database the same guarantee `fsStorage` has. `false` when skipped.
+*/
+async function writeChanged({ storage, manifest, file, source, signal }) {
+	signal?.throwIfAborted();
+	const stored = await storage.readItem(file.path);
+	if (stored !== null && (matchesStored({
 		stored,
 		source
-	})) return true;
-	return manifest?.isUpToDate({
-		key,
+	}) || manifest?.isUpToDate({
+		key: file.path,
 		source,
 		disk: stored
-	}) ?? false;
+	}))) return false;
+	signal?.throwIfAborted();
+	await storage.writeItem(file.path, source, { stored });
+	manifest?.track({
+		key: file.path,
+		source
+	});
+	return true;
+}
+/** Reports finished files in input order: each finished file flushes the run of finished files ahead of it as one update. */
+function createProgress(files, config, hooks) {
+	const finished = [];
+	let flushed = 0;
+	return async (index) => {
+		finished[index] = true;
+		const updates = [];
+		while (finished[flushed]) {
+			flushed++;
+			updates.push({
+				file: files[flushed - 1],
+				processed: flushed,
+				total: files.length,
+				percentage: flushed / files.length * 100,
+				config
+			});
+		}
+		if (updates.length) await hooks.callHook("kubb:files:processing:update", { files: updates });
+	};
 }
 /**
 * In-memory file store for generated files, and the writer that turns them into source
@@ -1859,25 +1928,17 @@ var FileManager = class {
 		}
 	}
 	#store(files, mergeExisting) {
-		const batch = files.length > 1 ? this.#dedupe(files) : files;
-		const resolved = [];
-		for (const file of batch) {
+		const batch = /* @__PURE__ */ new Set();
+		const resolved = files.map((file) => {
 			const existing = this.#cache.get(file.path);
-			const merged = existing && mergeExisting ? ast.factory.createFile(mergeFile(existing, file)) : ast.factory.createFile(file);
+			const merged = ast.factory.createFile(existing && (mergeExisting || batch.has(file.path)) ? mergeFile(existing, file) : file);
 			this.#cache.set(merged.path, merged);
-			resolved.push(merged);
-		}
+			batch.add(merged.path);
+			return merged;
+		});
 		if (resolved.length > 0) this.#sorted = null;
 		return resolved;
 	}
-	#dedupe(files) {
-		const seen = /* @__PURE__ */ new Map();
-		for (const file of files) {
-			const prev = seen.get(file.path);
-			seen.set(file.path, prev ? mergeFile(prev, file) : file);
-		}
-		return [...seen.values()];
-	}
 	/**
 	* Releases all stored files. Called by the core after `kubb:build:end`.
 	*/
@@ -1905,50 +1966,38 @@ var FileManager = class {
 	* Parses and writes every file through a bounded pool of workers. A small spec runs all its files
 	* at once; a spec with thousands of files keeps at most {@link FILE_CONCURRENCY} parsed sources in
 	* memory rather than holding every source, while still overlapping each file's write with the
-	* next file's parse. Files finish in whatever order they parse, so the update rows are sorted back
-	* into input order before `kubb:files:processing:update` fires once with the whole batch.
+	* next file's parse. Files finish in whatever order they parse, so each finished file flushes the
+	* run of finished files ahead of it as one `kubb:files:processing:update`, keeping rows in input order.
 	*
 	* A file the storage already holds is skipped, so a rebuild that generates identical output
-	* writes nothing and leaves every mtime where it was.
+	* writes nothing and leaves every mtime where it was. `kubb:files:processing:end` lists the
+	* skipped paths as `unchanged`.
 	*/
 	async write(files, { storage, parsers, manifest, signal, hooks, config }) {
 		if (files.length === 0) return;
 		await hooks?.callHook("kubb:files:processing:start", { files });
-		const total = files.length;
-		const updates = [];
+		const unchanged = [];
+		const progress = hooks && config ? createProgress(files, config, hooks) : void 0;
 		await inParallel({
 			items: files,
 			limit: 50,
 			run: async (file, index) => {
 				signal?.throwIfAborted();
 				const source = await this.parse(file, { parsers });
-				if (config) updates.push({
+				if (source && !await writeChanged({
+					storage,
+					manifest,
 					file,
-					processed: index + 1,
-					total,
-					percentage: (index + 1) / total * 100,
-					config
-				});
-				if (!source) return;
-				signal?.throwIfAborted();
-				const stored = await storage.readItem(file.path);
-				if (isUnchanged({
-					stored,
 					source,
-					key: file.path,
-					manifest
-				})) return;
-				signal?.throwIfAborted();
-				await storage.writeItem(file.path, source, { stored });
-				manifest?.track({
-					key: file.path,
-					source
-				});
+					signal
+				})) unchanged.push(file.path);
+				await progress?.(index);
 			}
 		});
-		updates.sort((a, b) => a.processed - b.processed);
-		await hooks?.callHook("kubb:files:processing:update", { files: updates });
-		await hooks?.callHook("kubb:files:processing:end", { files });
+		await hooks?.callHook("kubb:files:processing:end", {
+			files,
+			unchanged
+		});
 	}
 };
 //#endregion
@@ -2276,10 +2325,15 @@ var KubbDriver = class {
 					plugin.options = normalizePluginOptions(plugin.options, plugin.name);
 				}
 				if (this.adapter && this.inputNode) {
+					const { meta, schemas, operations } = this.inputNode;
 					const buildStartContext = this.#withFiles({
 						config,
 						adapter: this.adapter,
-						meta: this.inputNode.meta,
+						meta,
+						nodeCounts: {
+							schemas: schemas.length,
+							operations: operations.length
+						},
 						getPlugin: this.getPlugin.bind(this)
 					});
 					await hooks.callHook("kubb:build:start", buildStartContext);
@@ -2564,7 +2618,10 @@ var KubbDriver = class {
 		}
 		return diagnostics;
 	}
-	/** Runs `node` through the generators whose `match` accepts it; `generate` picks the method for the node kind. */
+	/**
+	* Runs `node` through the generators whose `match` accepts it; `generate` picks the method for the
+	* node kind.
+	*/
 	async #dispatchNode({ generators, node, ctx, generate }) {
 		for (const generator of generators) {
 			if (!(generator.match ? await generator.match(node, ctx) : true)) continue;
@@ -2799,6 +2856,6 @@ var Hookable = class {
 	}
 };
 //#endregion
-export { inParallel as A, useOptions as C, Diagnostics as D, resolveMeta as E, toError as F, camelCase as I, __name as L, read as M, toPosixPath as N, formatMs as O, write as P, useKubb as S, defineExtension as T, setMacros as _, FileManager as a, tryUseKubb as b, Resolver as c, definePlugin as d, addGenerator as f, requirePlugin as g, kubbContext as h, createNodeCache as i, isPathInside as j, getElapsedMs as k, getInputKind as l, injectFile as m, KubbDriver as n, _usingCtx as o, addMacro as p, pluginNotFoundError as r, createResolver as s, Hookable as t, assertPluginOption as u, setOptions as v, checkCompatibility as w, useConfig as x, setResolver as y };
+export { inParallel as A, __name as B, useOptions as C, Diagnostics as D, resolveMeta as E, rm as F, write as I, writeRaw as L, isPathInside as M, listFiles as N, formatMs as O, read as P, toError as R, useKubb as S, defineExtension as T, setMacros as _, FileManager as a, tryUseKubb as b, Resolver as c, definePlugin as d, addGenerator as f, requirePlugin as g, kubbContext as h, createNodeCache as i, existsSync$1 as j, getElapsedMs as k, getInputKind as l, injectFile as m, KubbDriver as n, _usingCtx as o, addMacro as p, pluginNotFoundError as r, createResolver as s, Hookable as t, assertPluginOption as u, setOptions as v, checkCompatibility as w, useConfig as x, setResolver as y, camelCase as z };
 
-//# sourceMappingURL=Hookable-Ce-Xu-KB.js.map
+//# sourceMappingURL=Hookable-7Kv_oj72.js.map