@depup/fumadocs-core 16.6.17-depup.0

package/dist/search/algolia.js

@@ -0,0 +1,75 @@
+//#region src/search/algolia.ts
+/**
+* Update index settings and replace all objects
+*
+* @param client - Algolia Admin Client
+* @param options - Index Options
+*/
+async function sync(client, options) {
+	const { indexName = "document", documents } = options;
+	await setIndexSettings(client, indexName);
+	await updateDocuments(client, indexName, documents);
+}
+async function setIndexSettings(client, indexName) {
+	await client.setSettings({
+		indexName,
+		indexSettings: {
+			attributeForDistinct: "page_id",
+			attributesToRetrieve: [
+				"title",
+				"section",
+				"content",
+				"url",
+				"section_id",
+				"breadcrumbs"
+			],
+			searchableAttributes: [
+				"title",
+				"section",
+				"content"
+			],
+			attributesToSnippet: [],
+			attributesForFaceting: ["tag"]
+		}
+	});
+}
+function toIndex(page) {
+	let id = 0;
+	const indexes = [];
+	const scannedHeadings = /* @__PURE__ */ new Set();
+	function createIndex(section, sectionId, content) {
+		return {
+			objectID: `${page._id}-${(id++).toString()}`,
+			breadcrumbs: page.breadcrumbs,
+			title: page.title,
+			url: page.url,
+			page_id: page._id,
+			tag: page.tag,
+			section,
+			section_id: sectionId,
+			content,
+			...page.extra_data
+		};
+	}
+	if (page.description) indexes.push(createIndex(void 0, void 0, page.description));
+	const { headings, contents } = page.structured;
+	for (const p of contents) {
+		const heading = p.heading ? headings.find((h) => p.heading === h.id) : null;
+		const index = createIndex(heading?.content, heading?.id, p.content);
+		if (heading && !scannedHeadings.has(heading.id)) {
+			scannedHeadings.add(heading.id);
+			indexes.push(createIndex(heading.content, heading.id, heading.content));
+		}
+		indexes.push(index);
+	}
+	return indexes;
+}
+async function updateDocuments(client, indexName, documents) {
+	const objects = documents.flatMap(toIndex);
+	await client.replaceAllObjects({
+		indexName,
+		objects
+	});
+}
+//#endregion
+export { setIndexSettings, sync, updateDocuments };

package/dist/search/client/algolia.d.ts

@@ -0,0 +1,2 @@
+import { m as algoliaClient, p as AlgoliaOptions } from "../../client-9fKBmECY.js";
+export { AlgoliaOptions, algoliaClient };

package/dist/search/client/algolia.js

@@ -0,0 +1,57 @@
+import { createContentHighlighter } from "../index.js";
+//#region src/search/client/algolia.ts
+function groupResults(hits) {
+	const grouped = [];
+	const scannedUrls = /* @__PURE__ */ new Set();
+	for (const hit of hits) {
+		if (!scannedUrls.has(hit.url)) {
+			scannedUrls.add(hit.url);
+			grouped.push({
+				id: hit.url,
+				type: "page",
+				breadcrumbs: hit.breadcrumbs,
+				url: hit.url,
+				content: hit.title
+			});
+		}
+		grouped.push({
+			id: hit.objectID,
+			type: hit.content === hit.section ? "heading" : "text",
+			url: hit.section_id ? `${hit.url}#${hit.section_id}` : hit.url,
+			content: hit.content
+		});
+	}
+	return grouped;
+}
+function algoliaClient(options) {
+	const { indexName, onSearch, client, locale, tag } = options;
+	return {
+		deps: [
+			indexName,
+			client,
+			locale,
+			tag
+		],
+		async search(query) {
+			if (query.trim().length === 0) return [];
+			const result = onSearch ? await onSearch(query, tag, locale) : await client.searchForHits({ requests: [{
+				type: "default",
+				indexName,
+				query,
+				distinct: 5,
+				hitsPerPage: 10,
+				filters: tag ? `tag:${tag}` : void 0
+			}] });
+			const highlighter = createContentHighlighter(query);
+			return groupResults(result.results[0].hits).flatMap((hit) => {
+				if (hit.type === "page") return {
+					...hit,
+					content: highlighter.highlightMarkdown(hit.content)
+				};
+				return [];
+			});
+		}
+	};
+}
+//#endregion
+export { algoliaClient };

package/dist/search/client/fetch.d.ts

@@ -0,0 +1,2 @@
+import { _ as FetchOptions, v as fetchClient } from "../../client-9fKBmECY.js";
+export { FetchOptions, fetchClient };

package/dist/search/client/fetch.js

@@ -0,0 +1,27 @@
+//#region src/search/client/fetch.ts
+const globalCache = /* @__PURE__ */ new Map();
+function fetchClient({ api = "/api/search", locale, tag, cache = globalCache } = {}) {
+	return {
+		deps: [
+			api,
+			locale,
+			tag
+		],
+		async search(query) {
+			const url = new URL(api, window.location.origin);
+			url.searchParams.set("query", query);
+			if (locale) url.searchParams.set("locale", locale);
+			if (tag) url.searchParams.set("tag", Array.isArray(tag) ? tag.join(",") : tag);
+			const key = url.toString();
+			const cached = cache.get(key);
+			if (cached) return cached;
+			const res = await fetch(url);
+			if (!res.ok) throw new Error(await res.text());
+			const result = await res.json();
+			cache.set(key, result);
+			return result;
+		}
+	};
+}
+//#endregion
+export { fetchClient };

package/dist/search/client/flexsearch-static.d.ts

@@ -0,0 +1,2 @@
+import { a as flexsearchStaticClient, i as FlexsearchStaticOptions } from "../../client-9fKBmECY.js";
+export { FlexsearchStaticOptions, flexsearchStaticClient };

package/dist/search/client/flexsearch-static.js

@@ -0,0 +1,41 @@
+import { n as search, t as createDocument } from "../../utils-ktUGajEb.js";
+//#region src/search/client/flexsearch-static.ts
+function initDocument(data) {
+	const document = createDocument();
+	for (const [k, v] of Object.entries(data)) document.import(k, v);
+	return document;
+}
+const cacheMap = /* @__PURE__ */ new Map();
+function flexsearchStaticClient(options = {}) {
+	const { from = "/api/search", locale = "", tag } = options;
+	let dbs = cacheMap.get(from);
+	if (!dbs) {
+		dbs = init(from);
+		cacheMap.set(from, dbs);
+	}
+	return {
+		deps: [
+			from,
+			locale,
+			tag
+		],
+		async search(query) {
+			const db = (await dbs).get(locale);
+			if (!db) return [];
+			return search(db, query, tag);
+		}
+	};
+}
+async function init(from) {
+	const res = await fetch(from);
+	if (!res.ok) throw new Error(`failed to fetch exported search indexes from ${from}, make sure the search database is exported and available for client.`);
+	const data = await res.json();
+	const dbs = /* @__PURE__ */ new Map();
+	if (data.type === "i18n") {
+		for (const [locale, map] of Object.entries(data.raw)) dbs.set(locale, initDocument(map));
+		return dbs;
+	} else dbs.set("", initDocument(data.raw));
+	return dbs;
+}
+//#endregion
+export { flexsearchStaticClient };

package/dist/search/client/mixedbread.d.ts

@@ -0,0 +1,2 @@
+import { c as mixedbreadClient, o as MixedbreadOptions, s as SearchMetadata } from "../../client-9fKBmECY.js";
+export { MixedbreadOptions, SearchMetadata, mixedbreadClient };

package/dist/search/client/mixedbread.js

@@ -0,0 +1,65 @@
+import { r as __toESM } from "../../chunk-BoAXSpZd.js";
+import { t as require_remove_markdown } from "../../remove-markdown-C5S415Dz.js";
+import Slugger from "github-slugger";
+//#region src/search/client/mixedbread.ts
+var import_remove_markdown = /* @__PURE__ */ __toESM(require_remove_markdown(), 1);
+const slugger = new Slugger();
+function extractHeadingTitle(text) {
+	const trimmedText = text.trim();
+	if (!trimmedText.startsWith("#")) return "";
+	const firstLine = trimmedText.split("\n")[0]?.trim();
+	if (firstLine) return (0, import_remove_markdown.default)(firstLine, { useImgAltText: false });
+	return "";
+}
+/**
+* @deprecated Use `createMixedbreadSearchAPI` from `fumadocs-core/search/mixedbread` instead.
+* This client-side approach exposes your API key in the browser.
+* The server-side approach keeps the key secure and uses `type: 'fetch'` on the client.
+*/
+function mixedbreadClient(options) {
+	const { client, storeIdentifier, tag } = options;
+	return {
+		deps: [
+			client,
+			storeIdentifier,
+			tag
+		],
+		async search(query) {
+			if (!query.trim()) return [];
+			return (await client.stores.search({
+				query,
+				store_identifiers: [storeIdentifier],
+				top_k: 10,
+				filters: {
+					key: "generated_metadata.tag",
+					operator: "eq",
+					value: tag
+				},
+				search_options: { return_metadata: true }
+			})).data.flatMap((item) => {
+				const metadata = item.generated_metadata;
+				const url = metadata.url || "#";
+				const title = metadata.title || "Untitled";
+				const chunkResults = [{
+					id: `${item.file_id}-${item.chunk_index}-page`,
+					type: "page",
+					content: title,
+					url
+				}];
+				const headingTitle = item.type === "text" && item.text ? extractHeadingTitle(item.text) : "";
+				if (headingTitle) {
+					slugger.reset();
+					chunkResults.push({
+						id: `${item.file_id}-${item.chunk_index}-heading`,
+						type: "heading",
+						content: headingTitle,
+						url: `${url}#${slugger.slug(headingTitle)}`
+					});
+				}
+				return chunkResults;
+			});
+		}
+	};
+}
+//#endregion
+export { mixedbreadClient };

package/dist/search/client/orama-cloud-legacy.d.ts

@@ -0,0 +1,2 @@
+import { l as OramaCloudLegacyOptions, u as oramaCloudLegacyClient } from "../../client-9fKBmECY.js";
+export { OramaCloudLegacyOptions, oramaCloudLegacyClient };

package/dist/search/client/orama-cloud-legacy.js

@@ -0,0 +1,84 @@
+import { createContentHighlighter } from "../index.js";
+import { t as removeUndefined } from "../../remove-undefined-Bfj4SlGF.js";
+//#region src/search/client/orama-cloud-legacy.ts
+function oramaCloudLegacyClient(options) {
+	const { index = "default", client, params: extraParams = {}, tag } = options;
+	return {
+		deps: [
+			index,
+			client,
+			tag
+		],
+		async search(query) {
+			const highlighter = createContentHighlighter(query);
+			const list = [];
+			if (index === "crawler") {
+				const result = await client.search({
+					...extraParams,
+					term: query,
+					where: {
+						category: tag ? { eq: tag.slice(0, 1).toUpperCase() + tag.slice(1) } : void 0,
+						...extraParams.where
+					},
+					limit: 10
+				});
+				if (!result) return list;
+				for (const hit of result.hits) {
+					const doc = hit.document;
+					list.push({
+						id: hit.id,
+						type: "page",
+						content: highlighter.highlightMarkdown(doc.title),
+						url: doc.path
+					}, {
+						id: "page" + hit.id,
+						type: "text",
+						content: highlighter.highlightMarkdown(doc.content),
+						url: doc.path
+					});
+				}
+				return list;
+			}
+			const params = {
+				...extraParams,
+				term: query,
+				where: removeUndefined({
+					tag,
+					...extraParams.where
+				}),
+				groupBy: {
+					properties: ["page_id"],
+					maxResult: 7,
+					...extraParams.groupBy
+				}
+			};
+			const result = await client.search(params);
+			if (!result || !result.groups) return list;
+			for (const item of result.groups) {
+				let addedHead = false;
+				for (const hit of item.result) {
+					const doc = hit.document;
+					if (!addedHead) {
+						list.push({
+							id: doc.page_id,
+							type: "page",
+							content: highlighter.highlightMarkdown(doc.title),
+							breadcrumbs: doc.breadcrumbs,
+							url: doc.url
+						});
+						addedHead = true;
+					}
+					list.push({
+						id: doc.id,
+						content: highlighter.highlightMarkdown(doc.content),
+						type: doc.content === doc.section ? "heading" : "text",
+						url: doc.section_id ? `${doc.url}#${doc.section_id}` : doc.url
+					});
+				}
+			}
+			return list;
+		}
+	};
+}
+//#endregion
+export { oramaCloudLegacyClient };

package/dist/search/client/orama-cloud.d.ts

@@ -0,0 +1,2 @@
+import { d as OramaCloudOptions, f as oramaCloudClient } from "../../client-9fKBmECY.js";
+export { OramaCloudOptions, oramaCloudClient };

package/dist/search/client/orama-cloud.js

@@ -0,0 +1,86 @@
+import { createContentHighlighter } from "../index.js";
+import { t as removeUndefined } from "../../remove-undefined-Bfj4SlGF.js";
+//#region src/search/client/orama-cloud.ts
+function oramaCloudClient(options) {
+	const { index = "default", client, params: extraParams, tag } = options;
+	return {
+		deps: [
+			index,
+			client,
+			tag
+		],
+		async search(query) {
+			const highlighter = createContentHighlighter(query);
+			const list = [];
+			if (index === "crawler") {
+				const result = await client.search({
+					datasources: [],
+					...extraParams,
+					term: query,
+					where: {
+						category: tag ? { eq: tag.slice(0, 1).toUpperCase() + tag.slice(1) } : void 0,
+						...extraParams?.where
+					},
+					limit: 10
+				});
+				if (!result) return list;
+				for (const hit of result.hits) {
+					const doc = hit.document;
+					list.push({
+						id: hit.id,
+						type: "page",
+						content: highlighter.highlightMarkdown(doc.title),
+						url: doc.path
+					}, {
+						id: "page" + hit.id,
+						type: "text",
+						content: highlighter.highlightMarkdown(doc.content),
+						url: doc.path
+					});
+				}
+				return list;
+			}
+			const result = await client.search({
+				datasources: [],
+				...extraParams,
+				term: query,
+				limit: 20,
+				where: removeUndefined({
+					tag,
+					...extraParams?.where
+				}),
+				groupBy: {
+					properties: ["page_id"],
+					max_results: 7,
+					...extraParams?.groupBy
+				}
+			});
+			if (!result || !result.groups) return list;
+			for (const item of result.groups) {
+				let addedHead = false;
+				for (const hit of item.result) {
+					const doc = hit.document;
+					if (!addedHead) {
+						list.push({
+							id: doc.page_id,
+							type: "page",
+							content: highlighter.highlightMarkdown(doc.title),
+							breadcrumbs: doc.breadcrumbs,
+							url: doc.url
+						});
+						addedHead = true;
+					}
+					list.push({
+						id: doc.id,
+						content: highlighter.highlightMarkdown(doc.content),
+						type: doc.content === doc.section ? "heading" : "text",
+						url: doc.section_id ? `${doc.url}#${doc.section_id}` : doc.url
+					});
+				}
+			}
+			return list.length > 80 ? list.slice(0, 80) : list;
+		}
+	};
+}
+//#endregion
+export { oramaCloudClient };

package/dist/search/client/orama-static.d.ts

@@ -0,0 +1,2 @@
+import { g as oramaStaticClient, h as StaticOptions } from "../../client-9fKBmECY.js";
+export { StaticOptions, oramaStaticClient };

package/dist/search/client/orama-static.js

@@ -0,0 +1,53 @@
+import { n as searchSimple, t as searchAdvanced } from "../../advanced-BZKQwtss.js";
+import { create, load } from "@orama/orama";
+//#region src/search/client/orama-static.ts
+const cache = /* @__PURE__ */ new Map();
+async function loadDB({ from = "/api/search", initOrama = (locale) => create({
+	schema: { _: "string" },
+	language: locale
+}) } = {}) {
+	const cacheKey = from;
+	const cached = cache.get(cacheKey);
+	if (cached) return cached;
+	async function init() {
+		const res = await fetch(from);
+		if (!res.ok) throw new Error(`failed to fetch exported search indexes from ${from}, make sure the search database is exported and available for client.`);
+		const data = await res.json();
+		const dbs = /* @__PURE__ */ new Map();
+		if (data.type === "i18n") {
+			await Promise.all(Object.entries(data.data).map(async ([k, v]) => {
+				const db = await initOrama(k);
+				load(db, v);
+				dbs.set(k, {
+					type: v.type,
+					db
+				});
+			}));
+			return dbs;
+		}
+		const db = await initOrama();
+		load(db, data);
+		dbs.set("", {
+			type: data.type,
+			db
+		});
+		return dbs;
+	}
+	const result = init();
+	cache.set(cacheKey, result);
+	return result;
+}
+function oramaStaticClient(options) {
+	const { tag, locale } = options;
+	return {
+		deps: [tag, locale],
+		async search(query) {
+			const db = (await loadDB(options)).get(locale ?? "");
+			if (!db) return [];
+			if (db.type === "simple") return searchSimple(db, query);
+			return searchAdvanced(db.db, query, tag);
+		}
+	};
+}
+//#endregion
+export { oramaStaticClient };

package/dist/search/client.d.ts

@@ -0,0 +1,2 @@
+import { _ as FetchOptions, d as OramaCloudOptions, h as StaticOptions, n as SearchClient, p as AlgoliaOptions, r as useDocsSearch, t as ClientPreset } from "../client-9fKBmECY.js";
+export { AlgoliaOptions, ClientPreset, FetchOptions, OramaCloudOptions, SearchClient, StaticOptions, useDocsSearch };

package/dist/search/client.js

@@ -0,0 +1,102 @@
+import { useOnChange } from "../utils/use-on-change.js";
+import { use, useEffect, useRef, useState } from "react";
+//#region src/utils/use-debounce.ts
+function useDebounce(value, delayMs = 1e3) {
+	const [debouncedValue, setDebouncedValue] = useState(value);
+	useEffect(() => {
+		if (delayMs === 0) return;
+		const handler = window.setTimeout(() => {
+			setDebouncedValue(value);
+		}, delayMs);
+		return () => clearTimeout(handler);
+	}, [delayMs, value]);
+	if (delayMs === 0) return value;
+	return debouncedValue;
+}
+//#endregion
+//#region src/search/client.ts
+const promiseMap = {};
+/**
+* Provide a hook to query different official search clients.
+*
+* Note: it will re-query when its parameters changed, make sure to define `deps` array if you encounter rendering issues.
+*/
+function useDocsSearch(clientOptions, deps) {
+	const { delayMs = 100, allowEmpty = false, ...clientRest } = clientOptions;
+	const [search, setSearch] = useState("");
+	const [results, setResults] = useState("empty");
+	const [error, setError] = useState();
+	const [isLoading, setIsLoading] = useState(false);
+	const debouncedValue = useDebounce(search, delayMs);
+	const onStart = useRef(void 0);
+	let client;
+	if ("type" in clientRest) switch (clientRest.type) {
+		case "fetch": {
+			const { fetchClient } = use(promiseMap[clientRest.type] ??= import("./client/fetch.js"));
+			client = fetchClient(clientRest);
+			break;
+		}
+		case "algolia": {
+			const { algoliaClient } = use(promiseMap[clientRest.type] ??= import("./client/algolia.js"));
+			client = algoliaClient(clientRest);
+			break;
+		}
+		case "orama-cloud": {
+			const { oramaCloudClient } = use(promiseMap[clientRest.type] ??= import("./client/orama-cloud.js"));
+			client = oramaCloudClient(clientRest);
+			break;
+		}
+		case "orama-cloud-legacy": {
+			const { oramaCloudLegacyClient } = use(promiseMap[clientRest.type] ??= import("./client/orama-cloud-legacy.js"));
+			client = oramaCloudLegacyClient(clientRest);
+			break;
+		}
+		case "mixedbread": {
+			const { mixedbreadClient } = use(promiseMap[clientRest.type] ??= import("./client/mixedbread.js"));
+			client = mixedbreadClient(clientRest);
+			break;
+		}
+		case "static": {
+			const { oramaStaticClient } = use(promiseMap[clientRest.type] ??= import("./client/orama-static.js"));
+			client = oramaStaticClient(clientRest);
+			break;
+		}
+		default: throw new Error("unknown search client");
+	}
+	else client = clientRest.client;
+	useOnChange([deps ?? client.deps, debouncedValue], () => {
+		if (onStart.current) {
+			onStart.current();
+			onStart.current = void 0;
+		}
+		setIsLoading(true);
+		let interrupt = false;
+		onStart.current = () => {
+			interrupt = true;
+		};
+		async function run() {
+			if (debouncedValue.length === 0 && !allowEmpty) return "empty";
+			return client.search(debouncedValue);
+		}
+		run().then((res) => {
+			if (interrupt) return;
+			setError(void 0);
+			setResults(res);
+		}).catch((err) => {
+			setError(err);
+		}).finally(() => {
+			setIsLoading(false);
+		});
+	});
+	return {
+		search,
+		setSearch,
+		query: {
+			isLoading,
+			data: results,
+			error
+		}
+	};
+}
+//#endregion
+export { useDocsSearch };

package/dist/search/flexsearch.d.ts

@@ -0,0 +1,52 @@
+import { t as Awaitable } from "../types-3ccArm6T.js";
+import { t as I18nConfig } from "../index-CsYVANvj.js";
+import { m as SharedIndex, n as SearchAPI, t as QueryOptions } from "../server-BVKBFI75.js";
+import { i as LoaderConfig, o as LoaderOutput, u as Page } from "../index-C5QIKZDy.js";
+import { DocumentData, DocumentOptions } from "flexsearch";
+
+//#region src/search/server/build-doc.d.ts
+interface SharedDocument {
+  id: string;
+  content: string;
+  page_id: string;
+  type: 'page' | 'heading' | 'text';
+  breadcrumbs?: string[];
+  tags: string[];
+  url: string;
+}
+//#endregion
+//#region src/search/flexsearch/utils.d.ts
+type Doc = SharedDocument & DocumentData;
+//#endregion
+//#region src/search/flexsearch.d.ts
+type Index = SharedIndex;
+interface IndexWithLocale extends Index {
+  locale: string;
+}
+interface Options {
+  indexes: Index[] | (() => Awaitable<Index[]>);
+  document?: DocumentOptions<Doc>;
+}
+type ExportedData = {
+  type: 'default';
+  raw: Record<string, string>;
+} | {
+  type: 'i18n';
+  raw: Record<string, Record<string, string>>;
+};
+interface I18nOptions extends Omit<Options, 'indexes'> {
+  i18n: I18nConfig;
+  indexes: IndexWithLocale[] | (() => Awaitable<IndexWithLocale[]>);
+  /**
+   * options for each locale, see https://github.com/nextapps-de/flexsearch/blob/master/doc/encoder.md.
+   */
+  localeMap?: Record<string, Partial<DocumentOptions<Doc>> | 'cjk'>;
+}
+declare function flexsearch(options: Options): SearchAPI;
+declare function flexsearchI18n(options: I18nOptions): SearchAPI;
+interface FromSourceOptions<C extends LoaderConfig> extends Pick<I18nOptions, 'localeMap' | 'document'> {
+  buildIndex?: (page: Page<C['source']['pageData']>) => Awaitable<Index>;
+}
+declare function flexsearchFromSource<C extends LoaderConfig>(loader: LoaderOutput<C>, options?: FromSourceOptions<NoInfer<C>>): SearchAPI<QueryOptions>;
+//#endregion
+export { ExportedData, FromSourceOptions, I18nOptions, Index, IndexWithLocale, Options, flexsearch, flexsearchFromSource, flexsearchI18n };