@kubb/core 5.0.0-beta.41 → 5.0.0-beta.43

package/dist/{memoryStorage-DZqlEW7H.cjs → memoryStorage-Biujme_q.cjs}

@@ -25,7 +25,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let node_events = require("node:events");
+let node_crypto = require("node:crypto");
 let node_util = require("node:util");
+let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let _kubb_ast = require("@kubb/ast");
@@ -661,7 +663,7 @@ var URLPath = class {
 };
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.41";
+var version = "5.0.0-beta.43";
 //#endregion
 //#region src/constants.ts
 /**
@@ -1230,6 +1232,89 @@ function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
+//#region src/Fingerprint.ts
+/**
+* Computes the cache key for an incremental build. All methods are static, so call them as
+* `Fingerprint.compute(...)` and `Fingerprint.stringify(...)`. The key holds no absolute
+* paths or modification times, so it never depends on where the project lives on disk.
+*/
+var Fingerprint = class Fingerprint {
+	/**
+	* Bumped when the snapshot format or fingerprint inputs change in an incompatible way, so stale
+	* cache entries from older Kubb builds are never reused.
+	*/
+	static version = 1;
+	/**
+	* Deterministically serializes a value to JSON: object keys are sorted recursively and
+	* `undefined` values and functions are dropped. Two structurally equal configs produce the same
+	* string regardless of key order, which keeps the fingerprint stable across machines.
+	*/
+	static stringify(value) {
+		return JSON.stringify(Fingerprint.#normalize(value));
+	}
+	/**
+	* Computes a cache key from everything that affects the generated output: the spec content, the
+	* output-shaping config, each plugin's name and options, the middleware names, the running
+	* `@kubb/core` version, and the cache format version. Returns `null` when the input can't be
+	* fingerprinted (remote URL or no adapter source), which disables caching for that build.
+	*/
+	static async compute({ config, adapterSource, version }) {
+		if (!adapterSource) return null;
+		const spec = await Fingerprint.#readSpec(adapterSource, config.root);
+		if (spec === null) return null;
+		const input = {
+			cacheVersion: Fingerprint.version,
+			version,
+			spec,
+			name: config.name,
+			output: config.output,
+			adapter: config.adapter?.name,
+			parsers: config.parsers.map((parser) => parser.name),
+			plugins: config.plugins.map((plugin) => ({
+				name: plugin.name,
+				options: plugin.options
+			})),
+			middleware: (config.middleware ?? []).map((middleware) => middleware.name)
+		};
+		return (0, node_crypto.createHash)("sha256").update(Fingerprint.stringify(input)).digest("hex");
+	}
+	static #normalize(value) {
+		if (value === null || typeof value !== "object") return typeof value === "function" ? void 0 : value;
+		if (Array.isArray(value)) return value.map((item) => Fingerprint.#normalize(item));
+		const source = value;
+		const result = {};
+		for (const key of Object.keys(source).sort()) {
+			const normalized = Fingerprint.#normalize(source[key]);
+			if (normalized !== void 0) result[key] = normalized;
+		}
+		return result;
+	}
+	/**
+	* Reads the spec content that feeds the fingerprint. Returns `null` for a remote URL source
+	* (hashing remote content would mean fetching it on every run) or when a file can't be read, so a
+	* missing or virtual spec disables caching instead of failing the build.
+	*/
+	static async #readSpec(source, root) {
+		if (source.type === "data") return {
+			kind: "data",
+			data: typeof source.data === "string" ? source.data : Fingerprint.stringify(source.data)
+		};
+		const paths = source.type === "paths" ? source.paths : [source.path];
+		if (paths.some((path) => new URLPath(path).isURL)) return null;
+		try {
+			return {
+				kind: "path",
+				contents: await Promise.all(paths.map(async (path) => ({
+					path: (0, node_path.relative)(root, path),
+					content: await (0, node_fs_promises.readFile)(path, "utf8")
+				})))
+			};
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
 //#region src/definePlugin.ts
 /**
 * Wraps a plugin factory and returns a function that accepts user options and
@@ -2001,7 +2086,7 @@ var Transform = class {
 	}
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/usingCtx.js
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();
@@ -2124,9 +2209,10 @@ var KubbDriver = class KubbDriver {
 	}
 	async setup() {
 		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
+		const dependenciesByName = new Map(normalized.map((plugin) => [plugin.name, new Set(plugin.dependencies ?? [])]));
 		normalized.sort((a, b) => {
-			if (b.dependencies?.includes(a.name)) return -1;
-			if (a.dependencies?.includes(b.name)) return 1;
+			if (dependenciesByName.get(b.name)?.has(a.name)) return -1;
+			if (dependenciesByName.get(a.name)?.has(b.name)) return 1;
 			return enforceOrder(a.enforce) - enforceOrder(b.enforce);
 		});
 		for (const plugin of normalized) {
@@ -2351,8 +2437,10 @@ var KubbDriver = class KubbDriver {
 			await hooks.emit("kubb:files:processing:start", { files });
 		});
 		const updateBuffer = [];
+		const snapshotSources = /* @__PURE__ */ new Map();
 		processor.hooks.on("update", (item) => {
 			updateBuffer.push(item);
+			if (item.source !== void 0) snapshotSources.set(item.file.path, item.source);
 		});
 		processor.hooks.on("end", async (files) => {
 			await hooks.emit("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
@@ -2368,6 +2456,19 @@ var KubbDriver = class KubbDriver {
 		this.fileManager.hooks.on("upsert", onFileUpsert);
 		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
 			try {
+				const cache = config.cache;
+				const outputRoot = (0, node_path.resolve)(config.root, config.output.path);
+				const cacheKey = cache ? await Fingerprint.compute({
+					config,
+					adapterSource: this.#adapterSource,
+					version
+				}) : null;
+				if (cache && cacheKey && await this.#restoreSnapshot({
+					cache,
+					cacheKey,
+					outputRoot,
+					storage
+				})) return { diagnostics: Diagnostics.dedupe(diagnostics) };
 				await this.#parseInput();
 				await this.emitSetupHooks();
 				if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
@@ -2426,7 +2527,13 @@ var KubbDriver = class KubbDriver {
 				await hooks.emit("kubb:build:end", {
 					files: this.fileManager.files,
 					config,
-					outputDir: (0, node_path.resolve)(config.root, config.output.path)
+					outputDir: outputRoot
+				});
+				if (cache && cacheKey && !Diagnostics.hasError(diagnostics)) await this.#persistSnapshot({
+					cache,
+					cacheKey,
+					outputRoot,
+					sources: snapshotSources
 				});
 				return { diagnostics: Diagnostics.dedupe(diagnostics) };
 			} catch (caughtError) {
@@ -2437,6 +2544,40 @@ var KubbDriver = class KubbDriver {
 			}
 		});
 	}
+	/**
+	* Writes a restored snapshot straight to storage and emits `kubb:build:end`. Returns `true` on a
+	* hit (the build is done), `false` on a miss so the caller falls through to a full build.
+	*/
+	async #restoreSnapshot({ cache, cacheKey, outputRoot, storage }) {
+		const snapshot = await cache.restore({ key: cacheKey });
+		if (!snapshot) return false;
+		for (const [relativePath, source] of Object.entries(snapshot.files)) {
+			const absolutePath = (0, node_path.join)(outputRoot, relativePath);
+			this.fileManager.upsert((0, _kubb_ast.createFile)({
+				path: absolutePath,
+				baseName: (0, node_path.basename)(relativePath)
+			}));
+			await storage.setItem(absolutePath, source);
+		}
+		await this.hooks.emit("kubb:build:end", {
+			files: this.fileManager.files,
+			config: this.config,
+			outputDir: outputRoot
+		});
+		return true;
+	}
+	/**
+	* Stores this run's rendered output, keyed by the input fingerprint, so the next unchanged build
+	* restores it instead of regenerating. `sources` is keyed by absolute path and relativized here.
+	*/
+	async #persistSnapshot({ cache, cacheKey, outputRoot, sources }) {
+		const files = {};
+		for (const [absolutePath, source] of sources) files[(0, node_path.relative)(outputRoot, absolutePath)] = source;
+		await cache.persist({
+			key: cacheKey,
+			snapshot: { files }
+		});
+	}
 	#filesPayload() {
 		const driver = this;
 		return {
@@ -2513,10 +2654,8 @@ var KubbDriver = class KubbDriver {
 		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 schemasBuffer = [];
-		for await (const schema of schemas) schemasBuffer.push(schema);
-		const operationsBuffer = [];
-		for await (const operation of operations) operationsBuffer.push(operation);
+		const schemasBuffer = await Array.fromAsync(schemas);
+		const operationsBuffer = await Array.fromAsync(operations);
 		const pruningStates = states.filter(({ plugin }) => {
 			const { include } = plugin.options;
 			return (include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false);
@@ -2990,4 +3129,4 @@ Object.defineProperty(exports, "memoryStorage", {
 	}
 });
 
-//# sourceMappingURL=memoryStorage-DZqlEW7H.cjs.map
+//# sourceMappingURL=memoryStorage-Biujme_q.cjs.map