@vezham/docs-core 1.0.1

package/dist/search/server.js

@@ -0,0 +1,237 @@
+import { n as defaultReadOptions, 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 searchSimple, t as searchAdvanced } from "../advanced-Ct13khZr.js";
+import { create, insertMultipleAsync, save } from "zbsearch";
+//#region src/search/zbsearch/create-db.ts
+const simpleSchema = {
+	url: "string",
+	title: "string",
+	breadcrumbs: "string[]",
+	description: "string",
+	content: "string",
+	keywords: "string",
+	locale: "enum"
+};
+const advancedSchema = {
+	content: "string",
+	page_id: "string",
+	type: "string",
+	breadcrumbs: "string[]",
+	tags: "enum[]",
+	url: "string",
+	locale: "enum",
+	embeddings: "vector[512]"
+};
+const DefaultLanguage = "multilingual";
+async function createDB({ indexes, tokenizer, language = DefaultLanguage, search: _, localeFilter: __, ...rest }) {
+	const items = typeof indexes === "function" ? await indexes() : indexes;
+	const resolvedTokenizer = tokenizer ?? rest.components?.tokenizer;
+	const db = create({
+		schema: advancedSchema,
+		language: resolvedTokenizer ? void 0 : language,
+		...rest,
+		components: {
+			...rest.components,
+			tokenizer: resolvedTokenizer
+		}
+	});
+	const mapTo = buildDocuments(items);
+	await insertMultipleAsync(db, mapTo);
+	return db;
+}
+async function createDBSimple({ indexes, tokenizer, language = DefaultLanguage, search: _, localeFilter: __, ...rest }) {
+	const items = typeof indexes === "function" ? await indexes() : indexes;
+	const resolvedTokenizer = tokenizer ?? rest.components?.tokenizer;
+	const db = create({
+		schema: simpleSchema,
+		language: resolvedTokenizer ? void 0 : language,
+		...rest,
+		components: {
+			...rest.components,
+			tokenizer: resolvedTokenizer
+		}
+	});
+	await insertMultipleAsync(db, items.map((page) => ({
+		title: page.title,
+		description: page.description,
+		breadcrumbs: page.breadcrumbs,
+		url: page.url,
+		content: page.content,
+		keywords: page.keywords,
+		locale: page.locale
+	})));
+	return db;
+}
+//#endregion
+//#region src/search/zbsearch/create-server.ts
+function initSimpleSearch(options) {
+	const doc = createDBSimple(options);
+	return {
+		async export() {
+			return {
+				type: "simple",
+				...options.localeFilter ? { i18n: true } : null,
+				...save(await doc)
+			};
+		},
+		async search(query, searchOptions = {}) {
+			const db = await doc;
+			const { limit, locale } = searchOptions;
+			return searchSimple(db, query, {
+				limit,
+				...options.search
+			}, options.localeFilter && locale ? locale : void 0);
+		}
+	};
+}
+function initAdvancedSearch(options) {
+	const get = createDB(options);
+	return {
+		async export() {
+			return {
+				type: "advanced",
+				...options.localeFilter ? { i18n: true } : null,
+				...save(await get)
+			};
+		},
+		async search(query, searchOptions = {}) {
+			const db = await get;
+			const { limit, tag, mode, locale } = searchOptions;
+			return searchAdvanced(db, query, tag, {
+				...options.search,
+				limit,
+				mode: mode === "vector" ? "vector" : "fulltext"
+			}, options.localeFilter && locale ? locale : void 0).catch((err) => {
+				if (mode === "vector") throw new Error("failed to search, make sure your indexes include `embeddings` and a plugin/proxy is configured to vectorize search terms.", { cause: err });
+				throw err;
+			});
+		}
+	};
+}
+function createSearchAPI(...args) {
+	return toAPI(args[0] === "simple" ? initSimpleSearch(args[1]) : initAdvancedSearch(args[1]));
+}
+function createI18nSearchAPI(...[type, options]) {
+	if (options.localeMap) return createI18nSearchAPILegacy(type, options);
+	const server = type === "simple" ? initSimpleSearch({
+		...options,
+		localeFilter: true
+	}) : initAdvancedSearch({
+		...options,
+		localeFilter: true
+	});
+	return toAPI({
+		export: server.export,
+		async search(query, searchOptions) {
+			return server.search(query, {
+				...searchOptions,
+				locale: searchOptions?.locale ?? options.i18n.defaultLanguage
+			});
+		}
+	});
+}
+function createI18nSearchAPILegacy(type, options) {
+	async function initSearchServers() {
+		const map = /* @__PURE__ */ new Map();
+		if (options.i18n.languages.length === 0) return map;
+		const indexes = typeof options.indexes === "function" ? await options.indexes() : options.indexes;
+		for (const locale of options.i18n.languages) {
+			const localeIndexes = indexes.filter((index) => index.locale === locale);
+			const mapped = options.localeMap?.[locale] ?? "multilingual";
+			if (type === "simple") map.set(locale, typeof mapped === "object" ? initSimpleSearch({
+				...options,
+				...mapped,
+				indexes: localeIndexes
+			}) : initSimpleSearch({
+				...options,
+				language: mapped,
+				indexes: localeIndexes
+			}));
+			else map.set(locale, typeof mapped === "object" ? initAdvancedSearch({
+				...options,
+				indexes: localeIndexes,
+				...mapped
+			}) : initAdvancedSearch({
+				...options,
+				language: mapped,
+				indexes: localeIndexes
+			}));
+		}
+		return map;
+	}
+	const get = initSearchServers();
+	return toAPI({
+		async export() {
+			const map = await get;
+			const entries = Array.from(map.entries()).map(async ([k, v]) => [k, await v.export()]);
+			return {
+				type: "i18n",
+				data: Object.fromEntries(await Promise.all(entries))
+			};
+		},
+		async search(query, searchOptions) {
+			const map = await get;
+			const locale = searchOptions?.locale ?? options.i18n.defaultLanguage;
+			const handler = map.get(locale);
+			if (handler) return handler.search(query, searchOptions);
+			return [];
+		}
+	});
+}
+/**
+* create server from loader, if passed as function, the server will re-index all records once a different instance of loader is returned.
+*/
+function createFromSource(loader, options = {}) {
+	const { buildIndex = buildIndexDefault } = options;
+	const cache = /* @__PURE__ */ new WeakMap();
+	async function initServer(loader) {
+		const indexes = await Promise.all(loader.getPages().map(async (page) => {
+			const index = await buildIndex(page);
+			return {
+				...index,
+				breadcrumbs: index.breadcrumbs ?? buildBreadcrumbs(loader, page),
+				locale: page.locale
+			};
+		}));
+		if (loader._i18n) return createI18nSearchAPI("advanced", {
+			...options,
+			indexes,
+			i18n: loader._i18n
+		});
+		return initAdvancedSearch({
+			indexes,
+			...options
+		});
+	}
+	async function getCurrentServer() {
+		const l = typeof loader === "function" ? await loader() : loader;
+		let server = cache.get(l);
+		if (!server) {
+			const promise = initServer(l);
+			promise.catch(() => {
+				if (cache.get(l) === promise) cache.delete(l);
+			});
+			cache.set(l, promise);
+			server = promise;
+		}
+		return await server;
+	}
+	return toAPI({
+		async export() {
+			return (await getCurrentServer()).export();
+		},
+		async search(query, options) {
+			return (await getCurrentServer()).search(query, options);
+		}
+	});
+}
+function toAPI(server) {
+	return createEndpoint(server, { readOptions(url) {
+		return {
+			...defaultReadOptions(url),
+			mode: url.searchParams.get("mode") === "vector" ? "vector" : "full"
+		};
+	} });
+}
+//#endregion
+export { createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };

package/dist/server-CCqACwlF.d.ts

@@ -0,0 +1,165 @@
+import { t as Awaitable } from "./types-D89QoQR-.js";
+import { i as StructuredData } from "./remark-structure-CnHwvNZr.js";
+import { n as I18nConfig } from "./index-DydiXvgS.js";
+import { r as SortedResult } from "./index-BM36H-xw.js";
+import { b as LoaderOutput, v as LoaderConfig } from "./index-DIwKCYOz.js";
+import { Language, RawData, SearchParams, TypedDocument, ZBSearch, create } from "zbsearch";
+//#region src/search/zbsearch/create-db.d.ts
+type SimpleDocument = TypedDocument<ZBSearch<typeof simpleSchema>>;
+declare const simpleSchema: {
+  readonly url: "string";
+  readonly title: "string";
+  readonly breadcrumbs: "string[]";
+  readonly description: "string";
+  readonly content: "string";
+  readonly keywords: "string";
+  readonly locale: "enum";
+};
+type AdvancedDocument = TypedDocument<ZBSearch<typeof advancedSchema>>;
+declare const advancedSchema: {
+  readonly content: "string";
+  readonly page_id: "string";
+  readonly type: "string";
+  readonly breadcrumbs: "string[]";
+  readonly tags: "enum[]";
+  readonly url: "string";
+  readonly locale: "enum";
+  readonly embeddings: "vector[512]";
+};
+//#endregion
+//#region src/search/server/build-index.d.ts
+interface SharedIndex {
+  id: string;
+  title: string;
+  description?: string;
+  breadcrumbs?: string[];
+  /**
+   * Locale of content (for i18n)
+   */
+  locale?: string;
+  /**
+   * Required if tag filter is enabled
+   */
+  tag?: string | string[];
+  /**
+   * preprocess mdx content with `structure`
+   */
+  structuredData: StructuredData;
+  url: string;
+}
+//#endregion
+//#region src/search/zbsearch/create-server.d.ts
+type CreateInput = NonNullable<Parameters<typeof create>[0]>;
+interface SharedOptions extends Pick<CreateInput, 'sort' | 'components' | 'plugins'> {
+  /**
+   * Tokenizer language.
+   *
+   * @defaultValue 'multilingual' - works with every language, zero config needed.
+   */
+  language?: string;
+  tokenizer?: Required<CreateInput>['components']['tokenizer'];
+  /**
+   * Filter search results by the `locale` query option, requires indexes to include a `locale` property.
+   *
+   * Enabled automatically by i18n search servers.
+   */
+  localeFilter?: boolean;
+}
+interface EngineQueryOptions extends QueryOptions {
+  mode?: 'full' | 'vector';
+}
+/**
+ * Resolve indexes dynamically
+ */
+type Dynamic<T> = () => Awaitable<T[]>;
+interface SimpleOptions extends SharedOptions {
+  indexes: Index[] | Dynamic<Index>;
+  /**
+   * Customize search options on server
+   */
+  search?: Partial<SearchParams<ZBSearch<typeof simpleSchema>, SimpleDocument>>;
+}
+interface AdvancedOptions extends SharedOptions {
+  indexes: AdvancedIndex[] | Dynamic<AdvancedIndex>;
+  /**
+   * Customize search options on server
+   */
+  search?: Partial<SearchParams<ZBSearch<typeof advancedSchema>, AdvancedDocument>>;
+}
+interface Index {
+  title: string;
+  description?: string;
+  breadcrumbs?: string[];
+  content: string;
+  url: string;
+  keywords?: string;
+  locale?: string;
+}
+type ExportedData = (RawData & {
+  type: 'simple' | 'advanced';
+  i18n?: boolean;
+}) | {
+  type: 'i18n';
+  data: Record<string, RawData & {
+    type: 'simple' | 'advanced';
+  }>;
+};
+declare function initSimpleSearch(options: SimpleOptions): SearchServer<EngineQueryOptions>;
+type AdvancedIndex = SharedIndex;
+declare function initAdvancedSearch(options: AdvancedOptions): SearchServer<EngineQueryOptions>;
+declare function createSearchAPI(type: 'simple', options: SimpleOptions): SearchAPI<EngineQueryOptions>;
+declare function createSearchAPI(type: 'advanced', options: AdvancedOptions): SearchAPI<EngineQueryOptions>;
+type I18nOptions<O extends SimpleOptions | AdvancedOptions, Idx> = Omit<O, 'language' | 'indexes'> & {
+  i18n: I18nConfig;
+  /**
+   * Map locale name from i18n config to a compatible `language` or options.
+   *
+   * @deprecated No longer needed - the default `multilingual` tokenizer supports every language with zero config.
+   * When specified, a separate database is created for each locale (legacy behaviour).
+   */
+  localeMap?: Record<string, Language | Partial<O> | undefined>;
+  indexes: WithLocale<Idx>[] | Dynamic<WithLocale<Idx>>;
+};
+type I18nSimpleOptions = I18nOptions<SimpleOptions, Index>;
+type I18nAdvancedOptions = I18nOptions<AdvancedOptions, AdvancedIndex>;
+type WithLocale<T> = T & {
+  locale: string;
+};
+declare function createI18nSearchAPI(type: 'simple', options: I18nSimpleOptions): SearchAPI<EngineQueryOptions>;
+declare function createI18nSearchAPI(type: 'advanced', options: I18nAdvancedOptions): SearchAPI<EngineQueryOptions>;
+interface Options<C extends LoaderConfig> extends Omit<AdvancedOptions, 'indexes'> {
+  /**
+   * @deprecated No longer needed - the default `multilingual` tokenizer supports every language with zero config.
+   */
+  localeMap?: { [K in C['i18n'] extends I18nConfig<infer Languages> ? Languages : string]?: Partial<AdvancedOptions> | Language; };
+  buildIndex?: (page: C['page']) => Awaitable<AdvancedIndex>;
+}
+/**
+ * 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 createFromSource<C extends LoaderConfig = LoaderConfig>(loader: LoaderOutput<C> | (() => Awaitable<LoaderOutput<C>>), options?: Options<C>): SearchAPI<EngineQueryOptions>;
+//#endregion
+//#region src/search/server/types.d.ts
+interface QueryOptions {
+  locale?: string | null;
+  tag?: string | string[];
+  limit?: number;
+}
+interface SearchServer<Q extends QueryOptions = QueryOptions> {
+  search: (query: string, options?: Q) => Promise<SortedResult[]>;
+  /**
+   * Export the database
+   *
+   * You can reference the exported database to implement client-side search
+   */
+  export: () => Promise<unknown>;
+}
+interface SearchAPI<Q extends QueryOptions = QueryOptions> extends SearchServer<Q> {
+  GET: (request: Request) => Promise<Response>;
+  /**
+   * `GET` route handler that exports search indexes for static search.
+   */
+  staticGET: () => Promise<Response>;
+}
+//#endregion
+export { AdvancedOptions as a, SimpleOptions as c, createSearchAPI as d, initAdvancedSearch as f, AdvancedIndex as i, createFromSource as l, SharedIndex as m, SearchAPI as n, ExportedData as o, initSimpleSearch as p, SearchServer as r, Index as s, QueryOptions as t, createI18nSearchAPI as u };

package/dist/server.browser.d.ts

@@ -0,0 +1,13 @@
+import { ElementType, ReactElement } from "react";
+//#region src/server.browser.d.ts
+/**
+ * Browser stub: Markdown rendering is server-only, components generated by
+ * `remarkLLMs` with `output: 'function'` render `null` in the browser.
+ */
+declare function asMarkdown(): boolean;
+declare function jsxComponents(components: Record<string, ElementType> | undefined): Record<string, ElementType>;
+declare function renderToMarkdown(): Promise<string>;
+declare function renderRoute(_element: ReactElement): Promise<string | undefined>;
+declare const md: () => never;
+//#endregion
+export { asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/server.browser.js

@@ -0,0 +1,22 @@
+//#region src/server.browser.ts
+/**
+* Browser stub: Markdown rendering is server-only, components generated by
+* `remarkLLMs` with `output: 'function'` render `null` in the browser.
+*/
+function asMarkdown() {
+	return false;
+}
+function jsxComponents(components) {
+	return components ?? {};
+}
+async function renderToMarkdown() {
+	throw new Error("`renderToMarkdown` is only available on the server.");
+}
+async function renderRoute(_element) {
+	throw new Error("`renderRoute` is only available on the server.");
+}
+const md = () => {
+	throw new Error("`md` is only available on the server.");
+};
+//#endregion
+export { asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/server.d.ts

@@ -0,0 +1,42 @@
+import { ElementType, ReactElement, ReactNode } from "react";
+//#region src/server.d.ts
+/**
+ * Whether the current component is being rendered into Markdown, calling it opts the component in.
+ */
+declare function asMarkdown(): boolean;
+/**
+ * Render a React tree into a Markdown document.
+ */
+declare function renderToMarkdown(node: ReactNode): Promise<string>;
+/**
+ * Render a page element into Markdown, `undefined` when its component doesn't call `asMarkdown()`.
+ */
+declare function renderRoute(element: ReactElement): Promise<string | undefined>;
+/**
+ * Resolve the MDX components of a generated Markdown component (`remarkLLMs` with `output: 'function'`):
+ * a missing component becomes a stub that `renderToMarkdown` serializes as JSX syntax.
+ */
+declare function jsxComponents(components: Record<string, ElementType> | undefined): Record<string, ElementType>;
+type MarkdownTag = (strings: TemplateStringsArray, ...values: ReactNode[]) => Promise<string>;
+/**
+ * Tagged template for Markdown, interpolated values can be strings, React nodes, promises, or arrays of them.
+ *
+ * Use `md\`${children}\`` inside a component to stringify its children before manipulating them, the result is not
+ * trimmed so block-level output keeps its trailing blank line.
+ *
+ * Formatters (Prettier, oxfmt) format `md` templates as Markdown and may move the content onto its own indented lines,
+ * so a leading empty line, the indentation before the closing backtick and the common indentation are removed.
+ */
+declare const md: MarkdownTag & {
+  /**
+   * Like `md`, but trims the result, prefixes every line (empty lines receive the trimmed prefix, e.g. `>` instead of
+   * `> `) and returns it as a block.
+   */
+  linePrefix: (prefix: string) => MarkdownTag;
+  /**
+   * Like `md`, but trims the result, indents every non-empty line and returns it as a block.
+   */
+  indent: (size?: number) => MarkdownTag;
+};
+//#endregion
+export { MarkdownTag, asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };