@kubb/core 4.35.0 → 4.36.0

package/dist/hooks.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { M as PluginManager, _ as PluginFactoryOptions, h as Plugin } from "./types-7DgxNmCG.js";
+import { N as PluginManager, _ as PluginFactoryOptions, h as Plugin } from "./types-D-MpaA4Z.js";
 import { KubbFile } from "@kubb/fabric-core/types";
 
 //#region src/hooks/useMode.d.ts

package/dist/index.cjs

@@ -409,7 +409,7 @@ function readSync(path) {
 * identical to what is already on disk.
 * Creates any missing parent directories automatically.
 * When `sanity` is `true`, re-reads the file after writing and throws if the
-* content does not match — useful for catching write failures on unreliable file systems.
+* content does not match.
 */
 async function write(path, data, options = {}) {
 	const trimmed = data.trim();
@@ -1367,8 +1367,109 @@ var PluginManager = class {
 	}
 };
 //#endregion
+//#region src/defineStorage.ts
+/**
+* Wraps a storage builder so the `options` argument is optional, following the
+* same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
+*
+* The builder receives the resolved options object and must return a
+* `DefineStorage`-compatible object that includes a `name` string.
+*
+* @example
+* ```ts
+* import { defineStorage } from '@kubb/core'
+*
+* export const memoryStorage = defineStorage((_options) => {
+*   const store = new Map<string, string>()
+*   return {
+*     name: 'memory',
+*     async hasItem(key) { return store.has(key) },
+*     async getItem(key) { return store.get(key) ?? null },
+*     async setItem(key, value) { store.set(key, value) },
+*     async removeItem(key) { store.delete(key) },
+*     async getKeys() { return [...store.keys()] },
+*     async clear() { store.clear() },
+*   }
+* })
+* ```
+*/
+function defineStorage(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/storages/fsStorage.ts
+/**
+* Built-in filesystem storage driver.
+*
+* This is the default storage when no `storage` option is configured in `output`.
+* Keys are resolved against `process.cwd()`, so root-relative paths such as
+* `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
+*
+* Internally uses the `write` utility from `@internals/utils`, which:
+* - trims leading/trailing whitespace before writing
+* - skips the write when file content is already identical (deduplication)
+* - creates missing parent directories automatically
+* - supports Bun's native file API when running under Bun
+*
+* @example
+* ```ts
+* import { defineConfig, fsStorage } from '@kubb/core'
+*
+* export default defineConfig({
+*   input:  { path: './petStore.yaml' },
+*   output: { path: './src/gen', storage: fsStorage() },
+* })
+* ```
+*/
+const fsStorage = defineStorage(() => ({
+	name: "fs",
+	async hasItem(key) {
+		try {
+			await (0, node_fs_promises.access)((0, node_path.resolve)(key));
+			return true;
+		} catch {
+			return false;
+		}
+	},
+	async getItem(key) {
+		try {
+			return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
+		} catch {
+			return null;
+		}
+	},
+	async setItem(key, value) {
+		await write((0, node_path.resolve)(key), value, { sanity: false });
+	},
+	async removeItem(key) {
+		await (0, node_fs_promises.rm)((0, node_path.resolve)(key), { force: true });
+	},
+	async getKeys(base) {
+		const keys = [];
+		async function walk(dir, prefix) {
+			let entries;
+			try {
+				entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) await walk((0, node_path.join)(dir, entry.name), rel);
+				else keys.push(rel);
+			}
+		}
+		await walk((0, node_path.resolve)(base ?? process.cwd()), "");
+		return keys;
+	},
+	async clear(base) {
+		if (!base) return;
+		await clean((0, node_path.resolve)(base));
+	}
+}));
+//#endregion
 //#region package.json
-var version = "4.35.0";
+var version = "4.36.0";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -1399,7 +1500,7 @@ async function setup(options) {
 			`  • Output: ${userConfig.output?.path || "not specified"}`,
 			`  • Plugins: ${userConfig.plugins?.length || 0}`,
 			"Output Settings:",
-			`  • Write: ${userConfig.output?.write !== false ? "enabled" : "disabled"}`,
+			`  • Storage: ${userConfig.output?.storage ? `custom(${userConfig.output.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
 			`  • Formatter: ${userConfig.output?.format || "none"}`,
 			`  • Linter: ${userConfig.output?.lint || "none"}`,
 			"Environment:",
@@ -1436,12 +1537,13 @@ async function setup(options) {
 		} : void 0,
 		plugins: userConfig.plugins
 	};
+	const storage = definedConfig.output.write === false ? null : definedConfig.output.storage ?? fsStorage();
 	if (definedConfig.output.clean) {
 		await events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: ["Cleaning output directories", `  • Output: ${definedConfig.output.path}`]
 		});
-		await clean(definedConfig.output.path);
+		await storage?.clear((0, node_path.resolve)(definedConfig.root, definedConfig.output.path));
 	}
 	const fabric = (0, _kubb_react_fabric.createFabric)();
 	fabric.use(_kubb_react_fabric_plugins.fsPlugin);
@@ -1461,7 +1563,8 @@ async function setup(options) {
 			source
 		});
 		if (source) {
-			if (definedConfig.output.write) await write(file.path, source, { sanity: false });
+			const key = (0, node_path.relative)((0, node_path.resolve)(definedConfig.root), file.path);
+			await storage?.setItem(key, source);
 			sources.set(file.path, source);
 		}
 	});
@@ -1476,7 +1579,7 @@ async function setup(options) {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
 			"✓ Fabric initialized",
-			`  • File writing: ${definedConfig.output.write ? "enabled" : "disabled (dry-run)"}`,
+			`  • Storage: ${storage ? storage.name : "disabled (dry-run)"}`,
 			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
 		]
 	});
@@ -1794,6 +1897,54 @@ var PackageManager = class PackageManager {
 	}
 };
 //#endregion
+//#region src/storages/memoryStorage.ts
+/**
+* In-memory storage driver. Useful for testing and dry-run scenarios where
+* generated output should be captured without touching the filesystem.
+*
+* All data lives in a `Map` scoped to the storage instance and is discarded
+* when the instance is garbage-collected.
+*
+* @example
+* ```ts
+* import { defineConfig, memoryStorage } from '@kubb/core'
+*
+* export default defineConfig({
+*   input:  { path: './petStore.yaml' },
+*   output: { path: './src/gen', storage: memoryStorage() },
+* })
+* ```
+*/
+const memoryStorage = defineStorage(() => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		name: "memory",
+		async hasItem(key) {
+			return store.has(key);
+		},
+		async getItem(key) {
+			return store.get(key) ?? null;
+		},
+		async setItem(key, value) {
+			store.set(key, value);
+		},
+		async removeItem(key) {
+			store.delete(key);
+		},
+		async getKeys(base) {
+			const keys = [...store.keys()];
+			return base ? keys.filter((k) => k.startsWith(base)) : keys;
+		},
+		async clear(base) {
+			if (!base) {
+				store.clear();
+				return;
+			}
+			for (const key of store.keys()) if (key.startsWith(base)) store.delete(key);
+		}
+	};
+});
+//#endregion
 //#region src/utils/FunctionParams.ts
 /**
 * @deprecated
@@ -2180,15 +2331,18 @@ Object.defineProperty(exports, "definePrinter", {
 		return _kubb_ast.definePrinter;
 	}
 });
+exports.defineStorage = defineStorage;
 exports.detectFormatter = detectFormatter;
 exports.detectLinter = detectLinter;
 exports.formatters = formatters;
+exports.fsStorage = fsStorage;
 exports.getBarrelFiles = getBarrelFiles;
 exports.getConfigs = getConfigs;
 exports.getMode = getMode;
 exports.isInputPath = isInputPath;
 exports.linters = linters;
 exports.logLevel = logLevel;
+exports.memoryStorage = memoryStorage;
 exports.safeBuild = safeBuild;
 exports.setup = setup;