fumadocs-core 15.6.12 → 15.7.0

package/dist/server/index.js

@@ -18,30 +18,30 @@ function getTableOfContents(content, remarkPlugins) {
 }
 
 // src/utils/page-tree.tsx
-function flattenTree(tree) {
-  return tree.flatMap((node) => {
-    if (node.type === "separator") return [];
+function flattenTree(nodes) {
+  const out = [];
+  for (const node of nodes) {
     if (node.type === "folder") {
-      const child = flattenTree(node.children);
-      if (node.index) return [node.index, ...child];
-      return child;
+      if (node.index) out.push(node.index);
+      out.push(...flattenTree(node.children));
+    } else if (node.type === "page") {
+      out.push(node);
     }
-    return [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);
-    for (let i = 0; i < list.length; i++) {
-      if (list[i].url === url) {
-        return {
-          next: list[i + 1],
-          previous: list[i - 1]
-        };
-      }
-    }
+    const idx = list.findIndex((item) => item.url === url);
+    if (idx === -1) continue;
+    return {
+      previous: list[idx - 1],
+      next: list[idx + 1]
+    };
   }
   return {};
 }
@@ -49,9 +49,7 @@ function getPageTreeRoots(pageTree) {
   const result = pageTree.children.flatMap((child) => {
     if (child.type !== "folder") return [];
     const roots = getPageTreeRoots(child);
-    if (child.root) {
-      roots.push(child);
-    }
+    if (child.root) roots.push(child);
     return roots;
   });
   if (!("type" in pageTree)) result.push(pageTree);
@@ -87,10 +85,13 @@ function findParentFromTree(node, url) {
       return node;
     }
   }
+  if ("fallback" in node && node.fallback) {
+    return findParentFromTree(node.fallback, url);
+  }
 }
 
-// src/server/page-tree.ts
-var page_tree_exports = {};
+// src/source/page-tree/definitions.ts
+var definitions_exports = {};
 
 // src/server/git-api.ts
 async function getGithubLastEdit({
@@ -190,7 +191,7 @@ function createMetadataImage(options) {
   };
 }
 export {
-  page_tree_exports as PageTree,
+  definitions_exports as PageTree,
   createMetadataImage,
   findNeighbour,
   flattenTree,

package/dist/source/index.d.ts

@@ -1,7 +1,6 @@
-import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { R as Root, I as Item, F as Folder, S as Separator } from '../definitions-Q95-psoo.js';
 import { I18nConfig } from '../i18n/index.js';
-import { R as Root, I as Item, F as Folder, S as Separator } from '../page-tree-bSt6K__E.js';
-import 'next/dist/server/web/types';
 
 /**
  * In memory file system.
@@ -9,22 +8,24 @@ import 'next/dist/server/web/types';
 declare class FileSystem<File> {
     files: Map<string, File>;
     folders: Map<string, string[]>;
-    constructor();
+    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(path: string): boolean;
+    deleteDir(path: string): boolean;
     getFiles(): string[];
     makeDir(path: string): void;
 }
 
 interface LoadOptions {
     transformers?: Transformer[];
-    buildFiles: (files: VirtualFile[]) => (MetaFile | PageFile)[];
+    buildFile: (file: VirtualFile) => MetaFile | PageFile;
 }
-type ContentStorage = FileSystem<MetaFile | PageFile>;
+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;
@@ -42,7 +43,21 @@ type Transformer = (context: {
     storage: ContentStorage;
     options: LoadOptions;
 }) => void;
-declare function loadFiles(files: VirtualFile[], options: LoadOptions): ContentStorage;
+declare const parsers: {
+    dir(path: string): [string, string?];
+    dot(path: string): [string, string?];
+    none(path: string): [string, string?];
+};
+/**
+ * @returns a map of locale and its content storage.
+ *
+ * in the storage, locale codes are removed from file paths, hence the same file will have same file paths in every storage.
+ */
+declare function loadFiles(files: VirtualFile[], options: LoadOptions, i18n: {
+    parser: keyof typeof parsers;
+    languages: string[];
+    defaultLanguage: string;
+}): Record<string, ContentStorage>;
 
 interface FileInfo {
     /**
@@ -86,7 +101,7 @@ declare function parseFolderPath(path: string): FolderInfo;
 
 interface LoaderConfig {
     source: SourceConfig;
-    i18n: boolean;
+    i18n: I18nConfig | undefined;
 }
 interface SourceConfig {
     pageData: PageData;
@@ -94,7 +109,7 @@ interface SourceConfig {
 }
 interface LoaderOptions<T extends SourceConfig = SourceConfig, I18n extends I18nConfig | undefined = I18nConfig | undefined> {
     baseUrl: string;
-    icon?: NonNullable<BuildPageTreeOptions['resolveIcon']>;
+    icon?: NonNullable<BaseOptions['resolveIcon']>;
     slugs?: (info: FileInfo) => string[];
     url?: UrlFn;
     source: Source<T>;
@@ -102,7 +117,7 @@ interface LoaderOptions<T extends SourceConfig = SourceConfig, I18n extends I18n
     /**
      * Additional options for page tree builder
      */
-    pageTree?: Partial<Omit<BuildPageTreeOptions<T['pageData'], T['metaData']>, 'storage'>>;
+    pageTree?: Partial<BaseOptions<T['pageData'], T['metaData']>>;
     /**
      * Configure i18n
      */
@@ -165,7 +180,7 @@ interface LanguageEntry<Data = PageData> {
     pages: Page<Data>[];
 }
 interface LoaderOutput<Config extends LoaderConfig> {
-    pageTree: Config['i18n'] extends true ? Record<string, Root> : Root;
+    pageTree: Config['i18n'] extends I18nConfig ? Record<string, Root> : Root;
     getPageTree: (locale?: string) => Root;
     getPageByHref: (href: string, options?: {
         language?: string;
@@ -204,7 +219,7 @@ interface LoaderOutput<Config extends LoaderConfig> {
 declare function createGetUrl(baseUrl: string, i18n?: I18nConfig): UrlFn;
 declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(options: LoaderOptions<Config, I18n>): LoaderOutput<{
     source: Config;
-    i18n: I18n extends I18nConfig ? true : false;
+    i18n: I18n;
 }>;
 /**
  * Convert file path into slugs, also encode non-ASCII characters, so they can work in pathname
@@ -231,34 +246,72 @@ type InferMetaType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput
  */
 type UrlFn = (slugs: string[], locale?: string) => string;
 
-interface BaseOptions<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+interface LegacyTransformerOptions<Page extends PageData, Meta extends MetaData> {
     /**
-     * Remove references to the file path of original nodes (`$ref`)
-     *
-     * @defaultValue false
+     * @deprecated use `transformers` instead
      */
-    noRef?: boolean;
     attachFile?: (node: Item, file?: PageFile<Page>) => Item;
+    /**
+     * @deprecated use `transformers` instead
+     */
     attachFolder?: (node: Folder, folder: {
         children: (PageFile<Page> | MetaFile<Meta>)[];
     }, meta?: MetaFile<Meta>) => Folder;
+    /**
+     * @deprecated use `transformers` instead
+     */
     attachSeparator?: (node: Separator) => Separator;
-    resolveIcon?: (icon: string | undefined) => ReactElement | undefined;
 }
-interface BuildPageTreeOptions<Page extends PageData = PageData, Meta extends MetaData = MetaData> extends BaseOptions<Page, Meta> {
-    storage: ContentStorage;
+
+interface PageTreeBuilderContext<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+    /**
+     * @internal
+     */
+    resolveName: (name: string, format: 'meta' | 'page') => string;
+    options: BaseOptions<Page, Meta>;
+    transformers: PageTreeTransformer<Page, Meta>[];
+    builder: PageTreeBuilder<Page, Meta>;
+    storage: ContentStorage<Page, Meta>;
+    getUrl: UrlFn;
+    storages?: Record<string, ContentStorage<Page, Meta>>;
+    locale?: string;
 }
-interface BuildPageTreeOptionsWithI18n<Page extends PageData = PageData, Meta extends MetaData = MetaData> extends BaseOptions<Page, Meta> {
-    storages: Record<string, ContentStorage>;
-    i18n: I18nConfig;
+interface PageTreeTransformer<Page extends PageData = any, Meta extends MetaData = any> {
+    name?: string;
+    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 BaseOptions<Page extends PageData = PageData, Meta extends MetaData = MetaData> extends LegacyTransformerOptions<Page, Meta> {
+    /**
+     * Remove references to the file path of original nodes (`$ref`)
+     *
+     * @defaultValue false
+     */
+    noRef?: boolean;
+    transformers?: PageTreeTransformer<Page, Meta>[];
+    resolveIcon?: (icon: string | undefined) => ReactNode | undefined;
 }
-interface PageTreeBuilder {
-    build: (options: BuildPageTreeOptions) => Root;
+interface PageTreeBuilder<Page extends PageData = PageData, Meta extends MetaData = MetaData> {
+    build: (options: BaseOptions<Page, Meta> & {
+        id?: string;
+        storage: ContentStorage<Page, Meta>;
+        /**
+         * generate fallback page tree
+         *
+         * @defaultValue true
+         */
+        generateFallback?: boolean;
+    }) => Root;
     /**
      * Build page tree and fallback to the default language if the localized page doesn't exist
      */
-    buildI18n: (options: BuildPageTreeOptionsWithI18n) => Record<string, Root>;
+    buildI18n: (options: BaseOptions<Page, Meta> & {
+        id?: string;
+        storages: Record<string, ContentStorage<Page, Meta>>;
+    }) => Record<string, Root>;
 }
 declare function createPageTreeBuilder(getUrl: UrlFn): PageTreeBuilder;
 
-export { type BuildPageTreeOptions, type BuildPageTreeOptionsWithI18n, type ContentStorage, type FileInfo, FileSystem, type FolderInfo, type InferMetaType, type InferPageType, type LanguageEntry, type LoadOptions, type LoaderConfig, type LoaderOptions, type LoaderOutput, type Meta, type MetaData, type MetaFile, type Page, type PageData, type PageFile, type PageTreeBuilder, type Source, type SourceConfig, type Transformer, type UrlFn, type VirtualFile, createGetUrl, createPageTreeBuilder, getSlugs, loadFiles, loader, parseFilePath, parseFolderPath };
+export { type BaseOptions, type ContentStorage, type FileInfo, FileSystem, type FolderInfo, type InferMetaType, type InferPageType, type LanguageEntry, type LoadOptions, type LoaderConfig, type LoaderOptions, type LoaderOutput, type Meta, type MetaData, type MetaFile, type Page, type PageData, type PageFile, type PageTreeBuilder, type PageTreeBuilderContext, type PageTreeTransformer, type Source, type SourceConfig, type Transformer, type UrlFn, type VirtualFile, createGetUrl, createPageTreeBuilder, getSlugs, loadFiles, loader, parseFilePath, parseFolderPath };