fumadocs-core 15.2.8 → 16.0.3

package/README.md

@@ -2,4 +2,4 @@
 
 The core library for Fumadocs.
 
-📘 Learn More: [Documentation](https://fumadocs.vercel.app)
+📘 Learn More: [Documentation](https://fumadocs.dev)

package/dist/algolia-IZEDLPHE.js

@@ -0,0 +1,58 @@
+import {
+  createContentHighlighter
+} from "./chunk-OTD7MV33.js";
+import "./chunk-U67V476Y.js";
+
+// src/search/client/algolia.ts
+function groupResults(hits) {
+  const grouped = [];
+  const scannedUrls = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    if (!scannedUrls.has(hit.url)) {
+      scannedUrls.add(hit.url);
+      grouped.push({
+        id: hit.url,
+        type: "page",
+        breadcrumbs: hit.breadcrumbs,
+        url: hit.url,
+        content: hit.title
+      });
+    }
+    grouped.push({
+      id: hit.objectID,
+      type: hit.content === hit.section ? "heading" : "text",
+      url: hit.section_id ? `${hit.url}#${hit.section_id}` : hit.url,
+      content: hit.content
+    });
+  }
+  return grouped;
+}
+async function searchDocs(query, { indexName, onSearch, client, locale, tag }) {
+  if (query.trim().length === 0) return [];
+  const result = onSearch ? await onSearch(query, tag, locale) : await client.searchForHits({
+    requests: [
+      {
+        type: "default",
+        indexName,
+        query,
+        distinct: 5,
+        hitsPerPage: 10,
+        filters: tag ? `tag:${tag}` : void 0
+      }
+    ]
+  });
+  const highlighter = createContentHighlighter(query);
+  return groupResults(result.results[0].hits).flatMap((hit) => {
+    if (hit.type === "page") {
+      return {
+        ...hit,
+        contentWithHighlights: hit.contentWithHighlights ?? highlighter.highlight(hit.content)
+      };
+    }
+    return [];
+  });
+}
+export {
+  groupResults,
+  searchDocs
+};

package/dist/breadcrumb.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { R as Root, N as Node } from './page-tree-BG3wP0gU.js';
+import { R as Root, N as Node } from './definitions-BRsJlZ6m.js';
 
 interface BreadcrumbItem {
     name: ReactNode;
@@ -7,18 +7,20 @@ interface BreadcrumbItem {
 }
 interface BreadcrumbOptions {
     /**
-     * Include the root itself in the breadcrumb items array.
-     * Specify the url by passing an object instead
+     * Include the root folders in the breadcrumb items array.
      *
      * @defaultValue false
      */
     includeRoot?: boolean | {
+        /**
+         * Specify the url of root
+         */
         url: string;
     };
     /**
      * Include the page itself in the breadcrumb items array
      *
-     * @defaultValue true
+     * @defaultValue false
      */
     includePage?: boolean;
     /**
@@ -37,7 +39,7 @@ declare function getBreadcrumbItemsFromPath(tree: Root, path: Node[], options: B
  * - When the page doesn't exist, return null
  *
  * @returns The path to the target node from root
- * @internal
+ * @internal Don't use this on your own
  */
 declare function searchPath(nodes: Node[], url: string): Node[] | null;
 

package/dist/breadcrumb.js

@@ -1,4 +1,10 @@
-import "./chunk-MLKGABMK.js";
+import {
+  normalizeUrl
+} from "./chunk-PFNP6PEB.js";
+import {
+  findPath
+} from "./chunk-IZPLHEX4.js";
+import "./chunk-U67V476Y.js";
 
 // src/breadcrumb.tsx
 import { useMemo } from "react";
@@ -16,33 +22,42 @@ function getBreadcrumbItems(url, tree, options = {}) {
   );
 }
 function getBreadcrumbItemsFromPath(tree, path, options) {
-  const { includePage = true, includeSeparator = false, includeRoot } = options;
+  const {
+    includePage = false,
+    includeSeparator = false,
+    includeRoot = false
+  } = options;
   let items = [];
-  path.forEach((item, i) => {
-    if (item.type === "separator" && includeSeparator) {
-      items.push({
-        name: item.name
-      });
+  for (let i = 0; i < path.length; i++) {
+    const item = path[i];
+    switch (item.type) {
+      case "page":
+        if (includePage)
+          items.push({
+            name: item.name,
+            url: item.url
+          });
+        break;
+      case "folder":
+        if (item.root && !includeRoot) {
+          items = [];
+          break;
+        }
+        if (i === path.length - 1 || item.index !== path[i + 1]) {
+          items.push({
+            name: item.name,
+            url: item.index?.url
+          });
+        }
+        break;
+      case "separator":
+        if (item.name && includeSeparator)
+          items.push({
+            name: item.name
+          });
+        break;
     }
-    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) {
     items.unshift({
       name: tree.name,
@@ -52,32 +67,11 @@ function getBreadcrumbItemsFromPath(tree, path, options) {
   return items;
 }
 function searchPath(nodes, url) {
-  if (url.endsWith("/")) url = url.slice(0, -1);
-  let separator;
-  for (const node of nodes) {
-    if (node.type === "separator") separator = node;
-    if (node.type === "folder") {
-      if (node.index?.url === url) {
-        const items2 = [];
-        if (separator) items2.push(separator);
-        items2.push(node, node.index);
-        return items2;
-      }
-      const items = searchPath(node.children, url);
-      if (items) {
-        items.unshift(node);
-        if (separator) items.unshift(separator);
-        return items;
-      }
-    }
-    if (node.type === "page" && node.url === url) {
-      const items = [];
-      if (separator) items.push(separator);
-      items.push(node);
-      return items;
-    }
-  }
-  return null;
+  const normalizedUrl = normalizeUrl(url);
+  return findPath(
+    nodes,
+    (node) => node.type === "page" && node.url === normalizedUrl
+  );
 }
 export {
   getBreadcrumbItems,

package/dist/builder-feW_xVjc.d.ts

@@ -0,0 +1,296 @@
+import { R as Root, I as Item, F as Folder, S as Separator } from './definitions-BRsJlZ6m.js';
+import { I18nConfig } from './i18n/index.js';
+import { ReactNode } from 'react';
+
+interface LoaderPlugin<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+    name?: string;
+    /**
+     * Change the order of plugin:
+     * - `pre`: before normal plugins
+     * - `post`: after normal plugins
+     */
+    enforce?: 'pre' | 'post';
+    /**
+     * receive & replace loader options
+     */
+    config?: (config: ResolvedLoaderConfig) => ResolvedLoaderConfig | void | undefined;
+    /**
+     * transform the storage after loading
+     */
+    transformStorage?: (context: {
+        storage: ContentStorage<Page, Meta>;
+    }) => void;
+    /**
+     * transform the generated page tree
+     */
+    transformPageTree?: PageTreeTransformer<Page, Meta>;
+}
+declare function buildPlugins(plugins: (LoaderPlugin | LoaderPlugin[] | undefined)[]): LoaderPlugin[];
+
+type IconResolver = (icon: string | undefined) => ReactNode;
+
+interface LoaderConfig {
+    source: SourceConfig;
+    i18n: I18nConfig | undefined;
+}
+interface SourceConfig {
+    pageData: PageData;
+    metaData: MetaData;
+}
+interface LoaderOptions<S extends SourceConfig = SourceConfig, I18n extends I18nConfig | undefined = I18nConfig | undefined> {
+    baseUrl: string;
+    i18n?: I18n;
+    url?: UrlFn;
+    /**
+     * Additional options for page tree builder
+     */
+    pageTree?: PageTreeOptions<S['pageData'], S['metaData']>;
+    plugins?: (LoaderPlugin<S['pageData'], S['metaData']> | LoaderPlugin<S['pageData'], S['metaData']>[] | undefined)[];
+    icon?: IconResolver;
+    slugs?: (info: {
+        path: string;
+    }) => string[];
+}
+interface ResolvedLoaderConfig {
+    source: Source;
+    url: UrlFn;
+    plugins?: LoaderPlugin[];
+    pageTree?: PageTreeOptions;
+    i18n?: I18nConfig | undefined;
+}
+interface Source<Config extends SourceConfig = SourceConfig> {
+    files: VirtualFile<Config>[];
+}
+interface SharedFileInfo {
+    /**
+     * Virtualized file path (relative to content directory)
+     *
+     * @example `docs/page.mdx`
+     */
+    path: string;
+    /**
+     * Absolute path of the file (can be empty)
+     */
+    absolutePath: string;
+}
+interface Page<Data = PageData> extends SharedFileInfo {
+    slugs: string[];
+    url: string;
+    data: Data;
+    locale?: string | undefined;
+}
+interface Meta<Data = MetaData> extends SharedFileInfo {
+    data: Data;
+}
+interface LoaderOutput<Config extends LoaderConfig> {
+    pageTree: Config['i18n'] extends I18nConfig ? Record<string, Root> : Root;
+    getPageTree: (locale?: string) => Root;
+    getPageByHref: (href: string, options?: {
+        language?: string;
+        /**
+         * resolve relative file paths in `href` from specified dirname, must be a virtual path.
+         */
+        dir?: string;
+    }) => {
+        page: Page<Config['source']['pageData']>;
+        hash?: string;
+    } | undefined;
+    /**
+     * @internal
+     */
+    _i18n?: I18nConfig;
+    /**
+     * Get a list of pages from specified language
+     *
+     * @param language - If empty, list pages from all languages.
+     */
+    getPages: (language?: string) => Page<Config['source']['pageData']>[];
+    /**
+     * get each language and its pages, empty if i18n is not enabled.
+     */
+    getLanguages: () => {
+        language: string;
+        pages: Page<Config['source']['pageData']>[];
+    }[];
+    /**
+     * Get page with slugs
+     *
+     * @param language - If empty, the default language will be used
+     */
+    getPage: (slugs: string[] | undefined, language?: string) => Page<Config['source']['pageData']> | undefined;
+    getNodePage: (node: Item, language?: string) => Page<Config['source']['pageData']> | undefined;
+    getNodeMeta: (node: Folder, language?: string) => Meta<Config['source']['metaData']> | undefined;
+    /**
+     * generate static params for Next.js SSG
+     *
+     * @param slug - customise parameter name for slugs
+     * @param lang - customise parameter name for lang
+     */
+    generateParams: <TSlug extends string = 'slug', TLang extends string = 'lang'>(slug?: TSlug, lang?: TLang) => (Record<TSlug, string[]> & Record<TLang, string>)[];
+}
+declare function createGetUrl(baseUrl: string, i18n?: I18nConfig): UrlFn;
+declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(source: Source<Config>, options: LoaderOptions<NoInfer<Config>, I18n>): LoaderOutput<{
+    source: Config;
+    i18n: I18n;
+}>;
+declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(options: LoaderOptions<NoInfer<Config>, I18n> & {
+    source: Source<Config>;
+}): LoaderOutput<{
+    source: Config;
+    i18n: I18n;
+}>;
+type _ConfigUnion_<T extends Record<string, Source>> = {
+    [K in keyof T]: T[K] extends Source<infer Config> ? {
+        pageData: Config['pageData'] & {
+            type: K;
+        };
+        metaData: Config['metaData'] & {
+            type: K;
+        };
+    } : never;
+}[keyof T];
+declare function multiple<T extends Record<string, Source>>(sources: T): Source<_ConfigUnion_<T>>;
+/**
+ * map virtual files in source
+ */
+declare function map<Config extends SourceConfig>(source: Source<Config>): {
+    page<$Page extends PageData>(fn: (entry: VirtualPage<Config["pageData"]>) => VirtualPage<$Page>): Source<{
+        pageData: $Page;
+        metaData: Config["metaData"];
+    }>;
+    meta<$Meta extends MetaData>(fn: (entry: VirtualMeta<Config["metaData"]>) => VirtualMeta<$Meta>): Source<{
+        pageData: Config["pageData"];
+        metaData: $Meta;
+    }>;
+};
+
+interface MetaData {
+    icon?: string | undefined;
+    title?: string | undefined;
+    root?: boolean | undefined;
+    pages?: string[] | undefined;
+    defaultOpen?: boolean | undefined;
+    description?: string | undefined;
+}
+interface PageData {
+    icon?: string | undefined;
+    title?: string;
+    description?: string | undefined;
+}
+interface BaseVirtualFile {
+    /**
+     * Virtualized path (relative to content directory)
+     *
+     * @example `docs/page.mdx`
+     */
+    path: string;
+    /**
+     * Absolute path of the file
+     */
+    absolutePath?: string;
+}
+interface VirtualPage<Data extends PageData> extends BaseVirtualFile {
+    type: 'page';
+    /**
+     * Specified Slugs for page
+     */
+    slugs?: string[];
+    data: Data;
+}
+interface VirtualMeta<Data extends MetaData> extends BaseVirtualFile {
+    type: 'meta';
+    data: Data;
+}
+type VirtualFile<Config extends SourceConfig = SourceConfig> = VirtualPage<Config['pageData']> | VirtualMeta<Config['metaData']>;
+type InferPageType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Page<Config['source']['pageData']> : never;
+type InferMetaType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Meta<Config['source']['metaData']> : never;
+/**
+ * @internal
+ */
+type UrlFn = (slugs: string[], locale?: string) => string;
+
+/**
+ * In memory file system.
+ */
+declare class FileSystem<File> {
+    files: Map<string, File>;
+    folders: Map<string, string[]>;
+    constructor(inherit?: FileSystem<File>);
+    read(path: string): File | undefined;
+    /**
+     * get the direct children of folder (in virtual file path)
+     */
+    readDir(path: string): string[] | undefined;
+    write(path: string, file: File): void;
+    /**
+     * Delete files at specified path.
+     *
+     * @param path - the target path.
+     * @param [recursive=false] - if set to `true`, it will also delete directories.
+     */
+    delete(path: string, recursive?: boolean): boolean;
+    getFiles(): string[];
+    makeDir(path: string): void;
+}
+
+type ContentStorage<Page extends PageData = PageData, Meta extends MetaData = MetaData> = FileSystem<MetaFile<Meta> | PageFile<Page>>;
+interface MetaFile<Data extends MetaData = MetaData> {
+    path: string;
+    absolutePath: string;
+    format: 'meta';
+    data: Data;
+}
+interface PageFile<Data extends PageData = PageData> {
+    path: string;
+    absolutePath: string;
+    format: 'page';
+    slugs: string[];
+    data: Data;
+}
+
+interface PageTreeBuilderContext<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+    /**
+     * @internal resolve paths without extensions
+     */
+    resolveName: (name: string, format: 'meta' | 'page') => string;
+    options: PageTreeOptions;
+    transformers: PageTreeTransformer<Page, Meta>[];
+    builder: PageTreeBuilder;
+    storage: ContentStorage<Page, Meta>;
+    getUrl: UrlFn;
+    storages?: Record<string, ContentStorage<Page, Meta>>;
+    locale?: string;
+    visitedPaths: Set<string>;
+}
+interface PageTreeTransformer<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+    file?: (this: PageTreeBuilderContext<Page, Meta>, node: Item, filePath?: string) => Item;
+    folder?: (this: PageTreeBuilderContext<Page, Meta>, node: Folder, folderPath: string, metaPath?: string) => Folder;
+    separator?: (this: PageTreeBuilderContext<Page, Meta>, node: Separator) => Separator;
+    root?: (this: PageTreeBuilderContext<Page, Meta>, node: Root) => Root;
+}
+interface PageTreeOptions<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+    id?: string;
+    /**
+     * Remove references to the file path of original nodes (`$ref`)
+     *
+     * @defaultValue false
+     */
+    noRef?: boolean;
+    /**
+     * generate fallback page tree
+     *
+     * @defaultValue true
+     */
+    generateFallback?: boolean;
+    /**
+     * Additional page tree transformers to apply
+     */
+    transformers?: PageTreeTransformer<Page, Meta>[];
+}
+interface PageTreeBuilder {
+    build: (storage: ContentStorage, options?: PageTreeOptions) => Root;
+    buildI18n: (storages: Record<string, ContentStorage>, options?: PageTreeOptions) => Record<string, Root>;
+}
+declare function createPageTreeBuilder(getUrl: UrlFn, plugins?: LoaderPlugin[]): PageTreeBuilder;
+
+export { type ContentStorage as C, FileSystem as F, type InferPageType as I, type LoaderPlugin as L, type MetaFile as M, type PageTreeTransformer as P, type ResolvedLoaderConfig as R, type SourceConfig as S, type UrlFn as U, type VirtualPage as V, type _ConfigUnion_ as _, type PageTreeBuilder as a, type PageTreeBuilderContext as b, createPageTreeBuilder as c, type PageTreeOptions as d, type PageFile as e, type LoaderConfig as f, type LoaderOptions as g, type Source as h, type Page as i, type Meta as j, type LoaderOutput as k, createGetUrl as l, loader as m, multiple as n, map as o, type MetaData as p, type PageData as q, type VirtualMeta as r, type VirtualFile as s, type InferMetaType as t, buildPlugins as u };

package/dist/{chunk-FVY6EZ3N.js → chunk-BBP7MIO4.js}

@@ -12,24 +12,22 @@ var FrameworkContext = createContext("FrameworkContext", {
   usePathname: notImplemented
 });
 function FrameworkProvider({
-  children,
-  ...props
+  Link: Link2,
+  useRouter: useRouter2,
+  useParams: useParams2,
+  usePathname: usePathname2,
+  Image: Image2,
+  children
 }) {
   const framework = React.useMemo(
     () => ({
-      usePathname: props.usePathname,
-      useRouter: props.useRouter,
-      Link: props.Link,
-      Image: props.Image,
-      useParams: props.useParams
+      usePathname: usePathname2,
+      useRouter: useRouter2,
+      Link: Link2,
+      Image: Image2,
+      useParams: useParams2
     }),
-    [
-      props.Link,
-      props.usePathname,
-      props.useRouter,
-      props.useParams,
-      props.Image
-    ]
+    [Link2, usePathname2, useRouter2, useParams2, Image2]
   );
   return /* @__PURE__ */ jsx(FrameworkContext.Provider, { value: framework, children });
 }

package/dist/{chunk-ORHEEQVY.js → chunk-EMWGTXSW.js}

@@ -4,13 +4,6 @@ function isDifferent(a, b) {
   if (Array.isArray(a) && Array.isArray(b)) {
     return b.length !== a.length || a.some((v, i) => isDifferent(v, b[i]));
   }
-  if (typeof a === "object" && a && typeof b === "object" && b) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    return aKeys.length !== bKeys.length || aKeys.some(
-      (key) => isDifferent(a[key], b[key])
-    );
-  }
   return a !== b;
 }
 function useOnChange(value, onChange, isUpdated = isDifferent) {

package/dist/chunk-FAEPKD7U.js

@@ -0,0 +1,20 @@
+// src/source/plugins/icon.ts
+function iconPlugin(resolveIcon) {
+  function replaceIcon(node) {
+    if (node.icon === void 0 || typeof node.icon === "string")
+      node.icon = resolveIcon(node.icon);
+    return node;
+  }
+  return {
+    name: "fumadocs:icon",
+    transformPageTree: {
+      file: replaceIcon,
+      folder: replaceIcon,
+      separator: replaceIcon
+    }
+  };
+}
+
+export {
+  iconPlugin
+};

package/dist/{chunk-NNKVN7WA.js → chunk-H2GMUTQG.js}

@@ -1,6 +1,6 @@
 import {
   Link
-} from "./chunk-FVY6EZ3N.js";
+} from "./chunk-BBP7MIO4.js";
 
 // src/link.tsx
 import { forwardRef } from "react";
@@ -8,7 +8,9 @@ import { jsx } from "react/jsx-runtime";
 var Link2 = forwardRef(
   ({
     href = "#",
-    external = !(href.startsWith("/") || href.startsWith("#") || href.startsWith(".")),
+    // any protocol
+    external = href.match(/^\w+:/) || // protocol relative URL
+    href.startsWith("//"),
     prefetch,
     ...props
   }, ref) => {