@vezham/docs-core 1.0.1

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-kQ39Ub0-.js";
+export { AlgoliaOptions, algoliaClient };

package/dist/search/client/algolia.js

@@ -0,0 +1,53 @@
+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);
+			const results = groupResults(result.results[0].hits);
+			for (const item of results) item.content = highlighter.highlightMarkdown(item.content);
+			return results;
+		}
+	};
+}
+//#endregion
+export { algoliaClient };

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

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

package/dist/search/client/fetch.js

@@ -0,0 +1,28 @@
+import { n as join, t as BASE_PATH } from "../../url-BVHvi3_K.js";
+//#region src/search/client/fetch.ts
+const globalCache = /* @__PURE__ */ new Map();
+function fetchClient({ api = join(BASE_PATH, "/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-kQ39Ub0-.js";
+export { FlexsearchStaticOptions, flexsearchStaticClient };

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

@@ -0,0 +1,42 @@
+import { n as join, t as BASE_PATH } from "../../url-BVHvi3_K.js";
+import { n as search, t as createDocument } from "../../utils-Bvy3V-fv.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 = join(BASE_PATH, "/api/search"), locale = "", tag } = options;
+	let dbs = cacheMap.get(from);
+	if (!dbs && typeof window !== "undefined") {
+		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-kQ39Ub0-.js";
+export { MixedbreadOptions, SearchMetadata, mixedbreadClient };

package/dist/search/client/mixedbread.js

@@ -0,0 +1,65 @@
+import { r as __toESM } from "../../rolldown-runtime-DC62tzP2.js";
+import { t as require_remove_markdown } from "../../remove-markdown-DfKNMl9w.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 `@vezham/docs-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 `client: fetchClient(...)` 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-kQ39Ub0-.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-CzMSKybq.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-kQ39Ub0-.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-CzMSKybq.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 { _ as staticClient, g as oramaStaticClient, h as StaticOptions } from "../../client-kQ39Ub0-.js";
+export { StaticOptions, oramaStaticClient, staticClient };

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

@@ -0,0 +1,75 @@
+import { n as join, t as BASE_PATH } from "../../url-BVHvi3_K.js";
+import { n as searchSimple, t as searchAdvanced } from "../../advanced-Ct13khZr.js";
+import { create, load } from "zbsearch";
+//#region src/search/client/orama-static.ts
+const cache = /* @__PURE__ */ new Map();
+async function loadDB(from, initDB = () => create({ schema: { _: "string" } })) {
+	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 map = /* @__PURE__ */ new Map();
+	if (data.type === "i18n") {
+		await Promise.all(Object.entries(data.data).map(async ([k, v]) => {
+			const db = await initDB(k);
+			load(db, v);
+			map.set(k, {
+				type: v.type,
+				db
+			});
+		}));
+		return {
+			map,
+			unified: false,
+			i18n: true
+		};
+	}
+	const db = await initDB();
+	load(db, data);
+	map.set("", {
+		type: data.type,
+		db
+	});
+	return {
+		map,
+		unified: true,
+		i18n: data.i18n === true
+	};
+}
+function getDBCached({ from = join(BASE_PATH, "/api/search"), initDB, initOrama }) {
+	const cacheKey = from;
+	const cached = cache.get(cacheKey);
+	if (cached) return cached;
+	const result = loadDB(from, initDB ?? initOrama);
+	cache.set(cacheKey, result);
+	return result;
+}
+function staticClient(options = {}) {
+	const { tag, locale, search } = options;
+	return {
+		deps: [tag, locale],
+		async search(query) {
+			const { map, unified, i18n } = await getDBCached(options);
+			let db;
+			let filterLocale;
+			if (unified) {
+				db = map.get("");
+				if (i18n) filterLocale = locale;
+			} else {
+				db = map.get(locale ?? "");
+				if (!db) {
+					console.warn(`failed to find search data for "${locale}", available: ${Array.from(map.keys())}.`);
+					db = map.values().next().value;
+				}
+			}
+			if (!db) return [];
+			if (db.type === "simple") return searchSimple(db.db, query, search, filterLocale);
+			return searchAdvanced(db.db, query, tag, search, filterLocale);
+		}
+	};
+}
+/**
+* @deprecated Renamed to `staticClient`, note that the search engine is now ZBSearch.
+*/
+const oramaStaticClient = staticClient;
+//#endregion
+export { oramaStaticClient, staticClient };

package/dist/search/client.d.ts

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

package/dist/search/client.js

@@ -0,0 +1,97 @@
+import { t as isEqualShallow } from "../is-equal-LdLqRs0o.js";
+import { useEffect, useMemo, 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
+/**
+* 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, customDeps) {
+	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);
+	let client;
+	if ("type" in clientRest) switch (clientRest.type) {
+		case "fetch":
+			client = import("./client/fetch.js").then((mod) => mod.fetchClient(clientRest));
+			break;
+		case "algolia":
+			client = import("./client/algolia.js").then((mod) => mod.algoliaClient(clientRest));
+			break;
+		case "orama-cloud":
+			client = import("./client/orama-cloud.js").then((mod) => mod.oramaCloudClient(clientRest));
+			break;
+		case "orama-cloud-legacy":
+			client = import("./client/orama-cloud-legacy.js").then((mod) => mod.oramaCloudLegacyClient(clientRest));
+			break;
+		case "mixedbread":
+			client = import("./client/mixedbread.js").then((mod) => mod.mixedbreadClient(clientRest));
+			break;
+		case "static":
+			client = import("./client/orama-static.js").then((mod) => mod.staticClient(clientRest));
+			break;
+		default: throw new Error("unknown search client");
+	}
+	else client = clientRest.client;
+	const deps = [customDeps ?? (client instanceof Promise ? JSON.stringify(clientRest) : client.deps), debouncedValue];
+	const [activeDeps, setActiveDeps] = useState(null);
+	const activeTaskRef = useRef(null);
+	if (!isEqualShallow(activeDeps, deps) && (!activeTaskRef.current || !isEqualShallow(activeTaskRef.current.deps, deps))) {
+		if (activeTaskRef.current) activeTaskRef.current.interrupt = true;
+		activeTaskRef.current = {
+			deps,
+			interrupt: false,
+			async start() {
+				try {
+					setIsLoading(true);
+					let res;
+					if (debouncedValue.length === 0 && !allowEmpty) res = "empty";
+					else res = await (await client).search(debouncedValue);
+					if (!this.interrupt) {
+						setActiveDeps(deps);
+						setError(void 0);
+						setResults(res);
+					}
+				} catch (err) {
+					if (!this.interrupt) setError(err);
+				} finally {
+					if (!this.interrupt) setIsLoading(false);
+				}
+			}
+		};
+		activeTaskRef.current.start();
+	}
+	return useMemo(() => ({
+		search,
+		setSearch,
+		query: {
+			isLoading,
+			data: results,
+			error
+		}
+	}), [
+		search,
+		isLoading,
+		results,
+		error
+	]);
+}
+//#endregion
+export { useDocsSearch };