@kubb/cli 4.23.0 → 4.24.0

package/dist/{generate-DhFw-owG.js → generate-DoM5hz_l.js}

@@ -1,21 +1,24 @@
-import { t as __name } from "./chunk-jHaXqnEa.js";
-import { t as version } from "./package-_Sd-Chc0.js";
-import { n as getConfigs, r as generate, t as getCosmiConfig } from "./getCosmiConfig-y2n_oW_y.js";
+import { t as __name } from "./chunk-EyRqdYP6.js";
+import { t as version } from "./package-DbleONiT.js";
 import { defineCommand, showUsage } from "citty";
 import path, { relative, resolve } from "node:path";
 import * as process$2 from "node:process";
 import process$1 from "node:process";
 import * as clack from "@clack/prompts";
-import { LogLevel, PromiseManager, defineLogger, isInputPath } from "@kubb/core";
-import { AsyncEventEmitter, executeIfOnline, formatHrtime, formatMs } from "@kubb/core/utils";
-import getLatestVersion from "latest-version";
+import { execa, execaCommand } from "execa";
 import pc from "picocolors";
+import { LogLevel, PromiseManager, defineLogger, isInputPath, safeBuild, setup } from "@kubb/core";
+import { AsyncEventEmitter, executeIfOnline, formatHrtime, formatMs, isPromise } from "@kubb/core/utils";
+import getLatestVersion from "latest-version";
 import { lt } from "semver";
-import { execa } from "execa";
 import gradientString from "gradient-string";
 import seedrandom from "seedrandom";
 import { Writable } from "node:stream";
 import { write } from "@kubb/core/fs";
+import { createHash } from "node:crypto";
+import { parseArgsStringToArgv } from "string-argv";
+import { cosmiconfig } from "cosmiconfig";
+import { createJiti } from "jiti";
 
 //#region src/utils/formatMsWithColor.ts
 /**
@@ -1142,6 +1145,430 @@ async function setupLogger(context, { logLevel }) {
 	return cleanup;
 }
 
+//#endregion
+//#region src/utils/detectFormatter.ts
+/**
+* Check if a formatter command is available in the system.
+*
+* @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
+* @returns Promise that resolves to true if the formatter is available, false otherwise
+*
+* @remarks
+* This function checks availability by running `<formatter> --version` command.
+* All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+*/
+async function isFormatterAvailable(formatter) {
+	try {
+		await execaCommand(`${formatter} --version`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detect which formatter is available in the system.
+*
+* @returns Promise that resolves to the first available formatter or undefined if none are found
+*
+* @remarks
+* Checks in order of preference: biome, oxfmt, prettier.
+* Uses the `--version` flag to detect if each formatter command is available.
+* This is a reliable method as all supported formatters implement this flag.
+*
+* @example
+* ```typescript
+* const formatter = await detectFormatter()
+* if (formatter) {
+*   console.log(`Using ${formatter} for formatting`)
+* } else {
+*   console.log('No formatter found')
+* }
+* ```
+*/
+async function detectFormatter() {
+	for (const formatter of [
+		"biome",
+		"oxfmt",
+		"prettier"
+	]) if (await isFormatterAvailable(formatter)) return formatter;
+}
+
+//#endregion
+//#region src/utils/detectLinter.ts
+/**
+* Check if a linter command is available in the system.
+*
+* @param linter - The linter to check ('biome', 'oxlint', or 'eslint')
+* @returns Promise that resolves to true if the linter is available, false otherwise
+*
+* @remarks
+* This function checks availability by running `<linter> --version` command.
+* All supported linters (biome, oxlint, eslint) implement the --version flag.
+*/
+async function isLinterAvailable(linter) {
+	try {
+		await execaCommand(`${linter} --version`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detect which linter is available in the system.
+*
+* @returns Promise that resolves to the first available linter or undefined if none are found
+*
+* @remarks
+* Checks in order of preference: biome, oxlint, eslint.
+* Uses the `--version` flag to detect if each linter command is available.
+* This is a reliable method as all supported linters implement this flag.
+*
+* @example
+* ```typescript
+* const linter = await detectLinter()
+* if (linter) {
+*   console.log(`Using ${linter} for linting`)
+* } else {
+*   console.log('No linter found')
+* }
+* ```
+*/
+async function detectLinter() {
+	for (const linter of [
+		"biome",
+		"oxlint",
+		"eslint"
+	]) if (await isLinterAvailable(linter)) return linter;
+}
+
+//#endregion
+//#region src/utils/executeHooks.ts
+async function executeHooks({ hooks, events }) {
+	const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean);
+	for (const command$1 of commands) {
+		const [cmd, ...args] = [...parseArgsStringToArgv(command$1)];
+		if (!cmd) continue;
+		const hookId = createHash("sha256").update(command$1).digest("hex");
+		await events.emit("hook:start", {
+			id: hookId,
+			command: cmd,
+			args
+		});
+		await events.onOnce("hook:end", async ({ success, error }) => {
+			if (!success) throw error;
+			await events.emit("success", `${pc.dim(command$1)} successfully executed`);
+		});
+	}
+}
+
+//#endregion
+//#region src/utils/formatters.ts
+const formatters = {
+	prettier: {
+		command: "prettier",
+		args: (outputPath) => [
+			"--ignore-unknown",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Prettier not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"format",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxfmt: {
+		command: "oxfmt",
+		args: (outputPath) => [outputPath],
+		errorMessage: "Oxfmt not found"
+	}
+};
+
+//#endregion
+//#region src/runners/generate.ts
+async function generate({ input, config: userConfig, events, logLevel }) {
+	const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
+	const hrStart = process$1.hrtime();
+	const config = {
+		...userConfig,
+		root: userConfig.root || process$1.cwd(),
+		input: inputPath ? {
+			...userConfig.input,
+			path: inputPath
+		} : userConfig.input,
+		output: {
+			write: true,
+			barrelType: "named",
+			extension: { ".ts": ".ts" },
+			format: "prettier",
+			...userConfig.output
+		}
+	};
+	await events.emit("generation:start", config);
+	await events.emit("info", config.name ? `Setup generation ${pc.bold(config.name)}` : "Setup generation", inputPath);
+	const { sources, fabric, pluginManager } = await setup({
+		config,
+		events
+	});
+	await events.emit("info", config.name ? `Build generation ${pc.bold(config.name)}` : "Build generation", inputPath);
+	const { files, failedPlugins, pluginTimings, error } = await safeBuild({
+		config,
+		events
+	}, {
+		pluginManager,
+		fabric,
+		events,
+		sources
+	});
+	await events.emit("info", "Load summary");
+	if (failedPlugins.size > 0 || error) {
+		[error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean).forEach((err) => {
+			events.emit("error", err);
+		});
+		await events.emit("generation:end", config, files, sources);
+		await events.emit("generation:summary", config, {
+			failedPlugins,
+			filesCreated: files.length,
+			status: failedPlugins.size > 0 || error ? "failed" : "success",
+			hrStart,
+			pluginTimings: logLevel >= LogLevel.verbose ? pluginTimings : void 0
+		});
+		process$1.exit(1);
+	}
+	await events.emit("success", "Generation successfully", inputPath);
+	await events.emit("generation:end", config, files, sources);
+	if (config.output.format) {
+		await events.emit("format:start");
+		let formatter = config.output.format;
+		if (formatter === "auto") {
+			const detectedFormatter = await detectFormatter();
+			if (!detectedFormatter) await events.emit("warn", "No formatter found (biome, prettier, or oxfmt). Skipping formatting.");
+			else {
+				formatter = detectedFormatter;
+				await events.emit("info", `Auto-detected formatter: ${pc.dim(formatter)}`);
+			}
+		}
+		if (formatter && formatter !== "auto" && formatter in formatters) {
+			const formatterConfig = formatters[formatter];
+			const outputPath = path.resolve(config.root, config.output.path);
+			try {
+				const hookId = createHash("sha256").update([config.name, formatter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: formatterConfig.command,
+					args: formatterConfig.args(outputPath)
+				});
+				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
+					if (!success) throw error$1;
+					await events.emit("success", [
+						`Formatting with ${pc.dim(formatter)}`,
+						logLevel >= LogLevel.info ? `on ${pc.dim(outputPath)}` : void 0,
+						"successfully"
+					].filter(Boolean).join(" "));
+				});
+			} catch (caughtError) {
+				const error$1 = new Error(formatterConfig.errorMessage);
+				error$1.cause = caughtError;
+				await events.emit("error", error$1);
+			}
+		}
+		await events.emit("format:end");
+	}
+	if (config.output.lint) {
+		await events.emit("lint:start");
+		let linter = config.output.lint;
+		if (linter === "auto") {
+			const detectedLinter = await detectLinter();
+			if (!detectedLinter) await events.emit("warn", "No linter found (biome, oxlint, or eslint). Skipping linting.");
+			else {
+				linter = detectedLinter;
+				await events.emit("info", `Auto-detected linter: ${pc.dim(linter)}`);
+			}
+		}
+		if (linter && linter !== "auto") {
+			await events.emit("info", [`Linting with ${pc.dim(linter)}`, logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : void 0].filter(Boolean).join(" "));
+			if (linter === "eslint") try {
+				const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: "eslint",
+					args: [path.resolve(config.root, config.output.path), "--fix"]
+				});
+				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
+					if (!success) throw error$1;
+					await events.emit("success", [
+						`Linted with ${pc.dim(linter)}`,
+						logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : void 0,
+						"successfully"
+					].filter(Boolean).join(" "));
+				});
+			} catch (caughtError) {
+				const error$1 = /* @__PURE__ */ new Error("Eslint not found");
+				error$1.cause = caughtError;
+				await events.emit("error", error$1);
+			}
+			if (linter === "biome") try {
+				const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: "biome",
+					args: [
+						"lint",
+						"--fix",
+						path.resolve(config.root, config.output.path)
+					]
+				});
+				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
+					if (!success) throw error$1;
+					await events.emit("success", [
+						`Linted with ${pc.dim(linter)}`,
+						logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : void 0,
+						"successfully"
+					].filter(Boolean).join(" "));
+				});
+			} catch (caughtError) {
+				const error$1 = /* @__PURE__ */ new Error("Biome not found");
+				error$1.cause = caughtError;
+				await events.emit("error", error$1);
+			}
+			if (linter === "oxlint") try {
+				const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: "oxlint",
+					args: ["--fix", path.resolve(config.root, config.output.path)]
+				});
+				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
+					if (!success) throw error$1;
+					await events.emit("success", [
+						`Linted with ${pc.dim(linter)}`,
+						logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : void 0,
+						"successfully"
+					].filter(Boolean).join(" "));
+				});
+			} catch (caughtError) {
+				const error$1 = /* @__PURE__ */ new Error("Oxlint not found");
+				error$1.cause = caughtError;
+				await events.emit("error", error$1);
+			}
+		}
+		await events.emit("lint:end");
+	}
+	if (config.hooks) {
+		await events.emit("hooks:start");
+		await executeHooks({
+			hooks: config.hooks,
+			events
+		});
+		await events.emit("hooks:end");
+	}
+	await events.emit("generation:summary", config, {
+		failedPlugins,
+		filesCreated: files.length,
+		status: failedPlugins.size > 0 || error ? "failed" : "success",
+		hrStart,
+		pluginTimings
+	});
+}
+
+//#endregion
+//#region src/utils/getPlugins.ts
+function isJSONPlugins(plugins) {
+	return !!plugins?.some((plugin) => {
+		return Array.isArray(plugin) && typeof plugin?.at(0) === "string";
+	});
+}
+function isObjectPlugins(plugins) {
+	return plugins instanceof Object && !Array.isArray(plugins);
+}
+function getPlugins(plugins) {
+	if (isObjectPlugins(plugins)) throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
+	if (isJSONPlugins(plugins)) throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
+	return Promise.resolve(plugins);
+}
+
+//#endregion
+//#region src/utils/getConfigs.ts
+/**
+* Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+*/
+async function getConfigs(result, args) {
+	const config = result?.config;
+	let kubbUserConfig = Promise.resolve(config);
+	if (typeof config === "function") {
+		const possiblePromise = config(args);
+		if (isPromise(possiblePromise)) kubbUserConfig = possiblePromise;
+		kubbUserConfig = Promise.resolve(possiblePromise);
+	}
+	let JSONConfig = await kubbUserConfig;
+	if (!Array.isArray(JSONConfig)) JSONConfig = [JSONConfig];
+	const results = [];
+	for (const item of JSONConfig) {
+		const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
+		results.push({
+			...item,
+			plugins
+		});
+	}
+	return results;
+}
+
+//#endregion
+//#region src/utils/getCosmiConfig.ts
+const tsLoader = async (configFile) => {
+	return await createJiti(configFile, {
+		jsx: {
+			runtime: "automatic",
+			importSource: "@kubb/react-fabric"
+		},
+		sourceMaps: true,
+		interopDefault: true
+	}).import(configFile, { default: true });
+};
+async function getCosmiConfig(moduleName, config) {
+	let result;
+	const searchPlaces = [
+		"package.json",
+		`.${moduleName}rc`,
+		`.${moduleName}rc.json`,
+		`.${moduleName}rc.yaml`,
+		`.${moduleName}rc.yml`,
+		`.${moduleName}rc.ts`,
+		`.${moduleName}rc.js`,
+		`.${moduleName}rc.mjs`,
+		`.${moduleName}rc.cjs`,
+		`${moduleName}.config.ts`,
+		`${moduleName}.config.js`,
+		`${moduleName}.config.mjs`,
+		`${moduleName}.config.cjs`
+	];
+	const explorer = cosmiconfig(moduleName, {
+		cache: false,
+		searchPlaces: [
+			...searchPlaces.map((searchPlace) => {
+				return `.config/${searchPlace}`;
+			}),
+			...searchPlaces.map((searchPlace) => {
+				return `configs/${searchPlace}`;
+			}),
+			...searchPlaces
+		],
+		loaders: { ".ts": tsLoader }
+	});
+	try {
+		result = config ? await explorer.load(config) : await explorer.search();
+	} catch (error) {
+		throw new Error("Config failed loading", { cause: error });
+	}
+	if (result?.isEmpty || !result || !result.config) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
+	return result;
+}
+
 //#endregion
 //#region src/utils/watcher.ts
 async function startWatcher(path$1, cb) {
@@ -1267,4 +1694,4 @@ var generate_default = command;
 
 //#endregion
 export { generate_default as default };
-//# sourceMappingURL=generate-DhFw-owG.js.map
+//# sourceMappingURL=generate-DoM5hz_l.js.map