fumadocs-core 15.6.12 → 15.7.0

package/dist/source/index.js

@@ -1,3 +1,8 @@
+import {
+  joinPath,
+  slash,
+  splitPath
+} from "../chunk-3JSIVMCJ.js";
 import {
   basename,
   dirname,
@@ -5,14 +10,72 @@ import {
   parseFilePath,
   parseFolderPath
 } from "../chunk-7GNSIKII.js";
-import {
-  joinPath,
-  slash,
-  splitPath
-} from "../chunk-3JSIVMCJ.js";
 import "../chunk-JSBRDJBE.js";
 
-// src/source/page-tree-builder.ts
+// src/source/page-tree/legacy.ts
+function legacyTransformer(transformer) {
+  return {
+    file(node, file) {
+      if (!transformer.attachFile) return node;
+      const content = file ? this.storage.read(file) : void 0;
+      return transformer.attachFile(
+        node,
+        content?.format === "page" ? content : void 0
+      );
+    },
+    folder(node, folderPath, metaPath) {
+      if (!transformer.attachFolder) return node;
+      const files = this.storage.readDir(folderPath) ?? [];
+      const meta = metaPath ? this.storage.read(metaPath) : void 0;
+      return transformer.attachFolder(
+        node,
+        {
+          children: files.flatMap((file) => this.storage.read(file) ?? [])
+        },
+        meta?.format === "meta" ? meta : void 0
+      );
+    },
+    separator(node) {
+      if (!transformer.attachSeparator) return node;
+      return transformer.attachSeparator(node);
+    }
+  };
+}
+
+// src/source/page-tree/transformer-fallback.ts
+function transformerFallback() {
+  const addedFiles = /* @__PURE__ */ new Set();
+  return {
+    name: "fumadocs:fallback",
+    root(root) {
+      const isolatedStorage = new FileSystem();
+      for (const file of this.storage.getFiles()) {
+        if (addedFiles.has(file)) continue;
+        const content = this.storage.read(file);
+        if (content) isolatedStorage.write(file, content);
+      }
+      if (isolatedStorage.getFiles().length === 0) return root;
+      root.fallback = this.builder.build({
+        ...this.options,
+        id: `fallback-${root.$id ?? ""}`,
+        storage: isolatedStorage,
+        generateFallback: false
+      });
+      addedFiles.clear();
+      return root;
+    },
+    file(node, file) {
+      if (file) addedFiles.add(file);
+      return node;
+    },
+    folder(node, _dir, metaPath) {
+      if (metaPath) addedFiles.add(metaPath);
+      return node;
+    }
+  };
+}
+
+// src/source/page-tree/builder.ts
 var group = /^\((?<name>.+)\)$/;
 var link = /^(?:\[(?<icon>[^\]]+)])?\[(?<name>[^\]]+)]\((?<url>[^)]+)\)$/;
 var separator = /^---(?:\[(?<icon>[^\]]+)])?(?<name>.+)---|^---$/;
@@ -42,26 +105,34 @@ function resolveFolderItem(folderPath, item, ctx, idx, restNodePaths) {
   const { options, resolveName } = ctx;
   let match = separator.exec(item);
   if (match?.groups) {
-    const node = {
+    let node = {
       $id: `${folderPath}#${idx}`,
       type: "separator",
       icon: options.resolveIcon?.(match.groups.icon),
       name: match.groups.name
     };
-    return [options.attachSeparator?.(node) ?? node];
+    for (const transformer of ctx.transformers) {
+      if (!transformer.separator) continue;
+      node = transformer.separator.call(ctx, node);
+    }
+    return [node];
   }
   match = link.exec(item);
   if (match?.groups) {
     const { icon, url, name } = match.groups;
     const isRelative = url.startsWith("/") || url.startsWith("#") || url.startsWith(".");
-    const node = {
+    let node = {
       type: "page",
       icon: options.resolveIcon?.(icon),
       name,
       url,
       external: !isRelative
     };
-    return [options.attachFile?.(node) ?? node];
+    for (const transformer of ctx.transformers) {
+      if (!transformer.file) continue;
+      node = transformer.file.call(ctx, node);
+    }
+    return [node];
   }
   const isExcept = item.startsWith(excludePrefix);
   const isExtract = !isExcept && item.startsWith(extractPrefix);
@@ -82,24 +153,27 @@ function resolveFolderItem(folderPath, item, ctx, idx, restNodePaths) {
   return fileNode ? [fileNode] : [];
 }
 function buildFolderNode(folderPath, isGlobalRoot, ctx) {
-  const { storage, localeStorage, options, resolveName } = ctx;
+  const { storage, options, resolveName, transformers } = ctx;
   const files = storage.readDir(folderPath);
   if (!files) return;
   const metaPath = resolveName(joinPath(folderPath, "meta"), "meta");
   const indexPath = resolveName(joinPath(folderPath, "index"), "page");
-  let meta = localeStorage?.read(metaPath) ?? storage.read(metaPath);
+  let meta = storage.read(metaPath);
   if (meta?.format !== "meta") {
     meta = void 0;
   }
-  const isRoot = meta?.data.root ?? isGlobalRoot;
-  let indexDisabled = false;
+  let indexDisabled = meta?.data.root ?? isGlobalRoot;
   let children;
   if (!meta?.data.pages) {
-    children = buildAll(files, ctx, (file) => isRoot || file !== indexPath);
+    children = buildAll(
+      files,
+      ctx,
+      (file) => indexDisabled || file !== indexPath
+    );
   } else {
     const restItems = new Set(files);
     const resolved = meta.data.pages.flatMap((item, i) => resolveFolderItem(folderPath, item, ctx, i, restItems));
-    if (!isRoot && !restItems.has(indexPath)) {
+    if (!indexDisabled && !restItems.has(indexPath)) {
       indexDisabled = true;
     }
     for (let i = 0; i < resolved.length; i++) {
@@ -108,8 +182,7 @@ function buildFolderNode(folderPath, isGlobalRoot, ctx) {
       const items = buildAll(
         files,
         ctx,
-        // index files are not included in ... unless it's a root folder
-        (file) => (file !== indexPath || isRoot) && restItems.has(file),
+        (file) => (indexDisabled || file !== indexPath) && restItems.has(file),
         item === restReversed
       );
       resolved.splice(i, 1, ...items);
@@ -123,7 +196,7 @@ function buildFolderNode(folderPath, isGlobalRoot, ctx) {
     const folderName = basename(folderPath);
     name = pathToName(group.exec(folderName)?.[1] ?? folderName);
   }
-  const node = {
+  let node = {
     type: "folder",
     name,
     icon: options.resolveIcon?.(meta?.data.icon) ?? index?.icon,
@@ -137,21 +210,18 @@ function buildFolderNode(folderPath, isGlobalRoot, ctx) {
       metaFile: metaPath
     } : void 0
   };
-  return options.attachFolder?.(
-    node,
-    {
-      get children() {
-        return files.flatMap((file) => storage.read(file) ?? []);
-      }
-    },
-    meta
-  ) ?? node;
+  for (const transformer of transformers) {
+    if (!transformer.folder) continue;
+    node = transformer.folder.call(ctx, node, folderPath, metaPath);
+  }
+  return node;
 }
-function buildFileNode(path, { options, getUrl, storage, localeStorage, locale }) {
-  const page = localeStorage?.read(path) ?? storage.read(path);
+function buildFileNode(path, ctx) {
+  const { options, getUrl, storage, locale, transformers } = ctx;
+  const page = storage.read(path);
   if (page?.format !== "page") return;
   const { title, description, icon } = page.data;
-  const item = {
+  let item = {
     $id: path,
     type: "page",
     name: title ?? pathToName(basename(path, extname(path))),
@@ -162,17 +232,36 @@ function buildFileNode(path, { options, getUrl, storage, localeStorage, locale }
       file: path
     } : void 0
   };
-  return options.attachFile?.(item, page) ?? item;
+  for (const transformer of transformers) {
+    if (!transformer.file) continue;
+    item = transformer.file.call(ctx, item, path);
+  }
+  return item;
 }
-function build(ctx) {
+function build(id, ctx) {
   const folder = buildFolderNode("", true, ctx);
-  return {
-    $id: ctx.locale ?? "root",
+  let root = {
+    $id: id,
     name: folder.name,
     children: folder.children
   };
+  for (const transformer of ctx.transformers) {
+    if (!transformer.root) continue;
+    root = transformer.root.call(ctx, root);
+  }
+  return root;
 }
 function createPageTreeBuilder(getUrl) {
+  function getTransformers(options, generateFallback = true) {
+    const transformers = [legacyTransformer(options)];
+    if (options.transformers) {
+      transformers.push(...options.transformers);
+    }
+    if (generateFallback) {
+      transformers.push(transformerFallback());
+    }
+    return transformers;
+  }
   function createFlattenPathResolver(storage) {
     const map = /* @__PURE__ */ new Map();
     const files = storage.getFiles();
@@ -186,36 +275,38 @@ function createPageTreeBuilder(getUrl) {
     };
   }
   return {
-    build(options) {
-      const resolve = createFlattenPathResolver(options.storage);
-      return build({
+    build({ storage, id, generateFallback, ...options }) {
+      const resolve = createFlattenPathResolver(storage);
+      return build(id ?? "root", {
+        transformers: getTransformers(options, generateFallback),
         options,
         builder: this,
-        storage: options.storage,
+        storage,
         getUrl,
         resolveName(name, format) {
           return resolve(name, format) ?? name;
         }
       });
     },
-    buildI18n({ i18n, ...options }) {
-      const storage = options.storages[i18n.defaultLanguage];
-      const resolve = createFlattenPathResolver(storage);
-      const entries = i18n.languages.map((lang) => {
-        const tree = build({
+    buildI18n({ id, storages, ...options }) {
+      const transformers = getTransformers(options);
+      const out = {};
+      for (const [locale, storage] of Object.entries(storages)) {
+        const resolve = createFlattenPathResolver(storage);
+        out[locale] = build(id ?? (locale.length === 0 ? "root" : locale), {
+          transformers,
+          builder: this,
           options,
           getUrl,
-          builder: this,
-          locale: lang,
+          locale,
           storage,
-          localeStorage: options.storages[lang],
+          storages,
           resolveName(name, format) {
             return resolve(name, format) ?? name;
           }
         });
-        return [lang, tree];
-      });
-      return Object.fromEntries(entries);
+      }
+      return out;
     }
   };
 }
@@ -231,10 +322,19 @@ function pathToName(name) {
 
 // src/source/file-system.ts
 var FileSystem = class {
-  constructor() {
+  constructor(inherit) {
     this.files = /* @__PURE__ */ new Map();
     this.folders = /* @__PURE__ */ new Map();
-    this.folders.set("", []);
+    if (inherit) {
+      for (const [k, v] of inherit.folders) {
+        this.folders.set(k, v);
+      }
+      for (const [k, v] of inherit.files) {
+        this.files.set(k, v);
+      }
+    } else {
+      this.folders.set("", []);
+    }
   }
   read(path) {
     return this.files.get(path);
@@ -246,11 +346,21 @@ var FileSystem = class {
     return this.folders.get(path);
   }
   write(path, file) {
+    if (this.files.has(path)) {
+      this.files.set(path, file);
+      return;
+    }
     const dir = dirname(path);
     this.makeDir(dir);
     this.readDir(dir)?.push(path);
     this.files.set(path, file);
   }
+  delete(path) {
+    return this.files.delete(path);
+  }
+  deleteDir(path) {
+    return this.folders.delete(path);
+  }
   getFiles() {
     return Array.from(this.files.keys());
   }
@@ -266,62 +376,59 @@ var FileSystem = class {
 };
 
 // src/source/load-files.ts
-function loadFiles(files, options) {
-  const { transformers = [] } = options;
-  const storage = new FileSystem();
-  const normalized = files.map((file) => ({
-    ...file,
-    path: normalizePath(file.path)
-  }));
-  for (const item of options.buildFiles(normalized)) {
-    storage.write(item.path, item);
-  }
-  for (const transformer of transformers) {
-    transformer({
-      storage,
-      options
-    });
-  }
-  return storage;
+function isLocaleValid(locale) {
+  return locale.length > 0 && !/\d+/.test(locale);
 }
-function loadFilesI18n(files, options, i18n) {
-  const parser = i18n.parser === "dir" ? dirParser : dotParser;
+var parsers = {
+  dir(path) {
+    const [locale, ...segs] = path.split("/");
+    if (locale && segs.length > 0 && isLocaleValid(locale))
+      return [segs.join("/"), locale];
+    return [path];
+  },
+  dot(path) {
+    const dir = dirname(path);
+    const base = basename(path);
+    const parts = base.split(".");
+    if (parts.length < 3) return [path];
+    const [locale] = parts.splice(parts.length - 2, 1);
+    if (!isLocaleValid(locale)) return [path];
+    return [joinPath(dir, parts.join(".")), locale];
+  },
+  none(path) {
+    return [path];
+  }
+};
+function loadFiles(files, options, i18n) {
+  const { buildFile, transformers = [] } = options;
+  const parser = parsers[i18n.parser];
   const storages = {};
+  const normalized = files.map(
+    (file) => buildFile({
+      ...file,
+      path: normalizePath(file.path)
+    })
+  );
+  function scan(lang, fallback) {
+    const storage = new FileSystem(fallback);
+    for (const item of normalized) {
+      const [path, locale = i18n.defaultLanguage] = parser(item.path);
+      if (locale === lang) storage.write(path, item);
+    }
+    for (const transformer of transformers) {
+      transformer({
+        storage,
+        options
+      });
+    }
+    return storage;
+  }
+  storages[i18n.defaultLanguage] = scan(i18n.defaultLanguage);
   for (const lang of i18n.languages) {
-    storages[lang] = loadFiles(
-      files.flatMap((file) => {
-        const [path, locale] = parser(normalizePath(file.path));
-        if ((locale ?? i18n.defaultLanguage) === lang) {
-          return {
-            ...file,
-            path
-          };
-        }
-        return [];
-      }),
-      options
-    );
+    storages[lang] ??= scan(lang, storages[i18n.defaultLanguage]);
   }
   return storages;
 }
-function dirParser(path) {
-  const parsed = path.split("/");
-  if (parsed.length >= 2) return [parsed.slice(1).join("/"), parsed[0]];
-  return [path];
-}
-function dotParser(path) {
-  const segs = path.split("/");
-  if (segs.length === 0) return [path];
-  const name = segs[segs.length - 1].split(".");
-  if (name.length >= 3) {
-    const locale = name.splice(name.length - 2, 1)[0];
-    if (locale.length > 0 && !/\d+/.test(locale)) {
-      segs[segs.length - 1] = name.join(".");
-      return [segs.join("/"), locale];
-    }
-  }
-  return [path];
-}
 function normalizePath(path) {
   const segments = splitPath(slash(path));
   if (segments[0] === "." || segments[0] === "..")
@@ -330,7 +437,7 @@ function normalizePath(path) {
 }
 
 // src/source/loader.ts
-function indexPages(storages, getUrl, i18n) {
+function indexPages(storages, getUrl) {
   const result = {
     // (locale.slugs -> page)
     pages: /* @__PURE__ */ new Map(),
@@ -339,36 +446,17 @@ function indexPages(storages, getUrl, i18n) {
     // (locale.path -> meta)
     pathToPage: /* @__PURE__ */ new Map()
   };
-  const defaultLanguage = i18n?.defaultLanguage ?? "";
-  for (const filePath of storages[defaultLanguage].getFiles()) {
-    const item = storages[defaultLanguage].read(filePath);
-    if (item.format === "meta") {
-      result.pathToMeta.set(
-        `${defaultLanguage}.${item.path}`,
-        fileToMeta(item)
-      );
-    }
-    if (item.format === "page") {
-      const page = fileToPage(item, getUrl, defaultLanguage);
-      result.pathToPage.set(`${defaultLanguage}.${item.path}`, page);
-      result.pages.set(`${defaultLanguage}.${page.slugs.join("/")}`, page);
-      if (!i18n) continue;
-      for (const lang of i18n.languages) {
-        if (lang === defaultLanguage) continue;
-        const localizedItem = storages[lang].read(filePath);
-        const localizedPage = fileToPage(
-          localizedItem?.format === "page" ? localizedItem : item,
-          getUrl,
-          lang
-        );
-        if (localizedItem) {
-          result.pathToPage.set(`${lang}.${item.path}`, localizedPage);
-        }
-        result.pages.set(
-          `${lang}.${localizedPage.slugs.join("/")}`,
-          localizedPage
-        );
+  for (const [lang, storage] of Object.entries(storages)) {
+    for (const filePath of storage.getFiles()) {
+      const item = storage.read(filePath);
+      const path = `${lang}.${filePath}`;
+      if (item.format === "meta") {
+        result.pathToMeta.set(path, fileToMeta(item));
+        continue;
       }
+      const page = fileToPage(item, getUrl, lang);
+      result.pathToPage.set(path, page);
+      result.pages.set(`${lang}.${page.slugs.join("/")}`, page);
     }
   }
   return result;
@@ -401,86 +489,84 @@ function createOutput(options) {
     i18n,
     slugs: slugsFn,
     url: getUrl = createGetUrl(baseUrl ?? "/", i18n),
-    transformers
+    transformers = []
   } = options;
   const defaultLanguage = i18n?.defaultLanguage ?? "";
   const files = typeof source.files === "function" ? source.files() : source.files;
-  function buildFiles(files2) {
-    const indexFiles = [];
+  const transformerSlugs = ({ storage }) => {
+    const indexFiles = /* @__PURE__ */ new Set();
     const taken = /* @__PURE__ */ new Set();
-    for (const file of files2) {
-      if (file.type !== "page" || file.slugs) continue;
-      if (isIndex(file.path) && !slugsFn) {
-        indexFiles.push(file);
+    for (const path of storage.getFiles()) {
+      const file = storage.read(path);
+      if (!file || file.format !== "page" || file.slugs) continue;
+      if (isIndex(path) && !slugsFn) {
+        indexFiles.add(path);
         continue;
       }
-      file.slugs = slugsFn ? slugsFn(parseFilePath(file.path)) : getSlugs(file.path);
+      file.slugs = slugsFn ? slugsFn(parseFilePath(path)) : getSlugs(path);
       const key = file.slugs.join("/");
       if (taken.has(key)) throw new Error("Duplicated slugs");
       taken.add(key);
     }
-    for (const file of indexFiles) {
-      file.slugs = getSlugs(file.path);
+    for (const path of indexFiles) {
+      const file = storage.read(path);
+      if (file?.format !== "page") continue;
+      file.slugs = getSlugs(path);
       if (taken.has(file.slugs.join("/"))) file.slugs.push("index");
     }
-    return files2.map((file) => {
-      if (file.type === "page") {
+  };
+  const storages = loadFiles(
+    files,
+    {
+      buildFile(file) {
+        if (file.type === "page") {
+          return {
+            format: "page",
+            path: file.path,
+            slugs: file.slugs,
+            data: file.data,
+            absolutePath: file.absolutePath ?? ""
+          };
+        }
         return {
-          format: "page",
+          format: "meta",
           path: file.path,
-          slugs: file.slugs,
-          data: file.data,
-          absolutePath: file.absolutePath ?? ""
+          absolutePath: file.absolutePath ?? "",
+          data: file.data
         };
-      }
-      return {
-        format: "meta",
-        path: file.path,
-        absolutePath: file.absolutePath ?? "",
-        data: file.data
-      };
-    });
-  }
-  const storages = i18n ? loadFilesI18n(
-    files,
-    {
-      buildFiles,
-      transformers
+      },
+      transformers: [transformerSlugs, ...transformers]
     },
-    {
+    i18n ? {
       ...i18n,
       parser: i18n.parser ?? "dot"
+    } : {
+      defaultLanguage,
+      parser: "none",
+      languages: [defaultLanguage]
     }
-  ) : {
-    "": loadFiles(files, {
-      transformers,
-      buildFiles
-    })
-  };
-  const walker = indexPages(storages, getUrl, i18n);
+  );
+  const walker = indexPages(storages, getUrl);
   const builder = createPageTreeBuilder(getUrl);
   let pageTree;
   return {
     _i18n: i18n,
     get pageTree() {
+      pageTree ??= builder.buildI18n({
+        storages,
+        resolveIcon: options.icon,
+        ...options.pageTree
+      });
+      return i18n ? pageTree : pageTree[defaultLanguage];
+    },
+    set pageTree(v) {
       if (i18n) {
-        pageTree ??= builder.buildI18n({
-          storages,
-          resolveIcon: options.icon,
-          i18n,
-          ...options.pageTree
-        });
+        pageTree = v;
       } else {
-        pageTree ??= builder.build({
-          storage: storages[""],
-          resolveIcon: options.icon,
-          ...options.pageTree
-        });
+        pageTree = {
+          defaultLanguage: v
+        };
       }
-      return pageTree;
-    },
-    set pageTree(v) {
-      pageTree = v;
     },
     getPageByHref(href, { dir = "", language } = {}) {
       const [value, hash] = href.split("#", 2);