@kubb/cli 5.14.6 → 5.15.0

package/dist/utils-C3vTpUje.cjs

@@ -1,645 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-CPE0t6oh.cjs");
-const require_Telemetry = require("./Telemetry-B5V_ufmv.cjs");
-const require_text = require("./text-DrsG1EDN.cjs");
-let node_util = require("node:util");
-let node_process = require("node:process");
-node_process = require_rolldown_runtime.__toESM(node_process, 1);
-let node_fs_promises = require("node:fs/promises");
-let node_path = require("node:path");
-require("node:fs");
-//#region ../../internals/utils/src/fs.ts
-/**
-* Resolves to `true` when the file or directory at `path` exists.
-* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
-*
-* @example
-* ```ts
-* if (await exists('./kubb.config.ts')) {
-*   const content = await read('./kubb.config.ts')
-* }
-* ```
-*/
-async function exists(path) {
-	if (require_Telemetry.runtime.isBun) return Bun.file(path).exists();
-	return (0, node_fs_promises.access)(path).then(() => true, () => false);
-}
-/**
-* Reads the file at `path` as a UTF-8 string.
-* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
-*
-* @example
-* ```ts
-* const source = await read('./src/Pet.ts')
-* ```
-*/
-async function read(path) {
-	if (require_Telemetry.runtime.isBun) return Bun.file(path).text();
-	return (0, node_fs_promises.readFile)(path, { encoding: "utf8" });
-}
-/**
-* Whether `stored` already holds `source`, comparing on the trimmed text rather than the exact
-* bytes. Surrounding whitespace is what a formatter adds and what editors strip, and neither is a
-* reason to rewrite the file.
-*
-* Both sides are trimmed, so a storage that keeps bytes verbatim settles on the same answer as one
-* that normalizes what it stores. Trimming only `stored` would leave a source with leading
-* whitespace rewritten on every build, since the stored copy keeps the whitespace the comparison
-* has already dropped.
-*/
-function matchesStored({ stored, source }) {
-	return stored.trim() === source.trim();
-}
-/**
-* Writes `data` to `path`, trimming surrounding whitespace and ending the file with a single newline
-* the way prettier, biome, and oxfmt all do.
-* Skips the write when the trimmed content is empty, or when the file already holds that content.
-* Creates any missing parent directories automatically.
-* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
-*
-* @example
-* ```ts
-* await write('./src/Pet.ts', source)         // writes and returns the trimmed content plus a newline
-* await write('./src/Pet.ts', source)         // null — file unchanged
-* await write('./src/Pet.ts', '  ')           // null — empty content skipped
-* ```
-*/
-async function write(path, data, options = {}) {
-	const trimmed = data.trim();
-	if (trimmed === "") return null;
-	const content = `${trimmed}\n`;
-	const resolved = (0, node_path.resolve)(path);
-	let stored = options.stored;
-	if (stored === void 0) {
-		if (require_Telemetry.runtime.isBun) {
-			const file = Bun.file(resolved);
-			stored = await file.exists() ? await file.text() : null;
-		} else try {
-			stored = await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" });
-		} catch {
-			stored = null;
-		}
-	}
-	if (matchesStored({
-		stored: stored ?? "",
-		source: trimmed
-	})) return null;
-	await writeRaw(resolved, content);
-	if (options.sanity) {
-		const savedData = await read(resolved);
-		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
-		return savedData;
-	}
-	return content;
-}
-/**
-* Writes UTF-8 content verbatim, including empty files and surrounding whitespace.
-* Uses Bun.write under Bun and creates missing parent directories under either runtime.
-*
-* @example
-* await writeRaw('./cache/output.ts', '  // keep these bytes\n\n')
-*/
-async function writeRaw(path, content) {
-	const resolved = (0, node_path.resolve)(path);
-	if (require_Telemetry.runtime.isBun) {
-		await Bun.write(resolved, content);
-		return;
-	}
-	try {
-		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
-	} catch (error) {
-		if (error.code !== "ENOENT") throw error;
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
-		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
-	}
-}
-/**
-* Resolves to `true` when `path` is `parent` itself or nested inside it. Both sides are resolved
-* to absolute paths first, so relative and `..`-containing inputs compare correctly.
-*
-* Guards a destructive or an out-of-tree operation: before wiping an output directory, check that
-* it does not contain the project root, and before loading a path a caller supplied, check that it
-* did not escape the directory it is allowed to read from.
-*
-* @example
-* isPathInside('./src/gen', '.')   // true  — nested inside the root
-* isPathInside('.', '.')           // true  — the same directory counts as inside
-* isPathInside('.', './src/gen')   // false — the root is not inside its own output
-* isPathInside('../other', '.')    // false — escapes the root
-*/
-function isPathInside(path, parent) {
-	const resolvedPath = (0, node_path.resolve)(path);
-	const resolvedParent = (0, node_path.resolve)(parent);
-	if (resolvedPath === resolvedParent) return true;
-	const rel = (0, node_path.relative)(resolvedParent, resolvedPath);
-	return rel !== "" && !rel.startsWith("..") && !(0, node_path.isAbsolute)(rel);
-}
-//#endregion
-//#region ../../internals/utils/src/promise.ts
-/**
-* Runs `run` over every item with at most `limit` in flight. Workers share one iterator, so each
-* takes the next item the moment it frees up instead of waiting for a batch to drain.
-*
-* @example
-* ```ts
-* await inParallel({ items: files, limit: 50, run: (file) => storage.writeItem(file.path, file.source) })
-* ```
-*/
-async function inParallel({ items, limit, run }) {
-	const queue = items.entries();
-	const worker = async () => {
-		for (const [index, item] of queue) await run(item, index);
-	};
-	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
-}
-//#endregion
-//#region src/loggers/banner.ts
-/**
-* xterm-256 color for each pixel letter of the mascot. Fixed codes rather than named colors, so a
-* terminal theme cannot repaint it.
-*/
-const colors = {
-	/** Hoodie. */
-	O: 208,
-	/** Shadow where the hood meets the face. */
-	R: 166,
-	/** Face. */
-	F: 223,
-	/** Eyes. */
-	K: 16,
-	/** Blush. */
-	B: 217,
-	/** Mouth. */
-	M: 131
-};
-/**
-* The two pixel rows of the face around the eyes, for each expression.
-*/
-const eyes = {
-	open: ["FFFFFFFFFF", "FFKFFFFKFF"],
-	left: ["FFFFFFFFFF", "FKFFFFKFFF"],
-	right: ["FFFFFFFFFF", "FFFKFFFFKF"],
-	blink: ["FFFFFFFFFF", "FKKFFFFKKF"],
-	happy: ["FFKFFFFKFF", "FKFKFFKFKF"]
-};
-/**
-* The frames the mascot plays when the CLI starts, each with how long it stays on screen. It ends on
-* open eyes, which stay.
-*/
-const wakeUp = [
-	["blink", 100],
-	["open", 180],
-	["left", 140],
-	["right", 140],
-	["open", 80],
-	["happy", 220],
-	["open", 0]
-];
-/**
-* The kid in the orange hoodie from the Kubb logo, one letter per pixel and `.` for none. Each
-* 2 × 2 block becomes one terminal cell, so a block holds at most two colors.
-*/
-function pixels(expression) {
-	const [top, bottom] = eyes[expression];
-	return [
-		"....OOOOOOOOOO....",
-		"..OORRRRRRRRRROO..",
-		`..OO${top}OO..`,
-		`OOFF${bottom}FFOO`,
-		"OOFFBBFFMMFFBBFFOO",
-		"..OOOOFFFFFFOOOO.."
-	];
-}
-/**
-* Quadrant glyphs indexed by which quarters are filled: top left 1, top right 2, bottom left 4,
-* bottom right 8.
-*/
-const quadrants = " ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█";
-/**
-* Draws each 2 × 2 block of pixels as one quadrant glyph. The glyph's filled quarters take the first
-* color in the block and the rest take the other.
-*/
-function drawHead(expression) {
-	const rows = pixels(expression);
-	const lines = [];
-	for (let y = 0; y < rows.length; y += 2) {
-		let line = "";
-		for (let x = 0; x < rows[y].length; x += 2) {
-			const block = [
-				rows[y][x],
-				rows[y][x + 1],
-				rows[y + 1][x],
-				rows[y + 1][x + 1]
-			];
-			const fg = block.find((pixel) => pixel in colors);
-			if (!fg) {
-				line += " ";
-				continue;
-			}
-			const bg = colors[block.find((pixel) => pixel !== fg) ?? "."];
-			const mask = block.reduce((bits, pixel, index) => pixel === fg ? bits | 1 << index : bits, 0);
-			line += `\x1b[38;5;${colors[fg]}${bg === void 0 ? "" : `;48;5;${bg}`}m${quadrants[mask]}\x1b[0m`;
-		}
-		lines.push(line);
-	}
-	return lines;
-}
-/**
-* Generates the Kubb mascot welcome banner as an ANSI-colored string: the head with the version,
-* title, and description beside it.
-*
-* @example
-* ```ts
-* console.log(getIntro({ title: 'kubb.config.ts', description: 'generating…', version: '5.0.0', expression: 'open' }))
-* ```
-*/
-function getIntro({ title, description, version, expression }) {
-	const brand = (value, bold = false) => `\x1b[${bold ? "1;" : ""}38;5;${colors.O}m${value}\x1b[0m`;
-	const text = [
-		brand(`KUBB v${version}`, true),
-		(0, node_util.styleText)("gray", title),
-		`${brand("➜")} ${(0, node_util.styleText)("white", description)}`
-	];
-	return drawHead(expression).map((line, index) => `  ${line}  ${text[index]}`).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 = require_Telemetry.formatMs(ms);
-	if (ms <= 500) return (0, node_util.styleText)("green", formatted);
-	if (ms <= 1e3) return (0, node_util.styleText)("yellow", formatted);
-	return (0, node_util.styleText)("red", formatted);
-}
-/**
-* A `size`-cell progress bar: `done` of `total` as filled cells, the rest light. Any progress shows
-* at least one cell, and only a finished bar fills the last one.
-*/
-function formatBar(done, total, size = 20) {
-	const filled = !done ? 0 : done >= total ? size : Math.min(size - 1, Math.max(1, Math.round(done / total * size)));
-	return (0, node_util.styleText)("magenta", "█".repeat(filled)) + (0, node_util.styleText)("dim", "░".repeat(size - filled));
-}
-//#endregion
-//#region src/ui/spinner.ts
-/**
-* 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 require_text.writer().spinner();
-}
-/** How long a wait may run before a spinner shows, so a fast answer draws nothing. */
-const SPINNER_DELAY_MS = 150;
-/**
-* Awaits `promise`, showing a spinner with `message` only when it takes longer than 150 ms.
-*/
-async function withSpinner({ promise, message }) {
-	let spinner;
-	const timer = setTimeout(() => {
-		spinner = createSpinner();
-		spinner.start(message);
-	}, SPINNER_DELAY_MS);
-	try {
-		return await promise;
-	} finally {
-		clearTimeout(timer);
-		spinner?.clear();
-	}
-}
-//#endregion
-//#region src/runners/generate/utils.ts
-/** Glob pattern for paths the file watcher ignores. */
-const WATCHER_IGNORED_PATHS = "**/{.git,node_modules}/**";
-/**
-* Quiet window in milliseconds that collapses a burst of watcher events (an editor save emits several) into one rebuild.
-* It outlasts chokidar's 100 ms atomic-save window, which holds back the event of a write-then-rename save.
-*/
-const WATCHER_DEBOUNCE_MS = 250;
-/** `14:02:11  petStore.yaml changed`, the line a watcher prints when its input changes. */
-function formatChange({ target, removed = false, now = /* @__PURE__ */ new Date() }) {
-	return `${(0, node_util.styleText)("dim", now.toTimeString().slice(0, 8))}  ${(0, node_util.styleText)("bold", target)} ${removed ? "removed" : "changed"}`;
-}
-/**
-* Starts a file watcher on the given paths and calls `cb` on any change.
-* Ignores `.git` and `node_modules` directories. Event bursts (an editor save emits several)
-* are debounced into one call. `cb` must never reject: its result is not awaited, so the caller
-* serializes and reports its own builds. Resolves to a function that stops watching.
-*/
-async function startWatcher(path, cb, log = {
-	info: console.log,
-	error: console.log
-}) {
-	const { watch } = await import("chokidar");
-	const watcher = watch(path, {
-		ignorePermissionErrors: true,
-		ignored: WATCHER_IGNORED_PATHS,
-		ignoreInitial: true
-	});
-	for (const signal of ["SIGINT", "SIGTERM"]) node_process.default.once(signal, () => void watcher.close());
-	let debounceTimer = null;
-	watcher.on("all", (type, file) => {
-		log.info(formatChange({
-			target: (0, node_path.relative)(node_process.default.cwd(), file),
-			removed: type === "unlink"
-		}));
-		if (debounceTimer) clearTimeout(debounceTimer);
-		debounceTimer = setTimeout(() => {
-			debounceTimer = null;
-			cb(path);
-		}, WATCHER_DEBOUNCE_MS);
-	});
-	return async () => {
-		if (debounceTimer) clearTimeout(debounceTimer);
-		await watcher.close();
-	};
-}
-function createSnapshot() {
-	return {
-		schemas: /* @__PURE__ */ new Set(),
-		operations: /* @__PURE__ */ new Set()
-	};
-}
-/**
-* Collects a {@link BuildSnapshot} from the hooks while a build runs. `take` hands back the finished
-* build's snapshot and starts the next one.
-*/
-function trackBuild(hooks) {
-	let current = createSnapshot();
-	hooks.hook("kubb:generate:schema", (node) => {
-		if (node.name) current.schemas.add(node.name);
-	});
-	hooks.hook("kubb:generate:operation", (node) => {
-		current.operations.add(node.operationId);
-	});
-	return { take() {
-		const snapshot = current;
-		current = createSnapshot();
-		return snapshot;
-	} };
-}
-function diffNames(previous, next) {
-	return {
-		added: [...next].filter((name) => !previous.has(name)).length,
-		removed: [...previous].filter((name) => !next.has(name)).length
-	};
-}
-/**
-* Compares two {@link BuildSnapshot}s by name.
-*/
-function diffBuilds(previous, next) {
-	return {
-		schemas: diffNames(previous.schemas, next.schemas),
-		operations: diffNames(previous.operations, next.operations)
-	};
-}
-/**
-* Compares file contents or fingerprints by path.
-*/
-function diffFiles(previous, next) {
-	const files = [];
-	let unchanged = 0;
-	for (const [path, fingerprint] of next) {
-		const before = previous.get(path);
-		if (before === fingerprint) unchanged++;
-		else files.push({
-			status: before === void 0 ? "A" : "M",
-			path
-		});
-	}
-	for (const path of previous.keys()) if (!next.has(path)) files.push({
-		status: "D",
-		path
-	});
-	return {
-		files,
-		unchanged
-	};
-}
-function countLineChanges(before, after) {
-	const remaining = /* @__PURE__ */ new Map();
-	for (const line of before ? before.split("\n") : []) remaining.set(line, (remaining.get(line) ?? 0) + 1);
-	let added = 0;
-	for (const line of after ? after.split("\n") : []) {
-		const count = remaining.get(line) ?? 0;
-		if (count > 0) remaining.set(line, count - 1);
-		else added++;
-	}
-	const removed = [...remaining.values()].reduce((sum, count) => sum + count, 0);
-	return {
-		added,
-		removed
-	};
-}
-/**
-* Reads the output before generation, so cleaning the directory cannot erase the diff baseline.
-* A missing directory or an unreadable file is skipped.
-*/
-async function readOutputFiles(outputPath) {
-	const entries = await (0, node_fs_promises.readdir)(outputPath, {
-		recursive: true,
-		withFileTypes: true
-	}).catch(() => []);
-	const files = /* @__PURE__ */ new Map();
-	await inParallel({
-		items: entries.filter((entry) => entry.isFile()).map((entry) => (0, node_path.join)(entry.parentPath, entry.name)),
-		limit: 50,
-		run: async (filePath) => {
-			const source = await read(filePath).catch(() => null);
-			if (source !== null) files.set(filePath, source);
-		}
-	});
-	return files;
-}
-/**
-* Compares generated output with the files captured before generation. The manifest recognizes
-* output rewritten by a formatter, and `clean` includes files the run would delete.
-*/
-async function diffOutput({ storage, paths, clean, manifest, previousFiles }) {
-	const generated = new Set(paths);
-	const changes = [];
-	let unchanged = 0;
-	await inParallel({
-		items: paths,
-		limit: 50,
-		run: async (filePath, index) => {
-			const next = await storage.readItem(filePath);
-			if (next === null) return;
-			const previous = previousFiles.get(filePath) ?? null;
-			if (previous !== null && (matchesStored({
-				stored: previous,
-				source: next
-			}) || manifest?.isUpToDate({
-				key: filePath,
-				source: next,
-				disk: previous
-			}))) {
-				unchanged++;
-				return;
-			}
-			changes[index] = {
-				status: previous === null ? "A" : "M",
-				path: filePath,
-				...countLineChanges(previous?.trim() ?? "", previous === null ? next.trimEnd() : next.trim())
-			};
-		}
-	});
-	const files = changes.filter((file) => file !== void 0);
-	if (clean) {
-		for (const [filePath, source] of previousFiles) if (!generated.has(filePath)) files.push({
-			status: "D",
-			path: filePath,
-			...countLineChanges(source.trimEnd(), "")
-		});
-	}
-	return {
-		files,
-		unchanged
-	};
-}
-/**
-* Reads `r` (rebuild) and `q` (quit) from an interactive stdin in raw mode, and keeps ctrl+c
-* working. Returns `undefined` when stdin is not a TTY. Otherwise returns `arm`, which turns raw
-* mode back on: a spinner restores the terminal when it stops, so call it after each build. Raw mode
-* is restored on exit.
-*/
-function listenForKeys({ rebuild, quit, input = node_process.default.stdin }) {
-	if (!input.isTTY) return void 0;
-	const arm = () => {
-		input.setRawMode(true);
-		input.resume();
-	};
-	input.setEncoding("utf8");
-	input.on("data", (data) => {
-		const key = data.trim();
-		if (key === "r") {
-			rebuild();
-			return;
-		}
-		if (key === "q" || data === "") {
-			input.setRawMode(false);
-			input.pause();
-			quit(key === "q" ? 0 : 130);
-		}
-	});
-	node_process.default.once("exit", () => input.setRawMode(false));
-	arm();
-	return arm;
-}
-//#endregion
-Object.defineProperty(exports, "createSpinner", {
-	enumerable: true,
-	get: function() {
-		return createSpinner;
-	}
-});
-Object.defineProperty(exports, "diffBuilds", {
-	enumerable: true,
-	get: function() {
-		return diffBuilds;
-	}
-});
-Object.defineProperty(exports, "diffFiles", {
-	enumerable: true,
-	get: function() {
-		return diffFiles;
-	}
-});
-Object.defineProperty(exports, "diffOutput", {
-	enumerable: true,
-	get: function() {
-		return diffOutput;
-	}
-});
-Object.defineProperty(exports, "exists", {
-	enumerable: true,
-	get: function() {
-		return exists;
-	}
-});
-Object.defineProperty(exports, "formatBar", {
-	enumerable: true,
-	get: function() {
-		return formatBar;
-	}
-});
-Object.defineProperty(exports, "formatMsWithColor", {
-	enumerable: true,
-	get: function() {
-		return formatMsWithColor;
-	}
-});
-Object.defineProperty(exports, "getIntro", {
-	enumerable: true,
-	get: function() {
-		return getIntro;
-	}
-});
-Object.defineProperty(exports, "isPathInside", {
-	enumerable: true,
-	get: function() {
-		return isPathInside;
-	}
-});
-Object.defineProperty(exports, "listenForKeys", {
-	enumerable: true,
-	get: function() {
-		return listenForKeys;
-	}
-});
-Object.defineProperty(exports, "read", {
-	enumerable: true,
-	get: function() {
-		return read;
-	}
-});
-Object.defineProperty(exports, "readOutputFiles", {
-	enumerable: true,
-	get: function() {
-		return readOutputFiles;
-	}
-});
-Object.defineProperty(exports, "startWatcher", {
-	enumerable: true,
-	get: function() {
-		return startWatcher;
-	}
-});
-Object.defineProperty(exports, "trackBuild", {
-	enumerable: true,
-	get: function() {
-		return trackBuild;
-	}
-});
-Object.defineProperty(exports, "wakeUp", {
-	enumerable: true,
-	get: function() {
-		return wakeUp;
-	}
-});
-Object.defineProperty(exports, "withSpinner", {
-	enumerable: true,
-	get: function() {
-		return withSpinner;
-	}
-});
-Object.defineProperty(exports, "write", {
-	enumerable: true,
-	get: function() {
-		return write;
-	}
-});
-Object.defineProperty(exports, "writeRaw", {
-	enumerable: true,
-	get: function() {
-		return writeRaw;
-	}
-});
-
-//# sourceMappingURL=utils-C3vTpUje.cjs.map