fumadocs-core 13.4.9 → 14.0.0

package/dist/{search-algolia/client.js → algolia-NTWLS6J3.js}

@@ -1,11 +1,6 @@
-import {
-  useDebounce
-} from "../chunk-NREWOIVI.js";
-import "../chunk-MLKGABMK.js";
+import "./chunk-MLKGABMK.js";
 
-// src/search-algolia/client.ts
-import { useState } from "react";
-import useSWR from "swr";
+// src/search/client/algolia.ts
 function groupResults(hits) {
   const grouped = [];
   const scannedUrls = /* @__PURE__ */ new Set();
@@ -28,39 +23,27 @@ function groupResults(hits) {
   }
   return grouped;
 }
-async function searchDocs(index, query, options) {
+async function searchDocs(index, query, tag, options) {
+  let filters = options?.filters;
+  if (tag) filters = filters ? `tag:${tag} AND (${filters})` : `tag:${tag}`;
   if (query.length === 0) {
     const result2 = await index.search(query, {
       distinct: 1,
       hitsPerPage: 8,
-      ...options
+      ...options,
+      filters
     });
     return groupResults(result2.hits).filter((hit) => hit.type === "page");
   }
   const result = await index.search(query, {
     distinct: 5,
     hitsPerPage: 10,
-    ...options
+    ...options,
+    filters
   });
   return groupResults(result.hits);
 }
-function useAlgoliaSearch(index, { allowEmpty = true, delay = 150, ...options } = {}) {
-  const [search, setSearch] = useState("");
-  const debouncedValue = useDebounce(search, delay);
-  const query = useSWR(
-    ["algolia-search", debouncedValue, allowEmpty, options],
-    async () => {
-      if (allowEmpty && debouncedValue.length === 0) return "empty";
-      return searchDocs(index, debouncedValue, options);
-    },
-    {
-      keepPreviousData: true
-    }
-  );
-  return { search, setSearch, query };
-}
 export {
   groupResults,
-  searchDocs,
-  useAlgoliaSearch
+  searchDocs
 };

package/dist/breadcrumb.d.ts

@@ -1,11 +1,11 @@
 import { ReactNode } from 'react';
-import { R as Root } from './page-tree-BTCDMLTU.js';
+import { R as Root, N as Node, F as Folder, I as Item, S as Separator } from './page-tree-r8qjoUla.js';
 
 interface BreadcrumbItem {
     name: ReactNode;
     url?: string;
 }
-interface BreadcrumbOptions extends SearchOptions {
+interface BreadcrumbOptions {
     /**
      * Include the root itself in the breadcrumb items array.
      * Specify the url by passing an object instead
@@ -15,10 +15,6 @@ interface BreadcrumbOptions extends SearchOptions {
     includeRoot?: boolean | {
         url: string;
     };
-}
-declare function useBreadcrumb(url: string, tree: Root, options?: BreadcrumbOptions): BreadcrumbItem[];
-declare function getBreadcrumbItems(url: string, tree: Root, options?: BreadcrumbOptions): BreadcrumbItem[];
-interface SearchOptions {
     /**
      * Include the page itself in the breadcrumb items array
      *
@@ -32,5 +28,17 @@ interface SearchOptions {
      */
     includeSeparator?: boolean;
 }
+declare function useBreadcrumb(url: string, tree: Root, options?: BreadcrumbOptions): BreadcrumbItem[];
+declare function getBreadcrumbItems(url: string, tree: Root, options?: BreadcrumbOptions): BreadcrumbItem[];
+declare function getBreadcrumbItemsFromPath(tree: Root, path: Node[], options: BreadcrumbOptions): BreadcrumbItem[];
+/**
+ * Search the path of a node in the tree by a specified url
+ *
+ * - When the page doesn't exist, return null
+ *
+ * @returns The path to the target node from root
+ * @internal
+ */
+declare function searchPath(nodes: Node[], url: string): (Folder | Item | Separator)[] | null;
 
-export { type BreadcrumbItem, type BreadcrumbOptions, getBreadcrumbItems, useBreadcrumb };
+export { type BreadcrumbItem, type BreadcrumbOptions, getBreadcrumbItems, getBreadcrumbItemsFromPath, searchPath, useBreadcrumb };

package/dist/breadcrumb.js

@@ -9,50 +9,70 @@ function useBreadcrumb(url, tree, options) {
   );
 }
 function getBreadcrumbItems(url, tree, options = {}) {
-  const { includeRoot, ...rest } = options;
-  const path = searchPath(tree.children, url, rest) ?? [];
+  return getBreadcrumbItemsFromPath(
+    tree,
+    searchPath(tree.children, url) ?? [],
+    options
+  );
+}
+function getBreadcrumbItemsFromPath(tree, path, options) {
+  const { includePage = true, includeSeparator = false, includeRoot } = options;
+  let items = [];
+  path.forEach((item, i) => {
+    if (item.type === "separator" && includeSeparator) {
+      items.push({
+        name: item.name
+      });
+    }
+    if (item.type === "folder") {
+      const next = path.at(i + 1);
+      if (next && item.index === next) return;
+      if (item.root) {
+        items = [];
+        return;
+      }
+      items.push({
+        name: item.name,
+        url: item.index?.url
+      });
+    }
+    if (item.type === "page" && includePage) {
+      items.push({
+        name: item.name,
+        url: item.url
+      });
+    }
+  });
   if (includeRoot) {
-    path.unshift({
+    items.unshift({
       name: tree.name,
       url: typeof includeRoot === "object" ? includeRoot.url : void 0
     });
   }
-  return path;
+  return items;
 }
-function searchPath(nodes, url, options) {
-  const { includePage = true, includeSeparator = false } = options;
+function searchPath(nodes, url) {
   let separator;
   for (const node of nodes) {
-    if (includeSeparator && node.type === "separator") separator = node.name;
+    if (node.type === "separator") separator = node;
     if (node.type === "folder") {
       if (node.index?.url === url) {
         const items2 = [];
-        if (separator) items2.push({ name: separator });
-        if (options.includePage)
-          items2.push({
-            name: node.index.name,
-            url: node.index.url
-          });
+        if (separator) items2.push(separator);
+        items2.push(node, node.index);
         return items2;
       }
-      const items = searchPath(node.children, url, options);
+      const items = searchPath(node.children, url);
       if (items) {
-        items.unshift({
-          name: node.name,
-          url: node.index?.url
-        });
-        if (separator) items.unshift({ name: separator });
+        items.unshift(node);
+        if (separator) items.unshift(separator);
         return items;
       }
     }
     if (node.type === "page" && node.url === url) {
       const items = [];
-      if (separator) items.push({ name: separator });
-      if (includePage)
-        items.push({
-          name: node.name,
-          url: node.url
-        });
+      if (separator) items.push(separator);
+      items.push(node);
       return items;
     }
   }
@@ -60,5 +80,7 @@ function searchPath(nodes, url, options) {
 }
 export {
   getBreadcrumbItems,
+  getBreadcrumbItemsFromPath,
+  searchPath,
   useBreadcrumb
 };

package/dist/chunk-2V6SCS43.js

@@ -0,0 +1,12 @@
+// src/utils/remove-undefined.ts
+function removeUndefined(value) {
+  const obj = value;
+  Object.keys(obj).forEach((key) => {
+    if (obj[key] === void 0) delete obj[key];
+  });
+  return value;
+}
+
+export {
+  removeUndefined
+};

package/dist/chunk-2ZSMGYVH.js

@@ -0,0 +1,78 @@
+import {
+  removeUndefined
+} from "./chunk-2V6SCS43.js";
+
+// src/search/search/simple.ts
+import { search } from "@orama/orama";
+async function searchSimple(db, query, params = {}) {
+  const result = await search(db, {
+    term: query,
+    tolerance: 1,
+    ...params,
+    boost: {
+      title: 2,
+      ..."boost" in params ? params.boost : void 0
+    }
+  });
+  return result.hits.map((hit) => ({
+    type: "page",
+    content: hit.document.title,
+    id: hit.document.url,
+    url: hit.document.url
+  }));
+}
+
+// src/search/search/advanced.ts
+import { getByID, search as search2 } from "@orama/orama";
+async function searchAdvanced(db, query, tag, extraParams = {}) {
+  let params = {
+    where: removeUndefined({
+      tag,
+      ...extraParams.where
+    }),
+    groupBy: {
+      properties: ["page_id"],
+      maxResult: 8,
+      ...extraParams.groupBy
+    }
+  };
+  if (query.length > 0) {
+    params = {
+      ...params,
+      term: query,
+      tolerance: 1,
+      properties: ["content", "keywords"],
+      ...extraParams,
+      where: params.where,
+      groupBy: params.groupBy
+    };
+  }
+  const result = await search2(db, params);
+  const list = [];
+  for (const item of result.groups ?? []) {
+    const pageId = item.values[0];
+    const page = getByID(db, pageId);
+    if (!page) continue;
+    list.push({
+      id: pageId,
+      type: "page",
+      content: page.content,
+      url: page.url
+    });
+    for (const hit of item.result) {
+      if (hit.document.type === "page") continue;
+      list.push({
+        id: hit.document.id.toString(),
+        content: hit.document.content,
+        type: hit.document.type,
+        url: hit.document.url
+      });
+    }
+  }
+  return list;
+}
+
+export {
+  searchSimple,
+  searchAdvanced
+};

package/dist/{chunk-UQV4A7HQ.js → chunk-4MNUWZIW.js}

@@ -15,7 +15,8 @@ var slugger = new Slugger();
 var regex = /\s*\[#(?<slug>[^]+?)]\s*$/;
 function remarkHeading({
   slug: defaultSlug,
-  customId = true
+  customId = true,
+  generateToc = true
 } = {}) {
   return (root, file) => {
     const toc = [];
@@ -43,14 +44,15 @@ function remarkHeading({
         id = defaultSlug ? defaultSlug(root, heading, value) : slugger.slug(value);
       }
       heading.data.hProperties.id = id;
-      toc.push({
-        title: value,
-        url: `#${id}`,
-        depth: heading.depth
-      });
+      if (generateToc)
+        toc.push({
+          title: value,
+          url: `#${id}`,
+          depth: heading.depth
+        });
       return "skip";
     });
-    file.data.toc = toc;
+    if (generateToc) file.data.toc = toc;
   };
 }
 

package/dist/{chunk-KGMG4N3Y.js → chunk-I5BWASD6.js}

@@ -1,8 +1,8 @@
 // src/utils/use-on-change.ts
 import { useState } from "react";
-function useOnChange(value, onChange) {
+function useOnChange(value, onChange, isUpdated = (prev, current) => prev !== current) {
   const [prev, setPrev] = useState(value);
-  if (prev !== value) {
+  if (isUpdated(prev, value)) {
     onChange(value, prev);
     setPrev(value);
   }

package/dist/dynamic-link.js

@@ -14,7 +14,8 @@ var DynamicLink = forwardRef(
     const url = useMemo(() => {
       return href?.replace(/\[.*]/, (key) => {
         const mappedKey = key.slice(1, -1);
-        const value = mappedKey in params ? params[mappedKey] : "undefined";
+        const value = mappedKey in params ? params[mappedKey] : void 0;
+        if (!value) return "";
         return typeof value === "string" ? value : value.join("/");
       });
     }, [params, href]);

package/dist/fetch-4K7QOPFM.js

@@ -0,0 +1,17 @@
+import "./chunk-MLKGABMK.js";
+
+// src/search/client/fetch.ts
+async function fetchDocs(query, locale, tag, options) {
+  const params = new URLSearchParams();
+  params.set("query", query);
+  if (locale) params.set("locale", locale);
+  if (tag) params.set("tag", tag);
+  const res = await fetch(
+    `${options.api ?? "/api/search"}?${params.toString()}`
+  );
+  if (!res.ok) throw new Error(await res.text());
+  return await res.json();
+}
+export {
+  fetchDocs
+};

package/dist/i18n/index.js

@@ -1,7 +1,68 @@
-import {
-  createI18nMiddleware
-} from "../chunk-MXOJWF66.js";
 import "../chunk-MLKGABMK.js";
+
+// src/i18n/middleware.ts
+import { match as matchLocale } from "@formatjs/intl-localematcher";
+import Negotiator from "negotiator";
+import { NextResponse } from "next/server";
+var COOKIE = "FD_LOCALE";
+function getLocale(request, locales, defaultLanguage) {
+  const negotiatorHeaders = {};
+  request.headers.forEach((value, key) => negotiatorHeaders[key] = value);
+  const languages = new Negotiator({ headers: negotiatorHeaders }).languages(
+    locales
+  );
+  return matchLocale(languages, locales, defaultLanguage);
+}
+var defaultFormat = (locale, path) => {
+  return `/${locale}/${path}`;
+};
+function createI18nMiddleware({
+  languages,
+  defaultLanguage,
+  format = defaultFormat,
+  hideLocale = "never"
+}) {
+  function getUrl(request, pathname, locale) {
+    if (!locale) {
+      return new URL(
+        pathname.startsWith("/") ? pathname : `/${pathname}`,
+        request.url
+      );
+    }
+    return new URL(
+      format(locale, pathname.startsWith("/") ? pathname.slice(1) : pathname),
+      request.url
+    );
+  }
+  return (request) => {
+    const { pathname } = request.nextUrl;
+    const pathLocale = languages.find(
+      (locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`
+    );
+    if (!pathLocale) {
+      if (hideLocale === "default-locale") {
+        return NextResponse.rewrite(getUrl(request, pathname, defaultLanguage));
+      }
+      const preferred = getLocale(request, languages, defaultLanguage);
+      if (hideLocale === "always") {
+        const locale = request.cookies.get(COOKIE)?.value ?? preferred;
+        return NextResponse.rewrite(getUrl(request, pathname, locale));
+      }
+      return NextResponse.redirect(getUrl(request, pathname, preferred));
+    }
+    if (hideLocale === "always") {
+      const path = pathname.slice(`/${pathLocale}`.length);
+      const res = NextResponse.redirect(getUrl(request, path));
+      res.cookies.set(COOKIE, pathLocale);
+      return res;
+    }
+    if (hideLocale === "default-locale" && pathLocale === defaultLanguage) {
+      const path = pathname.slice(`/${pathLocale}`.length);
+      return NextResponse.redirect(getUrl(request, path));
+    }
+    return NextResponse.next();
+  };
+}
 export {
   createI18nMiddleware
 };

package/dist/mdx-plugins/index.d.ts

@@ -48,6 +48,7 @@ type RehypeCodeOptions = RehypeShikiOptions & {
  * Handle codeblocks
  */
 declare function rehypeCode(this: Processor, options?: Partial<RehypeCodeOptions>): Transformer<Root, Root>;
+declare function transformerTab(): ShikiTransformer;
 
 interface RemarkImageOptions {
     /**
@@ -98,16 +99,20 @@ interface RemarkHeadingOptions {
     /**
      * Allow custom headings ids
      *
-     * @defaultValue `true`
+     * @defaultValue true
      */
     customId?: boolean;
+    /**
+     * Attach an array of `TOCItemType` to `file.data.toc`
+     *
+     * @defaultValue true
+     */
+    generateToc?: boolean;
 }
 /**
  * Add heading ids and extract TOC
- *
- * Attach an array of `TOCItemType` to `file.data.toc`
  */
-declare function remarkHeading({ slug: defaultSlug, customId, }?: RemarkHeadingOptions): Transformer<Root$1, Root$1>;
+declare function remarkHeading({ slug: defaultSlug, customId, generateToc, }?: RemarkHeadingOptions): Transformer<Root$1, Root$1>;
 
 interface RemarkAdmonitionOptions {
     tag?: string;
@@ -124,4 +129,14 @@ interface RemarkAdmonitionOptions {
  */
 declare function remarkAdmonition(options?: RemarkAdmonitionOptions): Transformer<Root$1, Root$1>;
 
-export { type CodeBlockIcon, type RehypeCodeOptions, type RemarkAdmonitionOptions, type RemarkHeadingOptions, type RemarkImageOptions, rehypeCode, rehypeCodeDefaultOptions, remarkAdmonition, remarkHeading, remarkImage, transformerIcon };
+interface RehypeTocOptions {
+    /**
+     * Export generated toc as a variable
+     *
+     * @defaultValue true
+     */
+    exportToc?: boolean;
+}
+declare function rehypeToc(this: Processor, { exportToc }?: RehypeTocOptions): Transformer<Root, Root>;
+
+export { type CodeBlockIcon, type RehypeCodeOptions, type RehypeTocOptions, type RemarkAdmonitionOptions, type RemarkHeadingOptions, type RemarkImageOptions, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkHeading, remarkImage, transformerIcon, transformerTab };