fumadocs-core 13.4.9 → 14.0.0

package/dist/mdx-plugins/index.js

@@ -1,7 +1,7 @@
 import {
   flattenNode,
   remarkHeading
-} from "../chunk-UQV4A7HQ.js";
+} from "../chunk-4MNUWZIW.js";
 import {
   slash
 } from "../chunk-UWEEHUJV.js";
@@ -15,15 +15,16 @@ import {
 // src/mdx-plugins/rehype-code.ts
 import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
 import {
+  transformerNotationDiff,
   transformerNotationHighlight,
   transformerNotationWordHighlight
 } from "@shikijs/transformers";
 import {
   getSingletonHighlighter,
-  createJavaScriptRegexEngine,
-  createWasmOnigEngine,
   bundledLanguages
 } from "shiki";
+import { createOnigurumaEngine } from "shiki/engine/oniguruma";
+import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
 
 // src/mdx-plugins/transformer-icon.ts
 var defaultShortcuts = {
@@ -193,7 +194,8 @@ var rehypeCodeDefaultOptions = {
   defaultColor: false,
   transformers: [
     transformerNotationHighlight(),
-    transformerNotationWordHighlight()
+    transformerNotationWordHighlight(),
+    transformerNotationDiff()
   ],
   parseMetaString(meta) {
     const map = {};
@@ -255,22 +257,22 @@ function rehypeCode(options = {}) {
     themeItems = [codeOptions.theme];
   }
   const highlighter = getSingletonHighlighter({
-    engine: codeOptions.experimentalJSEngine ? createJavaScriptRegexEngine() : createWasmOnigEngine(import("shiki/wasm")),
+    engine: codeOptions.experimentalJSEngine ? createJavaScriptRegexEngine() : createOnigurumaEngine(() => import("shiki/wasm")),
     themes: themeItems.filter(Boolean),
     langs: codeOptions.langs ?? Object.keys(bundledLanguages)
   });
+  const transformer = highlighter.then(
+    (instance) => rehypeShikiFromHighlighter(instance, codeOptions)
+  );
   return async (tree, file) => {
-    const transformer = rehypeShikiFromHighlighter(
-      await highlighter,
-      codeOptions
-    );
-    await transformer(tree, file, () => {
+    await (await transformer)(tree, file, () => {
     });
   };
 }
 function transformerTab() {
   return {
     name: "rehype-code:tab",
+    // @ts-expect-error -- types not compatible with MDX
     root(root) {
       const meta = this.options.meta;
       if (typeof meta?.tab !== "string") return root;
@@ -295,7 +297,7 @@ function transformerTab() {
 }
 
 // src/mdx-plugins/remark-image.ts
-import path from "path";
+import path from "node:path";
 import { visit } from "unist-util-visit";
 import sizeOf from "image-size";
 var VALID_BLUR_EXT = [".jpeg", ".png", ".webp", ".avif", ".jpg"];
@@ -443,7 +445,6 @@ async function getImageSize(src, dir) {
 import Slugger from "github-slugger";
 import { remark } from "remark";
 import remarkGfm from "remark-gfm";
-import remarkMdx from "remark-mdx";
 import { visit as visit2 } from "unist-util-visit";
 var slugger = new Slugger();
 function remarkStructure({
@@ -487,7 +488,7 @@ function remarkStructure({
   };
 }
 function structure(content, remarkPlugins = [], options = {}) {
-  const result = remark().use(remarkGfm).use(remarkMdx).use(remarkPlugins).use(remarkStructure, options).processSync(content);
+  const result = remark().use(remarkGfm).use(remarkPlugins).use(remarkStructure, options).processSync(content);
   return result.data.structuredData;
 }
 
@@ -554,14 +555,139 @@ function remarkAdmonition(options = {}) {
     });
   };
 }
+
+// src/mdx-plugins/rehype-toc.ts
+import { toEstree } from "hast-util-to-estree";
+
+// src/mdx-plugins/hast-utils.ts
+function visit4(node, tagNames, handler) {
+  if (node.type === "element" && tagNames.includes(node.tagName)) {
+    const result = handler(node);
+    if (result === "skip") return;
+  }
+  if ("children" in node)
+    node.children.forEach((n) => {
+      visit4(n, tagNames, handler);
+    });
+}
+
+// src/mdx-plugins/rehype-toc.ts
+function rehypeToc({ exportToc = true } = {}) {
+  return (tree) => {
+    const output = [];
+    visit4(tree, ["h1", "h2", "h3", "h4", "h5", "h6"], (element) => {
+      const id = element.properties.id;
+      if (!id) return "skip";
+      const estree = toEstree(element, {
+        elementAttributeNameCase: "react",
+        stylePropertyNameCase: "dom"
+      });
+      if (estree.body[0].type === "ExpressionStatement")
+        output.push({
+          title: estree.body[0].expression,
+          depth: Number(element.tagName.slice(1)),
+          url: `#${id}`
+        });
+      return "skip";
+    });
+    const declaration = {
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: {
+            type: "Identifier",
+            name: "toc"
+          },
+          init: {
+            type: "ArrayExpression",
+            elements: output.map((item) => ({
+              type: "ObjectExpression",
+              properties: [
+                {
+                  type: "Property",
+                  method: false,
+                  shorthand: false,
+                  computed: false,
+                  key: {
+                    type: "Identifier",
+                    name: "depth"
+                  },
+                  value: {
+                    type: "Literal",
+                    value: item.depth
+                  },
+                  kind: "init"
+                },
+                {
+                  type: "Property",
+                  method: false,
+                  shorthand: false,
+                  computed: false,
+                  key: {
+                    type: "Identifier",
+                    name: "url"
+                  },
+                  value: {
+                    type: "Literal",
+                    value: item.url
+                  },
+                  kind: "init"
+                },
+                {
+                  type: "Property",
+                  method: false,
+                  shorthand: false,
+                  computed: false,
+                  key: {
+                    type: "Identifier",
+                    name: "title"
+                  },
+                  value: {
+                    type: "JSXFragment",
+                    openingFragment: { type: "JSXOpeningFragment" },
+                    closingFragment: { type: "JSXClosingFragment" },
+                    children: item.title.children
+                  },
+                  kind: "init"
+                }
+              ]
+            }))
+          }
+        }
+      ]
+    };
+    tree.children.push({
+      type: "mdxjsEsm",
+      value: "",
+      data: {
+        estree: {
+          type: "Program",
+          body: [
+            exportToc ? {
+              type: "ExportNamedDeclaration",
+              declaration,
+              specifiers: []
+            } : declaration
+          ],
+          sourceType: "module",
+          comments: []
+        }
+      }
+    });
+  };
+}
 export {
   rehypeCode,
   rehypeCodeDefaultOptions,
+  rehypeToc,
   remarkAdmonition,
   default2 as remarkGfm,
   remarkHeading,
   remarkImage,
   remarkStructure,
   structure,
-  transformerIcon
+  transformerIcon,
+  transformerTab
 };

package/dist/{page-tree-BTCDMLTU.d.ts → page-tree-r8qjoUla.d.ts}

@@ -11,18 +11,21 @@ interface Item {
     url: string;
     external?: boolean;
     icon?: ReactElement;
+    $ref?: {
+        file: string;
+    };
 }
 interface Separator {
     type: 'separator';
     name: ReactNode;
 }
 interface Folder {
-    /**
-     * Optional id to be attached to folders
-     */
-    id?: string;
+    $ref?: {
+        metaFile?: string;
+    };
     type: 'folder';
     name: ReactNode;
+    description?: ReactNode;
     root?: boolean;
     defaultOpen?: boolean;
     index?: Item;

package/dist/{search-algolia/server.d.ts → search/algolia.d.ts}

@@ -64,4 +64,4 @@ interface BaseIndex {
     content: string;
 }
 
-export { type BaseIndex, type SyncOptions, setIndexSettings, sync, updateDocuments };
+export { type BaseIndex, type DocumentRecord, type SyncOptions, setIndexSettings, sync, updateDocuments };

package/dist/{search-algolia/server.js → search/algolia.js}

@@ -1,6 +1,6 @@
 import "../chunk-MLKGABMK.js";
 
-// src/search-algolia/server.ts
+// src/search/algolia.ts
 async function sync(client, options) {
   const { document = "document", documents } = options;
   const index = client.initIndex(document);

package/dist/search/client.d.ts

@@ -1,19 +1,49 @@
-import { SWRResponse } from 'swr';
-import { SortedResult } from './shared.js';
+import { S as SortedResult } from '../types-Ch8gnVgO.js';
+import { SearchOptions } from '@algolia/client-search';
+import { SearchIndex } from 'algoliasearch/lite';
+
+interface FetchOptions {
+    /**
+     * API route for search endpoint
+     */
+    api?: string;
+}
+
+interface StaticOptions {
+    /**
+     * Where to download exported search indexes (URL)
+     */
+    from?: string;
+}
+
+interface AlgoliaOptions extends SearchOptions {
+    index: SearchIndex;
+}
 
 interface UseDocsSearch {
     search: string;
     setSearch: (v: string) => void;
-    query: SWRResponse<SortedResult[] | 'empty', Error, {
-        keepPreviousData: true;
-    }>;
+    query: {
+        isLoading: boolean;
+        data?: SortedResult[] | 'empty';
+        error?: Error;
+    };
 }
+type Client = ({
+    type: 'fetch';
+} & FetchOptions) | ({
+    type: 'static';
+} & StaticOptions) | ({
+    type: 'algolia';
+} & AlgoliaOptions);
 /**
+ * @param client - search client
  * @param locale - Filter with locale
  * @param tag - Filter with specific tag
- * @param api - The Search API URL
  * @param delayMs - The debounced delay for performing a search.
+ * @param allowEmpty - still perform search even if query is empty
+ * @param key - cache key
  */
-declare function useDocsSearch(locale?: string, tag?: string, api?: string, delayMs?: number): UseDocsSearch;
+declare function useDocsSearch(client: Client, locale?: string, tag?: string, delayMs?: number, allowEmpty?: boolean, key?: string): UseDocsSearch;
 
 export { useDocsSearch };

package/dist/search/client.js

@@ -1,32 +1,84 @@
 import {
-  useDebounce
-} from "../chunk-NREWOIVI.js";
+  useOnChange
+} from "../chunk-I5BWASD6.js";
 import "../chunk-MLKGABMK.js";
 
 // src/search/client.ts
-import { useState } from "react";
-import useSWR from "swr";
-async function fetchDocs(api, query, locale, tag) {
-  if (query.length === 0) return "empty";
-  const params = new URLSearchParams();
-  params.set("query", query);
-  if (locale) params.set("locale", locale);
-  if (tag) params.set("tag", tag);
-  const res = await fetch(`${api}?${params.toString()}`);
-  if (!res.ok) throw new Error(await res.text());
-  return await res.json();
+import { useMemo, useRef as useRef2, useState as useState2 } from "react";
+
+// src/utils/use-debounce.ts
+import { useRef, useState } from "react";
+function useDebounce(value, delayMs = 1e3) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  const timer = useRef();
+  if (delayMs === 0) return value;
+  if (value !== debouncedValue && timer.current?.value !== value) {
+    if (timer.current) clearTimeout(timer.current.handler);
+    const handler = window.setTimeout(() => {
+      setDebouncedValue(value);
+    }, delayMs);
+    timer.current = { value, handler };
+  }
+  return debouncedValue;
 }
-function useDocsSearch(locale, tag, api = "/api/search", delayMs = 100) {
-  const [search, setSearch] = useState("");
+
+// src/search/client.ts
+var cache = /* @__PURE__ */ new Map();
+var staticClient;
+function useDocsSearch(client, locale, tag, delayMs = 100, allowEmpty = false, key) {
+  const [search, setSearch] = useState2("");
+  const [results, setResults] = useState2("empty");
+  const [error, setError] = useState2();
+  const [isLoading, setIsLoading] = useState2(false);
   const debouncedValue = useDebounce(search, delayMs);
-  const query = useSWR(
-    [api, debouncedValue, locale, tag],
-    (args) => fetchDocs(...args),
-    {
-      keepPreviousData: true
+  const onStart = useRef2();
+  const cacheKey = useMemo(() => {
+    return key ?? JSON.stringify([client, debouncedValue, locale, tag]);
+  }, [client, debouncedValue, locale, tag, key]);
+  useOnChange(cacheKey, () => {
+    const cached = cache.get(cacheKey);
+    if (onStart.current) {
+      onStart.current();
+      onStart.current = void 0;
+    }
+    if (cached) {
+      setIsLoading(false);
+      setError(void 0);
+      setResults(cached);
+      return;
+    }
+    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-4K7QOPFM.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 { createStaticClient } = await import("../static-5GPJ7RUY.js");
+      if (!staticClient) staticClient = createStaticClient(client);
+      return staticClient.search(debouncedValue, locale, tag);
     }
-  );
-  return { search, setSearch, query };
+    void run().then((res) => {
+      cache.set(cacheKey, res);
+      if (interrupt) return;
+      setError(void 0);
+      setResults(res);
+    }).catch((err) => {
+      setError(err);
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  });
+  return { search, setSearch, query: { isLoading, data: results, error } };
 }
 export {
   useDocsSearch

package/dist/search/server.d.ts

@@ -1,64 +1,97 @@
+import { TypedDocument, Orama, Language, SearchParams, SorterConfig, Tokenizer, DefaultTokenizerConfig, OramaPlugin } from '@orama/orama';
 import { NextRequest } from 'next/server';
 import { S as StructuredData } from '../remark-structure-mP51W1AN.js';
-import { SortedResult } from './shared.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 'mdast';
 import 'unified';
 import 'unist-util-visit';
+import 'react';
+import '../page-tree-r8qjoUla.js';
 
-interface I18nSimpleOptions extends Omit<SimpleOptions, 'language' | 'indexes'> {
-    i18n: I18nConfig;
-    indexes: WithLocale<Index>[] | Dynamic<WithLocale<Index>>;
-}
-interface I18nAdvancedOptions extends Omit<AdvancedOptions, 'language' | 'indexes'> {
+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 schema>>;
+declare const schema: {
+    readonly url: "string";
+    readonly title: "string";
+    readonly description: "string";
+    readonly content: "string";
+    readonly keywords: "string";
+};
+
+type LocaleMap<O> = Record<string, Language | O>;
+type Options$1<O extends SimpleOptions | AdvancedOptions, Idx> = Omit<O, 'language' | 'indexes'> & {
     i18n: I18nConfig;
-    indexes: WithLocale<AdvancedIndex>[] | Dynamic<WithLocale<AdvancedIndex>>;
-}
+    /**
+     * Map locale name from i18n config to Orama compatible `language` or options
+     */
+    localeMap?: LocaleMap<Partial<O>>;
+    indexes: WithLocale<Idx>[] | Dynamic<WithLocale<Idx>>;
+};
+type I18nSimpleOptions = Options$1<SimpleOptions, Index>;
+type I18nAdvancedOptions = Options$1<AdvancedOptions, AdvancedIndex>;
 type WithLocale<T> = T & {
     locale: string;
 };
-declare function createI18nSearchAPI$1<T extends 'simple' | 'advanced'>(type: T, options: T extends 'simple' ? I18nSimpleOptions : I18nAdvancedOptions): SearchAPI;
+declare function createI18nSearchAPI<T extends 'simple' | 'advanced'>(type: T, options: T extends 'simple' ? I18nSimpleOptions : I18nAdvancedOptions): SearchAPI;
 
-type ToI18n<T extends {
-    indexes: unknown;
-}> = Omit<T, 'indexes' | 'language'> & {
-    indexes: ([language: string, indexes: T['indexes']] | {
-        language: string;
-        indexes: T['indexes'];
-    })[];
+type Options = Omit<AdvancedOptions, 'language' | 'indexes'> & {
+    localeMap?: LocaleMap<Partial<AdvancedOptions>>;
 };
-declare function createI18nSearchAPI<T extends 'simple' | 'advanced'>(type: T, options: T extends 'simple' ? ToI18n<SimpleOptions> : ToI18n<AdvancedOptions>): SearchAPI;
+declare function createFromSource<S extends LoaderOutput<LoaderConfig>>(source: S, pageToIndex?: (page: InferPageType<S>) => AdvancedIndex, options?: Options): SearchAPI;
 
 interface SearchServer {
     search: (query: string, options?: {
         locale?: string;
         tag?: string;
     }) => Promise<SortedResult[]>;
+    /**
+     * Export the database
+     *
+     * You can reference the exported database to implement client-side search
+     */
+    export: () => Promise<unknown>;
 }
 interface SearchAPI extends SearchServer {
     GET: (request: NextRequest) => Promise<Response>;
-    search: (query: string, options?: {
-        locale?: string;
-        tag?: string;
-    }) => Promise<SortedResult[]>;
+    /**
+     * `GET` route handler that exports search indexes for static search.
+     */
+    staticGET: () => Promise<Response>;
 }
 /**
  * Resolve indexes dynamically
  */
 type Dynamic<T> = () => T[] | Promise<T[]>;
-interface SimpleOptions {
-    indexes: Index[] | Dynamic<Index>;
+interface SharedOptions {
     language?: string;
+    sort?: SorterConfig;
+    tokenizer?: Tokenizer | DefaultTokenizerConfig;
+    plugins?: OramaPlugin[];
 }
-interface AdvancedOptions {
+interface SimpleOptions extends SharedOptions {
+    indexes: Index[] | Dynamic<Index>;
+    /**
+     * Customise search options on server
+     */
+    search?: Partial<SearchParams<Orama<typeof schema>, SimpleDocument>>;
+}
+interface AdvancedOptions extends SharedOptions {
     indexes: AdvancedIndex[] | Dynamic<AdvancedIndex>;
     /**
-     * Enable search tags for filtering results
-     *
-     * @defaultValue false
+     * Customise search options on server
      */
-    tag?: boolean;
-    language?: string;
+    search?: Partial<SearchParams<Orama<typeof advancedSchema>, AdvancedDocument>>;
 }
 declare function createSearchAPI<T extends 'simple' | 'advanced'>(type: T, options: T extends 'simple' ? SimpleOptions : AdvancedOptions): SearchAPI;
 interface Index {
@@ -68,7 +101,7 @@ interface Index {
     url: string;
     keywords?: string;
 }
-declare function initSimpleSearch({ indexes, language, }: SimpleOptions): SearchServer;
+declare function initSimpleSearch(options: SimpleOptions): SearchServer;
 interface AdvancedIndex {
     id: string;
     title: string;
@@ -84,6 +117,6 @@ interface AdvancedIndex {
     structuredData: StructuredData;
     url: string;
 }
-declare function initAdvancedSearch({ indexes, language, tag, }: AdvancedOptions): SearchServer;
+declare function initAdvancedSearch(options: AdvancedOptions): SearchServer;
 
-export { type AdvancedIndex, type AdvancedOptions, type Dynamic, type Index, type SearchAPI, type SearchServer, type SimpleOptions, createI18nSearchAPI, createI18nSearchAPI$1 as createI18nSearchAPIExperimental, createSearchAPI, initAdvancedSearch, initSimpleSearch };
+export { type AdvancedIndex, type AdvancedOptions, type Dynamic, type Index, type SearchAPI, type SearchServer, type SimpleOptions, createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };