@kidd-cli/core 0.3.0 → 0.5.0

package/dist/middleware/icons.js

@@ -0,0 +1,824 @@
+import { n as decorateContext, t as middleware } from "../middleware-BewRXb2G.js";
+import { join } from "node:path";
+import { attemptAsync, ok } from "@kidd-cli/utils/fp";
+import { z } from "zod";
+import { match as match$1 } from "ts-pattern";
+import { mkdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { getFonts } from "font-list";
+//#region src/middleware/icons/definitions.ts
+/**
+* Predefined icon definitions organized by category.
+*
+* Each icon has a Nerd Font glyph and an emoji fallback. The middleware
+* resolves to one or the other based on font detection.
+*
+* @module
+*/
+/**
+* Git-related icons for version control operations.
+*
+* Emoji values use Unicode escape sequences rather than literal emoji
+* characters to avoid encoding issues across editors, terminals, and
+* build tools that may not handle multi-byte characters correctly.
+*
+* Nerd Font sources: nf-dev (Devicons), nf-fa (Font Awesome)
+*/
+const GIT_ICONS = Object.freeze({
+	branch: {
+		emoji: "🔀",
+		nerdFont: ""
+	},
+	clone: {
+		emoji: "📋",
+		nerdFont: ""
+	},
+	commit: {
+		emoji: "📝",
+		nerdFont: ""
+	},
+	compare: {
+		emoji: "🔄",
+		nerdFont: ""
+	},
+	fetch: {
+		emoji: "⬇️",
+		nerdFont: ""
+	},
+	fork: {
+		emoji: "🔀",
+		nerdFont: ""
+	},
+	git: {
+		emoji: "💻",
+		nerdFont: ""
+	},
+	merge: {
+		emoji: "🔀",
+		nerdFont: ""
+	},
+	pr: {
+		emoji: "📥",
+		nerdFont: ""
+	},
+	tag: {
+		emoji: "🏷️",
+		nerdFont: ""
+	},
+	worktree: {
+		emoji: "🌳",
+		nerdFont: ""
+	}
+});
+/**
+* DevOps and infrastructure icons.
+*
+* Nerd Font sources: nf-dev (Devicons), nf-fa (Font Awesome)
+*/
+const DEVOPS_ICONS = Object.freeze({
+	ci: {
+		emoji: "⚙️",
+		nerdFont: ""
+	},
+	cloud: {
+		emoji: "☁️",
+		nerdFont: ""
+	},
+	deploy: {
+		emoji: "🚀",
+		nerdFont: ""
+	},
+	docker: {
+		emoji: "🐳",
+		nerdFont: ""
+	},
+	kubernetes: {
+		emoji: "☸️",
+		nerdFont: ""
+	},
+	server: {
+		emoji: "🖥️",
+		nerdFont: ""
+	},
+	terminal: {
+		emoji: "💻",
+		nerdFont: ""
+	}
+});
+/**
+* Status indicator icons.
+*
+* Nerd Font sources: nf-fa (Font Awesome)
+*/
+const STATUS_ICONS = Object.freeze({
+	error: {
+		emoji: "❌",
+		nerdFont: ""
+	},
+	info: {
+		emoji: "ℹ️",
+		nerdFont: ""
+	},
+	pending: {
+		emoji: "⏳",
+		nerdFont: ""
+	},
+	running: {
+		emoji: "▶️",
+		nerdFont: ""
+	},
+	stopped: {
+		emoji: "⏹️",
+		nerdFont: ""
+	},
+	success: {
+		emoji: "✅",
+		nerdFont: ""
+	},
+	warning: {
+		emoji: "⚠️",
+		nerdFont: ""
+	}
+});
+/**
+* File type and filesystem icons.
+*
+* Nerd Font sources: nf-fa (Font Awesome), nf-dev (Devicons)
+*/
+const FILES_ICONS = Object.freeze({
+	config: {
+		emoji: "⚙️",
+		nerdFont: ""
+	},
+	file: {
+		emoji: "📄",
+		nerdFont: ""
+	},
+	folder: {
+		emoji: "📁",
+		nerdFont: ""
+	},
+	javascript: {
+		emoji: "📄",
+		nerdFont: ""
+	},
+	json: {
+		emoji: "📄",
+		nerdFont: ""
+	},
+	lock: {
+		emoji: "🔒",
+		nerdFont: ""
+	},
+	markdown: {
+		emoji: "📄",
+		nerdFont: ""
+	},
+	typescript: {
+		emoji: "📄",
+		nerdFont: ""
+	}
+});
+/**
+* Merge all category icon records into a single definitions record.
+*
+* @returns A frozen record of all predefined icons.
+*/
+function createDefaultIcons() {
+	return Object.freeze({
+		...GIT_ICONS,
+		...DEVOPS_ICONS,
+		...STATUS_ICONS,
+		...FILES_ICONS
+	});
+}
+/**
+* Retrieve the icon definitions for a specific category.
+*
+* @param category - The icon category to retrieve.
+* @returns The frozen record of icons for that category.
+*/
+function getIconsByCategory(category) {
+	return match$1(category).with("git", () => GIT_ICONS).with("devops", () => DEVOPS_ICONS).with("status", () => STATUS_ICONS).with("files", () => FILES_ICONS).exhaustive();
+}
+//#endregion
+//#region src/middleware/icons/install.ts
+/**
+* Nerd Font installation for macOS and Linux.
+*
+* Detects installed system fonts, matches them to available Nerd Font
+* equivalents, and lets the user choose which to install. Supports
+* Homebrew on macOS and direct download on Linux.
+*
+* All shell commands run asynchronously so the spinner can animate
+* and ctrl+c remains responsive.
+*
+* @module
+*/
+const execAsync = promisify(exec);
+/**
+* Zod schema for validating font names before shell interpolation.
+*
+* Restricts to alphanumeric characters and hyphens to prevent command injection.
+*
+* @private
+*/
+const fontNameSchema = z.string().regex(/^[A-Za-z0-9-]+$/, "Font name must be alphanumeric or hyphen");
+/**
+* Maps base font family name patterns to their Nerd Font release names.
+*
+* Keys are lowercase patterns matched against installed font names.
+* Values are the exact release archive names on GitHub.
+*
+* @private
+*/
+const FONT_MAP = Object.freeze([
+	["jetbrains mono", "JetBrainsMono"],
+	["fira code", "FiraCode"],
+	["fira mono", "FiraMono"],
+	["cascadia code", "CascadiaCode"],
+	["cascadia mono", "CascadiaMono"],
+	["hack", "Hack"],
+	["source code pro", "SourceCodePro"],
+	["meslo", "Meslo"],
+	["inconsolata", "Inconsolata"],
+	["dejavu sans mono", "DejaVuSansMono"],
+	["droid sans mono", "DroidSansMono"],
+	["ubuntu mono", "UbuntuMono"],
+	["ubuntu sans", "UbuntuSans"],
+	["roboto mono", "RobotoMono"],
+	["ibm plex mono", "IBMPlexMono"],
+	["victor mono", "VictorMono"],
+	["iosevka", "Iosevka"],
+	["mononoki", "Mononoki"],
+	["geist mono", "GeistMono"],
+	["space mono", "SpaceMono"],
+	["anonymous pro", "AnonymousPro"],
+	["overpass", "Overpass"],
+	["go mono", "Go-Mono"],
+	["noto", "Noto"],
+	["commit mono", "CommitMono"],
+	["monaspace", "Monaspace"],
+	["intel one mono", "IntelOneMono"],
+	["zed mono", "ZedMono"],
+	["comic shanns", "ComicShannsMono"],
+	["lilex", "Lilex"],
+	["recursive", "Recursive"],
+	["hermit", "Hermit"],
+	["hasklig", "Hasklig"],
+	["martian mono", "MartianMono"],
+	["0xproto", "0xProto"],
+	["departure mono", "DepartureMono"],
+	["atkinson hyperlegible", "AtkinsonHyperlegibleMono"]
+]);
+/**
+* Popular Nerd Fonts shown as fallback options when no matches are found.
+*
+* @private
+*/
+const POPULAR_FONTS = Object.freeze([
+	"JetBrainsMono",
+	"FiraCode",
+	"Hack",
+	"CascadiaCode",
+	"Meslo",
+	"SourceCodePro",
+	"Iosevka",
+	"VictorMono"
+]);
+/**
+* Interactively install a Nerd Font on the user's system.
+*
+* Detects installed system fonts, matches them against available Nerd Font
+* equivalents, and presents a selection prompt. If a `font` option is
+* provided, skips detection and installs that font directly after confirmation.
+*
+* @param options - Installation options including context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installNerdFont(options) {
+	const { ctx, font } = options;
+	if (font !== void 0) {
+		const parsed = fontNameSchema.safeParse(font);
+		if (!parsed.success) return iconsError({
+			message: `Invalid font name: ${parsed.error.message}`,
+			type: "install_failed"
+		});
+		return installWithConfirmation({
+			ctx,
+			fontName: parsed.data
+		});
+	}
+	return installWithSelection(ctx);
+}
+/**
+* Run the font selection flow: detect installed fonts, match to Nerd Fonts,
+* and let the user pick.
+*
+* @private
+* @param ctx - The icons context with prompts, spinner, and logger.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installWithSelection(ctx) {
+	ctx.spinner.start("Detecting installed fonts...");
+	const matches = await detectMatchingFonts();
+	ctx.spinner.stop("Font detection complete");
+	const choices = buildFontChoices(matches);
+	const selected = await ctx.prompts.select({
+		message: "Select a Nerd Font to install",
+		options: choices
+	});
+	if (selected === void 0 || typeof selected === "symbol") return ok(false);
+	const fontName = String(selected);
+	const parsed = fontNameSchema.safeParse(fontName);
+	if (!parsed.success) return iconsError({
+		message: `Invalid font name: ${parsed.error.message}`,
+		type: "install_failed"
+	});
+	const action = await ctx.prompts.select({
+		message: "How would you like to install?",
+		options: [{
+			label: "Auto install",
+			value: "auto"
+		}, {
+			label: "Show install commands",
+			value: "commands"
+		}]
+	});
+	if (action === void 0 || typeof action === "symbol") return ok(false);
+	return match$1(String(action)).with("auto", () => installFontWithSpinner({
+		ctx,
+		fontName: parsed.data
+	})).with("commands", () => showInstallCommands({
+		ctx,
+		fontName: parsed.data
+	})).otherwise(() => ok(false));
+}
+/**
+* Confirm and install a specific font by name.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installWithConfirmation({ ctx, fontName }) {
+	if (!await ctx.prompts.confirm({ message: `Nerd Fonts not detected. Install ${fontName} Nerd Font?` })) return ok(false);
+	return installFontWithSpinner({
+		ctx,
+		fontName
+	});
+}
+/**
+* Detect system fonts and match them to available Nerd Font equivalents.
+*
+* @private
+* @returns An array of matched Nerd Font release names.
+*/
+async function detectMatchingFonts() {
+	const [error, systemFonts] = await attemptAsync(() => getFonts({ disableQuoting: true }));
+	if (error || systemFonts === null) return [];
+	const lowerFonts = systemFonts.map((f) => f.toLowerCase());
+	return FONT_MAP.filter(([pattern]) => lowerFonts.some((f) => f.includes(pattern))).map(([, nerdName]) => nerdName);
+}
+/**
+* Build the select prompt choices from matched and popular fonts.
+*
+* Matched fonts (based on what's installed) appear first with a hint,
+* followed by popular alternatives that weren't already matched.
+*
+* @private
+* @param matches - Nerd Font names matched from installed system fonts.
+* @returns An array of select options.
+*/
+function buildFontChoices(matches) {
+	const matchedSet = new Set(matches);
+	const matchedChoices = matches.map((name) => ({
+		hint: "detected on your system",
+		label: `${name} Nerd Font`,
+		value: name
+	}));
+	const popularChoices = POPULAR_FONTS.filter((name) => !matchedSet.has(name)).map((name) => ({
+		label: `${name} Nerd Font`,
+		value: name
+	}));
+	return [...matchedChoices, ...popularChoices];
+}
+/**
+* Print the install commands for the user to run manually.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with false since nothing was installed.
+*/
+async function showInstallCommands({ ctx, fontName }) {
+	const slug = fontNameToSlug(fontName);
+	const url = `https://github.com/ryanoasis/nerd-fonts/releases/latest/download/${fontName}.zip`;
+	const fontDir = match$1(process.platform).with("darwin", () => join(homedir(), "Library", "Fonts")).otherwise(() => join(homedir(), ".local", "share", "fonts"));
+	const hasBrew = await checkBrewAvailable();
+	return ok(match$1(process.platform).with("darwin", () => match$1(hasBrew).with(true, () => [
+		"",
+		"Run the following command to install via Homebrew:",
+		"",
+		`  brew install --cask font-${slug}-nerd-font`,
+		""
+	]).with(false, () => [
+		"",
+		"Run the following commands to install manually:",
+		"",
+		`  curl -fsSL -o "${fontDir}/${fontName}.zip" "${url}"`,
+		`  unzip -o "${fontDir}/${fontName}.zip" -d "${fontDir}"`,
+		`  rm -f "${fontDir}/${fontName}.zip"`,
+		""
+	]).exhaustive()).with("linux", () => [
+		"",
+		"Run the following commands to install:",
+		"",
+		`  mkdir -p "${fontDir}"`,
+		`  curl -fsSL -o "${fontDir}/${fontName}.zip" "${url}"`,
+		`  unzip -o "${fontDir}/${fontName}.zip" -d "${fontDir}"`,
+		`  rm -f "${fontDir}/${fontName}.zip"`,
+		"  fc-cache -fv",
+		""
+	]).otherwise(() => [
+		"",
+		`Download the font from: ${url}`,
+		""
+	]).reduce((_acc, line) => {
+		ctx.logger.info(line);
+		return false;
+	}, false));
+}
+/**
+* Install a Nerd Font with spinner feedback.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installFontWithSpinner({ ctx, fontName }) {
+	ctx.spinner.start(`Installing ${fontName} Nerd Font...`);
+	const result = await installFont({
+		ctx,
+		fontName
+	});
+	const [error] = result;
+	if (error) {
+		ctx.spinner.stop(`Failed to install ${fontName} Nerd Font`);
+		return result;
+	}
+	ctx.spinner.stop(`${fontName} Nerd Font installed successfully`);
+	return result;
+}
+/**
+* Install a Nerd Font by name, dispatching to the platform-appropriate method.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installFont({ ctx, fontName }) {
+	return match$1(process.platform).with("darwin", () => installDarwin({
+		ctx,
+		fontName
+	})).with("linux", () => installLinux({
+		ctx,
+		fontName
+	})).otherwise(() => Promise.resolve(iconsError({
+		message: `Unsupported platform: ${process.platform}`,
+		type: "install_failed"
+	})));
+}
+/**
+* Install a Nerd Font on macOS via Homebrew or direct download.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installDarwin({ ctx, fontName }) {
+	const slug = fontNameToSlug(fontName);
+	if (await checkBrewAvailable()) return installViaBrew({
+		ctx,
+		slug
+	});
+	return installViaDownload({
+		ctx,
+		fontName
+	});
+}
+/**
+* Install a Nerd Font on Linux via direct download.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installLinux({ ctx, fontName }) {
+	return installViaDownload({
+		ctx,
+		fontName
+	});
+}
+/**
+* Check whether Homebrew is available on the system.
+*
+* @private
+* @returns A promise resolving to true when the `brew` command is found.
+*/
+async function checkBrewAvailable() {
+	const [error] = await attemptAsync(() => execAsync("command -v brew"));
+	return error === null;
+}
+/**
+* Install a Nerd Font via Homebrew cask.
+*
+* @private
+* @param params - The icons context and cask slug.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installViaBrew({ ctx, slug }) {
+	try {
+		ctx.spinner.message(`Installing font-${slug}-nerd-font via Homebrew...`);
+		await execAsync(`brew install --cask font-${slug}-nerd-font`);
+		return ok(true);
+	} catch {
+		return iconsError({
+			message: `Homebrew installation failed for font-${slug}-nerd-font`,
+			type: "install_failed"
+		});
+	}
+}
+/**
+* Install a Nerd Font by downloading from GitHub releases.
+*
+* Downloads the zip archive, extracts it to the appropriate font directory,
+* and refreshes the font cache on Linux.
+*
+* @private
+* @param params - The icons context and font name.
+* @returns A Result with true on success or an IconsError on failure.
+*/
+async function installViaDownload({ ctx, fontName }) {
+	const fontDir = match$1(process.platform).with("darwin", () => join(homedir(), "Library", "Fonts")).otherwise(() => join(homedir(), ".local", "share", "fonts"));
+	try {
+		await mkdir(fontDir, { recursive: true });
+		const url = `https://github.com/ryanoasis/nerd-fonts/releases/latest/download/${fontName}.zip`;
+		const tmpZip = join(fontDir, `${fontName}.zip`);
+		ctx.spinner.message(`Downloading ${fontName} Nerd Font...`);
+		await execAsync(`curl -fsSL -o "${tmpZip}" "${url}"`, { timeout: 12e4 });
+		ctx.spinner.message(`Extracting ${fontName} Nerd Font...`);
+		await execAsync(`unzip -o "${tmpZip}" -d "${fontDir}"`);
+		await rm(tmpZip, { force: true });
+		if (process.platform === "linux") {
+			ctx.spinner.message("Refreshing font cache...");
+			await execAsync("fc-cache -fv");
+		}
+		return ok(true);
+	} catch {
+		return iconsError({
+			message: `Failed to download and install ${fontName} Nerd Font`,
+			type: "install_failed"
+		});
+	}
+}
+/**
+* Canonical mapping of Nerd Font release names to Homebrew cask slugs.
+*
+* The generic regex-based conversion produces incorrect slugs for
+* abbreviations (e.g. IBM, DejaVu) and compound names. This map
+* provides the correct slugs for all fonts in {@link FONT_MAP}.
+*
+* @private
+*/
+const BREW_SLUG_MAP = Object.freeze({
+	"0xProto": "0xproto",
+	AnonymousPro: "anonymous-pro",
+	AtkinsonHyperlegibleMono: "atkinson-hyperlegible-mono",
+	CascadiaCode: "cascadia-code",
+	CascadiaMono: "cascadia-mono",
+	ComicShannsMono: "comic-shanns-mono",
+	CommitMono: "commit-mono",
+	DejaVuSansMono: "dejavu-sans-mono",
+	DepartureMono: "departure-mono",
+	DroidSansMono: "droid-sans-mono",
+	FiraCode: "fira-code",
+	FiraMono: "fira-mono",
+	GeistMono: "geist-mono",
+	"Go-Mono": "go-mono",
+	Hack: "hack",
+	Hasklig: "hasklig",
+	Hermit: "hermit",
+	IBMPlexMono: "ibm-plex-mono",
+	Inconsolata: "inconsolata",
+	IntelOneMono: "intone-mono",
+	Iosevka: "iosevka",
+	JetBrainsMono: "jetbrains-mono",
+	Lilex: "lilex",
+	MartianMono: "martian-mono",
+	Meslo: "meslo-lg",
+	Monaspace: "monaspace",
+	Mononoki: "mononoki",
+	Noto: "noto",
+	Overpass: "overpass",
+	Recursive: "recursive",
+	RobotoMono: "roboto-mono",
+	SourceCodePro: "sauce-code-pro",
+	SpaceMono: "space-mono",
+	UbuntuMono: "ubuntu-mono",
+	UbuntuSans: "ubuntu-sans",
+	VictorMono: "victor-mono",
+	ZedMono: "zed-mono"
+});
+/**
+* Convert a font family name to a Homebrew cask slug.
+*
+* Uses the canonical {@link BREW_SLUG_MAP} when available, falling
+* back to a regex-based conversion for unknown font names.
+*
+* @private
+* @param name - The font family name (e.g. 'JetBrainsMono').
+* @returns The slug (e.g. 'jetbrains-mono').
+*/
+function fontNameToSlug(name) {
+	const mapped = BREW_SLUG_MAP[name];
+	if (mapped !== void 0) return mapped;
+	return name.replaceAll(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+* Construct a failure Result tuple with an {@link IconsError}.
+*
+* @private
+* @param error - The icons error.
+* @returns A synchronous Result tuple `[IconsError, null]`.
+*/
+function iconsError(error) {
+	return [error, null];
+}
+//#endregion
+//#region src/middleware/icons/context.ts
+/**
+* Create an {@link IconsContext} value for `ctx.icons`.
+*
+* The returned object exposes methods for resolving icons (`get`, `has`,
+* `installed`, `setup`, `category`).
+*
+* @param options - Factory options.
+* @returns An IconsContext instance.
+*/
+function createIconsContext(options) {
+	const { ctx, icons, font, forceSetup } = options;
+	const state = { isInstalled: options.isInstalled };
+	return Object.freeze({
+		category: (cat) => {
+			const categoryIcons = getIconsByCategory(cat);
+			return Object.freeze(Object.fromEntries(Object.entries(categoryIcons).map(([name, def]) => [name, resolveIcon(icons, name, state.isInstalled, def)])));
+		},
+		get: (name) => resolveIcon(icons, name, state.isInstalled),
+		has: (name) => name in icons,
+		installed: () => match$1(forceSetup).with(true, () => false).otherwise(() => state.isInstalled),
+		setup: async () => {
+			const [error, result] = await installNerdFont({
+				ctx,
+				font
+			});
+			if (error) return [error, null];
+			if (result) state.isInstalled = true;
+			return [null, result];
+		}
+	});
+}
+/**
+* Resolve a single icon to its appropriate glyph string.
+*
+* @private
+* @param icons - The full icon definitions record.
+* @param name - The icon name to resolve.
+* @param nerdFontsInstalled - Whether Nerd Fonts are available.
+* @param fallbackDef - Optional fallback definition (used for category resolution).
+* @returns The resolved glyph string, or empty string if not found.
+*/
+function resolveIcon(icons, name, nerdFontsInstalled, fallbackDef) {
+	const def = icons[name] ?? fallbackDef;
+	if (def === void 0) return "";
+	return match$1(nerdFontsInstalled).with(true, () => def.nerdFont).with(false, () => def.emoji).exhaustive();
+}
+//#endregion
+//#region src/middleware/icons/detect.ts
+/**
+* Nerd Font detection using the `font-list` package.
+*
+* Queries the system font catalog and checks whether any installed
+* font family name contains "Nerd".
+*
+* @module
+*/
+/**
+* Detect whether Nerd Fonts are installed on the system.
+*
+* Uses the `font-list` package to query installed font families and
+* checks for any family name containing "Nerd".
+*
+* @returns A promise that resolves to true when at least one Nerd Font is found.
+*/
+async function detectNerdFonts() {
+	const [error, fonts] = await attemptAsync(() => getFonts({ disableQuoting: true }));
+	if (error || fonts === null) return false;
+	return fonts.some((font) => /nerd/i.test(font));
+}
+//#endregion
+//#region src/middleware/icons/icons.ts
+/**
+* Icons middleware factory.
+*
+* Detects Nerd Font availability, optionally prompts for installation,
+* and decorates `ctx.icons` with an icon resolver.
+*
+* @module
+*/
+/**
+* Create an icons middleware that decorates `ctx.icons`.
+*
+* Detects whether Nerd Fonts are installed. When `autoSetup` is enabled
+* and fonts are missing, prompts the user to install them. Merges any
+* custom icon definitions with the built-in defaults.
+*
+* @param options - Optional middleware configuration.
+* @returns A Middleware instance.
+*
+* @example
+* ```ts
+* import { icons } from '@kidd-cli/core/icons'
+*
+* cli({
+*   middleware: [
+*     icons({ autoSetup: true, font: 'JetBrainsMono' }),
+*   ],
+* })
+* ```
+*/
+function icons(options) {
+	const resolved = resolveOptions(options);
+	const frozenIcons = Object.freeze({
+		...createDefaultIcons(),
+		...resolved.icons
+	});
+	return middleware(async (ctx, next) => {
+		const isInstalled = await resolveInstallStatus({
+			ctx,
+			isDetected: await detectNerdFonts(),
+			resolved
+		});
+		decorateContext(ctx, "icons", createIconsContext({
+			ctx,
+			font: resolved.font,
+			forceSetup: resolved.forceSetup,
+			icons: frozenIcons,
+			isInstalled
+		}));
+		return next();
+	});
+}
+/**
+* Extract options into a resolved shape, avoiding optional chaining.
+*
+* @private
+* @param options - Raw middleware options.
+* @returns Resolved options with defaults applied.
+*/
+function resolveOptions(options) {
+	if (options === void 0) return {
+		autoSetup: false,
+		font: void 0,
+		forceSetup: false,
+		icons: void 0
+	};
+	return {
+		autoSetup: options.autoSetup === true,
+		font: options.font,
+		forceSetup: options.forceSetup === true,
+		icons: options.icons
+	};
+}
+/**
+* Determine final install status, triggering auto-setup if configured.
+*
+* @private
+* @param params - Detection state, resolved options, and middleware context.
+* @returns Whether Nerd Fonts should be considered installed.
+*/
+async function resolveInstallStatus({ isDetected, resolved, ctx }) {
+	if (isDetected) return true;
+	if (!resolved.autoSetup) return false;
+	const [error, result] = await installNerdFont({
+		ctx,
+		font: resolved.font
+	});
+	if (error) ctx.logger.warn(`Auto-setup failed: ${error.message}`);
+	return result === true;
+}
+//#endregion
+export { icons };
+
+//# sourceMappingURL=icons.js.map