@kubb/core 5.0.0-alpha.36 → 5.0.0-alpha.39

package/dist/index.js

@@ -1,15 +1,11 @@
 import "./chunk--u3MIqq1.js";
-import { S as camelCase, _ as DEFAULT_STUDIO_URL, a as buildDefaultBanner, b as logLevel, c as defaultResolveFooter, d as defineResolver, f as definePlugin, g as DEFAULT_EXTENSION, h as DEFAULT_BANNER, i as FileManager, l as defaultResolveOptions, m as BARREL_FILENAME, n as getMode, o as defaultResolveBanner, p as pLimit, r as applyHookResult, s as defaultResolveFile, t as PluginDriver, u as defaultResolvePath, v as formatters, x as isValidVarName, y as linters } from "./PluginDriver-B_65W4fv.js";
+import { a as definePlugin, c as DEFAULT_BANNER, d as logLevel, f as isValidVarName, i as defineResolver, l as DEFAULT_EXTENSION, n as applyHookResult, o as pLimit, p as camelCase, r as FileManager, s as BARREL_FILENAME, t as PluginDriver, u as DEFAULT_STUDIO_URL } from "./PluginDriver-CgXFtmNP.js";
 import { EventEmitter } from "node:events";
-import { existsSync, readFileSync } from "node:fs";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { dirname, join, posix, resolve } from "node:path";
 import * as ast from "@kubb/ast";
-import { composeTransformers, createExport, createFile, createSource, definePrinter, extractStringsFromNodes, transform, walk } from "@kubb/ast";
-import { x } from "tinyexec";
+import { createExport, createFile, createSource, extractStringsFromNodes, transform, walk } from "@kubb/ast";
 import { version } from "node:process";
-import { sortBy } from "remeda";
-import { coerce, satisfies } from "semver";
 //#region ../../internals/utils/src/errors.ts
 /**
 * Thrown when one or more errors occur during a Kubb build.
@@ -185,26 +181,6 @@ function formatMs(ms) {
 //#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
-* Walks up the directory tree from `cwd` (defaults to `process.cwd()`) and
-* returns the absolute path of the nearest `package.json`, or `null` when none
-* is found before reaching the filesystem root.
-*
-* @example
-* ```ts
-* const pkgPath = findPackageJSON('/home/user/project/src') // '/home/user/project/package.json'
-* ```
-*/
-function findPackageJSON(cwd) {
-	let dir = cwd ? resolve(cwd) : process.cwd();
-	while (true) {
-		const pkgPath = join(dir, "package.json");
-		if (existsSync(pkgPath)) return pkgPath;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-/**
 * Converts all backslashes to forward slashes.
 * Extended-length Windows paths (`\\?\...`) are left unchanged.
 */
@@ -243,17 +219,6 @@ async function exists(path) {
 	return access(path).then(() => true, () => false);
 }
 /**
-* Synchronous counterpart of `read`.
-*
-* @example
-* ```ts
-* const source = readSync('./src/Pet.ts')
-* ```
-*/
-function readSync(path) {
-	return readFileSync(path, { encoding: "utf8" });
-}
-/**
 * 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.
@@ -539,6 +504,12 @@ function createStorage(build) {
 //#endregion
 //#region src/storages/fsStorage.ts
 /**
+* Detects the filesystem error used to indicate that a path does not exist.
+*/
+function isMissingPathError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+/**
 * Built-in filesystem storage driver.
 *
 * This is the default storage when no `storage` option is configured in `output`.
@@ -567,15 +538,17 @@ const fsStorage = createStorage(() => ({
 		try {
 			await access(resolve(key));
 			return true;
-		} catch {
-			return false;
+		} catch (error) {
+			if (isMissingPathError(error)) return false;
+			throw new Error(`Failed to access storage item "${key}"`, { cause: error });
 		}
 	},
 	async getItem(key) {
 		try {
 			return await readFile(resolve(key), "utf8");
-		} catch {
-			return null;
+		} catch (error) {
+			if (isMissingPathError(error)) return null;
+			throw new Error(`Failed to read storage item "${key}"`, { cause: error });
 		}
 	},
 	async setItem(key, value) {
@@ -586,12 +559,14 @@ const fsStorage = createStorage(() => ({
 	},
 	async getKeys(base) {
 		const keys = [];
+		const resolvedBase = resolve(base ?? process.cwd());
 		async function walk(dir, prefix) {
 			let entries;
 			try {
 				entries = await readdir(dir, { withFileTypes: true });
-			} catch {
-				return;
+			} catch (error) {
+				if (isMissingPathError(error)) return;
+				throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
 			}
 			for (const entry of entries) {
 				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -599,7 +574,7 @@ const fsStorage = createStorage(() => ({
 				else keys.push(rel);
 			}
 		}
-		await walk(resolve(base ?? process.cwd()), "");
+		await walk(resolvedBase, "");
 		return keys;
 	},
 	async clear(base) {
@@ -609,7 +584,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-alpha.36";
+var version$1 = "5.0.0-alpha.39";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -724,14 +699,14 @@ var TreeNode = class TreeNode {
 				name: filteredTree.name,
 				path: filteredTree.path,
 				file: filteredTree.file,
-				type: getMode(filteredTree.path)
+				type: PluginDriver.getMode(filteredTree.path)
 			});
 			const recurse = (node, item) => {
 				const subNode = node.addChild({
 					name: item.name,
 					path: item.path,
 					file: item.file,
-					type: getMode(item.path)
+					type: PluginDriver.getMode(item.path)
 				});
 				if (item.children?.length) item.children?.forEach((child) => {
 					recurse(subNode, child);
@@ -1316,30 +1291,6 @@ function createKubb(options) {
 	return instance;
 }
 //#endregion
-//#region src/createPlugin.ts
-/**
-* Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
-*
-* @example
-* ```ts
-* export const myPlugin = createPlugin<MyPlugin>((options) => {
-*   return {
-*     name: 'my-plugin',
-*     get options() { return options },
-*     resolvePath(baseName) { ... },
-*     resolveName(name, type) { ... },
-*   }
-* })
-*
-* // instantiate
-* const plugin = myPlugin({ output: { path: 'src/gen' } })
-* ```
-* @deprecated use definePlugin instead
-*/
-function createPlugin(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
 //#region src/createRenderer.ts
 /**
 * Creates a renderer factory for use in generator definitions.
@@ -1473,245 +1424,6 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-//#region src/utils/formatters.ts
-/**
-* Returns `true` when the given formatter is installed and callable.
-*
-* Availability is detected by running `<formatter> --version` and checking
-* that the process exits without error.
-*/
-async function isFormatterAvailable(formatter) {
-	try {
-		await x(formatter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detects the first available code formatter on the current system.
-*
-* - Checks in preference order: `biome`, `oxfmt`, `prettier`.
-* - Returns `null` when none are found.
-*
-* @example
-* ```ts
-* const formatter = await detectFormatter()
-* if (formatter) {
-*   console.log(`Using ${formatter} for formatting`)
-* }
-* ```
-*/
-async function detectFormatter() {
-	const formatterNames = new Set([
-		"biome",
-		"oxfmt",
-		"prettier"
-	]);
-	for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
-	return null;
-}
-//#endregion
-//#region src/utils/getFunctionParams.ts
-function order(items) {
-	return sortBy(items.filter(Boolean), ([_key, item]) => {
-		if (item?.children) return 0;
-		if (item?.optional) return 1;
-		if (item?.default) return 2;
-		return 0;
-	});
-}
-function parseChild(key, item, options) {
-	const entries = order(Object.entries(item.children));
-	const types = [];
-	const names = [];
-	const optional = entries.every(([_key, item]) => item?.optional || !!item?.default);
-	entries.forEach(([key, entryItem]) => {
-		if (entryItem) {
-			const name = parseItem(key, {
-				...entryItem,
-				type: void 0
-			}, options);
-			if (entryItem.children) {
-				const subTypes = Object.entries(entryItem.children).map(([key]) => {
-					return key;
-				}).join(", ");
-				if (subTypes) names.push(`${name}: { ${subTypes} }`);
-				else names.push(name);
-			} else if (options.type === "call" && options.transformName) names.push(`${key}: ${name}`);
-			else names.push(name);
-			if (entries.some(([_key, item]) => item?.type)) types.push(parseItem(key, {
-				...entryItem,
-				default: void 0
-			}, options));
-		}
-	});
-	const name = item.mode === "inline" ? key : names.length ? `{ ${names.join(", ")} }` : void 0;
-	const type = item.type ? item.type : types.length ? `{ ${types.join("; ")} }` : void 0;
-	if (!name) return null;
-	return parseItem(name, {
-		type,
-		default: item.default,
-		optional: !item.default ? optional : void 0
-	}, options);
-}
-function parseItem(name, item, options) {
-	const acc = [];
-	const transformedName = options.transformName ? options.transformName(name) : name;
-	const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type;
-	if (options.type === "object") return transformedName;
-	if (options.type === "objectValue") return item.value ? `${transformedName}: ${item.value}` : transformedName;
-	if (item.type && options.type === "constructor") if (item.optional) if (transformedName.startsWith("{")) acc.push(`${transformedName}: ${transformedType} = {}`);
-	else acc.push(`${transformedName}?: ${transformedType}`);
-	else acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ""}`);
-	else if (item.default && options.type === "constructor") acc.push(`${transformedName} = ${item.default}`);
-	else if (item.value) acc.push(`${transformedName} : ${item.value}`);
-	else if (item.mode === "inlineSpread") acc.push(`... ${transformedName}`);
-	else acc.push(transformedName);
-	return acc[0];
-}
-function getFunctionParams(params, options) {
-	return order(Object.entries(params)).reduce((acc, [key, item]) => {
-		if (!item) return acc;
-		if (item.children) {
-			if (Object.keys(item.children).length === 0) return acc;
-			if (item.mode === "inlineSpread") return [...acc, getFunctionParams(item.children, options)];
-			const parsedItem = parseChild(key, item, options);
-			if (!parsedItem) return acc;
-			return [...acc, parsedItem];
-		}
-		const parsedItem = parseItem(key, item, options);
-		return [...acc, parsedItem];
-	}, []).join(", ");
-}
-/**
-* @deprecated use @kubb/ast
-*/
-function createFunctionParams(params) {
-	return params;
-}
-/**
-* @deprecated use @kubb/ast
-*/
-var FunctionParams = class FunctionParams {
-	#params;
-	static factory(params) {
-		return new FunctionParams(params);
-	}
-	constructor(params) {
-		this.#params = params;
-	}
-	get params() {
-		return this.#params;
-	}
-	get flatParams() {
-		const flatter = (acc, [key, item]) => {
-			if (item?.children) return Object.entries(item.children).reduce(flatter, acc);
-			if (item) acc[key] = item;
-			return acc;
-		};
-		return Object.entries(this.#params).reduce(flatter, {});
-	}
-	toCall({ transformName, transformType } = {}) {
-		return getFunctionParams(this.#params, {
-			type: "call",
-			transformName,
-			transformType
-		});
-	}
-	toObject() {
-		return getFunctionParams(this.#params, { type: "object" });
-	}
-	toObjectValue() {
-		return getFunctionParams(this.#params, { type: "objectValue" });
-	}
-	toConstructor() {
-		return getFunctionParams(this.#params, { type: "constructor" });
-	}
-};
-//#endregion
-//#region src/utils/linters.ts
-/**
-* Returns `true` when the given linter is installed and callable.
-*
-* Availability is detected by running `<linter> --version` and checking
-* that the process exits without error.
-*/
-async function isLinterAvailable(linter) {
-	try {
-		await x(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detects the first available linter on the current system.
-*
-* - Checks in preference order: `biome`, `oxlint`, `eslint`.
-* - Returns `null` when none are found.
-*
-* @example
-* ```ts
-* const linter = await detectLinter()
-* if (linter) {
-*   console.log(`Using ${linter} for linting`)
-* }
-* ```
-*/
-async function detectLinter() {
-	const linterNames = new Set([
-		"biome",
-		"oxlint",
-		"eslint"
-	]);
-	for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
-	return null;
-}
-//#endregion
-//#region src/utils/packageJSON.ts
-function getPackageJSONSync(cwd) {
-	const pkgPath = findPackageJSON(cwd);
-	if (!pkgPath) return null;
-	return JSON.parse(readSync(pkgPath));
-}
-function match(packageJSON, dependency) {
-	const dependencies = {
-		...packageJSON.dependencies || {},
-		...packageJSON.devDependencies || {}
-	};
-	if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
-	const matched = Object.keys(dependencies).find((dep) => dep.match(dependency));
-	return matched ? dependencies[matched] ?? null : null;
-}
-function getVersionSync(dependency, cwd) {
-	const packageJSON = getPackageJSONSync(cwd);
-	return packageJSON ? match(packageJSON, dependency) : null;
-}
-/**
-* Returns `true` when the nearest `package.json` declares a dependency that
-* satisfies the given semver range.
-*
-* - Searches both `dependencies` and `devDependencies`.
-* - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
-* - Uses `semver.satisfies` for range comparison; returns `false` when the
-*   version string cannot be coerced into a valid semver.
-*
-* @example
-* ```ts
-* satisfiesDependency('react', '>=18')          // true when react@18.x is installed
-* satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
-* ```
-*/
-function satisfiesDependency(dependency, version, cwd) {
-	const packageVersion = getVersionSync(dependency, cwd);
-	if (!packageVersion) return false;
-	if (packageVersion === version) return true;
-	const semVer = coerce(packageVersion);
-	if (!semVer) return false;
-	return satisfies(semVer, version);
-}
-//#endregion
-export { AsyncEventEmitter, FileManager, FileProcessor, FunctionParams, PluginDriver, URLPath, ast, buildDefaultBanner, composeTransformers, createAdapter, createFunctionParams, createKubb, createPlugin, createRenderer, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineGenerator, defineLogger, defineParser, definePlugin, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getFunctionParams, getMode, isInputPath, linters, logLevel, memoryStorage, satisfiesDependency };
+export { AsyncEventEmitter, FileManager, FileProcessor, PluginDriver, URLPath, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
 
 //# sourceMappingURL=index.js.map