fumadocs-core 15.2.8 → 16.0.3

package/dist/search/client.js

@@ -1,75 +1,96 @@
 import {
   useOnChange
-} from "../chunk-ORHEEQVY.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-EMWGTXSW.js";
+import "../chunk-U67V476Y.js";
 
 // src/search/client.ts
-import { useRef as useRef2, useState as useState2 } from "react";
+import { useRef, useState as useState2 } from "react";
 
 // src/utils/use-debounce.ts
-import { useRef, useState } from "react";
+import { useEffect, useState } from "react";
 function useDebounce(value, delayMs = 1e3) {
   const [debouncedValue, setDebouncedValue] = useState(value);
-  const timer = useRef(void 0);
-  if (delayMs === 0) return value;
-  if (value !== debouncedValue && timer.current?.value !== value) {
-    if (timer.current) clearTimeout(timer.current.handler);
+  useEffect(() => {
+    if (delayMs === 0) return;
     const handler = window.setTimeout(() => {
       setDebouncedValue(value);
     }, delayMs);
-    timer.current = { value, handler };
-  }
+    return () => clearTimeout(handler);
+  }, [delayMs, value]);
+  if (delayMs === 0) return value;
   return debouncedValue;
 }
 
 // src/search/client.ts
-var staticClient;
-function useDocsSearch(client, locale, tag, delayMs = 100, allowEmpty = false, key) {
+function isDifferentDeep(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return b.length !== a.length || a.some((v, i) => isDifferentDeep(v, b[i]));
+  }
+  if (typeof a === "object" && a && typeof b === "object" && b) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length !== bKeys.length || aKeys.some(
+      (key) => isDifferentDeep(a[key], b[key])
+    );
+  }
+  return a !== b;
+}
+function useDocsSearch(clientOptions) {
+  const { delayMs = 100, allowEmpty = false, ...client } = clientOptions;
   const [search, setSearch] = useState2("");
   const [results, setResults] = useState2("empty");
   const [error, setError] = useState2();
   const [isLoading, setIsLoading] = useState2(false);
   const debouncedValue = useDebounce(search, delayMs);
-  const onStart = useRef2(void 0);
-  useOnChange(key ?? [client, debouncedValue, locale, tag], () => {
-    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";
-      if (client.type === "fetch") {
-        const { fetchDocs } = await import("../fetch-W5EHIBOE.js");
-        return fetchDocs(debouncedValue, locale, tag, client);
-      }
-      if (client.type === "algolia") {
-        const { index, type: _, ...rest } = client;
-        const { searchDocs } = await import("../algolia-NTWLS6J3.js");
-        return searchDocs(index, debouncedValue, tag, rest);
+  const onStart = useRef(void 0);
+  useOnChange(
+    [client, debouncedValue],
+    () => {
+      if (onStart.current) {
+        onStart.current();
+        onStart.current = void 0;
       }
-      if (client.type === "orama-cloud") {
-        const { searchDocs } = await import("../orama-cloud-USLSOSXS.js");
-        return searchDocs(debouncedValue, tag, client);
+      setIsLoading(true);
+      let interrupt = false;
+      onStart.current = () => {
+        interrupt = true;
+      };
+      async function run() {
+        if (debouncedValue.length === 0 && !allowEmpty) return "empty";
+        if (client.type === "fetch") {
+          const { fetchDocs } = await import("../fetch-2XFMBLBA.js");
+          return fetchDocs(debouncedValue, client);
+        }
+        if (client.type === "algolia") {
+          const { searchDocs } = await import("../algolia-IZEDLPHE.js");
+          return searchDocs(debouncedValue, client);
+        }
+        if (client.type === "orama-cloud") {
+          const { searchDocs } = await import("../orama-cloud-WEGQE5A6.js");
+          return searchDocs(debouncedValue, client);
+        }
+        if (client.type === "static") {
+          const { search: search2 } = await import("../static-A2YJ5TXV.js");
+          return search2(debouncedValue, client);
+        }
+        if (client.type === "mixedbread") {
+          const { search: search2 } = await import("../mixedbread-RAHDVXGJ.js");
+          return search2(debouncedValue, client);
+        }
+        throw new Error("unknown search client");
       }
-      const { createStaticClient } = await import("../static-VESU2S64.js");
-      if (!staticClient) staticClient = createStaticClient(client);
-      return staticClient.search(debouncedValue, locale, tag);
-    }
-    void run().then((res) => {
-      if (interrupt) return;
-      setError(void 0);
-      setResults(res);
-    }).catch((err) => {
-      setError(err);
-    }).finally(() => {
-      setIsLoading(false);
-    });
-  });
+      void run().then((res) => {
+        if (interrupt) return;
+        setError(void 0);
+        setResults(res);
+      }).catch((err) => {
+        setError(err);
+      }).finally(() => {
+        setIsLoading(false);
+      });
+    },
+    isDifferentDeep
+  );
   return { search, setSearch, query: { isLoading, data: results, error } };
 }
 export {

package/dist/search/index.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+
+interface SortedResult<Content = string> {
+    id: string;
+    url: string;
+    type: 'page' | 'heading' | 'text';
+    content: Content;
+    /**
+     * breadcrumbs to be displayed on UI
+     */
+    breadcrumbs?: Content[];
+    contentWithHighlights?: HighlightedText<Content>[];
+}
+type ReactSortedResult = SortedResult<ReactNode>;
+interface HighlightedText<Content = string> {
+    type: 'text';
+    content: Content;
+    styles?: {
+        highlight?: boolean;
+    };
+}
+declare function createContentHighlighter(query: string | RegExp): {
+    highlight(content: string): HighlightedText[];
+};
+
+export { type HighlightedText, type ReactSortedResult, type SortedResult, createContentHighlighter };

package/dist/search/index.js

@@ -0,0 +1,7 @@
+import {
+  createContentHighlighter
+} from "../chunk-OTD7MV33.js";
+import "../chunk-U67V476Y.js";
+export {
+  createContentHighlighter
+};

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

@@ -1,6 +1,6 @@
-import { CloudManager } from '@oramacloud/client';
-import { S as StructuredData } from '../remark-structure-FIjTA11P.js';
-import '../remark-heading-BPCoYwjn.js';
+import { S as StructuredData } from '../remark-structure-DkCXCzpD.js';
+import '../remark-code-tab-DmyIyi6m.js';
+import { OramaCloud } from '@orama/core';
 import 'mdast';
 import 'unified';
 import 'mdast-util-mdx-jsx';
@@ -50,6 +50,7 @@ interface OramaDocument {
      * Data to be added to each section index
      */
     extra_data?: object;
+    breadcrumbs?: string[];
 }
 interface OramaIndex {
     id: string;
@@ -64,13 +65,14 @@ interface OramaIndex {
      * 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>;
+declare function sync(orama: OramaCloud, options: SyncOptions): Promise<void>;
+declare function syncI18n(orama: OramaCloud, options: I18nSyncOptions): Promise<void>;
 
 export { type I18nSyncOptions, type OramaDocument, type OramaIndex, type SyncOptions, sync, syncI18n };

package/dist/search/orama-cloud.js

@@ -1,18 +1,24 @@
-import "../chunk-MLKGABMK.js";
+import "../chunk-U67V476Y.js";
 
 // src/search/orama-cloud.ts
-async function sync(cloudManager, options) {
+async function sync(orama, options) {
   const { autoDeploy = true } = options;
-  const index = cloudManager.index(options.index);
-  await index.snapshot(options.documents.flatMap(toIndex));
-  if (autoDeploy) await index.deploy();
+  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(cloudManager, options) {
-  const { autoDeploy = true } = options;
+async function syncI18n(orama, options) {
+  const { autoDeploy = true, indexes } = 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();
+    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);
 }
@@ -25,11 +31,13 @@ function toIndex(page) {
       id: `${page.id}-${(id++).toString()}`,
       title: page.title,
       url: page.url,
+      // TODO: explicit declare enums
       page_id: page.id,
       tag: page.tag,
       section,
       section_id: sectionId,
       content,
+      breadcrumbs: page.breadcrumbs,
       ...page.extra_data
     };
   }

package/dist/search/server.d.ts

@@ -1,39 +1,50 @@
 import { TypedDocument, Orama, Language, RawData, create, SearchParams } from '@orama/orama';
-import { S as StructuredData } from '../remark-structure-FIjTA11P.js';
-import { S as SortedResult } from '../types-Ch8gnVgO.js';
-import { I as I18nConfig } from '../config-inq6kP6y.js';
-import { LoaderOutput, LoaderConfig, InferPageType } from '../source/index.js';
+import { S as StructuredData } from '../remark-structure-DkCXCzpD.js';
+import { SortedResult } from './index.js';
+export { HighlightedText, ReactSortedResult, createContentHighlighter } from './index.js';
+import { I18nConfig } from '../i18n/index.js';
+import { k as LoaderOutput, f as LoaderConfig, I as InferPageType } from '../builder-feW_xVjc.js';
 import 'mdast';
 import 'unified';
 import 'mdast-util-mdx-jsx';
 import 'react';
-import '../page-tree-BG3wP0gU.js';
+import '../definitions-BRsJlZ6m.js';
 
-type AdvancedDocument = TypedDocument<Orama<typeof advancedSchema>>;
-declare const advancedSchema: {
-    readonly content: "string";
-    readonly page_id: "string";
-    readonly type: "string";
-    readonly keywords: "string";
-    readonly tag: "string";
-    readonly url: "string";
-};
 type SimpleDocument = TypedDocument<Orama<typeof simpleSchema>>;
 declare const simpleSchema: {
     readonly url: "string";
     readonly title: "string";
+    readonly breadcrumbs: "string[]";
     readonly description: "string";
     readonly content: "string";
     readonly keywords: "string";
 };
+type AdvancedDocument = TypedDocument<Orama<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 embeddings: "vector[512]";
+};
+
+type Awaitable<T> = T | Promise<T>;
+interface Options<S extends LoaderOutput<LoaderConfig>> extends Omit<AdvancedOptions, 'indexes'> {
+    localeMap?: {
+        [K in S extends LoaderOutput<infer C> ? C['i18n'] extends I18nConfig<infer Languages> ? Languages : string : string]?: Partial<AdvancedOptions> | Language;
+    };
+    buildIndex?: (page: InferPageType<S>) => Awaitable<AdvancedIndex>;
+}
+declare function createFromSource<S extends LoaderOutput<LoaderConfig>>(source: S, options?: Options<S>): SearchAPI;
 
-type LocaleMap<O> = Record<string, Language | O>;
 type I18nOptions<O extends SimpleOptions | AdvancedOptions, Idx> = Omit<O, 'language' | 'indexes'> & {
     i18n: I18nConfig;
     /**
      * Map locale name from i18n config to Orama compatible `language` or options
      */
-    localeMap?: LocaleMap<Partial<O>>;
+    localeMap?: Record<string, Language | Partial<O> | undefined>;
     indexes: WithLocale<Idx>[] | Dynamic<WithLocale<Idx>>;
 };
 type I18nSimpleOptions = I18nOptions<SimpleOptions, Index>;
@@ -43,11 +54,6 @@ type WithLocale<T> = T & {
 };
 declare function createI18nSearchAPI<T extends 'simple' | 'advanced'>(type: T, options: T extends 'simple' ? I18nSimpleOptions : I18nAdvancedOptions): SearchAPI;
 
-type Options = Omit<AdvancedOptions, 'language' | 'indexes'> & {
-    localeMap?: LocaleMap<Partial<AdvancedOptions>>;
-};
-declare function createFromSource<S extends LoaderOutput<LoaderConfig>>(source: S, pageToIndexFn?: (page: InferPageType<S>) => AdvancedIndex, options?: Options): SearchAPI;
-
 type SearchType = 'simple' | 'advanced';
 type ExportedData = (RawData & {
     type: SearchType;
@@ -60,7 +66,8 @@ type ExportedData = (RawData & {
 interface SearchServer {
     search: (query: string, options?: {
         locale?: string;
-        tag?: string;
+        tag?: string | string[];
+        mode?: 'vector' | 'full';
     }) => Promise<SortedResult[]>;
     /**
      * Export the database
@@ -103,6 +110,7 @@ declare function createSearchAPI<T extends SearchType>(type: T, options: T exten
 interface Index {
     title: string;
     description?: string;
+    breadcrumbs?: string[];
     content: string;
     url: string;
     keywords?: string;
@@ -112,11 +120,11 @@ interface AdvancedIndex {
     id: string;
     title: string;
     description?: string;
-    keywords?: string;
+    breadcrumbs?: string[];
     /**
      * Required if tag filter is enabled
      */
-    tag?: string;
+    tag?: string | string[];
     /**
      * preprocess mdx content with `structure`
      */
@@ -125,4 +133,4 @@ interface AdvancedIndex {
 }
 declare function initAdvancedSearch(options: AdvancedOptions): SearchServer;
 
-export { type AdvancedIndex, type AdvancedOptions, type Dynamic, type ExportedData, type Index, type SearchAPI, type SearchServer, type SimpleOptions, createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };
+export { type AdvancedIndex, type AdvancedOptions, type Dynamic, type ExportedData, type Index, type SearchAPI, type SearchServer, type SimpleOptions, SortedResult, createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };

package/dist/search/server.js

@@ -1,9 +1,19 @@
 import {
   searchAdvanced,
   searchSimple
-} from "../chunk-WFUH5VBX.js";
-import "../chunk-KAOEMCTI.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-XOFXGHS4.js";
+import "../chunk-ZMWYLUDP.js";
+import {
+  basename,
+  extname
+} from "../chunk-XZSI7AHE.js";
+import {
+  createContentHighlighter
+} from "../chunk-OTD7MV33.js";
+import {
+  findPath
+} from "../chunk-IZPLHEX4.js";
+import "../chunk-U67V476Y.js";
 
 // src/search/server.ts
 import {
@@ -24,8 +34,9 @@ function createEndpoint(server) {
       if (!query) return Response.json([]);
       return Response.json(
         await search(query, {
-          tag: url.searchParams.get("tag") ?? void 0,
-          locale: url.searchParams.get("locale") ?? void 0
+          tag: url.searchParams.get("tag")?.split(",") ?? void 0,
+          locale: url.searchParams.get("locale") ?? void 0,
+          mode: url.searchParams.get("mode") === "vector" ? "vector" : "full"
         })
       );
     }
@@ -37,13 +48,22 @@ import {
   create,
   insertMultiple
 } from "@orama/orama";
+var simpleSchema = {
+  url: "string",
+  title: "string",
+  breadcrumbs: "string[]",
+  description: "string",
+  content: "string",
+  keywords: "string"
+};
 var advancedSchema = {
   content: "string",
   page_id: "string",
   type: "string",
-  keywords: "string",
-  tag: "string",
-  url: "string"
+  breadcrumbs: "string[]",
+  tags: "enum[]",
+  url: "string",
+  embeddings: "vector[512]"
 };
 async function createDB({
   indexes,
@@ -62,6 +82,8 @@ async function createDB({
   });
   const mapTo = [];
   items.forEach((page) => {
+    const pageTag = page.tag ?? [];
+    const tags = Array.isArray(pageTag) ? pageTag : [pageTag];
     const data = page.structuredData;
     let id = 0;
     mapTo.push({
@@ -69,15 +91,16 @@ async function createDB({
       page_id: page.id,
       type: "page",
       content: page.title,
-      keywords: page.keywords,
-      tag: page.tag,
+      breadcrumbs: page.breadcrumbs,
+      tags,
       url: page.url
     });
+    const nextId = () => `${page.id}-${id++}`;
     if (page.description) {
       mapTo.push({
-        id: `${page.id}-${(id++).toString()}`,
+        id: nextId(),
         page_id: page.id,
-        tag: page.tag,
+        tags,
         type: "text",
         url: page.url,
         content: page.description
@@ -85,19 +108,19 @@ async function createDB({
     }
     for (const heading of data.headings) {
       mapTo.push({
-        id: `${page.id}-${(id++).toString()}`,
+        id: nextId(),
         page_id: page.id,
         type: "heading",
-        tag: page.tag,
+        tags,
         url: `${page.url}#${heading.id}`,
         content: heading.content
       });
     }
     for (const content of data.contents) {
       mapTo.push({
-        id: `${page.id}-${(id++).toString()}`,
+        id: nextId(),
         page_id: page.id,
-        tag: page.tag,
+        tags,
         type: "text",
         url: content.heading ? `${page.url}#${content.heading}` : page.url,
         content: content.content
@@ -107,13 +130,6 @@ async function createDB({
   await insertMultiple(db, mapTo);
   return db;
 }
-var simpleSchema = {
-  url: "string",
-  title: "string",
-  description: "string",
-  content: "string",
-  keywords: "string"
-};
 async function createDBSimple({
   indexes,
   tokenizer,
@@ -133,6 +149,7 @@ async function createDBSimple({
     items.map((page) => ({
       title: page.title,
       description: page.description,
+      breadcrumbs: page.breadcrumbs,
       url: page.url,
       content: page.content,
       keywords: page.keywords
@@ -142,41 +159,71 @@ async function createDBSimple({
 }
 
 // src/search/orama/create-from-source.ts
-function pageToIndex(page) {
-  if (!("structuredData" in page.data)) {
-    throw new Error(
-      "Cannot find structured data from page, please define the page to index function."
-    );
+function defaultBuildIndex(source) {
+  function isBreadcrumbItem(item) {
+    return typeof item === "string" && item.length > 0;
   }
-  const structuredData = page.data.structuredData;
-  return {
-    title: page.data.title ?? page.file.name,
-    description: "description" in page.data ? page.data.description : void 0,
-    url: page.url,
-    id: page.url,
-    structuredData
+  return async (page) => {
+    let breadcrumbs;
+    let structuredData;
+    if ("structuredData" in page.data) {
+      structuredData = page.data.structuredData;
+    } else if ("load" in page.data && typeof page.data.load === "function") {
+      structuredData = (await page.data.load()).structuredData;
+    }
+    if (!structuredData)
+      throw new Error(
+        "Cannot find structured data from page, please define the page to index function."
+      );
+    const pageTree = source.getPageTree(page.locale);
+    const path = findPath(
+      pageTree.children,
+      (node) => node.type === "page" && node.url === page.url
+    );
+    if (path) {
+      breadcrumbs = [];
+      path.pop();
+      if (isBreadcrumbItem(pageTree.name)) {
+        breadcrumbs.push(pageTree.name);
+      }
+      for (const segment of path) {
+        if (!isBreadcrumbItem(segment.name)) continue;
+        breadcrumbs.push(segment.name);
+      }
+    }
+    return {
+      title: page.data.title ?? basename(page.path, extname(page.path)),
+      breadcrumbs,
+      description: page.data.description,
+      url: page.url,
+      id: page.url,
+      structuredData
+    };
   };
 }
-function createFromSource(source, pageToIndexFn = pageToIndex, options = {}) {
+function createFromSource(source, options = {}) {
+  const { buildIndex = defaultBuildIndex(source) } = options;
   if (source._i18n) {
     return createI18nSearchAPI("advanced", {
       ...options,
       i18n: source._i18n,
-      indexes: source.getLanguages().flatMap((entry) => {
-        return entry.pages.map((page) => {
-          return {
-            ...pageToIndexFn(page),
+      indexes: async () => {
+        const indexes = source.getLanguages().flatMap((entry) => {
+          return entry.pages.map(async (page) => ({
+            ...await buildIndex(page),
             locale: entry.language
-          };
+          }));
         });
-      })
+        return Promise.all(indexes);
+      }
     });
   }
   return createSearchAPI("advanced", {
     ...options,
-    indexes: source.getPages().map((page) => {
-      return pageToIndexFn(page);
-    })
+    indexes: async () => {
+      const indexes = source.getPages().map((page) => buildIndex(page));
+      return Promise.all(indexes);
+    }
   });
 }
 
@@ -273,7 +320,7 @@ function createI18nSearchAPI(type, options) {
   return createEndpoint({
     async export() {
       const map = await get;
-      const entries = Object.entries(map).map(async ([k, v]) => [
+      const entries = Array.from(map.entries()).map(async ([k, v]) => [
         k,
         await v.export()
       ]);
@@ -325,11 +372,26 @@ function initAdvancedSearch(options) {
     },
     async search(query, searchOptions) {
       const db = await get;
-      return searchAdvanced(db, query, searchOptions?.tag, options.search);
+      const mode = searchOptions?.mode;
+      return searchAdvanced(db, query, searchOptions?.tag, {
+        ...options.search,
+        mode: mode === "vector" ? "vector" : "fulltext"
+      }).catch((err) => {
+        if (mode === "vector") {
+          throw new Error(
+            "failed to search, make sure you have installed `@orama/plugin-embeddings` according to their docs.",
+            {
+              cause: err
+            }
+          );
+        }
+        throw err;
+      });
     }
   };
 }
 export {
+  createContentHighlighter,
   createFromSource,
   createI18nSearchAPI,
   createSearchAPI,