@kubb/cli 5.5.6 → 5.6.0

package/dist/output-B6Ondw0g.js

@@ -0,0 +1,776 @@
+import "./rolldown-runtime-CRm0XQPb.js";
+import { i as isCIEnvironment, n as formatMs, r as getElapsedMs, t as getAgentName } from "./agent-BPIqnEl2.js";
+import { styleText } from "node:util";
+import process$1 from "node:process";
+import { relative } from "node:path";
+import * as clack from "@clack/prompts";
+import { Diagnostics, logLevel } from "@kubb/core";
+//#region src/loggers/banner.ts
+/**
+* Parses a CSS hex color string (`#RGB`) into its RGB channels.
+* Falls back to `255` for any channel that cannot be parsed.
+*/
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
+}
+/**
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
+*/
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+function gradient(colorStops, text) {
+	const chars = text.split("");
+	return chars.map((char, i) => {
+		const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
+		const seg = Math.min(Math.floor(t * (colorStops.length - 1)), colorStops.length - 2);
+		const lt = t * (colorStops.length - 1) - seg;
+		const from = parseHex(colorStops[seg]);
+		const to = parseHex(colorStops[seg + 1]);
+		return `\x1b[38;2;${Math.round(from.r + (to.r - from.r) * lt)};${Math.round(from.g + (to.g - from.g) * lt)};${Math.round(from.b + (to.b - from.b) * lt)}m${char}\x1b[0m`;
+	}).join("");
+}
+/**
+* ANSI color functions for each part of the Kubb mascot illustration.
+*/
+const palette = {
+	/**
+	* Top cap of the skittle.
+	*/
+	lid: hex("#F55A17"),
+	/**
+	* Upper wood body.
+	*/
+	woodTop: hex("#F5A217"),
+	/**
+	* Middle wood body.
+	*/
+	woodMid: hex("#F58517"),
+	/**
+	* Base wood body.
+	*/
+	woodBase: hex("#B45309"),
+	/**
+	* Eye whites.
+	*/
+	eye: hex("#FFFFFF"),
+	/**
+	* Highlight accent.
+	*/
+	highlight: hex("#adadc6"),
+	/**
+	* Cheek blush.
+	*/
+	blush: hex("#FDA4AF")
+};
+/**
+* Generates the Kubb mascot welcome banner as an ANSI-colored string.
+*
+* @example
+* ```ts
+* console.log(getIntro({ title: 'kubb.config.ts', description: 'generating…', version: '5.0.0', areEyesOpen: true }))
+* ```
+*/
+function getIntro({ title, description, version, areEyesOpen }) {
+	const kubbVersion = gradient([
+		"#F58517",
+		"#F5A217",
+		"#F55A17"
+	], `KUBB v${version}`);
+	const eyeTop = areEyesOpen ? palette.eye("█▀█") : palette.eye("───");
+	const eyeBottom = areEyesOpen ? palette.eye("▀▀▀") : palette.eye("───");
+	return [
+		`   ${palette.lid("▄▄▄▄▄▄▄▄▄▄▄▄▄")}`,
+		`  ${palette.woodTop("█  ")}${palette.highlight("▄▄")}${palette.woodTop("     ")}${palette.highlight("▄▄")}${palette.woodTop("  █")} ${kubbVersion}`,
+		`  ${palette.woodMid("█ ")}${eyeTop}${palette.woodMid("     ")}${eyeTop}${palette.woodMid(" █")} ${styleText("gray", title)}`,
+		`  ${palette.woodMid("█ ")}${eyeBottom}${palette.woodMid("  ")}${palette.blush("◡")}${palette.woodMid("  ")}${eyeBottom}${palette.woodMid(" █")} ${styleText("yellow", "➜")} ${styleText("white", description)}`,
+		`   ${palette.woodBase("▀▀▀▀▀▀▀▀▀▀▀▀▀")}`
+	].join("\n");
+}
+/**
+* Formats a millisecond duration with a threshold-based ANSI color.
+* `≤ 500 ms` → green · `≤ 1 000 ms` → yellow · `> 1 000 ms` → red.
+*
+* @example
+* ```ts
+* formatMsWithColor(200)  // '\x1b[32m200ms\x1b[39m'
+* formatMsWithColor(800)  // '\x1b[33m800ms\x1b[39m'
+* formatMsWithColor(1500) // '\x1b[31m1.50s\x1b[39m'
+* ```
+*/
+function formatMsWithColor(ms) {
+	const formatted = formatMs(ms);
+	if (ms <= 500) return styleText("green", formatted);
+	if (ms <= 1e3) return styleText("yellow", formatted);
+	return styleText("red", formatted);
+}
+//#endregion
+//#region src/loggers/createLogger.ts
+/** Display path for a config's input: the string form, or its `path` field when the input is an object. */
+function getInputPath(config) {
+	const { input } = config;
+	if (typeof input === "string") return input;
+	return typeof input?.path === "string" ? input.path : void 0;
+}
+/** Counts a noun, so a message never reads `1 files`. */
+function pluralize(count, noun) {
+	return `${count} ${count === 1 ? noun : `${noun}s`}`;
+}
+/** Prefixes a `[HH:MM:SS]` timestamp at verbose and above. */
+function formatMessage(message, logLevel$1) {
+	if (logLevel$1 >= logLevel.verbose) {
+		const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+			hour12: false,
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit"
+		});
+		return `${styleText("dim", `[${timestamp}]`)} ${message}`;
+	}
+	return message;
+}
+/** Renders a `studio:connected` event's versions: the runtime only when it differs from the host, Studio's only when it sent one. */
+function formatVersions({ studio, kubb, agent }) {
+	return [
+		`v${agent}`,
+		kubb !== agent ? `runtime v${kubb}` : void 0,
+		studio ? `Studio v${studio}` : void 0
+	].filter(Boolean).join(", ");
+}
+/** The first three frames of a stack, without the message line. */
+function topFrames(stack) {
+	return stack.split("\n").slice(1, 4).map((frame) => frame.trim());
+}
+/** First stack frames for verbose error output, including an optional `cause` chain. */
+function formatErrorFrames(error) {
+	if (!error.stack) return null;
+	const frames = topFrames(error.stack);
+	const caused = error.cause instanceof Error ? error.cause : void 0;
+	if (!caused?.stack) return { frames };
+	return {
+		frames,
+		cause: {
+			header: `└─ caused by ${caused.message}`,
+			frames: topFrames(caused.stack)
+		}
+	};
+}
+/** The progress summary line the clack logger shows, `null` when there is nothing to display. */
+function buildProgressLine(state) {
+	const parts = [];
+	const duration = formatMs(getElapsedMs(state.hrStart));
+	if (state.totalPlugins > 0) {
+		const pluginStr = state.failedPlugins > 0 ? `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins} ${styleText("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
+		parts.push(pluginStr);
+	}
+	if (state.totalFiles > 0) parts.push(`Files ${styleText("green", state.processedFiles.toString())}/${state.totalFiles}`);
+	if (parts.length === 0) return null;
+	parts.push(`${styleText("green", duration)} elapsed`);
+	return parts.join(styleText("dim", " | "));
+}
+function createProgressCounters() {
+	return {
+		totalPlugins: 0,
+		completedPlugins: 0,
+		failedPlugins: 0,
+		totalFiles: 0,
+		processedFiles: 0,
+		hrStart: process$1.hrtime()
+	};
+}
+/**
+* The three output phases, in the order the generate runner runs them.
+*/
+const PHASES = {
+	format: {
+		running: "Formatting",
+		success: "Formatted",
+		failure: "Formatting failed"
+	},
+	lint: {
+		running: "Linting",
+		success: "Linted",
+		failure: "Linting failed"
+	},
+	hooks: {
+		running: "Running post-generate hooks",
+		success: "Post-generate hooks completed",
+		failure: "Post-generate hooks failed",
+		showHookResults: true
+	}
+};
+/**
+* Drops the blank lines a subprocess leaves at either end of its output, so its block does not open
+* or close on an empty row.
+*/
+function trimBlankEdges(lines) {
+	const start = lines.findIndex((line) => line.trim());
+	if (start === -1) return [];
+	return lines.slice(start, lines.findLastIndex((line) => line.trim()) + 1);
+}
+/**
+* Wires a {@link LoggerWriter} onto the run's hooks. This owns what a run says and in what order:
+* one group per config, a step over the plugin work, a progress bar for the writes, one step per
+* output phase, then the summary and the group's closing result. The writer only decides how each
+* line looks, so every logger reports the same run the same way.
+*
+* @example
+* ```ts
+* export const plainLogger = createLogger(writer)
+* ```
+*/
+function createLogger(writer) {
+	return function install(context, { logLevel: logLevel$2 }) {
+		const silent = logLevel$2 <= logLevel.silent;
+		const state = {
+			...createProgressCounters(),
+			spinner: null,
+			progress: null,
+			hooks: /* @__PURE__ */ new Map(),
+			/**
+			* Plugin results held back while the generation step owns the line.
+			*/
+			pluginLines: [],
+			phase: null,
+			groupOpen: false
+		};
+		function text(message) {
+			return formatMessage(message, logLevel$2);
+		}
+		function startSpinner(message) {
+			if (silent) return;
+			state.spinner = writer.spinner();
+			state.spinner.start(text(message));
+		}
+		function stopSpinner(message, status = "success") {
+			const spinner = state.spinner;
+			if (!spinner) return;
+			state.spinner = null;
+			if (message === void 0) {
+				spinner.clear();
+				return;
+			}
+			if (status === "failed") {
+				spinner.error(text(message));
+				return;
+			}
+			spinner.stop(text(message));
+		}
+		function stopProgress(message) {
+			const progress = state.progress;
+			if (!progress) return;
+			state.progress = null;
+			progress.stop(message === void 0 ? "" : text(message));
+		}
+		function startPhase({ running, success, failure, showHookResults = false }) {
+			state.phase = {
+				successLabel: success,
+				failureLabel: failure,
+				showHookResults,
+				failed: false,
+				hrStart: process$1.hrtime(),
+				lines: [],
+				output: []
+			};
+			startSpinner(running);
+		}
+		function endPhase() {
+			const phase = state.phase;
+			state.phase = null;
+			if (!phase || silent) return;
+			const duration = formatMsWithColor(getElapsedMs(phase.hrStart));
+			stopSpinner(phase.failed ? `${phase.failureLabel} after ${duration}` : `${phase.successLabel} in ${duration}`, phase.failed ? "failed" : "success");
+			if (phase.lines.length) writer.block(phase.lines);
+			writeOutput(phase.output);
+		}
+		function writeOutput(lines) {
+			const output = trimBlankEdges(lines);
+			if (output.length) writer.raw(output);
+		}
+		function closeGroup(status) {
+			if (!state.groupOpen) return;
+			state.groupOpen = false;
+			stopSpinner();
+			stopProgress();
+			writer.groupEnd(status === "failed" ? styleText("red", "✗ Generation failed") : styleText("green", "✓ Generation succeeded"));
+		}
+		function reset() {
+			stopSpinner();
+			stopProgress();
+			Object.assign(state, createProgressCounters());
+			state.hooks.clear();
+			state.pluginLines = [];
+			state.phase = null;
+			state.groupOpen = false;
+		}
+		function formatLine(symbol, message, info) {
+			return text([
+				symbol,
+				message,
+				info && styleText("dim", info)
+			].filter(Boolean).join(" "));
+		}
+		context.hook("kubb:warn", ({ message, info }) => {
+			if (logLevel$2 < logLevel.warn) return;
+			writer.warn(formatLine(styleText("yellow", "⚠"), message, logLevel$2 >= logLevel.info ? info : void 0));
+		});
+		context.hook("kubb:error", ({ error }) => {
+			if (state.phase) state.phase.failed = true;
+			if (state.spinner) stopSpinner(error.message, "failed");
+			else writer.error(text(error.message));
+			const frames = logLevel$2 >= logLevel.verbose ? formatErrorFrames(error) : null;
+			if (!frames) return;
+			writer.block(frames.frames.map((frame) => text(styleText("dim", frame))));
+			if (frames.cause) writer.block([styleText("dim", frames.cause.header), ...frames.cause.frames.map((frame) => text(`    ${styleText("dim", frame)}`))]);
+		});
+		context.hook("kubb:diagnostic", ({ diagnostic }) => {
+			if (silent && diagnostic.severity !== "error") return;
+			stopSpinner();
+			stopProgress();
+			if (Diagnostics.isUpdate(diagnostic)) {
+				writer.update([`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\``, "Run `npm install -g @kubb/cli` to update"], "Update available for `Kubb`");
+				return;
+			}
+			const { headline, details } = Diagnostics.format(diagnostic);
+			writer.diagnostic([headline, ...details]);
+		});
+		context.hook("studio:connecting", ({ url }) => {
+			startSpinner(`Connecting to ${styleText("cyan", url)}`);
+		});
+		context.hook("studio:disconnected", ({ reason }) => {
+			if (logLevel$2 < logLevel.warn) return;
+			stopSpinner();
+			writer.warn(text(`⚠ Kubb Studio ended the session (${reason})`));
+		});
+		context.hook("studio:warn", ({ message, permission }) => {
+			if (logLevel$2 < logLevel.warn) return;
+			const remedy = permission ? `; pass --${permission.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)} to allow it` : "";
+			writer.warn(text(`⚠ ${message}${remedy}`));
+		});
+		context.hook("studio:error", ({ error }) => {
+			if (state.spinner) {
+				stopSpinner(error.message, "failed");
+				return;
+			}
+			writer.error(text(error.message));
+		});
+		context.hook("kubb:lifecycle:start", () => {
+			reset();
+		});
+		context.hook("kubb:generation:start", ({ config }) => {
+			closeGroup("failed");
+			reset();
+			state.totalPlugins = config.plugins?.length ?? 0;
+			if (silent) return;
+			const inputPath = getInputPath(config);
+			writer.group(text([styleText("bold", config.name ?? "kubb"), inputPath ? styleText("dim", inputPath) : void 0].filter(Boolean).join(" ")));
+			state.groupOpen = true;
+			startSpinner("Generating");
+		});
+		context.hook("kubb:format:start", () => startPhase(PHASES.format));
+		context.hook("kubb:format:end", endPhase);
+		context.hook("kubb:lint:start", () => startPhase(PHASES.lint));
+		context.hook("kubb:lint:end", endPhase);
+		context.hook("kubb:hooks:start", () => startPhase(PHASES.hooks));
+		context.hook("kubb:hooks:end", endPhase);
+		context.hook("kubb:hook:end", (ctx) => {
+			const { id, command, name, args, success, error } = ctx;
+			if (!id) return;
+			if (!success && state.phase) state.phase.failed = true;
+			if (silent) {
+				if (!ctx.success) {
+					if (ctx.stdout) console.log(ctx.stdout);
+					if (ctx.stderr) console.error(ctx.stderr);
+				}
+				return;
+			}
+			const active = state.hooks.get(id);
+			if (!active) return;
+			state.hooks.delete(id);
+			const label = styleText("dim", name ?? (args?.length ? `${command} ${args.join(" ")}` : command));
+			const reason = error?.message ? ` (${error.message})` : "";
+			const result = success ? `${styleText("green", "✓")} ${label} in ${formatMsWithColor(getElapsedMs(active.hrStart))}` : `${styleText("red", "✗")} ${label} failed${reason}`;
+			const phase = state.phase;
+			if (phase) {
+				if (phase.showHookResults || !success) phase.lines.push(result);
+				phase.output.push(...active.lines);
+				return;
+			}
+			stopSpinner();
+			writer.step(text(result));
+			writeOutput(active.lines);
+		});
+		context.hook("kubb:generation:end", () => {
+			stopSpinner();
+			stopProgress();
+		});
+		context.hook("kubb:lifecycle:end", () => {
+			closeGroup("failed");
+			reset();
+		});
+		if (!silent) {
+			context.hook("kubb:info", ({ message, info }) => {
+				const line = formatLine(styleText("blue", "ℹ"), message, info);
+				if (state.phase) {
+					state.phase.lines.push(line);
+					return;
+				}
+				if (state.spinner) {
+					state.spinner.message(line);
+					return;
+				}
+				writer.info(line);
+			});
+			context.hook("kubb:success", ({ message, info }) => {
+				const line = formatLine(styleText("green", "✓"), message, logLevel$2 >= logLevel.info ? info : void 0);
+				if (state.spinner) {
+					state.spinner.message(line);
+					return;
+				}
+				writer.success(line);
+			});
+			context.hook("studio:connected", ({ url, versions }) => {
+				const line = `Connected to ${styleText("cyan", url)} ${styleText("dim", `(${formatVersions(versions)})`)}`;
+				if (state.spinner) {
+					stopSpinner(line);
+					return;
+				}
+				writer.success(text(`✓ ${line}`));
+			});
+			context.hook("studio:ready", () => {
+				startSpinner("✓ Ready to receive jobs");
+			});
+			context.hook("studio:command:start", ({ command }) => {
+				stopSpinner();
+				writer.info(text(`Kubb Studio asked to ${styleText("bold", command)}`));
+			});
+			context.hook("studio:command:end", ({ command, info }) => {
+				writer.success(text(`✓ Finished ${command}${info ? ` ${styleText("dim", `(${info})`)}` : ""}`));
+				startSpinner("✓ Ready to receive jobs");
+			});
+			context.hook("studio:reconnecting", ({ delayMs }) => {
+				stopSpinner();
+				writer.info(text(styleText("dim", `Retrying connection to Kubb Studio in ${formatMs(delayMs)}`)));
+			});
+			context.hook("kubb:plugin:start", ({ plugin }) => {
+				state.spinner?.message(text(`Generating ${styleText("dim", plugin.name)}`));
+			});
+			context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
+				if (success) state.completedPlugins++;
+				if (!success) state.failedPlugins++;
+				state.pluginLines.push(text(`${plugin.name} ${success ? "completed" : "failed"} in ${formatMsWithColor(duration)}`));
+			});
+			context.hook("kubb:plugins:end", () => {
+				const failed = state.failedPlugins > 0;
+				stopSpinner(buildProgressLine(state) ?? "No plugins ran", failed ? "failed" : "success");
+				if (state.pluginLines.length) {
+					writer.block(state.pluginLines);
+					state.pluginLines = [];
+				}
+			});
+			context.hook("kubb:files:processing:start", ({ files }) => {
+				stopSpinner();
+				state.totalFiles = files.length;
+				state.processedFiles = 0;
+				state.progress = writer.progress(files.length);
+				state.progress.start(text(`Writing ${pluralize(files.length, "file")}`));
+			});
+			context.hook("kubb:files:processing:update", ({ files }) => {
+				for (const { file, config } of files) {
+					state.processedFiles++;
+					state.progress?.advance(`Writing ${relative(config.root, file.path)}`);
+				}
+			});
+			context.hook("kubb:files:processing:end", () => {
+				stopProgress(`Wrote ${pluralize(state.processedFiles, "file")}`);
+			});
+			context.hook("kubb:hook:start", ({ id }) => {
+				if (!id) return;
+				state.hooks.set(id, {
+					hrStart: process$1.hrtime(),
+					lines: []
+				});
+			});
+			context.hook("kubb:hook:line", ({ id, line }) => {
+				const active = state.hooks.get(id);
+				if (!active) return;
+				if (state.phase) {
+					active.lines.push(line);
+					return;
+				}
+				writer.raw([line]);
+			});
+		}
+		return { renderSummary(lines, { status }) {
+			if (silent || !state.groupOpen) return;
+			closeGroup(status);
+			writer.diagnostic([...lines]);
+		} };
+	};
+}
+//#endregion
+//#region src/loggers/plainLogger.ts
+/**
+* Prefixes that stand in for the symbols clack draws, so plain output reads the same way.
+*/
+const SYMBOLS = {
+	info: "ℹ",
+	warn: "⚠",
+	error: "✗",
+	step: "◇"
+};
+/** Draws with one `write` call per line. Nothing animates, so a step prints at start and end. */
+function createWriter(write) {
+	return {
+		group: write,
+		groupEnd: write,
+		step: (text) => write(`${SYMBOLS.step} ${text}`),
+		info: write,
+		success: write,
+		warn: write,
+		error: (text) => write(`${SYMBOLS.error} ${text}`),
+		block: (lines) => write(lines.join("\n")),
+		raw: (lines) => write(lines.join("\n")),
+		diagnostic: (lines) => write(lines.join("\n")),
+		update: (lines, title) => write([title, ...lines].join("\n")),
+		spinner: () => ({
+			start: write,
+			message: write,
+			clear: () => {},
+			stop: (text) => text && write(text),
+			error: (text) => write(`${SYMBOLS.error} ${text}`)
+		}),
+		progress: () => ({
+			start: write,
+			advance: write,
+			stop: (text) => text && write(text)
+		})
+	};
+}
+/** The plain logger writing through `write`, e.g. `console.error` so stdout carries only JSON. */
+function createPlainLogger(write) {
+	return createLogger(createWriter(write));
+}
+/** Draws on the console, for non-TTY environments and for an AI coding agent reading the output. */
+const plainWriter = createWriter((line) => console.log(line));
+/**
+* Console adapter for non-TTY environments, and for an AI coding agent reading the output. Reports
+* the same run in the same order as `clackLogger`, without the animation.
+*/
+const plainLogger = createLogger(plainWriter);
+//#endregion
+//#region src/utils/env.ts
+/**
+* Returns `true` when the process has an interactive TTY with a valid terminal
+* width and is not running in CI.
+*
+* Some IDE-embedded terminals report `isTTY = true` but set `columns` to `0`,
+* which breaks clack's box-drawing helpers (they call `String.prototype.repeat`
+* with a negative count and throw a `RangeError`). A positive column count is
+* required before the TTY counts as usable.
+*
+* @example
+* ```ts
+* if (canUseTTY()) {
+*   renderProgressBar()
+* }
+* ```
+*/
+function canUseTTY() {
+	return process.stdout.isTTY && (process.stdout.columns ?? 0) > 0 && !isCIEnvironment();
+}
+/**
+* Returns `true` when output can carry spinners and clack's gutter: an interactive TTY that no AI
+* coding agent is reading. Cursor-movement escapes are hard for an agent to parse even over a
+* pseudo-TTY, so it gets the plain writer.
+*/
+function isRichOutput() {
+	return canUseTTY() && !getAgentName();
+}
+//#endregion
+//#region src/loggers/clackLogger.ts
+/**
+* Draws with clack: a gutter bar per group, animated steps, and a progress bar for the writes.
+*/
+const clackWriter = {
+	group: (title) => clack.intro(title),
+	groupEnd: (text) => clack.outro(text),
+	step: (text) => clack.log.step(text, { spacing: 0 }),
+	info: (text) => clack.log.info(text),
+	success: (text) => clack.log.success(text),
+	warn: (text) => clack.log.warn(text),
+	error: (text) => clack.log.error(text),
+	block: (lines) => clack.log.message(lines, { spacing: 0 }),
+	raw: (lines) => console.log(styleText("dim", lines.join("\n"))),
+	diagnostic: (lines) => clack.log.message(lines, {
+		symbol: "",
+		secondarySymbol: ""
+	}),
+	update: (lines, title) => clack.box(lines.join("\n"), title, {
+		width: "auto",
+		formatBorder: (border) => styleText("yellow", border),
+		rounded: true,
+		withGuide: false,
+		contentAlign: "center",
+		titleAlign: "center"
+	}),
+	spinner() {
+		const spinner = clack.spinner();
+		return {
+			start: (text) => spinner.start(text),
+			message: (text) => spinner.message(text),
+			clear: () => spinner.clear(),
+			stop: (text) => spinner.stop(text),
+			error: (text) => spinner.error(text)
+		};
+	},
+	progress(max) {
+		const bar = clack.progress({
+			style: "block",
+			max,
+			size: 30
+		});
+		return {
+			start: (text) => bar.start(text),
+			advance: (text) => bar.advance(1, text),
+			stop: (text) => bar.stop(text)
+		};
+	}
+};
+/**
+* TTY logger for local development, with animated steps and progress bars.
+*/
+const clackLogger = createLogger(clackWriter);
+//#endregion
+//#region src/loggers/output.ts
+const SPONSOR_TIPS = [
+	"Your sponsorship keeps Kubb codegen, plugins, and docs maintained",
+	"Sponsor faster generators and better Kubb Studio workflows",
+	"Help keep Kubb free for TypeScript teams building APIs",
+	"Support React Query, Zod, Faker, and MSW integrations",
+	"Back open-source tools that turn OpenAPI into TypeScript",
+	"Sponsor fixes, releases, and new plugins for your API workflow",
+	"Help Kubb stay independent and focused on developer tools"
+];
+const SPONSOR_LINKS = [
+	"https://github.com/sponsors/stijnvanhulle",
+	"https://opencollective.com/kubb",
+	"https://kubb.dev/sponsors"
+];
+/** The writer the loggers draw with on this terminal, so a command's own lines look like its run. */
+function writer() {
+	return isRichOutput() ? clackWriter : plainWriter;
+}
+function nextTip() {
+	return `${SPONSOR_TIPS[Math.floor(Math.random() * SPONSOR_TIPS.length)]}: ${SPONSOR_LINKS[Math.floor(Math.random() * SPONSOR_LINKS.length)]}`;
+}
+function formatTip(tip) {
+	return styleText("magenta", " Tip  ") + styleText("yellow", tip);
+}
+/**
+* Prints one random tip outside every group. Rich terminals get the styled variant;
+* plain/CI output gets a stable text-only line so the tip is still visible as final output.
+*/
+function logTip() {
+	const tip = nextTip();
+	if (!isRichOutput()) {
+		console.log(`Tip: ${tip}`);
+		return;
+	}
+	console.log(`${styleText("magenta", "✦")}${formatTip(tip)}`);
+}
+function write(level, message) {
+	if (isRichOutput()) {
+		clack.log[level](message);
+		return;
+	}
+	console.log(`${SYMBOLS[level]} ${message}`);
+}
+/**
+* Opens a command's output with its title.
+*/
+function logIntro({ title, warning, block = true }) {
+	if (block && isRichOutput()) {
+		if (title) clack.intro(title);
+		if (warning) clack.log.warn(warning);
+		return;
+	}
+	if (title) console.log(title);
+	if (warning) console.warn(warning);
+	if (title || warning) console.log();
+}
+/**
+* Closes the block {@link logIntro} opened. The closing gutter is not a written line, so plain
+* output prints the text on its own.
+*/
+function logOutro(text) {
+	writer().groupEnd(text);
+}
+/**
+* Prints one empty line between two groups, without clack's gutter bar, since the bar belongs to a
+* group and a spacer sits outside every one.
+*/
+function logSpacer() {
+	console.log("");
+}
+/**
+* Opens the command with the Kubb mascot and version, or a single version line where the terminal
+* cannot draw it.
+*/
+function logBanner(version) {
+	if (isRichOutput()) {
+		console.log(`\n${getIntro({
+			title: "Turn your API spec into type-safe code",
+			description: "Ready to start",
+			version,
+			areEyesOpen: true
+		})}\n`);
+		return;
+	}
+	console.log(`Kubb CLI v${version}`);
+}
+/** Prints lines as one block, without a symbol in front of them. Not the writer's block, which drops clack's spacing around it. */
+function logBlock(lines) {
+	if (isRichOutput()) {
+		clack.log.message(lines);
+		return;
+	}
+	console.log([lines].flat().join("\n"));
+}
+function logInfo(message) {
+	write("info", message);
+}
+function logWarn(message) {
+	write("warn", message);
+}
+function logError(message) {
+	write("error", message);
+}
+/**
+* Reports a step the command is taking, rather than something it found.
+*/
+function logStep(message) {
+	write("step", message);
+}
+/**
+* A progress spinner, or a writer that prints each message it is given when the terminal cannot
+* animate one. Callers drive both the same way, including the failure state.
+*/
+function createSpinner() {
+	return writer().spinner();
+}
+//#endregion
+export { pluralize as _, logInfo as a, logSpacer as c, logWarn as d, clackLogger as f, plainLogger as g, createPlainLogger as h, logError as i, logStep as l, isRichOutput as m, logBanner as n, logIntro as o, canUseTTY as p, logBlock as r, logOutro as s, createSpinner as t, logTip as u };
+
+//# sourceMappingURL=output-B6Ondw0g.js.map