fumadocs-core 15.2.8 → 16.0.3

package/dist/mixedbread-RAHDVXGJ.js

@@ -0,0 +1,118 @@
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-U67V476Y.js";
+
+// ../../node_modules/.pnpm/remove-markdown@0.6.2/node_modules/remove-markdown/index.js
+var require_remove_markdown = __commonJS({
+  "../../node_modules/.pnpm/remove-markdown@0.6.2/node_modules/remove-markdown/index.js"(exports, module) {
+    "use strict";
+    module.exports = function(md, options) {
+      options = options || {};
+      options.listUnicodeChar = options.hasOwnProperty("listUnicodeChar") ? options.listUnicodeChar : false;
+      options.stripListLeaders = options.hasOwnProperty("stripListLeaders") ? options.stripListLeaders : true;
+      options.gfm = options.hasOwnProperty("gfm") ? options.gfm : true;
+      options.useImgAltText = options.hasOwnProperty("useImgAltText") ? options.useImgAltText : true;
+      options.abbr = options.hasOwnProperty("abbr") ? options.abbr : false;
+      options.replaceLinksWithURL = options.hasOwnProperty("replaceLinksWithURL") ? options.replaceLinksWithURL : false;
+      options.htmlTagsToSkip = options.hasOwnProperty("htmlTagsToSkip") ? options.htmlTagsToSkip : [];
+      options.throwError = options.hasOwnProperty("throwError") ? options.throwError : false;
+      var output = md || "";
+      output = output.replace(/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/gm, "");
+      try {
+        if (options.stripListLeaders) {
+          if (options.listUnicodeChar)
+            output = output.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, options.listUnicodeChar + " $1");
+          else
+            output = output.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, "$1");
+        }
+        if (options.gfm) {
+          output = output.replace(/\n={2,}/g, "\n").replace(/~{3}.*\n/g, "").replace(/~~/g, "").replace(/```(?:.*)\n([\s\S]*?)```/g, (_, code) => code.trim());
+        }
+        if (options.abbr) {
+          output = output.replace(/\*\[.*\]:.*\n/, "");
+        }
+        let htmlReplaceRegex = /<[^>]*>/g;
+        if (options.htmlTagsToSkip && options.htmlTagsToSkip.length > 0) {
+          const joinedHtmlTagsToSkip = options.htmlTagsToSkip.join("|");
+          htmlReplaceRegex = new RegExp(
+            `<(?!/?(${joinedHtmlTagsToSkip})(?=>|s[^>]*>))[^>]*>`,
+            "g"
+          );
+        }
+        output = output.replace(htmlReplaceRegex, "").replace(/^[=\-]{2,}\s*$/g, "").replace(/\[\^.+?\](\: .*?$)?/g, "").replace(/\s{0,2}\[.*?\]: .*?$/g, "").replace(/\!\[(.*?)\][\[\(].*?[\]\)]/g, options.useImgAltText ? "$1" : "").replace(/\[([\s\S]*?)\]\s*[\(\[].*?[\)\]]/g, options.replaceLinksWithURL ? "$2" : "$1").replace(/^(\n)?\s{0,3}>\s?/gm, "$1").replace(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/g, "").replace(/^(\n)?\s{0,}#{1,6}\s*( (.+))? +#+$|^(\n)?\s{0,}#{1,6}\s*( (.+))?$/gm, "$1$3$4$6").replace(/([\*]+)(\S)(.*?\S)??\1/g, "$2$3").replace(/(^|\W)([_]+)(\S)(.*?\S)??\2($|\W)/g, "$1$3$4$5").replace(/(`{3,})(.*?)\1/gm, "$2").replace(/`(.+?)`/g, "$1").replace(/~(.*?)~/g, "$1");
+      } catch (e) {
+        if (options.throwError) throw e;
+        console.error("remove-markdown encountered error: %s", e);
+        return md;
+      }
+      return output;
+    };
+  }
+});
+
+// src/search/client/mixedbread.ts
+var import_remove_markdown = __toESM(require_remove_markdown(), 1);
+import Slugger from "github-slugger";
+var slugger = new Slugger();
+function extractHeadingTitle(text) {
+  const trimmedText = text.trim();
+  if (!trimmedText.startsWith("#")) {
+    return "";
+  }
+  const lines = trimmedText.split("\n");
+  const firstLine = lines[0]?.trim();
+  if (firstLine) {
+    const plainText = (0, import_remove_markdown.default)(firstLine, {
+      useImgAltText: false
+    });
+    return plainText;
+  }
+  return "";
+}
+async function search(query, options) {
+  const { client, vectorStoreId, tag } = options;
+  if (!query.trim()) {
+    return [];
+  }
+  const res = await client.vectorStores.search({
+    query,
+    vector_store_identifiers: [vectorStoreId],
+    top_k: 10,
+    filters: {
+      key: "generated_metadata.tag",
+      operator: "eq",
+      value: tag
+    },
+    search_options: {
+      return_metadata: true
+    }
+  });
+  return res.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" ? 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;
+  });
+}
+export {
+  search
+};

package/dist/negotiation/index.d.ts

@@ -0,0 +1,19 @@
+import Negotiator from 'negotiator';
+
+declare function getNegotiator(request: Request): Negotiator;
+/**
+ * Rewrite incoming path matching the `source` pattern into the `destination` pattern.
+ *
+ * See [`path-to-regexp`](https://github.com/pillarjs/path-to-regexp) for accepted pattern formats.
+ *
+ * @param source - the original pattern of incoming paths
+ * @param destination - the target pattern to convert into
+ */
+declare function rewritePath(source: string, destination: string): {
+    rewrite(pathname: string): string | false;
+};
+declare function isMarkdownPreferred(request: Request, options?: {
+    markdownMediaTypes?: string[];
+}): boolean;
+
+export { getNegotiator, isMarkdownPreferred, rewritePath };

package/dist/negotiation/index.js

@@ -0,0 +1,11 @@
+import {
+  getNegotiator,
+  isMarkdownPreferred,
+  rewritePath
+} from "../chunk-YVVDKJ2H.js";
+import "../chunk-U67V476Y.js";
+export {
+  getNegotiator,
+  isMarkdownPreferred,
+  rewritePath
+};

package/dist/{orama-cloud-USLSOSXS.js → orama-cloud-WEGQE5A6.js}

@@ -1,57 +1,64 @@
 import {
   removeUndefined
-} from "./chunk-KAOEMCTI.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-ZMWYLUDP.js";
+import {
+  createContentHighlighter
+} from "./chunk-OTD7MV33.js";
+import "./chunk-U67V476Y.js";
 
 // src/search/client/orama-cloud.ts
-async function searchDocs(query, tag, options) {
+async function searchDocs(query, options) {
+  const highlighter = createContentHighlighter(query);
   const list = [];
-  const { index = "default", client, params: extraParams = {} } = options;
+  const { index = "default", client, params: extraParams, tag } = options;
   if (index === "crawler") {
     const result2 = await client.search({
+      datasources: [],
       ...extraParams,
       term: query,
       where: {
         category: tag ? {
           eq: tag.slice(0, 1).toUpperCase() + tag.slice(1)
         } : void 0,
-        ...extraParams.where
+        ...extraParams?.where
       },
       limit: 10
     });
     if (!result2) return list;
-    if (index === "crawler") {
-      for (const hit of result2.hits) {
-        const doc = hit.document;
-        list.push(
-          {
-            id: hit.id,
-            type: "page",
-            content: doc.title,
-            url: doc.path
-          },
-          {
-            id: "page" + hit.id,
-            type: "text",
-            content: doc.content,
-            url: doc.path
-          }
-        );
-      }
-      return list;
+    for (const hit of result2.hits) {
+      const doc = hit.document;
+      list.push(
+        {
+          id: hit.id,
+          type: "page",
+          content: doc.title,
+          contentWithHighlights: highlighter.highlight(doc.title),
+          url: doc.path
+        },
+        {
+          id: "page" + hit.id,
+          type: "text",
+          content: doc.content,
+          contentWithHighlights: highlighter.highlight(doc.content),
+          url: doc.path
+        }
+      );
     }
+    return list;
   }
   const params = {
+    datasources: [],
     ...extraParams,
     term: query,
     where: removeUndefined({
       tag,
-      ...extraParams.where
+      ...extraParams?.where
     }),
     groupBy: {
+      // TODO: this was causing error on number of group variants
       properties: ["page_id"],
-      maxResult: 7,
-      ...extraParams.groupBy
+      max_results: 7,
+      ...extraParams?.groupBy
     }
   };
   const result = await client.search(params);
@@ -65,6 +72,8 @@ async function searchDocs(query, tag, options) {
           id: doc.page_id,
           type: "page",
           content: doc.title,
+          breadcrumbs: doc.breadcrumbs,
+          contentWithHighlights: highlighter.highlight(doc.title),
           url: doc.url
         });
         addedHead = true;
@@ -72,6 +81,7 @@ async function searchDocs(query, tag, options) {
       list.push({
         id: doc.id,
         content: doc.content,
+        contentWithHighlights: highlighter.highlight(doc.content),
         type: doc.content === doc.section ? "heading" : "text",
         url: doc.section_id ? `${doc.url}#${doc.section_id}` : doc.url
       });

package/dist/page-tree/index.d.ts

@@ -0,0 +1,32 @@
+import { N as Node, I as Item, R as Root, F as Folder } from '../definitions-BRsJlZ6m.js';
+export { S as Separator } from '../definitions-BRsJlZ6m.js';
+import 'react';
+
+/**
+ * Flatten tree to an array of page nodes
+ */
+declare function flattenTree(nodes: Node[]): Item[];
+/**
+ * Get neighbours of a page, useful for implementing "previous & next" buttons
+ */
+declare function findNeighbour(tree: Root, url: string, options?: {
+    separateRoot?: boolean;
+}): {
+    previous?: Item;
+    next?: Item;
+};
+declare function getPageTreeRoots(pageTree: Root | Folder): (Root | Folder)[];
+/**
+ * Get other page tree nodes that lives under the same parent
+ */
+declare function getPageTreePeers(treeOrTrees: Root | Record<string, Root>, url: string): Item[];
+/**
+ * Search the path of a node in the tree matched by the matcher.
+ *
+ * @returns The path to the target node (from starting root), or null if the page doesn't exist
+ */
+declare function findPath(nodes: Node[], matcher: (node: Node) => boolean, options?: {
+    includeSeparator?: boolean;
+}): Node[] | null;
+
+export { Folder, Item, Node, Root, findNeighbour, findPath, flattenTree, getPageTreePeers, getPageTreeRoots };

package/dist/page-tree/index.js

@@ -0,0 +1,15 @@
+import {
+  findNeighbour,
+  findPath,
+  flattenTree,
+  getPageTreePeers,
+  getPageTreeRoots
+} from "../chunk-IZPLHEX4.js";
+import "../chunk-U67V476Y.js";
+export {
+  findNeighbour,
+  findPath,
+  flattenTree,
+  getPageTreePeers,
+  getPageTreeRoots
+};

package/dist/remark-code-tab-DmyIyi6m.d.ts

@@ -0,0 +1,57 @@
+import { Root, Heading, Code } from 'mdast';
+import { Transformer, Processor } from 'unified';
+import { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
+
+declare module 'mdast' {
+    interface HeadingData extends Data {
+        hProperties?: {
+            id?: string;
+        };
+    }
+}
+interface RemarkHeadingOptions {
+    slug?: (root: Root, heading: Heading, text: string) => string;
+    /**
+     * Allow custom headings ids
+     *
+     * @defaultValue true
+     */
+    customId?: boolean;
+    /**
+     * Attach an array of `TOCItemType` to `file.data.toc`
+     *
+     * @defaultValue true
+     */
+    generateToc?: boolean;
+}
+/**
+ * Add heading ids and extract TOC
+ */
+declare function remarkHeading({ slug: defaultSlug, customId, generateToc, }?: RemarkHeadingOptions): Transformer<Root, Root>;
+
+type TabType = keyof typeof Types;
+interface RemarkCodeTabOptions {
+    Tabs?: TabType;
+    /**
+     * Parse MDX in tab values
+     *
+     * @defaultValue false
+     */
+    parseMdx?: boolean;
+}
+declare module 'mdast' {
+    interface CodeData {
+        tab?: string;
+    }
+}
+declare const Types: {
+    CodeBlockTabs: {
+        convert(processor: Processor, nodes: Code[], withMdx?: boolean, withParent?: boolean): MdxJsxFlowElement;
+    };
+    Tabs: {
+        convert(processor: Processor, nodes: Code[], withMdx?: boolean, withParent?: boolean): MdxJsxFlowElement;
+    };
+};
+declare function remarkCodeTab(this: Processor, options?: RemarkCodeTabOptions): Transformer<Root, Root>;
+
+export { type RemarkHeadingOptions as R, type RemarkCodeTabOptions as a, remarkCodeTab as b, remarkHeading as r };

package/dist/{remark-structure-FIjTA11P.d.ts → remark-structure-DkCXCzpD.d.ts}

@@ -1,6 +1,6 @@
 import { Nodes, Root } from 'mdast';
 import { Transformer, PluggableList } from 'unified';
-import { MdxJsxAttribute, MdxJsxExpressionAttribute } from 'mdast-util-mdx-jsx';
+import { MdxJsxFlowElement, MdxJsxAttribute, MdxJsxExpressionAttribute } from 'mdast-util-mdx-jsx';
 
 interface Heading {
     id: string;
@@ -24,7 +24,13 @@ interface StructureOptions {
      * @defaultValue ['heading', 'paragraph', 'blockquote', 'tableCell', 'mdxJsxFlowElement']
      */
     types?: string[] | ((node: Nodes) => boolean);
-    allowedMdxAttributes?: string[] | ((node: Nodes, attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => boolean);
+    /**
+     * A list of indexable MDX attributes, either:
+     *
+     * - an array of attribute names.
+     * - a function that determines if attribute should be indexed.
+     */
+    allowedMdxAttributes?: string[] | ((node: MdxJsxFlowElement, attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => boolean);
 }
 declare module 'mdast' {
     interface Data {
@@ -36,6 +42,11 @@ declare module 'mdast' {
         _string?: string[];
     }
 }
+declare module 'vfile' {
+    interface DataMap {
+        structuredData: StructuredData;
+    }
+}
 /**
  * Attach structured data to VFile, you can access via `vfile.data.structuredData`.
  */

package/dist/search/algolia.d.ts

@@ -1,5 +1,5 @@
-import { SearchClient, SearchIndex } from 'algoliasearch';
-import { S as StructuredData } from '../remark-structure-FIjTA11P.js';
+import { Algoliasearch } from 'algoliasearch';
+import { S as StructuredData } from '../remark-structure-DkCXCzpD.js';
 import 'mdast';
 import 'unified';
 import 'mdast-util-mdx-jsx';
@@ -11,6 +11,7 @@ interface DocumentRecord {
     _id: string;
     title: string;
     description?: string;
+    breadcrumbs?: string[];
     /**
      * URL to the page
      */
@@ -27,9 +28,9 @@ interface DocumentRecord {
 }
 interface SyncOptions {
     /**
-     * Index Name for documents
+     * Index Name for documents.
      */
-    document?: string;
+    indexName?: string;
     /**
      * Search indexes
      */
@@ -41,9 +42,9 @@ interface SyncOptions {
  * @param client - Algolia Admin Client
  * @param options - Index Options
  */
-declare function sync(client: SearchClient, options: SyncOptions): Promise<void>;
-declare function setIndexSettings(index: SearchIndex): Promise<void>;
-declare function updateDocuments(index: SearchIndex, documents: DocumentRecord[]): Promise<void>;
+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;
@@ -61,6 +62,7 @@ interface BaseIndex {
      * Heading (anchor) id
      */
     section_id?: string;
+    breadcrumbs?: string[];
     content: string;
 }
 

package/dist/search/algolia.js

@@ -1,19 +1,28 @@
-import "../chunk-MLKGABMK.js";
+import "../chunk-U67V476Y.js";
 
 // src/search/algolia.ts
 async function sync(client, options) {
-  const { document = "document", documents } = options;
-  const index = client.initIndex(document);
-  await setIndexSettings(index);
-  await updateDocuments(index, documents);
+  const { indexName = "document", documents } = options;
+  await setIndexSettings(client, indexName);
+  await updateDocuments(client, indexName, documents);
 }
-async function setIndexSettings(index) {
-  await index.setSettings({
-    attributeForDistinct: "page_id",
-    attributesToRetrieve: ["title", "section", "content", "url", "section_id"],
-    searchableAttributes: ["title", "section", "content"],
-    attributesToSnippet: [],
-    attributesForFaceting: ["tag"]
+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) {
@@ -23,6 +32,7 @@ function toIndex(page) {
   function createIndex(section, sectionId, content) {
     return {
       objectID: `${page._id}-${(id++).toString()}`,
+      breadcrumbs: page.breadcrumbs,
       title: page.title,
       url: page.url,
       page_id: page._id,
@@ -35,20 +45,24 @@ function toIndex(page) {
   }
   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 { 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(index, documents) {
+async function updateDocuments(client, indexName, documents) {
   const objects = documents.flatMap(toIndex);
-  await index.replaceAllObjects(objects);
+  await client.replaceAllObjects({
+    indexName,
+    objects
+  });
 }
 export {
   setIndexSettings,

package/dist/search/client.d.ts

@@ -1,41 +1,100 @@
-import { S as SortedResult } from '../types-Ch8gnVgO.js';
 import { AnyOrama } from '@orama/orama';
-import { SearchOptions } from '@algolia/client-search';
-import { SearchIndex } from 'algoliasearch/lite';
-import '../remark-structure-FIjTA11P.js';
-import { OramaClient, ClientSearchParams } from '@oramacloud/client';
+import '../remark-structure-DkCXCzpD.js';
+import { BaseIndex } from './algolia.js';
+import { LiteClient, SearchResponse } from 'algoliasearch/lite';
+import { OramaCloud, OramaCloudSearchParams } from '@orama/core';
+import Mixedbread from '@mixedbread/sdk';
+import { SortedResult } from './index.js';
 import 'mdast';
 import 'unified';
 import 'mdast-util-mdx-jsx';
+import 'algoliasearch';
+import 'react';
 
 interface FetchOptions {
     /**
      * API route for search endpoint
+     *
+     * @defaultValue '/api/search'
      */
     api?: string;
+    /**
+     * Filter results with specific tag(s).
+     */
+    tag?: string | string[];
+    /**
+     * Filter by locale
+     */
+    locale?: string;
 }
 
 interface StaticOptions {
     /**
      * Where to download exported search indexes (URL)
+     *
+     * @defaultValue '/api/search'
      */
     from?: string;
     initOrama?: (locale?: string) => AnyOrama | Promise<AnyOrama>;
+    /**
+     * Filter results with specific tag(s).
+     */
+    tag?: string | string[];
+    /**
+     * Filter by locale (unsupported at the moment)
+     */
+    locale?: string;
 }
 
-interface AlgoliaOptions extends SearchOptions {
-    index: SearchIndex;
+interface AlgoliaOptions {
+    indexName: string;
+    client: LiteClient;
+    /**
+     * Filter results with specific tag.
+     */
+    tag?: string;
+    locale?: string;
+    onSearch?: (query: string, tag?: string, locale?: string) => Promise<{
+        results: SearchResponse<BaseIndex>[];
+    }>;
 }
 
 interface OramaCloudOptions {
-    client: OramaClient;
+    client: OramaCloud;
     /**
      * The type of your index.
      *
      * You can set it to `crawler` if you use crawler instead of the JSON index with schema provided by Fumadocs
      */
     index?: 'default' | 'crawler';
-    params?: ClientSearchParams;
+    params?: Partial<OramaCloudSearchParams>;
+    /**
+     * Filter results with specific tag.
+     */
+    tag?: string;
+    /**
+     * Filter by locale (unsupported at the moment)
+     */
+    locale?: string;
+}
+
+interface MixedbreadOptions {
+    /**
+     * The ID of the vector store to search in
+     */
+    vectorStoreId: string;
+    /**
+     * The Mixedbread SDK client instance
+     */
+    client: Mixedbread;
+    /**
+     * Filter results with specific tag.
+     */
+    tag?: string;
+    /**
+     * Filter by locale (unsupported at the moment)
+     */
+    locale?: string;
 }
 
 interface UseDocsSearch {
@@ -55,15 +114,27 @@ type Client = ({
     type: 'algolia';
 } & AlgoliaOptions) | ({
     type: 'orama-cloud';
-} & OramaCloudOptions);
+} & OramaCloudOptions) | ({
+    type: 'mixedbread';
+} & MixedbreadOptions);
 /**
- * @param client - search client
- * @param locale - Filter with locale
- * @param tag - Filter with specific tag
- * @param delayMs - The debounced delay for performing a search.
- * @param allowEmpty - still perform search even if query is empty
- * @param key - cache key
+ * Provide a hook to query different official search clients.
+ *
+ * Note: it will re-query when its parameters changed, make sure to use `useCallback()` on functions passed to this hook.
  */
-declare function useDocsSearch(client: Client, locale?: string, tag?: string, delayMs?: number, allowEmpty?: boolean, key?: string): UseDocsSearch;
+declare function useDocsSearch(clientOptions: Client & {
+    /**
+     * The debounced delay for performing a search (in ms).
+     * .
+     * @defaultValue 100
+     */
+    delayMs?: number;
+    /**
+     * still perform search even if query is empty.
+     *
+     * @defaultValue false
+     */
+    allowEmpty?: boolean;
+}): UseDocsSearch;
 
 export { type AlgoliaOptions, type Client, type FetchOptions, type OramaCloudOptions, type StaticOptions, useDocsSearch };