@vezham/docs-core 1.0.1

package/dist/search/flexsearch.d.ts

@@ -0,0 +1,56 @@
+import { t as Awaitable } from "../types-D89QoQR-.js";
+import { n as I18nConfig } from "../index-DydiXvgS.js";
+import "../index-BM36H-xw.js";
+import { m as SharedIndex, n as SearchAPI, t as QueryOptions } from "../server-CCqACwlF.js";
+import { b as LoaderOutput, v as LoaderConfig } from "../index-DIwKCYOz.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;
+  locale?: 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: C['page']) => Awaitable<Index>;
+}
+/**
+ * create server from loader, if passed as function, the server will re-index all records once a different instance of loader is returned.
+ */
+declare function flexsearchFromSource<C extends LoaderConfig>(loader: LoaderOutput<C> | (() => Awaitable<LoaderOutput<C>>), options?: FromSourceOptions<NoInfer<C>>): SearchAPI<QueryOptions>;
+//#endregion
+export { ExportedData, FromSourceOptions, I18nOptions, Index, IndexWithLocale, Options, flexsearch, flexsearchFromSource, flexsearchI18n };

package/dist/search/flexsearch.js

@@ -0,0 +1,128 @@
+import { t as createEndpoint } from "../endpoint-MyoBU5IC.js";
+import { n as buildBreadcrumbs, r as buildIndexDefault, t as buildDocuments } from "../build-doc-4OvfjVN2.js";
+import { n as search, t as createDocument } from "../utils-Bvy3V-fv.js";
+import Search from "flexsearch";
+//#region src/search/flexsearch.ts
+function server(options) {
+	function initIndex(indexes) {
+		const index = createDocument(options.document);
+		for (const doc of buildDocuments(indexes)) index.add(doc.id, doc);
+		return index;
+	}
+	const indexPromise = typeof options.indexes === "function" ? Promise.resolve(options.indexes()).then(initIndex) : initIndex(options.indexes);
+	return {
+		async export() {
+			const index = await indexPromise;
+			const raw = {};
+			index.export((key, data) => {
+				raw[key] = data;
+			});
+			return {
+				type: "default",
+				raw
+			};
+		},
+		async search(query, searchOptions) {
+			return search(await indexPromise, query, searchOptions?.tag, searchOptions?.limit);
+		}
+	};
+}
+function serverI18n(options) {
+	const { indexes: inputIndexes, localeMap } = options;
+	async function initSearchServers() {
+		const map = /* @__PURE__ */ new Map();
+		const indexMap = /* @__PURE__ */ new Map();
+		const indexes = typeof inputIndexes === "function" ? await inputIndexes() : inputIndexes;
+		for (const index of indexes) {
+			let list = indexMap.get(index.locale);
+			if (!list) {
+				list = [];
+				indexMap.set(index.locale, list);
+			}
+			list.push(index);
+		}
+		for (const [locale, list] of indexMap) {
+			const override = localeMap?.[locale];
+			map.set(locale, server({
+				indexes: list,
+				document: override === "cjk" ? {
+					...options.document,
+					encoder: Search.Charset.CJK
+				} : {
+					...options.document,
+					...override
+				}
+			}));
+		}
+		return map;
+	}
+	const get = initSearchServers();
+	return {
+		async export() {
+			const map = await get;
+			const entries = Array.from(map.entries()).map(async ([k, v]) => {
+				return [k, (await v.export()).raw];
+			});
+			return {
+				type: "i18n",
+				raw: Object.fromEntries(await Promise.all(entries))
+			};
+		},
+		async search(query, searchOptions) {
+			const handler = (await get).get(searchOptions?.locale ?? options.i18n.defaultLanguage);
+			if (handler) return handler.search(query, searchOptions);
+			return [];
+		}
+	};
+}
+function flexsearch(options) {
+	return createEndpoint(server(options));
+}
+function flexsearchI18n(options) {
+	return createEndpoint(serverI18n(options));
+}
+/**
+* create server from loader, if passed as function, the server will re-index all records once a different instance of loader is returned.
+*/
+function flexsearchFromSource(loader, options = {}) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const { buildIndex = buildIndexDefault, ...rest } = options;
+	async function initServer(loader) {
+		const indexes = await Promise.all(loader.getPages().map(async (page) => {
+			const index = await buildIndex(page);
+			return {
+				...index,
+				locale: page.locale,
+				breadcrumbs: index.breadcrumbs ?? buildBreadcrumbs(loader, page)
+			};
+		}));
+		if (loader._i18n) return serverI18n({
+			indexes,
+			i18n: loader._i18n,
+			...rest
+		});
+		return server({
+			indexes,
+			...rest
+		});
+	}
+	async function getCurrentServer() {
+		const l = typeof loader === "function" ? await loader() : loader;
+		let server = cache.get(l);
+		if (!server) {
+			server = initServer(l);
+			cache.set(l, server);
+		}
+		return await server;
+	}
+	return createEndpoint({
+		async export() {
+			return (await getCurrentServer()).export();
+		},
+		async search(query, options) {
+			return (await getCurrentServer()).search(query, options);
+		}
+	});
+}
+//#endregion
+export { flexsearch, flexsearchFromSource, flexsearchI18n };

package/dist/search/index.d.ts

@@ -0,0 +1,2 @@
+import { i as createContentHighlighter, n as ReactSortedResult, r as SortedResult, t as HighlightedText } from "../index-BM36H-xw.js";
+export { HighlightedText, ReactSortedResult, SortedResult, createContentHighlighter };

package/dist/search/index.js

@@ -0,0 +1,74 @@
+import { remark } from "remark";
+import { visit } from "unist-util-visit";
+//#region src/search/index.ts
+function escapeRegExp(input) {
+	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildRegexFromQuery(q) {
+	const trimmed = q.trim();
+	if (trimmed.length === 0) return null;
+	const terms = Array.from(new Set(trimmed.split(/\s+/).filter(Boolean)));
+	if (terms.length === 0) return null;
+	const escaped = terms.map(escapeRegExp).join("|");
+	return new RegExp(`(${escaped})`, "gi");
+}
+const processor = remark();
+function createContentHighlighter(query) {
+	const regex = typeof query === "string" ? buildRegexFromQuery(query) : query;
+	return {
+		/**
+		* @deprecated use `highlightMarkdown()` instead.
+		*/
+		highlight(content) {
+			if (!regex) return [{
+				type: "text",
+				content
+			}];
+			const out = [];
+			let i = 0;
+			for (const match of content.matchAll(regex)) {
+				if (i < match.index) out.push({
+					type: "text",
+					content: content.substring(i, match.index)
+				});
+				out.push({
+					type: "text",
+					content: match[0],
+					styles: { highlight: true }
+				});
+				i = match.index + match[0].length;
+			}
+			if (i < content.length) out.push({
+				type: "text",
+				content: content.substring(i)
+			});
+			return out;
+		},
+		/**
+		* @param content - Markdown, it assumes the content is already sanitized & safe, no escape is performed.
+		*/
+		highlightMarkdown(content) {
+			if (!regex) return content;
+			const tree = processor.parse(content);
+			highlightInTree(tree, regex);
+			return processor.stringify(tree).trim();
+		}
+	};
+}
+function highlightInTree(tree, regex) {
+	visit(tree, "text", (node) => {
+		let out = "";
+		const content = node.value;
+		let i = 0;
+		for (const match of content.matchAll(regex)) {
+			if (i < match.index) out += content.substring(i, match.index);
+			out += `<mark>${match[0]}</mark>`;
+			i = match.index + match[0].length;
+		}
+		if (i < content.length) out += content.substring(i);
+		node.type = "html";
+		node.value = out;
+	});
+}
+//#endregion
+export { createContentHighlighter };

package/dist/search/mixedbread.d.ts

@@ -0,0 +1,49 @@
+import { r as SortedResult } from "../index-BM36H-xw.js";
+import { n as SearchAPI } from "../server-CCqACwlF.js";
+import Mixedbread from "@mixedbread/sdk";
+import { StoreSearchResponse } from "@mixedbread/sdk/resources/stores";
+//#region src/search/mixedbread.d.ts
+interface SearchMetadata {
+  title?: string;
+  description?: string;
+  url?: string;
+  tag?: string;
+}
+type StoreSearchResult = StoreSearchResponse['data'][number] & {
+  generated_metadata: SearchMetadata;
+};
+interface MixedbreadSearchOptions {
+  /**
+   * The Mixedbread SDK client instance
+   */
+  client: Mixedbread;
+  /**
+   * The identifier of the store to search in
+   */
+  storeIdentifier: string;
+  /**
+   * Maximum number of results to return
+   *
+   * @defaultValue 10
+   */
+  topK?: number;
+  /**
+   * Re-rank search results for improved relevance (this adds latency to the search)
+   */
+  rerank?: boolean;
+  /**
+   * Rewrite the query for better search results (this adds latency to the search)
+   */
+  rewriteQuery?: boolean;
+  /**
+   * Minimum score threshold for results
+   */
+  scoreThreshold?: number;
+  /**
+   * Custom transform function for search results
+   */
+  transform?: (results: StoreSearchResult[], query: string) => SortedResult[];
+}
+declare function createMixedbreadSearchAPI(options: MixedbreadSearchOptions): SearchAPI;
+//#endregion
+export { MixedbreadSearchOptions, SearchMetadata, createMixedbreadSearchAPI };

package/dist/search/mixedbread.js

@@ -0,0 +1,77 @@
+import { r as __toESM } from "../rolldown-runtime-DC62tzP2.js";
+import { t as createEndpoint } from "../endpoint-MyoBU5IC.js";
+import { t as require_remove_markdown } from "../remove-markdown-DfKNMl9w.js";
+import Slugger from "github-slugger";
+//#region src/search/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 "";
+}
+function defaultTransform(results) {
+	return results.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;
+	});
+}
+function createMixedbreadSearchAPI(options) {
+	const { client, storeIdentifier, topK = 10, rerank, rewriteQuery, scoreThreshold, transform } = options;
+	return createEndpoint({
+		async search(query, searchOptions = {}) {
+			if (!query.trim()) return [];
+			const { tag, limit } = searchOptions;
+			let filters;
+			if (Array.isArray(tag) && tag.length > 0) filters = {
+				key: "generated_metadata.tag",
+				operator: "in",
+				value: tag
+			};
+			else if (typeof tag === "string") filters = {
+				key: "generated_metadata.tag",
+				operator: "eq",
+				value: tag
+			};
+			const results = (await client.stores.search({
+				query,
+				store_identifiers: [storeIdentifier],
+				top_k: limit ?? topK,
+				filters,
+				search_options: {
+					return_metadata: true,
+					rerank,
+					rewrite_query: rewriteQuery,
+					score_threshold: scoreThreshold
+				}
+			})).data;
+			if (transform) return transform(results, query);
+			return defaultTransform(results);
+		},
+		async export() {
+			throw new Error("Mixedbread search does not support exporting indexes. Use the Mixedbread dashboard to manage your store.");
+		}
+	});
+}
+//#endregion
+export { createMixedbreadSearchAPI };

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

@@ -0,0 +1,75 @@
+import { i as StructuredData } from "../remark-structure-CnHwvNZr.js";
+import "../index-DAYtLGbx.js";
+import { CloudManager } from "@oramacloud/client";
+//#region src/search/orama-cloud-legacy.d.ts
+interface SyncOptions {
+  /**
+   * Index name to sync
+   */
+  index: string;
+  documents: OramaDocument[];
+  /**
+   * Deploy changes
+   *
+   * @defaultValue true
+   */
+  autoDeploy?: boolean;
+}
+interface I18nSyncOptions extends Omit<SyncOptions, 'index' | 'documents'> {
+  /**
+   * Indexes to sync.
+   *
+   * Pairs of `locale`-`index`.
+   **/
+  indexes: Record<string, string>;
+  documents: {
+    locale: string;
+    items: OramaDocument[];
+  }[];
+}
+interface OramaDocument {
+  /**
+   * The ID of document, must be unique
+   */
+  id: string;
+  title: string;
+  description?: string;
+  /**
+   * URL to the page
+   */
+  url: string;
+  structured: StructuredData;
+  /**
+   * Tag to filter results
+   */
+  tag?: string;
+  /**
+   * Data to be added to each section index
+   */
+  extra_data?: object;
+  breadcrumbs?: string[];
+}
+interface OramaIndex {
+  id: string;
+  title: string;
+  url: string;
+  tag?: string;
+  /**
+   * The id of page, used for `group by`
+   */
+  page_id: string;
+  /**
+   * Heading content
+   */
+  section?: string;
+  breadcrumbs?: string[];
+  /**
+   * Heading (anchor) id
+   */
+  section_id?: string;
+  content: string;
+}
+declare function sync(cloudManager: CloudManager, options: SyncOptions): Promise<void>;
+declare function syncI18n(cloudManager: CloudManager, options: I18nSyncOptions): Promise<void>;
+//#endregion
+export { I18nSyncOptions, OramaDocument, OramaIndex, SyncOptions, sync, syncI18n };

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

@@ -0,0 +1,48 @@
+//#region src/search/orama-cloud-legacy.ts
+async function sync(cloudManager, options) {
+	const { autoDeploy = true } = options;
+	const index = cloudManager.index(options.index);
+	await index.snapshot(options.documents.flatMap(toIndex));
+	if (autoDeploy) await index.deploy();
+}
+async function syncI18n(cloudManager, options) {
+	const { autoDeploy = true } = options;
+	const tasks = options.documents.map(async (document) => {
+		const index = cloudManager.index(options.indexes[document.locale]);
+		await index.snapshot(document.items.flatMap(toIndex));
+		if (autoDeploy) await index.deploy();
+	});
+	await Promise.all(tasks);
+}
+function toIndex(page) {
+	let id = 0;
+	const indexes = [];
+	const scannedHeadings = /* @__PURE__ */ new Set();
+	function createIndex(section, sectionId, content) {
+		return {
+			id: `${page.id}-${(id++).toString()}`,
+			title: page.title,
+			url: page.url,
+			page_id: page.id,
+			tag: page.tag,
+			section,
+			section_id: sectionId,
+			content,
+			breadcrumbs: page.breadcrumbs,
+			...page.extra_data
+		};
+	}
+	if (page.description) indexes.push(createIndex(void 0, void 0, page.description));
+	page.structured.contents.forEach((p) => {
+		const heading = p.heading ? page.structured.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;
+}
+//#endregion
+export { sync, syncI18n };

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

@@ -0,0 +1,75 @@
+import { i as StructuredData } from "../remark-structure-CnHwvNZr.js";
+import "../index-DAYtLGbx.js";
+import { OramaCloud } from "@orama/core";
+//#region src/search/orama-cloud.d.ts
+interface SyncOptions {
+  /**
+   * Index name to sync
+   */
+  index: string;
+  documents: OramaDocument[];
+  /**
+   * Deploy changes
+   *
+   * @defaultValue true
+   */
+  autoDeploy?: boolean;
+}
+interface I18nSyncOptions extends Omit<SyncOptions, 'index' | 'documents'> {
+  /**
+   * Indexes to sync.
+   *
+   * Pairs of `locale`-`index`.
+   **/
+  indexes: Record<string, string>;
+  documents: {
+    locale: string;
+    items: OramaDocument[];
+  }[];
+}
+interface OramaDocument {
+  /**
+   * The ID of document, must be unique
+   */
+  id: string;
+  title: string;
+  description?: string;
+  /**
+   * URL to the page
+   */
+  url: string;
+  structured: StructuredData;
+  /**
+   * Tag to filter results
+   */
+  tag?: string;
+  /**
+   * Data to be added to each section index
+   */
+  extra_data?: object;
+  breadcrumbs?: string[];
+}
+interface OramaIndex {
+  id: string;
+  title: string;
+  url: string;
+  tag?: string;
+  /**
+   * The id of page, used for `group by`
+   */
+  page_id: string;
+  /**
+   * Heading content
+   */
+  section?: string;
+  breadcrumbs?: string[];
+  /**
+   * Heading (anchor) id
+   */
+  section_id?: string;
+  content: string;
+}
+declare function sync(orama: OramaCloud, options: SyncOptions): Promise<void>;
+declare function syncI18n(orama: OramaCloud, options: I18nSyncOptions): Promise<void>;
+//#endregion
+export { I18nSyncOptions, OramaDocument, OramaIndex, SyncOptions, sync, syncI18n };

package/dist/search/orama-cloud.js

@@ -0,0 +1,50 @@
+//#region src/search/orama-cloud.ts
+async function sync(orama, options) {
+	const { autoDeploy = true } = options;
+	const index = orama.index.set(options.index);
+	await index.transaction.open();
+	await index.transaction.insertDocuments(options.documents.flatMap(toIndex));
+	if (autoDeploy) await index.transaction.commit();
+}
+async function syncI18n(orama, options) {
+	const { autoDeploy = true, indexes } = options;
+	const tasks = options.documents.map(async (document) => {
+		const index = orama.index.set(indexes[document.locale]);
+		await index.transaction.open();
+		await index.transaction.insertDocuments(document.items.flatMap(toIndex));
+		if (autoDeploy) await index.transaction.commit();
+	});
+	await Promise.all(tasks);
+}
+function toIndex(page) {
+	let id = 0;
+	const indexes = [];
+	const scannedHeadings = /* @__PURE__ */ new Set();
+	function createIndex(section, sectionId, content) {
+		return {
+			id: `${page.id}-${(id++).toString()}`,
+			title: page.title,
+			url: page.url,
+			page_id: page.id,
+			tag: page.tag,
+			section,
+			section_id: sectionId,
+			content,
+			breadcrumbs: page.breadcrumbs,
+			...page.extra_data
+		};
+	}
+	if (page.description) indexes.push(createIndex(void 0, void 0, page.description));
+	page.structured.contents.forEach((p) => {
+		const heading = p.heading ? page.structured.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;
+}
+//#endregion
+export { sync, syncI18n };

package/dist/search/server.d.ts

@@ -0,0 +1,2 @@
+import { a as AdvancedOptions, c as SimpleOptions, d as createSearchAPI, f as initAdvancedSearch, i as AdvancedIndex, l as createFromSource, n as SearchAPI, o as ExportedData, p as initSimpleSearch, r as SearchServer, s as Index, t as QueryOptions, u as createI18nSearchAPI } from "../server-CCqACwlF.js";
+export { AdvancedIndex, AdvancedOptions, ExportedData, Index, QueryOptions, SearchAPI, SearchServer, SimpleOptions, createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };