fumadocs-core 15.2.8 → 16.0.3

package/dist/chunk-IZPLHEX4.js

@@ -0,0 +1,113 @@
+// src/page-tree/utils.ts
+function flattenTree(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (node.type === "folder") {
+      if (node.index) out.push(node.index);
+      out.push(...flattenTree(node.children));
+    } else if (node.type === "page") {
+      out.push(node);
+    }
+  }
+  return out;
+}
+function findNeighbour(tree, url, options) {
+  const { separateRoot = true } = options ?? {};
+  const roots = separateRoot ? getPageTreeRoots(tree) : [tree];
+  if (tree.fallback) roots.push(tree.fallback);
+  for (const root of roots) {
+    const list = flattenTree(root.children);
+    const idx = list.findIndex((item) => item.url === url);
+    if (idx === -1) continue;
+    return {
+      previous: list[idx - 1],
+      next: list[idx + 1]
+    };
+  }
+  return {};
+}
+function getPageTreeRoots(pageTree) {
+  const result = pageTree.children.flatMap((child) => {
+    if (child.type !== "folder") return [];
+    const roots = getPageTreeRoots(child);
+    if (child.root) roots.push(child);
+    return roots;
+  });
+  if (!("type" in pageTree)) result.push(pageTree);
+  return result;
+}
+function getPageTreePeers(treeOrTrees, url) {
+  if ("children" in treeOrTrees) {
+    const tree = treeOrTrees;
+    const parent = findParentFromTree(tree, url);
+    if (!parent) return [];
+    return parent.children.filter(
+      (item) => item.type === "page" && item.url !== url
+    );
+  }
+  const trees = treeOrTrees;
+  for (const lang in trees) {
+    const rootTree = trees[lang];
+    if (rootTree) {
+      const parent = findParentFromTree(rootTree, url);
+      if (parent) {
+        return parent.children.filter(
+          (item) => item.type === "page" && item.url !== url
+        );
+      }
+    }
+  }
+  return [];
+}
+function findParentFromTree(node, url) {
+  if ("index" in node && node.index?.url === url) {
+    return node;
+  }
+  for (const child of node.children) {
+    if (child.type === "folder") {
+      const parent = findParentFromTree(child, url);
+      if (parent) return parent;
+    }
+    if (child.type === "page" && child.url === url) {
+      return node;
+    }
+  }
+  if ("fallback" in node && node.fallback) {
+    return findParentFromTree(node.fallback, url);
+  }
+}
+function findPath(nodes, matcher, options = {}) {
+  const { includeSeparator = true } = options;
+  function run(nodes2) {
+    let separator;
+    for (const node of nodes2) {
+      if (matcher(node)) {
+        const items = [];
+        if (separator) items.push(separator);
+        items.push(node);
+        return items;
+      }
+      if (node.type === "separator" && includeSeparator) {
+        separator = node;
+        continue;
+      }
+      if (node.type === "folder") {
+        const items = node.index && matcher(node.index) ? [node.index] : run(node.children);
+        if (items) {
+          items.unshift(node);
+          if (separator) items.unshift(separator);
+          return items;
+        }
+      }
+    }
+  }
+  return run(nodes) ?? null;
+}
+
+export {
+  flattenTree,
+  findNeighbour,
+  getPageTreeRoots,
+  getPageTreePeers,
+  findPath
+};

package/dist/chunk-OTD7MV33.js

@@ -0,0 +1,53 @@
+// src/search/index.ts
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildRegexFromQuery(q) {
+  const trimmed = q.trim();
+  if (trimmed.length === 0) return null;
+  const terms = Array.from(
+    new Set(
+      trimmed.split(/\s+/).map((t) => t.trim()).filter(Boolean)
+    )
+  );
+  if (terms.length === 0) return null;
+  const escaped = terms.map(escapeRegExp).join("|");
+  return new RegExp(`(${escaped})`, "gi");
+}
+function createContentHighlighter(query) {
+  const regex = typeof query === "string" ? buildRegexFromQuery(query) : query;
+  return {
+    highlight(content) {
+      if (!regex) return [{ type: "text", content }];
+      const out = [];
+      let i = 0;
+      for (const match of content.matchAll(regex)) {
+        if (i < match.index) {
+          out.push({
+            type: "text",
+            content: content.substring(i, match.index)
+          });
+        }
+        out.push({
+          type: "text",
+          content: match[0],
+          styles: {
+            highlight: true
+          }
+        });
+        i = match.index + match[0].length;
+      }
+      if (i < content.length) {
+        out.push({
+          type: "text",
+          content: content.substring(i)
+        });
+      }
+      return out;
+    }
+  };
+}
+
+export {
+  createContentHighlighter
+};

package/dist/chunk-PFNP6PEB.js

@@ -0,0 +1,11 @@
+// src/utils/normalize-url.tsx
+function normalizeUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) return url;
+  if (!url.startsWith("/")) url = "/" + url;
+  if (url.length > 1 && url.endsWith("/")) url = url.slice(0, -1);
+  return url;
+}
+
+export {
+  normalizeUrl
+};

package/dist/{chunk-Y2774T3B.js → chunk-QMATWJ5F.js}

@@ -24,25 +24,24 @@ function remarkHeading({
     visit(root, "heading", (heading) => {
       heading.data ||= {};
       heading.data.hProperties ||= {};
-      let id = heading.data.hProperties.id;
+      const props = heading.data.hProperties;
       const lastNode = heading.children.at(-1);
-      if (!id && lastNode?.type === "text" && customId) {
+      if (lastNode?.type === "text" && customId) {
         const match = regex.exec(lastNode.value);
         if (match?.[1]) {
-          id = match[1];
+          props.id = match[1];
           lastNode.value = lastNode.value.slice(0, match.index);
         }
       }
       let flattened = null;
-      if (!id) {
+      if (!props.id) {
         flattened ??= flattenNode(heading);
-        id = defaultSlug ? defaultSlug(root, heading, flattened) : slugger.slug(flattened);
+        props.id = defaultSlug ? defaultSlug(root, heading, flattened) : slugger.slug(flattened);
       }
-      heading.data.hProperties.id = id;
       if (generateToc) {
         toc.push({
           title: flattened ?? flattenNode(heading),
-          url: `#${id}`,
+          url: `#${props.id}`,
           depth: heading.depth
         });
       }

package/dist/chunk-U67V476Y.js

@@ -0,0 +1,35 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/{chunk-BUCUQ3WX.js → chunk-XN2LKXFZ.js}

@@ -1,66 +1,70 @@
 // src/highlight/shiki.ts
-import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+import {
+  toJsxRuntime
+} from "hast-util-to-jsx-runtime";
 import { Fragment } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-function createStyleTransformer() {
-  return {
-    name: "rehype-code:styles",
-    line(hast) {
-      if (hast.children.length === 0) {
-        hast.children.push({
-          type: "text",
-          value: " "
-        });
-      }
-    }
-  };
-}
 var defaultThemes = {
   light: "github-light",
   dark: "github-dark"
 };
 var highlighters = /* @__PURE__ */ new Map();
-async function _highlight(code, options) {
-  const { lang, components: _, engine, ...rest } = options;
-  let themes = { themes: defaultThemes };
+async function highlightHast(code, options) {
+  const {
+    lang: initialLang,
+    fallbackLanguage,
+    components: _,
+    engine = "js",
+    ...rest
+  } = options;
+  let lang = initialLang;
+  let themes;
+  let themesToLoad;
   if ("theme" in options && options.theme) {
     themes = { theme: options.theme };
-  } else if ("themes" in options && options.themes) {
-    themes = { themes: options.themes };
+    themesToLoad = [themes.theme];
+  } else {
+    themes = {
+      themes: "themes" in options && options.themes ? options.themes : defaultThemes
+    };
+    themesToLoad = Object.values(themes.themes).filter((v) => v !== void 0);
   }
-  const highlighter = await getHighlighter("custom", {
-    engine,
-    langs: [lang],
-    themes: "theme" in themes ? [themes.theme] : Object.values(themes.themes).filter((v) => v !== void 0)
+  const highlighter = await getHighlighter(engine, {
+    langs: [],
+    themes: themesToLoad
   });
+  try {
+    await highlighter.loadLanguage(lang);
+  } catch {
+    lang = fallbackLanguage ?? "text";
+    await highlighter.loadLanguage(lang);
+  }
   return highlighter.codeToHast(code, {
     lang,
     ...rest,
     ...themes,
-    transformers: [createStyleTransformer(), ...rest.transformers ?? []],
     defaultColor: "themes" in themes ? false : void 0
   });
 }
-function _renderHighlight(hast, options) {
+function hastToJsx(hast, options) {
   return toJsxRuntime(hast, {
     jsx,
     jsxs,
     development: false,
-    components: options?.components,
-    Fragment
+    Fragment,
+    ...options
   });
 }
 async function getHighlighter(engineType, options) {
   const { createHighlighter } = await import("shiki");
   let highlighter = highlighters.get(engineType);
   if (!highlighter) {
-    let engine = options.engine;
+    let engine;
     if (engineType === "js") {
       engine = import("shiki/engine/javascript").then(
         (res) => res.createJavaScriptRegexEngine()
       );
-    }
-    if (engineType === "oniguruma" || !engine) {
+    } else {
       engine = import("shiki/engine/oniguruma").then(
         (res) => res.createOnigurumaEngine(import("shiki/wasm"))
       );
@@ -83,14 +87,15 @@ async function getHighlighter(engineType, options) {
   });
 }
 async function highlight(code, options) {
-  return _renderHighlight(await _highlight(code, options), options);
+  return hastToJsx(await highlightHast(code, options), {
+    components: options.components
+  });
 }
 
 export {
-  createStyleTransformer,
   defaultThemes,
-  _highlight,
-  _renderHighlight,
+  highlightHast,
+  hastToJsx,
   getHighlighter,
   highlight
 };

package/dist/{chunk-WFUH5VBX.js → chunk-XOFXGHS4.js}

@@ -1,10 +1,14 @@
 import {
   removeUndefined
-} from "./chunk-KAOEMCTI.js";
+} from "./chunk-ZMWYLUDP.js";
+import {
+  createContentHighlighter
+} from "./chunk-OTD7MV33.js";
 
 // src/search/orama/search/simple.ts
 import { search } from "@orama/orama";
 async function searchSimple(db, query, params = {}) {
+  const highlighter = createContentHighlighter(query);
   const result = await search(db, {
     term: query,
     tolerance: 1,
@@ -17,6 +21,8 @@ async function searchSimple(db, query, params = {}) {
   return result.hits.map((hit) => ({
     type: "page",
     content: hit.document.title,
+    breadcrumbs: hit.document.breadcrumbs,
+    contentWithHighlights: highlighter.highlight(hit.document.title),
     id: hit.document.url,
     url: hit.document.url
   }));
@@ -24,38 +30,46 @@ async function searchSimple(db, query, params = {}) {
 
 // src/search/orama/search/advanced.ts
 import { getByID, search as search2 } from "@orama/orama";
-async function searchAdvanced(db, query, tag, extraParams = {}) {
+async function searchAdvanced(db, query, tag = [], {
+  mode = "fulltext",
+  ...override
+} = {}) {
+  if (typeof tag === "string") tag = [tag];
   let params = {
+    ...override,
+    mode,
     where: removeUndefined({
-      tag,
-      ...extraParams.where
+      tags: tag.length > 0 ? {
+        containsAll: tag
+      } : void 0,
+      ...override.where
     }),
     groupBy: {
       properties: ["page_id"],
       maxResult: 8,
-      ...extraParams.groupBy
+      ...override.groupBy
     }
   };
   if (query.length > 0) {
     params = {
       ...params,
       term: query,
-      properties: ["content", "keywords"],
-      ...extraParams,
-      where: params.where,
-      groupBy: params.groupBy
+      properties: mode === "fulltext" ? ["content"] : ["content", "embeddings"]
     };
   }
+  const highlighter = createContentHighlighter(query);
   const result = await search2(db, params);
   const list = [];
   for (const item of result.groups ?? []) {
     const pageId = item.values[0];
-    const page = await getByID(db, pageId);
+    const page = getByID(db, pageId);
     if (!page) continue;
     list.push({
       id: pageId,
       type: "page",
       content: page.content,
+      breadcrumbs: page.breadcrumbs,
+      contentWithHighlights: highlighter.highlight(page.content),
       url: page.url
     });
     for (const hit of item.result) {
@@ -63,6 +77,8 @@ async function searchAdvanced(db, query, tag, extraParams = {}) {
       list.push({
         id: hit.document.id.toString(),
         content: hit.document.content,
+        breadcrumbs: hit.document.breadcrumbs,
+        contentWithHighlights: highlighter.highlight(hit.document.content),
         type: hit.document.type,
         url: hit.document.url
       });

package/dist/chunk-XZSI7AHE.js

@@ -0,0 +1,67 @@
+import {
+  __export
+} from "./chunk-U67V476Y.js";
+
+// src/source/path.ts
+var path_exports = {};
+__export(path_exports, {
+  basename: () => basename,
+  dirname: () => dirname,
+  extname: () => extname,
+  joinPath: () => joinPath,
+  slash: () => slash,
+  splitPath: () => splitPath
+});
+function basename(path, ext) {
+  const idx = path.lastIndexOf("/");
+  return path.substring(
+    idx === -1 ? 0 : idx + 1,
+    ext ? path.length - ext.length : path.length
+  );
+}
+function extname(path) {
+  const dotIdx = path.lastIndexOf(".");
+  if (dotIdx !== -1) {
+    return path.substring(dotIdx);
+  }
+  return "";
+}
+function dirname(path) {
+  return path.split("/").slice(0, -1).join("/");
+}
+function splitPath(path) {
+  return path.split("/").filter((p) => p.length > 0);
+}
+function joinPath(...paths) {
+  const out = [];
+  const parsed = paths.flatMap(splitPath);
+  for (const seg of parsed) {
+    switch (seg) {
+      case "..":
+        out.pop();
+        break;
+      case ".":
+        break;
+      default:
+        out.push(seg);
+    }
+  }
+  return out.join("/");
+}
+function slash(path) {
+  const isExtendedLengthPath = path.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path;
+  }
+  return path.replaceAll("\\", "/");
+}
+
+export {
+  basename,
+  extname,
+  dirname,
+  splitPath,
+  joinPath,
+  slash,
+  path_exports
+};

package/dist/chunk-YVVDKJ2H.js

@@ -0,0 +1,34 @@
+// src/negotiation/index.ts
+import Negotiator from "negotiator";
+import { compile, match } from "path-to-regexp";
+function getNegotiator(request) {
+  const headers = {};
+  request.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return new Negotiator({ headers });
+}
+function rewritePath(source, destination) {
+  const matcher = match(source, { decode: false });
+  const compiler = compile(destination, { encode: false });
+  return {
+    rewrite(pathname) {
+      const result = matcher(pathname);
+      if (!result) return false;
+      return compiler(result.params);
+    }
+  };
+}
+function isMarkdownPreferred(request, options) {
+  const {
+    markdownMediaTypes = ["text/plain", "text/markdown", "text/x-markdown"]
+  } = options ?? {};
+  const mediaTypes = getNegotiator(request).mediaTypes();
+  return markdownMediaTypes.some((type) => mediaTypes.includes(type));
+}
+
+export {
+  getNegotiator,
+  rewritePath,
+  isMarkdownPreferred
+};

package/dist/chunk-ZMWYLUDP.js

@@ -0,0 +1,21 @@
+// src/utils/remove-undefined.ts
+function removeUndefined(value, deep = false) {
+  const obj = value;
+  for (const key in obj) {
+    if (obj[key] === void 0) delete obj[key];
+    if (!deep) continue;
+    const entry = obj[key];
+    if (typeof entry === "object" && entry !== null) {
+      removeUndefined(entry, deep);
+      continue;
+    }
+    if (Array.isArray(entry)) {
+      for (const item of entry) removeUndefined(item, deep);
+    }
+  }
+  return value;
+}
+
+export {
+  removeUndefined
+};

package/dist/content/github.d.ts

@@ -0,0 +1,34 @@
+interface GetGithubLastCommitOptions {
+    /**
+     * Repository name, like "fumadocs"
+     */
+    repo: string;
+    /** Owner of repository */
+    owner: string;
+    /**
+     * Path to file
+     */
+    path: string;
+    /**
+     * GitHub access token
+     */
+    token?: string;
+    /**
+     * SHA or ref (branch or tag) name.
+     */
+    sha?: string;
+    /**
+     * Custom query parameters
+     */
+    params?: Record<string, string>;
+    options?: RequestInit;
+}
+/**
+ * Get the last edit time of a file using GitHub API
+ *
+ * By default, this will cache the result forever.
+ * Set `options.next.revalidate` to customise this.
+ */
+declare function getGithubLastEdit({ repo, token, owner, path, sha, options, params: customParams, }: GetGithubLastCommitOptions): Promise<Date | null>;
+
+export { type GetGithubLastCommitOptions, getGithubLastEdit };

package/dist/content/github.js

@@ -0,0 +1,43 @@
+import "../chunk-U67V476Y.js";
+
+// src/content/github.ts
+async function getGithubLastEdit({
+  repo,
+  token,
+  owner,
+  path,
+  sha,
+  options = {},
+  params: customParams = {}
+}) {
+  const headers = new Headers(options.headers);
+  const params = new URLSearchParams();
+  params.set("path", path);
+  params.set("page", "1");
+  params.set("per_page", "1");
+  if (sha) params.set("sha", sha);
+  for (const [key, value] of Object.entries(customParams)) {
+    params.set(key, value);
+  }
+  if (token) {
+    headers.append("authorization", token);
+  }
+  const res = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/commits?${params.toString()}`,
+    {
+      cache: "force-cache",
+      ...options,
+      headers
+    }
+  );
+  if (!res.ok)
+    throw new Error(
+      `Failed to fetch last edit time from Git ${await res.text()}`
+    );
+  const data = await res.json();
+  if (data.length === 0) return null;
+  return new Date(data[0].commit.committer.date);
+}
+export {
+  getGithubLastEdit
+};

package/dist/content/index.d.ts

@@ -0,0 +1,16 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Compatible } from 'vfile';
+import { Components } from 'hast-util-to-jsx-runtime';
+import { PluggableList } from 'unified';
+
+interface MarkdownProps {
+    components?: Components;
+}
+declare function Markdown({ children: content, remarkPlugins, rehypePlugins, ...options }: MarkdownProps & {
+    remarkPlugins?: PluggableList;
+    rehypePlugins?: PluggableList;
+    children: Compatible;
+}): Promise<react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | (string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined)>;
+
+export { Markdown, type MarkdownProps };