@kubb/cli 4.21.2 → 4.22.1

package/dist/{generate-DgWO-YRb.js → generate-Bgpw_dcv.js}

@@ -1,26 +1,21 @@
 import { t as __name } from "./chunk-jHaXqnEa.js";
-import { t as version } from "./package-DRskcFXO.js";
+import { t as version } from "./package-BQu01PU2.js";
+import { n as getConfigs, r as generate, t as getCosmiConfig } from "./getCosmiConfig-y2n_oW_y.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, safeBuild, setup } from "@kubb/core";
-import { AsyncEventEmitter, executeIfOnline, formatHrtime, formatMs, isPromise, serializePluginOptions } from "@kubb/core/utils";
+import { LogLevel, PromiseManager, defineLogger, isInputPath } from "@kubb/core";
+import { AsyncEventEmitter, executeIfOnline, formatHrtime, formatMs } from "@kubb/core/utils";
 import getLatestVersion from "latest-version";
 import pc from "picocolors";
 import { lt } from "semver";
-import { execa, execaCommand } from "execa";
+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";
-import { readFileSync } from "node:fs";
-import { createServer } from "node:http";
 
 //#region src/utils/formatMsWithColor.ts
 /**
@@ -1129,614 +1124,6 @@ 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/loggers/streamLogger.ts
-/**
-* Stream logger for SSE (Server-Sent Events) streaming
-* Sends Kubb events to HTTP client via SSE protocol
-*/
-function createStreamLogger(res) {
-	return defineLogger({
-		name: "stream",
-		install(context, options) {
-			const logLevel = options?.logLevel || LogLevel.info;
-			const state = { res };
-			function send(type, ...data) {
-				if (!state.res.destroyed) state.res.write(`data: ${JSON.stringify({
-					type,
-					data
-				})}\n\n`);
-			}
-			context.on("plugin:start", (plugin) => {
-				send("plugin:start", { name: plugin.name });
-			});
-			context.on("plugin:end", (plugin, { duration, success }) => {
-				send("plugin:end", { name: plugin.name }, {
-					duration,
-					success
-				});
-			});
-			context.on("files:processing:start", (files) => {
-				send("files:processing:start", { total: files.length });
-			});
-			context.on("file:processing:update", ({ file, processed, total, percentage, config }) => {
-				send("file:processing:update", {
-					file: file.path ? relative(config.root, file.path) : file.baseName || "unknown",
-					processed,
-					total,
-					percentage
-				});
-			});
-			context.on("files:processing:end", (files) => {
-				send("files:processing:end", { total: files.length });
-			});
-			context.on("info", (message, info) => {
-				if (logLevel <= LogLevel.silent) return;
-				send("info", message, info);
-			});
-			context.on("success", (message, info) => {
-				if (logLevel <= LogLevel.silent) return;
-				send("success", message, info);
-			});
-			context.on("warn", (message, info) => {
-				if (logLevel < LogLevel.warn) return;
-				send("warn", message, info);
-			});
-			context.on("error", (error) => {
-				send("error", {
-					message: error.message,
-					stack: logLevel >= LogLevel.debug ? error.stack : void 0
-				});
-			});
-			context.on("generation:start", (config) => {
-				send("generation:start", {
-					name: config.name,
-					plugins: config.plugins?.length || 0
-				});
-			});
-			context.on("generation:end", (config, files, sources) => {
-				send("generation:end", config, files, Object.fromEntries(sources));
-			});
-		}
-	});
-}
-
-//#endregion
-//#region src/utils/streamServer.ts
-async function startStreamServer({ port, host, configPath, config, input, args }) {
-	const server = createServer(async (req, res) => {
-		res.setHeader("Access-Control-Allow-Origin", "*");
-		res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-		res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-		if (req.method === "OPTIONS") {
-			res.writeHead(204);
-			res.end();
-			return;
-		}
-		if (req.url === "/api/health" && req.method === "GET") {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			const body = {
-				status: "ok",
-				version,
-				configPath: path.relative(process$1.cwd(), configPath)
-			};
-			res.end(JSON.stringify(body));
-			return;
-		}
-		if (req.url === "/api/info" && req.method === "GET") {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			let specContent;
-			if (config && "path" in config.input) {
-				const specPath = path.resolve(process$1.cwd(), config.root, config.input.path);
-				try {
-					specContent = readFileSync(specPath, "utf-8");
-				} catch {}
-			}
-			const body = {
-				version,
-				configPath: path.relative(process$1.cwd(), configPath),
-				spec: specContent,
-				config: {
-					name: config.name,
-					root: config.root,
-					input: { path: "path" in config.input ? config.input.path : void 0 },
-					output: {
-						path: config.output.path,
-						write: config.output.write,
-						extension: config.output.extension,
-						barrelType: config.output.barrelType
-					},
-					plugins: config.plugins?.map((plugin) => ({
-						name: `@kubb/${plugin.name}`,
-						options: serializePluginOptions(plugin.options)
-					}))
-				}
-			};
-			res.end(JSON.stringify(body));
-			return;
-		}
-		if (req.url === "/api/stream" && req.method === "POST") {
-			await handleGenerate(res, config, input, args);
-			return;
-		}
-		res.writeHead(404, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ error: "Not found" }));
-	});
-	server.listen(port, host, () => {
-		const address = server.address();
-		const serverUrl = `http://${host}:${typeof address === "object" && address ? address.port : port}`;
-		clack.log.success(pc.green(`Stream server started on ${pc.bold(serverUrl)}`));
-		clack.log.info(pc.dim(`Config: ${path.relative(process$1.cwd(), configPath)}`));
-		clack.log.info(pc.dim(`Connect: ${serverUrl}/api/info`));
-		clack.log.info(pc.dim(`Stream: ${serverUrl}/api/stream`));
-		clack.log.info(pc.dim(`Health: ${serverUrl}/api/health`));
-		clack.log.step(pc.yellow("Waiting for requests... (Press Ctrl+C to stop)"));
-	});
-	process$1.on("SIGINT", () => {
-		clack.log.info("Shutting down stream server...");
-		server.close(() => {
-			clack.log.success("Server stopped");
-			process$1.exit(0);
-		});
-	});
-}
-async function handleGenerate(res, config, input, args) {
-	const events = new AsyncEventEmitter();
-	const logLevel = LogLevel[args.logLevel] || 3;
-	res.writeHead(200, {
-		"Content-Type": "text/event-stream",
-		"Cache-Control": "no-cache",
-		Connection: "keep-alive"
-	});
-	function send(type, ...data) {
-		res.write(`data: ${JSON.stringify({
-			type,
-			data
-		})}\n\n`);
-	}
-	await createStreamLogger(res).install(events, { logLevel });
-	try {
-		await generate({
-			input,
-			config,
-			logLevel,
-			events
-		});
-		send("lifecycle:end");
-	} catch (error) {
-		send("error", {
-			message: error instanceof Error ? error.message : "Unknown error",
-			stack: error instanceof Error ? error.stack : void 0
-		});
-	} finally {
-		res.end();
-	}
-}
-
 //#endregion
 //#region src/utils/watcher.ts
 async function startWatcher(path$1, cb) {
@@ -1798,21 +1185,6 @@ const command = defineCommand({
 			alias: "s",
 			default: false
 		},
-		stream: {
-			type: "boolean",
-			description: "Start HTTP server with SSE streaming",
-			default: false
-		},
-		port: {
-			type: "string",
-			description: "Port for stream server (requires --stream). If not specified, an available port is automatically selected.",
-			alias: "p"
-		},
-		host: {
-			type: "string",
-			description: "Host for stream server (requires --stream)",
-			default: "localhost"
-		},
 		help: {
 			type: "boolean",
 			description: "Show help",
@@ -1838,20 +1210,6 @@ const command = defineCommand({
 		try {
 			const result = await getCosmiConfig("kubb", args.config);
 			const configs = await getConfigs(result, args);
-			if (args.stream) {
-				if (configs.length > 1) clack.log.warn(pc.yellow("Stream mode only supports a single configuration. Only the first config will be used."));
-				const port = args.port ? Number.parseInt(args.port, 10) : 0;
-				const host = args.host;
-				await startStreamServer({
-					port,
-					host,
-					configPath: result.filepath,
-					config: configs[0],
-					input,
-					args
-				});
-				return;
-			}
 			await events.emit("config:start");
 			await events.emit("info", "Config loaded", path.relative(process$2.cwd(), result.filepath));
 			await events.emit("success", "Config loaded successfully", path.relative(process$2.cwd(), result.filepath));
@@ -1891,4 +1249,4 @@ var generate_default = command;
 
 //#endregion
 export { generate_default as default };
-//# sourceMappingURL=generate-DgWO-YRb.js.map
+//# sourceMappingURL=generate-Bgpw_dcv.js.map