fumadocs-core 15.2.8 → 16.0.3

package/dist/content/index.js

@@ -0,0 +1,30 @@
+import "../chunk-U67V476Y.js";
+
+// src/content/index.ts
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+import remarkRehype from "remark-rehype";
+import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+import * as JsxRuntime from "react/jsx-runtime";
+function rehypeReact(options = {}) {
+  this.compiler = (tree, file) => {
+    return toJsxRuntime(tree, {
+      development: false,
+      filePath: file.path,
+      ...JsxRuntime,
+      ...options
+    });
+  };
+}
+async function Markdown({
+  children: content,
+  remarkPlugins = [],
+  rehypePlugins = [],
+  ...options
+}) {
+  const processor = remark().use(remarkGfm).use(remarkPlugins).use(remarkRehype).use(rehypePlugins).use(rehypeReact, options);
+  return (await processor.process(content)).result;
+}
+export {
+  Markdown
+};

package/dist/{get-toc-Cr2URuiP.d.ts → content/toc.d.ts}

@@ -1,25 +1,21 @@
-import { ReactNode } from 'react';
 import { PluggableList } from 'unified';
 import { Compatible } from 'vfile';
+import { TOCItemType } from '../toc.js';
+import 'react';
+import 'react/jsx-runtime';
 
-interface TOCItemType {
-    title: ReactNode;
-    url: string;
-    depth: number;
-}
-type TableOfContents = TOCItemType[];
 /**
  * Get Table of Contents from markdown/mdx document (using remark)
  *
  * @param content - Markdown content or file
  */
-declare function getTableOfContents(content: Compatible): TableOfContents;
+declare function getTableOfContents(content: Compatible): TOCItemType[];
 /**
  * Get Table of Contents from markdown/mdx document (using remark)
  *
  * @param content - Markdown content or file
  * @param remarkPlugins - remark plugins to be applied first
  */
-declare function getTableOfContents(content: Compatible, remarkPlugins: PluggableList): Promise<TableOfContents>;
+declare function getTableOfContents(content: Compatible, remarkPlugins: PluggableList): Promise<TOCItemType[]>;
 
-export { type TableOfContents as T, type TOCItemType as a, getTableOfContents as g };
+export { getTableOfContents };

package/dist/content/toc.js

@@ -0,0 +1,21 @@
+import {
+  remarkHeading
+} from "../chunk-QMATWJ5F.js";
+import "../chunk-U67V476Y.js";
+
+// src/content/toc.ts
+import { remark } from "remark";
+function getTableOfContents(content, remarkPlugins) {
+  if (remarkPlugins) {
+    return remark().use(remarkPlugins).use(remarkHeading).process(content).then((result2) => {
+      if ("toc" in result2.data) return result2.data.toc;
+      return [];
+    });
+  }
+  const result = remark().use(remarkHeading).processSync(content);
+  if ("toc" in result.data) return result.data.toc;
+  return [];
+}
+export {
+  getTableOfContents
+};

package/dist/{page-tree-BG3wP0gU.d.ts → definitions-BRsJlZ6m.d.ts}

@@ -1,9 +1,13 @@
-import { ReactNode, ReactElement } from 'react';
+import { ReactNode } from 'react';
 
 interface Root {
     $id?: string;
     name: ReactNode;
     children: Node[];
+    /**
+     * Another page tree that won't be displayed unless being opened.
+     */
+    fallback?: Root;
 }
 type Node = Item | Separator | Folder;
 interface Item {
@@ -19,13 +23,13 @@ interface Item {
     url: string;
     external?: boolean;
     description?: ReactNode;
-    icon?: ReactElement;
+    icon?: ReactNode;
 }
 interface Separator {
     $id?: string;
     type: 'separator';
-    name: ReactNode;
-    icon?: ReactElement;
+    name?: ReactNode;
+    icon?: ReactNode;
 }
 interface Folder {
     $id?: string;
@@ -41,17 +45,8 @@ interface Folder {
     root?: boolean;
     defaultOpen?: boolean;
     index?: Item;
-    icon?: ReactElement;
+    icon?: ReactNode;
     children: Node[];
 }
 
-type pageTree_Folder = Folder;
-type pageTree_Item = Item;
-type pageTree_Node = Node;
-type pageTree_Root = Root;
-type pageTree_Separator = Separator;
-declare namespace pageTree {
-  export type { pageTree_Folder as Folder, pageTree_Item as Item, pageTree_Node as Node, pageTree_Root as Root, pageTree_Separator as Separator };
-}
-
-export { type Folder as F, type Item as I, type Node as N, type Root as R, type Separator as S, pageTree as p };
+export type { Folder as F, Item as I, Node as N, Root as R, Separator as S };

package/dist/dynamic-link.js

@@ -1,11 +1,11 @@
 "use client";
 import {
   Link
-} from "./chunk-NNKVN7WA.js";
+} from "./chunk-H2GMUTQG.js";
 import {
   useParams
-} from "./chunk-FVY6EZ3N.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-BBP7MIO4.js";
+import "./chunk-U67V476Y.js";
 
 // src/dynamic-link.tsx
 import { forwardRef, useMemo } from "react";

package/dist/fetch-2XFMBLBA.js

@@ -0,0 +1,22 @@
+import "./chunk-U67V476Y.js";
+
+// src/search/client/fetch.ts
+var cache = /* @__PURE__ */ new Map();
+async function fetchDocs(query, { api = "/api/search", locale, tag }) {
+  const url = new URL(api, window.location.origin);
+  url.searchParams.set("query", query);
+  if (locale) url.searchParams.set("locale", locale);
+  if (tag)
+    url.searchParams.set("tag", Array.isArray(tag) ? tag.join(",") : tag);
+  const key = `${url.pathname}?${url.searchParams}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const res = await fetch(key);
+  if (!res.ok) throw new Error(await res.text());
+  const result = await res.json();
+  cache.set(key, result);
+  return result;
+}
+export {
+  fetchDocs
+};

package/dist/framework/index.d.ts

@@ -29,7 +29,7 @@ interface Framework {
     }>;
     Image?: FC<ImageProps>;
 }
-declare function FrameworkProvider({ children, ...props }: Framework & {
+declare function FrameworkProvider({ Link, useRouter, useParams, usePathname, Image, children, }: Framework & {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 declare function usePathname(): string;

package/dist/framework/index.js

@@ -7,8 +7,8 @@ import {
   useParams,
   usePathname,
   useRouter
-} from "../chunk-FVY6EZ3N.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-BBP7MIO4.js";
+import "../chunk-U67V476Y.js";
 export {
   FrameworkProvider,
   Image,

package/dist/framework/next.js

@@ -1,8 +1,8 @@
 "use client";
 import {
   FrameworkProvider
-} from "../chunk-FVY6EZ3N.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-BBP7MIO4.js";
+import "../chunk-U67V476Y.js";
 
 // src/framework/next.tsx
 import { useParams, usePathname, useRouter } from "next/navigation";

package/dist/framework/react-router.js

@@ -1,7 +1,7 @@
 import {
   FrameworkProvider
-} from "../chunk-FVY6EZ3N.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-BBP7MIO4.js";
+import "../chunk-U67V476Y.js";
 
 // src/framework/react-router.tsx
 import { useMemo } from "react";

package/dist/framework/tanstack.js

@@ -1,7 +1,7 @@
 import {
   FrameworkProvider
-} from "../chunk-FVY6EZ3N.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-BBP7MIO4.js";
+import "../chunk-U67V476Y.js";
 
 // src/framework/tanstack.tsx
 import { useMemo } from "react";

package/dist/framework/waku.d.ts

@@ -0,0 +1,8 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+declare function WakuProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+export { WakuProvider };

package/dist/framework/waku.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  FrameworkProvider
+} from "../chunk-BBP7MIO4.js";
+import "../chunk-U67V476Y.js";
+
+// src/framework/waku.tsx
+import { useMemo } from "react";
+import { Link as WakuLink, useRouter } from "waku";
+import { jsx } from "react/jsx-runtime";
+var framework = {
+  usePathname() {
+    const { path } = useRouter();
+    return path;
+  },
+  useParams() {
+    const { query } = useRouter();
+    return useMemo(() => {
+      const params = new URLSearchParams(query);
+      return Object.fromEntries(
+        Array.from(params.entries()).map(([key, value]) => [
+          key,
+          Array.isArray(value) ? value[0] : value
+        ])
+      );
+    }, [query]);
+  },
+  useRouter() {
+    const router = useRouter();
+    return useMemo(
+      () => ({
+        push(url) {
+          void router.push(url);
+        },
+        refresh() {
+          void router.push(router.path);
+        }
+      }),
+      [router]
+    );
+  },
+  Link({ href, prefetch: _prefetch, ...props }) {
+    return /* @__PURE__ */ jsx(WakuLink, { to: href, ...props, children: props.children });
+  }
+};
+function WakuProvider({ children }) {
+  return /* @__PURE__ */ jsx(FrameworkProvider, { ...framework, children });
+}
+export {
+  WakuProvider
+};

package/dist/hide-if-empty.d.ts

@@ -0,0 +1,18 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, HTMLAttributes, FC } from 'react';
+
+declare function HideIfEmptyProvider({ nonce, children, }: {
+    nonce?: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * The built-in CSS `:empty` selector cannot detect if the children is hidden, classes such as `md:hidden` causes it to fail.
+ * This component is an enhancement to `empty:hidden` to fix the issue described above.
+ *
+ * This can be expensive, please avoid this whenever possible.
+ */
+declare function HideIfEmpty<Props extends HTMLAttributes<HTMLElement>>({ as: Comp, ...props }: Props & {
+    as: FC<Props>;
+}): react_jsx_runtime.JSX.Element;
+
+export { HideIfEmpty, HideIfEmptyProvider };

package/dist/hide-if-empty.js

@@ -0,0 +1,83 @@
+"use client";
+import "./chunk-U67V476Y.js";
+
+// src/hide-if-empty.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useId,
+  useMemo,
+  useState
+} from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var Context = createContext({
+  nonce: void 0
+});
+function HideIfEmptyProvider({
+  nonce,
+  children
+}) {
+  return /* @__PURE__ */ jsx(Context.Provider, { value: useMemo(() => ({ nonce }), [nonce]), children });
+}
+function getElement(id) {
+  return document.querySelector(`[data-fd-if-empty="${id}"]`);
+}
+function isEmpty(node) {
+  for (let i = 0; i < node.childNodes.length; i++) {
+    const child = node.childNodes.item(i);
+    if (child.nodeType === Node.TEXT_NODE || child.nodeType === Node.ELEMENT_NODE && window.getComputedStyle(child).display !== "none") {
+      return false;
+    }
+  }
+  return true;
+}
+function HideIfEmpty({
+  as: Comp,
+  ...props
+}) {
+  const id = useId();
+  const { nonce } = useContext(Context);
+  const [empty, setEmpty] = useState(() => {
+    const element = typeof window !== "undefined" ? getElement(id) : null;
+    if (element) return isEmpty(element);
+  });
+  useEffect(() => {
+    const handleResize = () => {
+      const element = getElement(id);
+      if (element) setEmpty(isEmpty(element));
+    };
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [id]);
+  const init = (id2) => {
+    const element = getElement(id2);
+    if (element) {
+      element.hidden = isEmpty(element);
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Comp,
+      {
+        ...props,
+        "data-fd-if-empty": id,
+        hidden: empty ?? false
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "script",
+      {
+        suppressHydrationWarning: true,
+        nonce,
+        dangerouslySetInnerHTML: {
+          __html: `{${getElement};${isEmpty};(${init})("${id}")}`
+        }
+      }
+    )
+  ] });
+}
+export {
+  HideIfEmpty,
+  HideIfEmptyProvider
+};

package/dist/highlight/client.d.ts

@@ -1,12 +1,15 @@
-import { ReactNode, DependencyList } from 'react';
+import { DependencyList, ReactNode } from 'react';
 import { HighlightOptions } from './index.js';
 import 'shiki';
 import 'shiki/themes';
 import 'hast-util-to-jsx-runtime';
+import 'hast';
 
-declare function useShiki(code: string, { defaultValue, withPrerenderScript, ...options }: HighlightOptions & {
-    withPrerenderScript?: boolean;
-    defaultValue?: ReactNode;
-}, deps?: DependencyList): ReactNode;
+/**
+ * get highlighted results, should be used with React Suspense API.
+ *
+ * note: results are cached with (lang, code) as keys, if this is not the desired behaviour, pass a `deps` instead.
+ */
+declare function useShiki(code: string, options: HighlightOptions, deps?: DependencyList): ReactNode;
 
 export { useShiki };

package/dist/highlight/client.js

@@ -1,101 +1,17 @@
 "use client";
 import {
-  _highlight,
-  _renderHighlight,
   highlight
-} from "../chunk-BUCUQ3WX.js";
-import "../chunk-MLKGABMK.js";
+} from "../chunk-XN2LKXFZ.js";
+import "../chunk-U67V476Y.js";
 
 // src/highlight/client.tsx
-import {
-  useId,
-  useMemo,
-  useRef,
-  use,
-  useState,
-  useLayoutEffect
-} from "react";
-import { jsx } from "react/jsx-runtime";
-var jsEngine;
-function getHighlightOptions(from) {
-  if (from.engine) return from;
-  if (!jsEngine) {
-    jsEngine = import("shiki/engine/javascript").then(
-      (res) => res.createJavaScriptRegexEngine()
-    );
-  }
-  return {
-    ...from,
-    engine: jsEngine
-  };
-}
-function useShiki(code, {
-  defaultValue,
-  withPrerenderScript = false,
-  ...options
-}, deps) {
-  const markupId = useId();
-  const key = useMemo(
-    () => deps ? JSON.stringify(deps) : `${options.lang}:${code}`,
-    [code, deps, options.lang]
-  );
-  const shikiOptions = getHighlightOptions(options);
-  const currentTask = useRef({
-    key,
-    aborted: false
-  });
-  const [rendered, setRendered] = useState(() => {
-    if (defaultValue) return defaultValue;
-    const element = withPrerenderScript && typeof document !== "undefined" ? document.querySelector(`[data-markup-id="${markupId}"]`) : null;
-    const attr = element?.getAttribute("data-markup");
-    if (attr) {
-      const hast = JSON.parse(attr);
-      return renderHighlightWithMarkup(markupId, hast, shikiOptions, attr);
-    }
-    currentTask.current = void 0;
-    const Pre = options.components?.pre ?? "pre";
-    const Code = options.components?.code ?? "code";
-    return /* @__PURE__ */ jsx(Pre, { children: /* @__PURE__ */ jsx(Code, { children: code }) });
-  });
-  useLayoutEffect(() => {
-    if (currentTask.current?.key === key) return;
-    if (currentTask.current) {
-      currentTask.current.aborted = true;
-    }
-    const task = {
-      key,
-      aborted: false
-    };
-    currentTask.current = task;
-    void highlight(code, shikiOptions).then((result) => {
-      if (!task.aborted) setRendered(result);
-    });
-  }, [key]);
-  if (typeof window === "undefined") {
-    return use(
-      _highlight(code, shikiOptions).then(
-        (tree) => renderHighlightWithMarkup(markupId, tree, shikiOptions)
-      )
-    );
-  }
-  return rendered;
-}
-function renderHighlightWithMarkup(id, tree, shikiOptions, rawAttr) {
-  const Pre = shikiOptions.components?.pre ?? "pre";
-  return _renderHighlight(tree, {
-    ...shikiOptions,
-    components: {
-      ...shikiOptions.components,
-      pre: (props) => /* @__PURE__ */ jsx(
-        Pre,
-        {
-          ...props,
-          "data-markup-id": id,
-          "data-markup": rawAttr ?? JSON.stringify(tree)
-        }
-      )
-    }
-  });
+import { use, useMemo } from "react";
+var promises = {};
+function useShiki(code, options, deps) {
+  const key = useMemo(() => {
+    return deps ? JSON.stringify(deps) : `${options.lang}:${code}`;
+  }, [code, deps, options.lang]);
+  return use(promises[key] ??= highlight(code, options));
 }
 export {
   useShiki

package/dist/highlight/index.d.ts

@@ -1,15 +1,30 @@
-import { CodeToHastOptionsCommon, BundledLanguage, CodeOptionsMeta, Awaitable, RegexEngine, CodeOptionsThemes, ShikiTransformer } from 'shiki';
+import { CodeToHastOptionsCommon, BundledLanguage, CodeOptionsMeta, CodeOptionsThemes, BundledHighlighterOptions, Highlighter } from 'shiki';
 import { BundledTheme } from 'shiki/themes';
-import { Components } from 'hast-util-to-jsx-runtime';
+import { Components, Options } from 'hast-util-to-jsx-runtime';
 import { ReactNode } from 'react';
+import { Root } from 'hast';
 
-declare function createStyleTransformer(): ShikiTransformer;
 type HighlightOptionsCommon = CodeToHastOptionsCommon<BundledLanguage> & CodeOptionsMeta & {
-    engine?: Awaitable<RegexEngine>;
+    /**
+     * The Regex Engine for Shiki
+     *
+     * @defaultValue 'js'
+     */
+    engine?: 'js' | 'oniguruma';
     components?: Partial<Components>;
+    fallbackLanguage?: BundledLanguage;
 };
 type HighlightOptionsThemes = CodeOptionsThemes<BundledTheme>;
 type HighlightOptions = HighlightOptionsCommon & (HighlightOptionsThemes | Record<never, never>);
+declare function highlightHast(code: string, options: HighlightOptions): Promise<Root>;
+declare function hastToJsx(hast: Root, options?: Partial<Options>): JSX.Element;
+/**
+ * Get Shiki highlighter instance of Fumadocs (mostly for internal use, you should use Shiki directly over this).
+ *
+ * @param engineType - Shiki Regex engine to use.
+ * @param options - Shiki options.
+ */
+declare function getHighlighter(engineType: 'js' | 'oniguruma', options: Omit<BundledHighlighterOptions<BundledLanguage, BundledTheme>, 'engine'>): Promise<Highlighter>;
 declare function highlight(code: string, options: HighlightOptions): Promise<ReactNode>;
 
-export { type HighlightOptions, type HighlightOptionsCommon, type HighlightOptionsThemes, createStyleTransformer, highlight };
+export { type HighlightOptions, type HighlightOptionsCommon, type HighlightOptionsThemes, getHighlighter, hastToJsx, highlight, highlightHast };

package/dist/highlight/index.js

@@ -1,9 +1,13 @@
 import {
-  createStyleTransformer,
-  highlight
-} from "../chunk-BUCUQ3WX.js";
-import "../chunk-MLKGABMK.js";
+  getHighlighter,
+  hastToJsx,
+  highlight,
+  highlightHast
+} from "../chunk-XN2LKXFZ.js";
+import "../chunk-U67V476Y.js";
 export {
-  createStyleTransformer,
-  highlight
+  getHighlighter,
+  hastToJsx,
+  highlight,
+  highlightHast
 };

package/dist/i18n/index.d.ts

@@ -1,12 +1,39 @@
-import { I as I18nConfig } from '../config-inq6kP6y.js';
-import { NextMiddleware } from 'next/dist/server/web/types';
-
-interface MiddlewareOptions extends I18nConfig {
+interface I18nConfig<Languages extends string = string> {
+    /**
+     * Supported locale codes.
+     *
+     * A page tree will be built for each language.
+     */
+    languages: Languages[];
+    /**
+     * Default locale if not specified
+     */
+    defaultLanguage: Languages;
+    /**
+     * Don't show the locale prefix on URL.
+     *
+     * - `always`: Always hide the prefix
+     * - `default-locale`: Only hide the default locale
+     * - `never`: Never hide the prefix
+     *
+     * This API uses `NextResponse.rewrite`.
+     *
+     * @defaultValue 'never'
+     */
+    hideLocale?: 'always' | 'default-locale' | 'never';
+    /**
+     * Used by `loader()`, specify the way to parse i18n file structure.
+     *
+     * @defaultValue 'dot'
+     */
+    parser?: 'dot' | 'dir' | 'none';
     /**
-     * A function that adds the locale prefix to path name
+     * the fallback language when the page has no translations available for a given locale.
+     *
+     * Default to ``defaultLanguage`, no fallback when set to `null`.
      */
-    format?: (locale: string, path: string) => string;
+    fallbackLanguage?: Languages | null;
 }
-declare function createI18nMiddleware({ languages, defaultLanguage, format, hideLocale, }: MiddlewareOptions): NextMiddleware;
+declare function defineI18n<Languages extends string>(config: I18nConfig<Languages>): I18nConfig<Languages>;
 
-export { I18nConfig, createI18nMiddleware };
+export { type I18nConfig, defineI18n };