@kubb/cli 4.22.3 → 4.24.0

package/dist/agent-Buz_5Op4.cjs

@@ -0,0 +1,22 @@
+const require_chunk = require('./chunk-C1_xRkKa.cjs');
+let citty = require("citty");
+
+//#region src/commands/agent.ts
+const command = (0, citty.defineCommand)({
+	args: { help: {
+		type: "boolean",
+		description: "Show help",
+		alias: "h",
+		default: false
+	} },
+	subCommands: { start: () => Promise.resolve().then(() => require("./start-Vf8kCm8g.cjs")).then((m) => m.default) },
+	async run(commandContext) {
+		const { args } = commandContext;
+		if (args.help) return (0, citty.showUsage)(command);
+	}
+});
+var agent_default = command;
+
+//#endregion
+exports.default = agent_default;
+//# sourceMappingURL=agent-Buz_5Op4.cjs.map

package/dist/agent-Buz_5Op4.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-Buz_5Op4.cjs","names":[],"sources":["../src/commands/agent.ts"],"sourcesContent":["import type { ArgsDef } from 'citty'\nimport { defineCommand, showUsage } from 'citty'\n\nconst args = {\n  help: {\n    type: 'boolean',\n    description: 'Show help',\n    alias: 'h',\n    default: false,\n  },\n} as const satisfies ArgsDef\n\nconst command = defineCommand({\n  args,\n  subCommands: {\n    start: () => import('./agent/start.ts').then((m) => m.default),\n  },\n  async run(commandContext) {\n    const { args } = commandContext\n\n    if (args.help) {\n      return showUsage(command)\n    }\n  },\n})\n\nexport default command\n"],"mappings":";;;;AAYA,MAAM,mCAAwB;CAC5B,MAVW,EACX,MAAM;EACJ,MAAM;EACN,aAAa;EACb,OAAO;EACP,SAAS;EACV,EACF;CAIC,aAAa,EACX,kDAAa,yBAA2B,MAAM,MAAM,EAAE,QAAQ,EAC/D;CACD,MAAM,IAAI,gBAAgB;EACxB,MAAM,EAAE,SAAS;AAEjB,MAAI,KAAK,KACP,6BAAiB,QAAQ;;CAG9B,CAAC;AAEF,oBAAe"}

package/dist/agent-C9MWOHKX.js

@@ -0,0 +1,22 @@
+import { t as __name } from "./chunk-EyRqdYP6.js";
+import { defineCommand, showUsage } from "citty";
+
+//#region src/commands/agent.ts
+const command = defineCommand({
+	args: { help: {
+		type: "boolean",
+		description: "Show help",
+		alias: "h",
+		default: false
+	} },
+	subCommands: { start: () => import("./start-DdvHHe8S.js").then((m) => m.default) },
+	async run(commandContext) {
+		const { args } = commandContext;
+		if (args.help) return showUsage(command);
+	}
+});
+var agent_default = command;
+
+//#endregion
+export { agent_default as default };
+//# sourceMappingURL=agent-C9MWOHKX.js.map

package/dist/agent-C9MWOHKX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-C9MWOHKX.js","names":[],"sources":["../src/commands/agent.ts"],"sourcesContent":["import type { ArgsDef } from 'citty'\nimport { defineCommand, showUsage } from 'citty'\n\nconst args = {\n  help: {\n    type: 'boolean',\n    description: 'Show help',\n    alias: 'h',\n    default: false,\n  },\n} as const satisfies ArgsDef\n\nconst command = defineCommand({\n  args,\n  subCommands: {\n    start: () => import('./agent/start.ts').then((m) => m.default),\n  },\n  async run(commandContext) {\n    const { args } = commandContext\n\n    if (args.help) {\n      return showUsage(command)\n    }\n  },\n})\n\nexport default command\n"],"mappings":";;;;AAYA,MAAM,UAAU,cAAc;CAC5B,MAVW,EACX,MAAM;EACJ,MAAM;EACN,aAAa;EACb,OAAO;EACP,SAAS;EACV,EACF;CAIC,aAAa,EACX,aAAa,OAAO,uBAAoB,MAAM,MAAM,EAAE,QAAQ,EAC/D;CACD,MAAM,IAAI,gBAAgB;EACxB,MAAM,EAAE,SAAS;AAEjB,MAAI,KAAK,KACP,QAAO,UAAU,QAAQ;;CAG9B,CAAC;AAEF,oBAAe"}

package/dist/{chunk-jHaXqnEa.js → chunk-EyRqdYP6.js}

@@ -1,9 +1,12 @@
+import { createRequire } from "node:module";
+
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", {
 	value,
 	configurable: true
 });
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
-export { __name as t };
+export { __require as n, __name as t };

package/dist/{generate-pe0DCVnp.cjs → generate-BYLZgOxz.cjs}

@@ -1,6 +1,5 @@
 const require_chunk = require('./chunk-C1_xRkKa.cjs');
-const require_package = require('./package-C1c2K_S0.cjs');
-const require_getCosmiConfig = require('./getCosmiConfig-Co29x0Wv.cjs');
+const require_package = require('./package-JlnkYQn6.cjs');
 let citty = require("citty");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
@@ -8,20 +7,24 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 let _clack_prompts = require("@clack/prompts");
 _clack_prompts = require_chunk.__toESM(_clack_prompts);
+let execa = require("execa");
+let picocolors = require("picocolors");
+picocolors = require_chunk.__toESM(picocolors);
 let _kubb_core = require("@kubb/core");
 let _kubb_core_utils = require("@kubb/core/utils");
 let latest_version = require("latest-version");
 latest_version = require_chunk.__toESM(latest_version);
-let picocolors = require("picocolors");
-picocolors = require_chunk.__toESM(picocolors);
 let semver = require("semver");
-let execa = require("execa");
 let gradient_string = require("gradient-string");
 gradient_string = require_chunk.__toESM(gradient_string);
 let seedrandom = require("seedrandom");
 seedrandom = require_chunk.__toESM(seedrandom);
 let node_stream = require("node:stream");
 let _kubb_core_fs = require("@kubb/core/fs");
+let node_crypto = require("node:crypto");
+let string_argv = require("string-argv");
+let cosmiconfig = require("cosmiconfig");
+let jiti = require("jiti");
 
 //#region src/utils/formatMsWithColor.ts
 /**
@@ -1148,17 +1151,441 @@ 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 (0, execa.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 (0, execa.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] = [...(0, string_argv.parseArgsStringToArgv)(command$1)];
+		if (!cmd) continue;
+		const hookId = (0, node_crypto.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", `${picocolors.default.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 = node_process.default.hrtime();
+	const config = {
+		...userConfig,
+		root: userConfig.root || node_process.default.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 ${picocolors.default.bold(config.name)}` : "Setup generation", inputPath);
+	const { sources, fabric, pluginManager } = await (0, _kubb_core.setup)({
+		config,
+		events
+	});
+	await events.emit("info", config.name ? `Build generation ${picocolors.default.bold(config.name)}` : "Build generation", inputPath);
+	const { files, failedPlugins, pluginTimings, error } = await (0, _kubb_core.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 >= _kubb_core.LogLevel.verbose ? pluginTimings : void 0
+		});
+		node_process.default.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: ${picocolors.default.dim(formatter)}`);
+			}
+		}
+		if (formatter && formatter !== "auto" && formatter in formatters) {
+			const formatterConfig = formatters[formatter];
+			const outputPath = node_path.default.resolve(config.root, config.output.path);
+			try {
+				const hookId = (0, node_crypto.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 ${picocolors.default.dim(formatter)}`,
+						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.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: ${picocolors.default.dim(linter)}`);
+			}
+		}
+		if (linter && linter !== "auto") {
+			await events.emit("info", [`Linting with ${picocolors.default.dim(linter)}`, logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.resolve(config.root, config.output.path))}` : void 0].filter(Boolean).join(" "));
+			if (linter === "eslint") try {
+				const hookId = (0, node_crypto.createHash)("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: "eslint",
+					args: [node_path.default.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 ${picocolors.default.dim(linter)}`,
+						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.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 = (0, node_crypto.createHash)("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: "biome",
+					args: [
+						"lint",
+						"--fix",
+						node_path.default.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 ${picocolors.default.dim(linter)}`,
+						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.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 = (0, node_crypto.createHash)("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
+				await events.emit("hook:start", {
+					id: hookId,
+					command: "oxlint",
+					args: ["--fix", node_path.default.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 ${picocolors.default.dim(linter)}`,
+						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.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 ((0, _kubb_core_utils.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 (0, jiti.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 = (0, cosmiconfig.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$2, cb) {
+async function startWatcher(path$3, cb) {
 	const { watch } = await import("chokidar");
-	watch(path$2, {
+	watch(path$3, {
 		ignorePermissionErrors: true,
 		ignored: "**/{.git,node_modules}/**"
 	}).on("all", async (type, file) => {
 		console.log(picocolors.default.yellow(picocolors.default.bold(`Change detected: ${type} ${file}`)));
 		try {
-			await cb(path$2);
+			await cb(path$3);
 		} catch (_e) {
 			console.log(picocolors.default.red("Watcher failed"));
 		}
@@ -1232,8 +1659,8 @@ const command = (0, citty.defineCommand)({
 			if ((0, semver.lt)(require_package.version, latestVersion)) await events.emit("version:new", require_package.version, latestVersion);
 		});
 		try {
-			const result = await require_getCosmiConfig.getCosmiConfig("kubb", args.config);
-			const configs = await require_getCosmiConfig.getConfigs(result, args);
+			const result = await getCosmiConfig("kubb", args.config);
+			const configs = await getConfigs(result, args);
 			await events.emit("config:start");
 			await events.emit("info", "Config loaded", node_path.default.relative(node_process.cwd(), result.filepath));
 			await events.emit("success", "Config loaded successfully", node_path.default.relative(node_process.cwd(), result.filepath));
@@ -1243,7 +1670,7 @@ const command = (0, citty.defineCommand)({
 				return async () => {
 					if ((0, _kubb_core.isInputPath)(config) && args.watch) {
 						await startWatcher([input || config.input.path], async (paths) => {
-							await require_getCosmiConfig.generate({
+							await generate({
 								input,
 								config,
 								logLevel,
@@ -1253,7 +1680,7 @@ const command = (0, citty.defineCommand)({
 						});
 						return;
 					}
-					await require_getCosmiConfig.generate({
+					await generate({
 						input,
 						config,
 						logLevel,
@@ -1273,4 +1700,4 @@ var generate_default = command;
 
 //#endregion
 exports.default = generate_default;
-//# sourceMappingURL=generate-pe0DCVnp.cjs.map
+//# sourceMappingURL=generate-BYLZgOxz.cjs.map