@hanzo/docs-core 16.5.0 → 16.5.3

package/dist/{index-2U6Tl4--.d.ts → path-B77y3W0_.d.ts}

@@ -1,10 +1,12 @@
-import { a as Separator, i as Root, n as Item, t as Folder } from "./definitions-DuxDer_c.js";
-import { t as I18nConfig } from "./index-Bw-DCOra.js";
+import { a as Separator, i as Root, n as Item, r as Node, t as Folder } from "./definitions-DSNTbAwC.js";
+import { I18nConfig } from "./i18n/index.js";
+import { SlugFn } from "./source/plugins/slugs.js";
+import { SerializedPageTree } from "./source/client/index.js";
 import { ReactNode } from "react";
 
 //#region src/source/source.d.ts
-interface Source<Config$1 extends SourceConfig = SourceConfig> {
-  files: VirtualFile<Config$1>[];
+interface Source<Config extends SourceConfig = SourceConfig> {
+  files: VirtualFile<Config>[];
 }
 interface SourceConfig {
   pageData: PageData;
@@ -24,7 +26,7 @@ interface PageData {
   title?: string;
   description?: string | undefined;
 }
-type VirtualFile<Config$1 extends SourceConfig = SourceConfig> = VirtualPage<Config$1['pageData']> | VirtualMeta<Config$1['metaData']>;
+type VirtualFile<Config extends SourceConfig = SourceConfig> = VirtualPage<Config['pageData']> | VirtualMeta<Config['metaData']>;
 interface BaseVirtualFile {
   /**
    * Virtualized path (relative to content directory)
@@ -58,31 +60,32 @@ type _ConfigUnion_<T extends Record<string, Source>> = { [K in keyof T]: T[K] ex
   };
 } : never }[keyof T];
 declare function multiple<T extends Record<string, Source>>(sources: T): Source<_ConfigUnion_<T>>;
-declare function source<Page$1 extends PageData, Meta$1 extends MetaData>(config: {
-  pages: VirtualPage<Page$1>[];
-  metas: VirtualMeta<Meta$1>[];
+declare function source<Page extends PageData, Meta extends MetaData>(config: {
+  pages: VirtualPage<Page>[];
+  metas: VirtualMeta<Meta>[];
 }): Source<{
-  pageData: Page$1;
-  metaData: Meta$1;
+  pageData: Page;
+  metaData: Meta;
 }>;
-/**
- * update a source object in-place.
- */
-declare function update<Config$1 extends SourceConfig>(source: Source<Config$1>): {
-  files<Page$1 extends PageData, Meta$1 extends MetaData>(fn: (files: VirtualFile<Config$1>[]) => (VirtualPage<Page$1> | VirtualMeta<Meta$1>)[]): typeof update<{
-    pageData: Page$1;
-    metaData: Meta$1;
+interface _SourceUpdate_<Config extends SourceConfig> {
+  files: <Page extends PageData, Meta extends MetaData>(fn: (files: VirtualFile<Config>[]) => (VirtualPage<Page> | VirtualMeta<Meta>)[]) => _SourceUpdate_<{
+    pageData: Page;
+    metaData: Meta;
   }>;
-  page<V extends PageData>(fn: (page: VirtualPage<Config$1["pageData"]>) => VirtualPage<V>): typeof update<{
+  page: <V extends PageData>(fn: (page: VirtualPage<Config['pageData']>) => VirtualPage<V>) => _SourceUpdate_<{
     pageData: V;
-    metaData: Config$1["metaData"];
+    metaData: Config['metaData'];
   }>;
-  meta<V extends MetaData>(fn: (meta: VirtualMeta<Config$1["metaData"]>) => VirtualMeta<V>): typeof update<{
-    pageData: Config$1["pageData"];
+  meta: <V extends MetaData>(fn: (meta: VirtualMeta<Config['metaData']>) => VirtualMeta<V>) => _SourceUpdate_<{
+    pageData: Config['pageData'];
     metaData: V;
   }>;
-  build(): Source<Config$1>;
-};
+  build: () => Source<Config>;
+}
+/**
+ * update a source object in-place.
+ */
+declare function update<Config extends SourceConfig>(source: Source<Config>): _SourceUpdate_<Config>;
 //#endregion
 //#region src/source/storage/file-system.d.ts
 /**
@@ -110,49 +113,53 @@ declare class FileSystem<File> {
 }
 //#endregion
 //#region src/source/storage/content.d.ts
-type ContentStorage<Config$1 extends SourceConfig = SourceConfig> = FileSystem<ContentStorageFile<Config$1>>;
-type ContentStorageFile<Config$1 extends SourceConfig = SourceConfig> = ContentStorageMetaFile<Config$1> | ContentStoragePageFile<Config$1>;
-interface ContentStorageMetaFile<Config$1 extends SourceConfig = SourceConfig> {
+type ContentStorage<Config extends SourceConfig = SourceConfig> = FileSystem<ContentStorageFile<Config>>;
+type ContentStorageFile<Config extends SourceConfig = SourceConfig> = ContentStorageMetaFile<Config> | ContentStoragePageFile<Config>;
+interface ContentStorageMetaFile<Config extends SourceConfig = SourceConfig> {
   path: string;
   absolutePath?: string;
   format: 'meta';
-  data: Config$1['metaData'];
+  data: Config['metaData'];
 }
-interface ContentStoragePageFile<Config$1 extends SourceConfig = SourceConfig> {
+interface ContentStoragePageFile<Config extends SourceConfig = SourceConfig> {
   path: string;
   absolutePath?: string;
   format: 'page';
   slugs: string[];
-  data: Config$1['pageData'];
+  data: Config['pageData'];
 }
 /**
- * @param defaultLanguage - language to use when i18n is not configured.
- * @returns a map of locale and its content storage.
+ * convert input files into virtual file system.
  *
  * in the storage, locale codes are removed from file paths, hence the same file will have same file paths in every storage.
  */
-declare function buildContentStorage(loaderConfig: ResolvedLoaderConfig, defaultLanguage: string): Record<string, ContentStorage>;
+declare function createContentStorageBuilder(loaderConfig: ResolvedLoaderConfig): {
+  i18n(): Record<string, ContentStorage>;
+  single(): ContentStorage;
+};
 //#endregion
 //#region src/source/page-tree/builder.d.ts
-interface PageTreeBuilderContext<Config$1 extends SourceConfig = SourceConfig> {
-  rootId: string;
-  generateNodeId: () => string;
-  options: PageTreeOptions;
-  transformers: PageTreeTransformer<Config$1>[];
+interface PageTreeBuilderContext<Config extends SourceConfig = SourceConfig> {
+  idPrefix: string;
+  noRef: boolean;
+  transformers: PageTreeTransformer<Config>[];
   builder: PageTreeBuilder;
-  storage: ContentStorage<Config$1>;
+  storage: ContentStorage<Config>;
   getUrl: ResolvedLoaderConfig['url'];
-  storages?: Record<string, ContentStorage<Config$1>>;
+  storages?: Record<string, ContentStorage<Config>>;
   locale?: string;
+  custom?: Record<string, unknown>;
 }
-interface PageTreeTransformer<Config$1 extends SourceConfig = SourceConfig> {
-  file?: (this: PageTreeBuilderContext<Config$1>, node: Item, filePath?: string) => Item;
-  folder?: (this: PageTreeBuilderContext<Config$1>, node: Folder, folderPath: string, metaPath?: string) => Folder;
-  separator?: (this: PageTreeBuilderContext<Config$1>, node: Separator) => Separator;
-  root?: (this: PageTreeBuilderContext<Config$1>, node: Root) => Root;
+interface PageTreeTransformer<Config extends SourceConfig = SourceConfig> {
+  file?: (this: PageTreeBuilderContext<Config>, node: Item, filePath?: string) => Item;
+  folder?: (this: PageTreeBuilderContext<Config>, node: Folder, folderPath: string, metaPath?: string) => Folder;
+  separator?: (this: PageTreeBuilderContext<Config>, node: Separator) => Separator;
+  root?: (this: PageTreeBuilderContext<Config>, node: Root) => Root;
 }
-interface PageTreeOptions<Config$1 extends LoaderConfig = LoaderConfig> {
-  id?: string;
+interface PageTreeOptions<Config extends LoaderConfig = LoaderConfig> {
+  /** generate URL from page */
+  url: ResolvedLoaderConfig['url'];
+  idPrefix?: string;
   /**
    * Remove references to the file path of original nodes (`$ref`)
    *
@@ -168,33 +175,40 @@ interface PageTreeOptions<Config$1 extends LoaderConfig = LoaderConfig> {
   /**
    * Additional page tree transformers to apply
    */
-  transformers?: PageTreeTransformer<Config$1['source']>[];
+  transformers?: PageTreeTransformer<Config['source']>[];
+  /** custom context */
+  context?: Record<string, unknown>;
 }
-interface PageTreeBuilder {
-  build: (storage: ContentStorage, options?: PageTreeOptions) => Root;
-  buildI18n: (storages: Record<string, ContentStorage>, options?: PageTreeOptions) => Record<string, Root>;
+declare class PageTreeBuilder {
+  private readonly flattenPathToFullPath;
+  private readonly transformers;
+  /** virtual file path -> output page tree node (if cached) */
+  private readonly pathToNode;
+  /** unfinished nodes */
+  private readonly unfinished;
+  private readonly ownerMap;
+  private _nextId;
+  /** passed as additional information to transformers */
+  private readonly ctx;
+  private readonly storage;
+  constructor(input: ContentStorage | [locale: string, storages: Record<string, ContentStorage>], options: PageTreeOptions);
+  resolveFlattenPath(name: string, format: string): string;
+  /**
+   * try to register as the owner of `node`.
+   *
+   * when a node is referenced by multiple folders, this determines which folder they should belong to.
+   *
+   * @returns whether the owner owns the node.
+   */
+  private own;
+  private transferOwner;
+  private generateId;
+  buildPaths(paths: string[], filter?: (file: string) => boolean, reversed?: boolean): Node[];
+  private resolveFolderItem;
+  folder(folderPath: string): Folder | undefined;
+  file(path: string): Item | undefined;
+  root(id?: string, path?: string): Root;
 }
-declare function createPageTreeBuilder(loaderConfig: ResolvedLoaderConfig): PageTreeBuilder;
-//#endregion
-//#region src/source/plugins/slugs.d.ts
-/**
- * a function to generate slugs, return `undefined` to fallback to default generation.
- */
-type SlugFn<Config$1 extends LoaderConfig = LoaderConfig> = (file: ContentStoragePageFile<Config$1['source']>) => string[] | undefined;
-/**
- * Generate slugs for pages if missing
- */
-declare function slugsPlugin<Config$1 extends LoaderConfig = LoaderConfig>(slugFn?: SlugFn<Config$1>): LoaderPlugin<Config$1>;
-/**
- * Generate slugs from file data (e.g. frontmatter).
- *
- * @param key - the property name in file data to generate slugs, default to `slug`.
- */
-declare function slugsFromData<Config$1 extends LoaderConfig = LoaderConfig>(key?: string): SlugFn<Config$1>;
-/**
- * Convert file path into slugs, also encode non-ASCII characters, so they can work in pathname
- */
-declare function getSlugs(file: string): string[];
 //#endregion
 //#region src/source/plugins/icon.d.ts
 type IconResolver = (icon: string | undefined) => ReactNode;
@@ -211,7 +225,7 @@ interface LoaderOptions<C extends LoaderConfig = LoaderConfig> {
   /**
    * Additional options for page tree builder
    */
-  pageTree?: PageTreeOptions<C>;
+  pageTree?: Partial<PageTreeOptions<C>>;
   plugins?: LoaderPluginOption[] | ((context: {
     typedPlugin: (plugin: LoaderPlugin<C>) => LoaderPlugin;
   }) => LoaderPluginOption[]);
@@ -222,7 +236,7 @@ interface ResolvedLoaderConfig {
   source: Source;
   url: (slugs: string[], locale?: string) => string;
   plugins?: LoaderPlugin[];
-  pageTree?: PageTreeOptions;
+  pageTree?: Partial<PageTreeOptions>;
   i18n?: I18nConfig | undefined;
 }
 interface SharedFileInfo {
@@ -246,8 +260,8 @@ interface Page<Data = PageData> extends SharedFileInfo {
 interface Meta<Data = MetaData> extends SharedFileInfo {
   data: Data;
 }
-interface LoaderOutput<Config$1 extends LoaderConfig> {
-  pageTree: Config$1['i18n'] extends I18nConfig ? Record<string, Root> : Root;
+interface LoaderOutput<Config extends LoaderConfig> {
+  pageTree: Config['i18n'] extends I18nConfig ? Record<string, Root> : Root;
   getPageTree: (locale?: string) => Root;
   /**
    * get referenced page from href, supported:
@@ -262,7 +276,7 @@ interface LoaderOutput<Config$1 extends LoaderConfig> {
      */
     dir?: string;
   }) => {
-    page: Page<Config$1['source']['pageData']>;
+    page: Page<Config['source']['pageData']>;
     hash?: string;
   } | undefined;
   /**
@@ -270,7 +284,7 @@ interface LoaderOutput<Config$1 extends LoaderConfig> {
    *
    * - relative file paths, like `./my/page.mdx`.
    */
-  resolveHref: (href: string, parent: Page<Config$1['source']['pageData']>) => string;
+  resolveHref: (href: string, parent: Page<Config['source']['pageData']>) => string;
   /**
    * @internal
    */
@@ -278,24 +292,24 @@ interface LoaderOutput<Config$1 extends LoaderConfig> {
   /**
    * Get a list of pages from specified language
    *
-   * @param language - If empty, list pages from all languages.
+   * @param language - If unspecified, list pages from all languages.
    */
-  getPages: (language?: string) => Page<Config$1['source']['pageData']>[];
+  getPages: (language?: string) => Page<Config['source']['pageData']>[];
   /**
    * get each language and its pages, empty if i18n is not enabled.
    */
   getLanguages: () => {
     language: string;
-    pages: Page<Config$1['source']['pageData']>[];
+    pages: Page<Config['source']['pageData']>[];
   }[];
   /**
    * Get page with slugs, the slugs can also be URI encoded.
    *
-   * @param language - If empty, the default language will be used
+   * @param language - If unspecified, the default language will be used.
    */
-  getPage: (slugs: string[] | undefined, language?: string) => Page<Config$1['source']['pageData']> | undefined;
-  getNodePage: (node: Item, language?: string) => Page<Config$1['source']['pageData']> | undefined;
-  getNodeMeta: (node: Folder, language?: string) => Meta<Config$1['source']['metaData']> | undefined;
+  getPage: (slugs: string[] | undefined, language?: string) => Page<Config['source']['pageData']> | undefined;
+  getNodePage: (node: Item, language?: string) => Page<Config['source']['pageData']> | undefined;
+  getNodeMeta: (node: Folder, language?: string) => Meta<Config['source']['metaData']> | undefined;
   /**
    * generate static params for Next.js SSG
    *
@@ -306,26 +320,26 @@ interface LoaderOutput<Config$1 extends LoaderConfig> {
   /**
    * serialize page tree for non-RSC environments
    */
-  serializePageTree: (tree: Root) => Promise<object>;
+  serializePageTree: (tree: Root) => Promise<SerializedPageTree>;
 }
 declare function createGetUrl(baseUrl: string, i18n?: I18nConfig): ResolvedLoaderConfig['url'];
-declare function loader<Config$1 extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(source: Source<Config$1>, options: LoaderOptions<{
-  source: NoInfer<Config$1>;
+declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(source: Source<Config>, options: LoaderOptions<{
+  source: NoInfer<Config>;
   i18n: I18n;
 }>): LoaderOutput<{
-  source: Config$1;
+  source: Config;
   i18n: I18n;
 }>;
-declare function loader<Config$1 extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(options: LoaderOptions<{
-  source: NoInfer<Config$1>;
+declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(options: LoaderOptions<{
+  source: NoInfer<Config>;
   i18n: I18n;
 }> & {
-  source: Source<Config$1>;
+  source: Source<Config>;
 }): LoaderOutput<{
-  source: Config$1;
+  source: Config;
   i18n: I18n;
 }>;
-interface LoaderPlugin<Config$1 extends LoaderConfig = LoaderConfig> {
+interface LoaderPlugin<Config extends LoaderConfig = LoaderConfig> {
   name?: string;
   /**
    * Change the order of plugin:
@@ -341,14 +355,14 @@ interface LoaderPlugin<Config$1 extends LoaderConfig = LoaderConfig> {
    * transform the storage after loading
    */
   transformStorage?: (context: {
-    storage: ContentStorage<Config$1['source']>;
+    storage: ContentStorage<Config['source']>;
   }) => void;
   /**
    * transform the generated page tree
    */
-  transformPageTree?: PageTreeTransformer<Config$1['source']>;
+  transformPageTree?: PageTreeTransformer<Config['source']>;
 }
-type LoaderPluginOption<Config$1 extends LoaderConfig = LoaderConfig> = LoaderPlugin<Config$1> | LoaderPluginOption<Config$1>[] | undefined;
+type LoaderPluginOption<Config extends LoaderConfig = LoaderConfig> = LoaderPlugin<Config> | LoaderPluginOption<Config>[] | undefined;
 type InferPageType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Page<Config['source']['pageData']> : never;
 type InferMetaType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Meta<Config['source']['metaData']> : never;
 declare namespace path_d_exports {
@@ -375,5 +389,4 @@ declare function splitPath(path: string): string[];
 declare function joinPath(...paths: string[]): string;
 declare function slash(path: string): string;
 //#endregion
-export { PageData as A, ContentStorage as C, buildContentStorage as D, ContentStoragePageFile as E, multiple as F, source as I, update as L, SourceConfig as M, VirtualFile as N, FileSystem as O, _ConfigUnion_ as P, createPageTreeBuilder as S, ContentStorageMetaFile as T, slugsPlugin as _, LoaderOptions as a, PageTreeOptions as b, LoaderPluginOption as c, ResolvedLoaderConfig as d, createGetUrl as f, slugsFromData as g, getSlugs as h, LoaderConfig as i, Source as j, MetaData as k, Meta as l, SlugFn as m, InferMetaType as n, LoaderOutput as o, loader as p, InferPageType as r, LoaderPlugin as s, path_d_exports as t, Page as u, PageTreeBuilder as v, ContentStorageFile as w, PageTreeTransformer as x, PageTreeBuilderContext as y };
-//# sourceMappingURL=index-2U6Tl4--.d.ts.map
+export { _SourceUpdate_ as A, FileSystem as C, SourceConfig as D, Source as E, source as M, update as N, VirtualFile as O, createContentStorageBuilder as S, PageData as T, PageTreeTransformer as _, LoaderOptions as a, ContentStorageMetaFile as b, LoaderPluginOption as c, ResolvedLoaderConfig as d, createGetUrl as f, PageTreeOptions as g, PageTreeBuilderContext as h, LoaderConfig as i, multiple as j, _ConfigUnion_ as k, Meta as l, PageTreeBuilder as m, InferMetaType as n, LoaderOutput as o, loader as p, InferPageType as r, LoaderPlugin as s, path_d_exports as t, Page as u, ContentStorage as v, MetaData as w, ContentStoragePageFile as x, ContentStorageFile as y };

package/dist/{path-DHIjrDBP.js → path-D0Bwm6Fs.js}

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "./chunk-B-ezknvj.js";
+import { n as __exportAll } from "./chunk-CaR5F9JI.js";
 
 //#region src/source/path.ts
 var path_exports = /* @__PURE__ */ __exportAll({
@@ -56,5 +56,4 @@ function slash(path) {
 }
 
 //#endregion
-export { path_exports as a, joinPath as i, dirname as n, slash as o, extname as r, splitPath as s, basename as t };
-//# sourceMappingURL=path-DHIjrDBP.js.map
+export { path_exports as a, joinPath as i, dirname as n, slash as o, extname as r, splitPath as s, basename as t };

package/dist/{remove-undefined-Cfs4o_mM.js → remove-undefined-CJm9cyrC.js}

@@ -15,5 +15,4 @@ function removeUndefined(value, deep = false) {
 }
 
 //#endregion
-export { removeUndefined as t };
-//# sourceMappingURL=remove-undefined-Cfs4o_mM.js.map
+export { removeUndefined as t };

package/dist/search/algolia.d.ts

@@ -1,3 +1,67 @@
-import "../remark-structure-DGuWR82i.js";
-import { a as sync, i as setIndexSettings, n as DocumentRecord, o as updateDocuments, r as SyncOptions, t as BaseIndex } from "../algolia-Cc1y6qWl.js";
+import { StructuredData } from "../mdx-plugins/remark-structure.js";
+import { Algoliasearch } from "algoliasearch";
+
+//#region src/search/algolia.d.ts
+interface DocumentRecord {
+  /**
+   * The ID of document, must be unique
+   */
+  _id: string;
+  title: string;
+  description?: string;
+  breadcrumbs?: 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;
+}
+interface SyncOptions {
+  /**
+   * Index Name for documents.
+   */
+  indexName?: string;
+  /**
+   * Search indexes
+   */
+  documents: DocumentRecord[];
+}
+/**
+ * Update index settings and replace all objects
+ *
+ * @param client - Algolia Admin Client
+ * @param options - Index Options
+ */
+declare function sync(client: Algoliasearch, options: SyncOptions): Promise<void>;
+declare function setIndexSettings(client: Algoliasearch, indexName: string): Promise<void>;
+declare function updateDocuments(client: Algoliasearch, indexName: string, documents: DocumentRecord[]): Promise<void>;
+interface BaseIndex {
+  objectID: string;
+  title: string;
+  url: string;
+  tag?: string;
+  /**
+   * The id of page, used for distinct
+   */
+  page_id: string;
+  /**
+   * Heading content
+   */
+  section?: string;
+  /**
+   * Heading (anchor) id
+   */
+  section_id?: string;
+  breadcrumbs?: string[];
+  content: string;
+}
+//#endregion
 export { BaseIndex, DocumentRecord, SyncOptions, setIndexSettings, sync, updateDocuments };

package/dist/search/algolia.js

@@ -73,5 +73,4 @@ async function updateDocuments(client, indexName, documents) {
 }
 
 //#endregion
-export { setIndexSettings, sync, updateDocuments };
-//# sourceMappingURL=algolia.js.map
+export { setIndexSettings, sync, updateDocuments };

package/dist/search/client.d.ts

@@ -1,13 +1,15 @@
-import "../definitions-DuxDer_c.js";
-import "../remark-structure-DGuWR82i.js";
-import { t as BaseIndex } from "../algolia-Cc1y6qWl.js";
+import "../definitions-DSNTbAwC.js";
+import "../utils-IgHyYnrz.js";
+import { BaseIndex } from "./algolia.js";
 import { SortedResult } from "./index.js";
-import "../server-DmY4lGBs.js";
-import "../index-2U6Tl4--.js";
+import "../create-i18n-Cv3Cocbs.js";
+import "../path-B77y3W0_.js";
+import "./server.js";
 import { DependencyList } from "react";
 import { AnyOrama } from "@orama/orama";
 import { LiteClient, SearchResponse } from "algoliasearch/lite";
 import { OramaCloud, OramaCloudSearchParams } from "@orama/core";
+import { ClientSearchParams, OramaClient } from "@oramacloud/client";
 import Mixedbread from "@mixedbread/sdk";
 
 //#region src/search/client/fetch.d.ts
@@ -81,6 +83,26 @@ interface OramaCloudOptions {
   locale?: string;
 }
 //#endregion
+//#region src/search/client/orama-cloud-legacy.d.ts
+interface OramaCloudLegacyOptions {
+  client: OramaClient;
+  /**
+   * The type of your index.
+   *
+   * You can set it to `crawler` if you use crawler instead of the JSON index with schema provided by Hanzo Docs
+   */
+  index?: 'default' | 'crawler';
+  params?: ClientSearchParams;
+  /**
+   * Filter results with specific tag.
+   */
+  tag?: string;
+  /**
+   * Filter by locale (unsupported at the moment)
+   */
+  locale?: string;
+}
+//#endregion
 //#region src/search/client/mixedbread.d.ts
 interface MixedbreadOptions {
   /**
@@ -120,6 +142,8 @@ type Client = ({
 } & AlgoliaOptions) | ({
   type: 'orama-cloud';
 } & OramaCloudOptions) | ({
+  type: 'orama-cloud-legacy';
+} & OramaCloudLegacyOptions) | ({
   type: 'mixedbread';
 } & MixedbreadOptions);
 /**
@@ -142,5 +166,4 @@ declare function useDocsSearch(clientOptions: Client & {
   allowEmpty?: boolean;
 }, deps?: DependencyList): UseDocsSearch;
 //#endregion
-export { type AlgoliaOptions, Client, type FetchOptions, type OramaCloudOptions, type StaticOptions, useDocsSearch };
-//# sourceMappingURL=client.d.ts.map
+export { type AlgoliaOptions, Client, type FetchOptions, type OramaCloudOptions, type StaticOptions, useDocsSearch };

package/dist/search/client.js

@@ -52,27 +52,33 @@ function useDocsSearch(clientOptions, deps) {
 		};
 		async function run() {
 			if (debouncedValue.length === 0 && !allowEmpty) return "empty";
-			if (client.type === "fetch") {
-				const { fetchDocs } = await import("../fetch-B5e9CFfN.js");
-				return fetchDocs(debouncedValue, client);
+			switch (client.type) {
+				case "fetch": {
+					const { fetchDocs } = await import("../fetch-HotVeLLF.js");
+					return fetchDocs(debouncedValue, client);
+				}
+				case "algolia": {
+					const { searchDocs } = await import("../algolia-C7Crg8-5.js");
+					return searchDocs(debouncedValue, client);
+				}
+				case "orama-cloud": {
+					const { searchDocs } = await import("../orama-cloud-ByznDyOk.js");
+					return searchDocs(debouncedValue, client);
+				}
+				case "orama-cloud-legacy": {
+					const { searchDocs } = await import("../orama-cloud-legacy-BbgJnf5f.js");
+					return searchDocs(debouncedValue, client);
+				}
+				case "mixedbread": {
+					const { search } = await import("../mixedbread-Bx9drx9S.js");
+					return search(debouncedValue, client);
+				}
+				case "static": {
+					const { search } = await import("../static-DTxK4eHk.js");
+					return search(debouncedValue, client);
+				}
+				default: throw new Error("unknown search client");
 			}
-			if (client.type === "algolia") {
-				const { searchDocs } = await import("../algolia-CQPXCnjV.js");
-				return searchDocs(debouncedValue, client);
-			}
-			if (client.type === "orama-cloud") {
-				const { searchDocs } = await import("../orama-cloud-DH3g37zc.js");
-				return searchDocs(debouncedValue, client);
-			}
-			if (client.type === "static") {
-				const { search: search$1 } = await import("../static-Dq8pA8Ay.js");
-				return search$1(debouncedValue, client);
-			}
-			if (client.type === "mixedbread") {
-				const { search: search$1 } = await import("../mixedbread-DlByNYSd.js");
-				return search$1(debouncedValue, client);
-			}
-			throw new Error("unknown search client");
 		}
 		run().then((res) => {
 			if (interrupt) return;
@@ -96,5 +102,4 @@ function useDocsSearch(clientOptions, deps) {
 }
 
 //#endregion
-export { useDocsSearch };
-//# sourceMappingURL=client.js.map
+export { useDocsSearch };

package/dist/search/index.d.ts

@@ -24,5 +24,4 @@ declare function createContentHighlighter(query: string | RegExp): {
   highlight(content: string): HighlightedText[];
 };
 //#endregion
-export { HighlightedText, ReactSortedResult, SortedResult, createContentHighlighter };
-//# sourceMappingURL=index.d.ts.map
+export { HighlightedText, ReactSortedResult, SortedResult, createContentHighlighter };

package/dist/search/index.js

@@ -1,3 +1,43 @@
-import { t as createContentHighlighter } from "../search-D6ChCLhY.js";
+//#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+/).map((t) => t.trim()).filter(Boolean)));
+	if (terms.length === 0) return null;
+	const escaped = terms.map(escapeRegExp).join("|");
+	return new RegExp(`(${escaped})`, "gi");
+}
+function createContentHighlighter(query) {
+	const regex = typeof query === "string" ? buildRegexFromQuery(query) : query;
+	return { 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;
+	} };
+}
 
+//#endregion
 export { createContentHighlighter };