boltdocs 3.3.5 → 3.3.6

package/dist/search-dialog-DzObE-Ar.js

@@ -0,0 +1,717 @@
+/**
+ * Boltdocs - https://boltdocs.vercel.app
+ * Copyright (c) 2026 Jesus Alcala
+ * Licensed under the MIT License.
+ */
+import { G as useConfig, H as X, J as useBoltdocsContext, d as normalizePath, l as createRouteIndex, o as cn, u as useRoutesContext, z as Search } from "./link-q1qHNGK_.js";
+import { E as useLocation, O as useNavigate, f as normalizeUrlBase, o as getVersionPrefixSegments } from "./router-CZBxMRAH.js";
+import { i as Navbar, n as createSearchHighlightRegex, o as ErrorBoundary, t as SearchDialog$1 } from "./search-dialog-mYnqU4v7.js";
+import { useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import fetchSearchData from "virtual:boltdocs-search";
+
+//#region src/client/hooks/use-routes.ts
+function stripBase(parts, base) {
+	const baseParts = normalizeUrlBase(base).split("/").filter(Boolean);
+	if (baseParts.length === 0) return parts;
+	if (parts.length < baseParts.length || !baseParts.every((part, index) => parts[index] === part)) return parts;
+	return parts.slice(baseParts.length);
+}
+function consumeVersion(parts, config) {
+	const versions = config.versions;
+	if (!versions) return { nextIndex: 0 };
+	const prefixParts = getVersionPrefixSegments(config);
+	let index = 0;
+	if (prefixParts.length > 0 && prefixParts.every((part, offset) => parts[offset] === part)) index = prefixParts.length;
+	else if (prefixParts.length > 0) {
+		if (prefixParts.length === 1 && parts.length > 0) {
+			const version = versions.versions.find((item) => `${prefixParts[0]}${item.path}` === parts[0]);
+			if (version) return {
+				version: version.path,
+				nextIndex: 1
+			};
+		}
+		return { nextIndex: 0 };
+	}
+	const candidate = parts[index];
+	if (candidate && versions.versions.some((version) => version.path === candidate)) return {
+		version: candidate,
+		nextIndex: index + 1
+	};
+	return { nextIndex: 0 };
+}
+function consumeLocale(parts, index, locales) {
+	const candidate = parts[index];
+	return candidate && locales.includes(candidate) ? {
+		locale: candidate,
+		nextIndex: index + 1
+	} : { nextIndex: index };
+}
+function effectiveVariantMatches(route, config, currentLocale, currentVersion) {
+	const localeMatches = !config.i18n || (route.locale || config.i18n.defaultLocale) === currentLocale;
+	const versionMatches = !config.versions || (route.version || config.versions.defaultVersion) === currentVersion;
+	return localeMatches && versionMatches;
+}
+function findCurrentCollectionRoute(routeIndex, structuralPathKey, config, currentLocale, currentVersion) {
+	return routeIndex.byCollectionPath?.get(structuralPathKey)?.find((route) => effectiveVariantMatches(route, config, currentLocale, currentVersion));
+}
+/** Filter generated variants using the URL's active locale/version contract. */
+function selectRoutesForContext(routes, options) {
+	const { config, currentLocale, currentVersion, isCurrentLocalePrefixed, isCurrentVersionPrefixed, countsByFilePath } = options;
+	return routes.filter((route) => {
+		const localeMatches = config.i18n ? (route.locale || config.i18n.defaultLocale) === currentLocale : true;
+		const versionMatches = config.versions ? (route.version || config.versions.defaultVersion) === currentVersion : true;
+		if (!(localeMatches && versionMatches)) return false;
+		if ((countsByFilePath.get(route.filePath) || 0) <= 1) return true;
+		const localeMismatch = config.i18n && isCurrentLocalePrefixed !== Boolean(route.locale);
+		const versionMismatch = config.versions && isCurrentVersionPrefixed !== Boolean(route.version);
+		return !(localeMismatch || versionMismatch);
+	});
+}
+/**
+* Hook to access the framework's routing state.
+* Returns both the complete set of routes and a filtered list based on the current
+* version and locale.
+*/
+function useRoutes() {
+	const routeContext = useRoutesContext();
+	const allRoutes = routeContext.routes;
+	const routeIndex = useMemo(() => routeContext.index?.byCollectionPath ? routeContext.index : createRouteIndex(allRoutes), [allRoutes, routeContext.index]);
+	const config = useConfig();
+	const { pathname } = useLocation();
+	const { currentLocale: currentLocaleStore, currentVersion: currentVersionStore } = useBoltdocsContext();
+	const currentPath = useMemo(() => normalizePath(pathname || "/"), [pathname]);
+	const pathParts = useMemo(() => currentPath.split("/").filter(Boolean), [currentPath]);
+	const localeConfig = config.i18n?.locales;
+	const configuredLocales = useMemo(() => localeConfig ? Array.isArray(localeConfig) ? localeConfig : Object.keys(localeConfig) : [], [localeConfig]);
+	const configuredVersions = useMemo(() => config.versions?.versions || [], [config.versions]);
+	const structuralPath = useMemo(() => {
+		const contentParts = stripBase(pathParts, config.base);
+		const versionMatch = consumeVersion(contentParts, config);
+		const localeMatch = consumeLocale(contentParts, versionMatch.nextIndex, configuredLocales);
+		return {
+			contentParts: contentParts.slice(localeMatch.nextIndex),
+			locale: localeMatch.locale,
+			version: versionMatch.version
+		};
+	}, [
+		config,
+		configuredLocales,
+		pathParts
+	]);
+	const currentLocale = config.i18n ? structuralPath.locale || (configuredLocales.includes(currentLocaleStore || "") ? currentLocaleStore : config.i18n.defaultLocale) : void 0;
+	const currentVersion = config.versions ? structuralPath.version || (configuredVersions.some((version) => version.path === currentVersionStore) ? currentVersionStore : config.versions.defaultVersion) : void 0;
+	const structuralPathKey = useMemo(() => `/${structuralPath.contentParts.join("/")}`, [structuralPath.contentParts]);
+	const currentRoute = useMemo(() => {
+		const direct = routeIndex.byPath.get(currentPath);
+		if (direct) return direct;
+		return findCurrentCollectionRoute(routeIndex, structuralPathKey, config, currentLocale, currentVersion);
+	}, [
+		config,
+		currentLocale,
+		currentPath,
+		currentVersion,
+		routeIndex,
+		structuralPathKey
+	]);
+	const isCurrentLocalePrefixed = structuralPath.locale !== void 0;
+	const isCurrentVersionPrefixed = structuralPath.version !== void 0;
+	const countsByFilePath = useMemo(() => {
+		if (routeIndex.countsByFilePath) return routeIndex.countsByFilePath;
+		const counts = /* @__PURE__ */ new Map();
+		for (const route of allRoutes) counts.set(route.filePath, (counts.get(route.filePath) || 0) + 1);
+		return counts;
+	}, [allRoutes, routeIndex.countsByFilePath]);
+	const routes = useMemo(() => selectRoutesForContext(allRoutes, {
+		config,
+		currentLocale,
+		currentVersion,
+		isCurrentLocalePrefixed,
+		isCurrentVersionPrefixed,
+		countsByFilePath
+	}), [
+		allRoutes,
+		config,
+		countsByFilePath,
+		currentLocale,
+		currentVersion,
+		isCurrentLocalePrefixed,
+		isCurrentVersionPrefixed
+	]);
+	const collections = useMemo(() => new Set(routeIndex.collectionNames.map((name) => name.toLowerCase())), [routeIndex.collectionNames]);
+	const currentCollection = structuralPath.contentParts[0]?.toLowerCase();
+	return {
+		routes,
+		allRoutes,
+		currentRoute,
+		isCollectionPage: collections.has(currentCollection || ""),
+		currentLocale,
+		currentVersion
+	};
+}
+
+//#endregion
+//#region src/client/components/internal/error-boundary.tsx
+function InternalFallback({ error, resetErrorBoundary, className }) {
+	return /* @__PURE__ */ jsxs("div", {
+		role: "alert",
+		className: cn("p-2 font-mono flex flex-col items-center justify-between min-h-[30vh]", className),
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "text-lg font-semibold text-danger-500",
+				children: "Something went wrong"
+			}),
+			error?.message && /* @__PURE__ */ jsx("pre", {
+				className: "text-sm mt-2 max-w-md overflow-auto whitespace-pre-wrap break-word",
+				children: error.message
+			}),
+			error?.stack && /* @__PURE__ */ jsxs("details", {
+				className: "mt-2 max-w-md text-left text-xs",
+				children: [/* @__PURE__ */ jsx("summary", {
+					className: "cursor-pointer text-muted select-none outline-none",
+					children: "Error details"
+				}), /* @__PURE__ */ jsx("pre", {
+					className: "mt-2 p-2 bg-soft rounded border-subtle border overflow-auto max-h-48 whitespace-pre-wrap break-words",
+					children: error.stack
+				})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2 mt-2",
+				children: [/* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: resetErrorBoundary,
+					className: "px-2 py-3 bg-soft rounded border-subtle border font-mono font-semibold text-body hover:scale-105 transition-transform active:scale-95 cursor-pointer",
+					children: "Try again"
+				}), typeof window !== "undefined" && /* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: () => window.location.reload(),
+					className: "px-2 py-3 rounded font-mono font-semibold text-muted hover:text-body transition-colors cursor-pointer",
+					children: "Reload page"
+				})]
+			})
+		]
+	});
+}
+function InternalErrorBoundary({ children, fallback, resetKeys }) {
+	return /* @__PURE__ */ jsx(ErrorBoundary, {
+		fallback,
+		resetKeys,
+		FallbackComponent: !fallback ? InternalFallback : void 0,
+		children
+	});
+}
+
+//#endregion
+//#region src/client/hooks/use-search.ts
+const SEARCH_DEBOUNCE_MS = 250;
+const SEARCH_RESULT_LIMIT = 10;
+function foldSearchText(value) {
+	return value.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLocaleLowerCase();
+}
+function decodeAlgoliaSnippet(value) {
+	return value.replace(/<[^>]*>/g, "").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, "\"").replace(/&#0?39;|&apos;/gi, "'").replace(/&amp;/gi, "&").replace(/&#(\d+);/g, (_match, code) => String.fromCodePoint(Number.parseInt(code, 10))).replace(/\s+/g, " ").trim();
+}
+function createSearchSnippet(content, query) {
+	const normalizedContent = content.replace(/\s+/g, " ").trim();
+	if (!normalizedContent) return "";
+	const terms = query.trim().split(/\s+/).filter(Boolean).map((term) => term.toLocaleLowerCase());
+	const lowerContent = normalizedContent.toLocaleLowerCase();
+	const matchIndexes = terms.map((term) => lowerContent.indexOf(term)).filter((index) => index >= 0);
+	const firstMatch = matchIndexes.length > 0 ? Math.min(...matchIndexes) : 0;
+	const start = Math.max(0, firstMatch - 48);
+	const end = Math.min(normalizedContent.length, firstMatch + 152);
+	return `${start > 0 ? "…" : ""}${normalizedContent.slice(start, end)}${end < normalizedContent.length ? "…" : ""}`;
+}
+function getLocalRelevance(doc, query) {
+	const normalizedQuery = foldSearchText(query.trim());
+	const terms = normalizedQuery.split(/\s+/).filter(Boolean);
+	if (terms.length === 0) return 0;
+	const title = foldSearchText(doc.title);
+	const display = foldSearchText(doc.display);
+	const content = foldSearchText(doc.content);
+	const combined = `${title} ${display} ${content}`;
+	if (!terms.every((term) => combined.includes(term))) return -1;
+	let score = terms.length;
+	if (title === normalizedQuery) score += 120;
+	else if (title.startsWith(normalizedQuery)) score += 80;
+	else if (title.includes(normalizedQuery)) score += 60;
+	else if (display.includes(normalizedQuery)) score += 35;
+	for (const term of terms) {
+		if (title.startsWith(term)) score += 24;
+		else if (title.includes(term)) score += 16;
+		if (content.includes(term)) score += 6;
+	}
+	return score;
+}
+/** Apply a frontmatter HMR delta in one immutable update. */
+function applySearchDelta(documents, delta) {
+	const next = new Map(documents.map((document) => [document.id, document]));
+	for (const document of delta.updated ?? []) next.set(document.id, document);
+	for (const id of delta.deleted ?? []) next.delete(id);
+	return [...next.values()];
+}
+function useSearch(routes, options = {}) {
+	const { currentLocale, currentVersion } = useRoutes();
+	const config = useConfig();
+	const algoliaConfig = config.integrations?.search?.algolia;
+	const [isOpen, setIsOpen] = useState(false);
+	const [query, setQuery] = useState("");
+	const [index, setIndex] = useState(null);
+	const [algoliaResults, setAlgoliaResults] = useState([]);
+	const [searchData, setSearchData] = useState([]);
+	const [searchDataLoading, setSearchDataLoading] = useState(false);
+	const [indexLoading, setIndexLoading] = useState(false);
+	const [algoliaLoading, setAlgoliaLoading] = useState(false);
+	const [searchDataError, setSearchDataError] = useState(null);
+	const [algoliaError, setAlgoliaError] = useState(null);
+	const searchGeneration = useRef(0);
+	const loadingGeneration = useRef(null);
+	const algoliaGeneration = useRef(0);
+	const algoliaController = useRef(null);
+	const navigate = useNavigate();
+	useEffect(() => {
+		if (algoliaConfig || !isOpen || searchData.length > 0) return;
+		setSearchDataLoading(true);
+		setIndexLoading(false);
+		setSearchDataError(null);
+		const generation = ++searchGeneration.current;
+		loadingGeneration.current = generation;
+		fetchSearchData().then((data) => {
+			if (generation !== searchGeneration.current) return;
+			setSearchData(Array.isArray(data) ? data : []);
+			setSearchDataError(null);
+			setIndex(null);
+		}).catch((error) => {
+			if (generation !== searchGeneration.current) return;
+			const normalized = error instanceof Error ? error : new Error(String(error));
+			console.error("[boltdocs] Failed to load search index:", normalized);
+			setSearchDataError(normalized);
+			setIndex(null);
+		}).finally(() => {
+			if (generation !== searchGeneration.current) return;
+			loadingGeneration.current = null;
+			setSearchDataLoading(false);
+		});
+		return () => {
+			if (loadingGeneration.current === generation) {
+				searchGeneration.current += 1;
+				loadingGeneration.current = null;
+			}
+		};
+	}, [
+		isOpen,
+		algoliaConfig,
+		searchData.length
+	]);
+	useEffect(() => {
+		const hot = options.hot ?? import.meta.hot;
+		if (!hot) return;
+		const applyFrontmatterDelta = (payload) => {
+			const delta = payload;
+			searchGeneration.current += 1;
+			if (loadingGeneration.current !== null) {
+				loadingGeneration.current = null;
+				setSearchDataLoading(false);
+			}
+			setSearchData((previous) => applySearchDelta(previous, delta.search ?? {}));
+			setSearchDataError(null);
+			setIndex(null);
+		};
+		const refreshFromAsset = () => {
+			const generation = ++searchGeneration.current;
+			loadingGeneration.current = generation;
+			setSearchDataLoading(true);
+			setSearchDataError(null);
+			fetchSearchData({ bustCache: true }).then((data) => {
+				if (generation !== searchGeneration.current) return;
+				setSearchData(Array.isArray(data) ? data : []);
+				setIndex(null);
+			}).catch((error) => {
+				if (generation !== searchGeneration.current) return;
+				const normalized = error instanceof Error ? error : new Error(String(error));
+				console.error("[boltdocs] Failed to refresh search index:", normalized);
+				setSearchDataError(normalized);
+			}).finally(() => {
+				if (generation !== searchGeneration.current) return;
+				loadingGeneration.current = null;
+				setSearchDataLoading(false);
+			});
+		};
+		hot.on("boltdocs:frontmatter-update", applyFrontmatterDelta);
+		hot.on("boltdocs:mdx-update", refreshFromAsset);
+		return () => {
+			searchGeneration.current += 1;
+			hot.off?.("boltdocs:frontmatter-update", applyFrontmatterDelta);
+			hot.off?.("boltdocs:mdx-update", refreshFromAsset);
+		};
+	}, [options.hot]);
+	useEffect(() => {
+		const handleKeyDown = (event) => {
+			if (event.defaultPrevented) return;
+			if ((/Mac|iPhone|iPad|iPod/.test(navigator.userAgent) ? event.metaKey : event.ctrlKey) && (event.key === "k" || event.key === "K" || event.key === "j" || event.key === "J")) {
+				event.preventDefault();
+				setIsOpen((previous) => !previous);
+			}
+		};
+		window.addEventListener("keydown", handleKeyDown);
+		return () => window.removeEventListener("keydown", handleKeyDown);
+	}, []);
+	const handleSelect = useCallback((key) => {
+		const path = String(key);
+		if (!path) return;
+		setIsOpen(false);
+		const url = new URL(path, window.location.origin);
+		if (query.trim()) url.searchParams.set("hl", query.trim());
+		navigate(`${url.pathname}${url.search}${url.hash}`);
+	}, [navigate, query]);
+	useEffect(() => {
+		if (algoliaConfig || !isOpen || searchData.length === 0 || index) return;
+		let cancelled = false;
+		const generation = searchGeneration.current;
+		setIndexLoading(true);
+		setSearchDataError(null);
+		import("flexsearch").then(({ Index: FlexIndex }) => {
+			if (cancelled || generation !== searchGeneration.current) return;
+			const nextIndex = new FlexIndex({
+				tokenize: "forward",
+				cache: true
+			});
+			searchData.forEach((document, id) => {
+				nextIndex.add(id, `${document.title} ${document.content}`);
+			});
+			setIndex(nextIndex);
+		}).catch((error) => {
+			if (cancelled || generation !== searchGeneration.current) return;
+			const normalized = error instanceof Error ? error : new Error(String(error));
+			console.error("[boltdocs] Failed to load search engine:", normalized);
+			setSearchDataError(normalized);
+		}).finally(() => {
+			if (cancelled || generation !== searchGeneration.current) return;
+			setIndexLoading(false);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		isOpen,
+		index,
+		algoliaConfig,
+		searchData
+	]);
+	useEffect(() => {
+		const normalizedQuery = query.trim();
+		if (!algoliaConfig) return;
+		if (!normalizedQuery) {
+			algoliaGeneration.current += 1;
+			algoliaController.current?.abort();
+			algoliaController.current = null;
+			setAlgoliaResults([]);
+			setAlgoliaError(null);
+			setAlgoliaLoading(false);
+			return;
+		}
+		const generation = ++algoliaGeneration.current;
+		algoliaController.current?.abort();
+		const controller = new AbortController();
+		algoliaController.current = controller;
+		setAlgoliaError(null);
+		setAlgoliaLoading(true);
+		const timer = setTimeout(() => {
+			(async () => {
+				try {
+					const facetFilters = [];
+					if (currentLocale) facetFilters.push(`lang:${currentLocale}`);
+					if (currentVersion) facetFilters.push(`version:${currentVersion}`);
+					const url = `https://${algoliaConfig.appId}-dsn.algolia.net/1/indexes/${encodeURIComponent(algoliaConfig.indexName)}/query`;
+					const params = new URLSearchParams({
+						query: normalizedQuery,
+						hitsPerPage: "20"
+					});
+					if (facetFilters.length > 0) params.set("facetFilters", JSON.stringify(facetFilters));
+					const response = await fetch(url, {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							"X-Algolia-API-Key": algoliaConfig.apiKey,
+							"X-Algolia-Application-Id": algoliaConfig.appId
+						},
+						body: JSON.stringify({ params: params.toString() }),
+						signal: controller.signal
+					});
+					if (!response.ok) throw new Error(`Algolia search request failed: ${response.status} ${response.statusText}`.trim());
+					const data = await response.json();
+					if (generation !== algoliaGeneration.current || controller.signal.aborted) return;
+					setAlgoliaResults((Array.isArray(data.hits) ? data.hits : []).map((hit) => {
+						let path = hit.url || "";
+						try {
+							if (/^https?:\/\//.test(path)) {
+								const urlObject = new URL(path);
+								path = `${urlObject.pathname}${urlObject.search}${urlObject.hash}`;
+							}
+						} catch {}
+						const hierarchy = hit.hierarchy ?? {};
+						const levels = [
+							hierarchy.lvl0,
+							hierarchy.lvl1,
+							hierarchy.lvl2,
+							hierarchy.lvl3,
+							hierarchy.lvl4,
+							hierarchy.lvl5,
+							hierarchy.lvl6
+						].filter((value) => Boolean(value));
+						if (!path) return null;
+						const title = levels.at(-1) ?? hit.content?.slice(0, 120) ?? "Documentation";
+						const rawSnippet = hit._snippetResult?.content?.value;
+						const snippet = rawSnippet ? decodeAlgoliaSnippet(rawSnippet) : void 0;
+						return {
+							id: hit.objectID || path,
+							title,
+							path,
+							bio: levels.join(" > "),
+							groupTitle: hierarchy.lvl0 ?? "Docs",
+							isHeading: Boolean(hit.anchor) || path.includes("#"),
+							...snippet ? { snippet } : {}
+						};
+					}).filter((result) => result !== null));
+				} catch (error) {
+					if (controller.signal.aborted || generation !== algoliaGeneration.current || error instanceof DOMException && error.name === "AbortError") return;
+					const normalized = error instanceof Error ? error : new Error(String(error));
+					console.error("[boltdocs] Algolia search failed:", normalized);
+					setAlgoliaError(normalized);
+					setAlgoliaResults([]);
+				} finally {
+					if (generation === algoliaGeneration.current) {
+						setAlgoliaLoading(false);
+						if (algoliaController.current === controller) algoliaController.current = null;
+					}
+				}
+			})();
+		}, SEARCH_DEBOUNCE_MS);
+		return () => {
+			clearTimeout(timer);
+			controller.abort();
+			if (algoliaController.current === controller) algoliaController.current = null;
+			if (generation === algoliaGeneration.current) {
+				algoliaGeneration.current += 1;
+				setAlgoliaLoading(false);
+			}
+		};
+	}, [
+		query,
+		algoliaConfig,
+		currentLocale,
+		currentVersion
+	]);
+	const list = useMemo(() => {
+		if (!query.trim()) return routes.filter((route) => {
+			const routeLocale = route.locale || config.i18n?.defaultLocale;
+			const routeVersion = route.version || config.versions?.defaultVersion;
+			return (!currentLocale || routeLocale === currentLocale) && (!currentVersion || routeVersion === currentVersion);
+		}).slice(0, SEARCH_RESULT_LIMIT).map((route) => ({
+			id: route.path,
+			title: route.title,
+			path: route.path,
+			bio: route.description || "",
+			groupTitle: route.groupTitle
+		}));
+		if (algoliaConfig) return algoliaResults;
+		if (!index || indexLoading) return [];
+		const flexRank = /* @__PURE__ */ new Map();
+		try {
+			index.search(query.trim(), {
+				limit: searchData.length,
+				suggest: true
+			}).forEach((id, rank) => {
+				const numericId = typeof id === "number" ? id : Number(id);
+				if (Number.isInteger(numericId)) flexRank.set(numericId, rank);
+			});
+		} catch (error) {
+			console.error("[boltdocs] Local search failed:", error);
+		}
+		const ranked = searchData.map((document, id) => {
+			const documentLocale = document.locale || config.i18n?.defaultLocale;
+			const documentVersion = document.version || config.versions?.defaultVersion;
+			if (currentLocale && documentLocale !== currentLocale) return null;
+			if (currentVersion && documentVersion !== currentVersion) return null;
+			const relevance = getLocalRelevance(document, query);
+			if (relevance < 0) return null;
+			return {
+				document,
+				score: relevance * 1e3 - (flexRank.get(id) ?? searchData.length)
+			};
+		}).filter((result) => result !== null).sort((left, right) => right.score - left.score);
+		const results = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const { document } of ranked) {
+			if (seen.has(document.url)) continue;
+			seen.add(document.url);
+			results.push({
+				id: document.url,
+				title: document.title,
+				path: document.url,
+				bio: document.display,
+				groupTitle: document.display.split(" > ")[0],
+				isHeading: document.url.includes("#"),
+				localeMatch: true,
+				snippet: createSearchSnippet(document.content, query)
+			});
+			if (results.length === SEARCH_RESULT_LIMIT) break;
+		}
+		return results;
+	}, [
+		query,
+		index,
+		indexLoading,
+		currentLocale,
+		currentVersion,
+		routes,
+		searchData,
+		algoliaConfig,
+		algoliaResults,
+		config
+	]);
+	const error = algoliaConfig ? algoliaError : searchDataError;
+	const status = error ? "error" : algoliaConfig ? algoliaLoading ? "searching" : query.trim() ? "ready" : "idle" : searchDataLoading ? "loading" : isOpen && searchData.length > 0 && indexLoading ? "indexing" : isOpen && searchData.length > 0 && !index ? "indexing" : isOpen ? "ready" : "idle";
+	return {
+		isOpen,
+		setIsOpen,
+		query,
+		setQuery,
+		list,
+		status,
+		isLoading: status === "loading" || status === "indexing" || status === "searching",
+		isIndexing: status === "indexing",
+		error,
+		searchDataLoading,
+		searchDataError,
+		searchError: algoliaError,
+		handleSelect,
+		input: {
+			value: query,
+			onChange: (event) => setQuery(event.target.value)
+		}
+	};
+}
+
+//#endregion
+//#region src/client/components/ui-base/search-dialog.tsx
+function SearchResultHighlight({ text, query, markClassName }) {
+	if (!query.trim() || !text) return /* @__PURE__ */ jsx(Fragment$1, { children: text });
+	const regex = createSearchHighlightRegex(query.split(/\s+/));
+	if (!regex) return /* @__PURE__ */ jsx(Fragment$1, { children: text });
+	return /* @__PURE__ */ jsx(Fragment$1, { children: text.split(regex).map((part, index) => index % 2 === 1 ? /* @__PURE__ */ jsx("mark", {
+		className: cn("bg-primary-500/20 text-primary-600 dark:text-primary-400 font-bold px-0.5 rounded-sm", markClassName),
+		children: part
+	}, `${part}-${index}`) : part) });
+}
+function SearchDialog({ routes, className, markClassName }) {
+	const { isOpen, setIsOpen, query, setQuery, list, status, isLoading, error, handleSelect } = useSearch(routes);
+	const statusId = useId();
+	const statusMessage = status === "loading" ? "Loading search index…" : status === "indexing" ? "Preparing search…" : status === "searching" ? "Searching…" : status === "error" ? "Search is temporarily unavailable." : query.trim() ? `${list.length} result${list.length === 1 ? "" : "s"} found.` : `${list.length} suggested page${list.length === 1 ? "" : "s"}.`;
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsxs(Navbar.SearchTrigger.Desktop, {
+			"aria-label": "Search docs",
+			"aria-keyshortcuts": "Control+K Meta+K",
+			onPress: () => setIsOpen(true),
+			className: "rounded-xl border border-subtle bg-surface text-muted transition-all duration-200 hover:border-primary-500/50 hover:text-body hover:bg-soft/50 hover:shadow-sm active:scale-[0.98] focus-visible:ring-2 focus-visible:ring-primary-500/30",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx(Search, { size: 16 }), /* @__PURE__ */ jsx("span", {
+					className: "text-paragraph hidden sm:inline-block",
+					children: "Search docs..."
+				})]
+			}), /* @__PURE__ */ jsx(Navbar.SearchTrigger.Kbd, { className: "[&_kbd]:bg-main [&_kbd]:border [&_kbd]:border-subtle [&_kbd]:rounded [&_kbd]:px-1.5 [&_kbd]:h-5 [&_kbd]:w-5" })]
+		}),
+		/* @__PURE__ */ jsx(Navbar.SearchTrigger.Mobile, {
+			"aria-label": "Search docs",
+			onPress: () => setIsOpen(true),
+			className: "rounded-xl text-muted transition-all duration-200 hover:text-body active:scale-95 focus-visible:ring-2 focus-visible:ring-primary-500/30",
+			children: /* @__PURE__ */ jsx(Search, { size: 20 })
+		}),
+		/* @__PURE__ */ jsx(InternalErrorBoundary, { children: /* @__PURE__ */ jsx(SearchDialog$1.Overlay, {
+			isOpen,
+			isDismissable: true,
+			onOpenChange: setIsOpen,
+			className: cn("fixed inset-0 z-100 flex items-center justify-center p-4 bg-black/40 backdrop-blur-xs animate-fade-in", className),
+			children: /* @__PURE__ */ jsx(SearchDialog$1.Content, {
+				className: "w-full max-w-lg bg-main border border-subtle shadow-md rounded-2xl overflow-hidden p-6",
+				children: /* @__PURE__ */ jsx(SearchDialog$1.Dialog, {
+					"aria-label": "Search documentation",
+					"aria-describedby": statusId,
+					"aria-busy": isLoading,
+					className: "flex flex-col min-h-0 h-[450px]",
+					children: /* @__PURE__ */ jsxs(SearchDialog$1.Autocomplete, {
+						className: "flex flex-col min-h-0",
+						children: [
+							/* @__PURE__ */ jsxs(SearchDialog$1.Input, {
+								value: query,
+								onChange: setQuery,
+								className: "flex items-center gap-2 border border-subtle bg-surface px-4 py-2.5 rounded-xl focus-within:border-primary-500 mb-4",
+								children: [/* @__PURE__ */ jsx(SearchDialog$1.Input.SearchInput, {
+									"aria-label": "Search documentation",
+									placeholder: "Search documentation...",
+									className: "w-full bg-transparent outline-none text-body text-sm"
+								}), query && /* @__PURE__ */ jsx(SearchDialog$1.Input.Button, {
+									slot: "clear",
+									"aria-label": "Clear search",
+									onPress: () => setQuery(""),
+									className: "text-muted hover:text-body hover:bg-surface rounded-md p-1 cursor-pointer select-none transition-colors",
+									children: /* @__PURE__ */ jsx(X, { size: 16 })
+								})]
+							}),
+							/* @__PURE__ */ jsx("div", {
+								id: statusId,
+								role: status === "error" ? "alert" : "status",
+								"aria-live": status === "error" ? "assertive" : "polite",
+								className: "sr-only",
+								children: statusMessage
+							}),
+							isLoading ? /* @__PURE__ */ jsx("div", {
+								className: "flex flex-1 items-center justify-center px-4 py-8 text-sm text-muted",
+								"aria-hidden": "true",
+								children: status === "loading" ? "Loading search index…" : status === "indexing" ? "Preparing search…" : "Searching…"
+							}) : error ? /* @__PURE__ */ jsx("div", {
+								className: "flex flex-1 items-center justify-center px-4 py-8 text-center text-sm text-muted",
+								children: "Search is temporarily unavailable."
+							}) : query.trim() && list.length === 0 ? /* @__PURE__ */ jsx("div", {
+								className: "flex flex-1 items-center justify-center px-4 py-8 text-sm text-muted",
+								children: "No results found."
+							}) : /* @__PURE__ */ jsx(SearchDialog$1.List, {
+								items: list,
+								onAction: handleSelect,
+								children: (item) => /* @__PURE__ */ jsxs(SearchDialog$1.Item, {
+									textValue: item.title,
+									className: "flex items-center gap-3 px-4 py-2 rounded-xl group dark:hover:bg-primary-300/40 hover:bg-primary-200/50 transition-colors duration-100",
+									children: [/* @__PURE__ */ jsx(SearchDialog$1.Item.Icon, {
+										isHeading: item.isHeading,
+										className: "text-muted group-hover:text-primary-500 group-focus:text-primary-500"
+									}), /* @__PURE__ */ jsxs("div", {
+										className: "flex flex-col justify-center min-w-0",
+										children: [/* @__PURE__ */ jsx(SearchDialog$1.Item.Title, {
+											className: "text-sm font-medium text-body truncate dark:group-hover:text-primary-100",
+											children: /* @__PURE__ */ jsx(SearchResultHighlight, {
+												text: item.title,
+												query,
+												markClassName
+											})
+										}), /* @__PURE__ */ jsx(SearchDialog$1.Item.Bio, {
+											className: "text-xs text-muted truncate",
+											children: /* @__PURE__ */ jsx(SearchResultHighlight, {
+												text: item.snippet ?? item.bio,
+												query,
+												markClassName
+											})
+										})]
+									})]
+								}, item.id)
+							})
+						]
+					})
+				})
+			})
+		}) })
+	] });
+}
+
+//#endregion
+export { useRoutes as a, InternalErrorBoundary as i, SearchResultHighlight as n, useSearch as r, SearchDialog as t };