fumadocs-core 15.5.0 → 15.5.2

package/dist/source/index.js

@@ -1,11 +1,15 @@
+import {
+  basename,
+  dirname,
+  extname,
+  parseFilePath,
+  parseFolderPath
+} from "../chunk-7GNSIKII.js";
 import {
   joinPath,
   slash,
   splitPath
-} from "../chunk-XMCPKVJQ.js";
-import {
-  __export
-} from "../chunk-MLKGABMK.js";
+} from "../chunk-3JSIVMCJ.js";
 
 // src/source/page-tree-builder.ts
 var group = /^\((?<name>.+)\)$/;
@@ -15,44 +19,30 @@ var rest = "...";
 var restReversed = "z...a";
 var extractPrefix = "...";
 var excludePrefix = "!";
-function isPageFile(node) {
-  return "data" in node && node.format === "page";
-}
-function buildAll(nodes, ctx, filter, reversed = false) {
-  const { localeStorage } = ctx;
+function buildAll(paths, ctx, filter, reversed = false) {
   const output = [];
-  for (const node of [...nodes].sort((a, b) => {
-    let result;
-    if (isPageFile(a) && "children" in b) result = -1;
-    else if ("children" in a && isPageFile(b)) result = 1;
-    else result = a.file.name.localeCompare(b.file.name);
-    return reversed ? result * -1 : result;
-  })) {
-    if (filter && !filter(node)) continue;
-    if (isPageFile(node)) {
-      const localized = localeStorage?.read(
-        joinPath(node.file.dirname, node.file.name),
-        "page"
-      );
-      const treeNode = buildFileNode(localized ?? node, ctx);
-      if (node.file.name === "index") {
-        output.unshift(treeNode);
-        continue;
-      }
-      output.push(treeNode);
-    } else if ("children" in node) {
-      output.push(buildFolderNode(node, false, ctx));
-    }
+  const sortedPaths = (filter ? paths.filter(filter) : [...paths]).sort(
+    (a, b) => a.localeCompare(b) * (reversed ? -1 : 1)
+  );
+  for (const path of sortedPaths) {
+    const fileNode = buildFileNode(path, ctx);
+    if (!fileNode) continue;
+    if (basename(path, extname(path)) === "index") output.unshift(fileNode);
+    else output.push(fileNode);
+  }
+  for (const dir of sortedPaths) {
+    const dirNode = buildFolderNode(dir, false, ctx);
+    if (dirNode) output.push(dirNode);
   }
   return output;
 }
-function resolveFolderItem(folder, item, ctx, idx, addedNodePaths) {
+function resolveFolderItem(folderPath, item, ctx, idx, restNodePaths) {
   if (item === rest || item === restReversed) return item;
-  const { options, storage, localeStorage } = ctx;
+  const { options, resolveName } = ctx;
   let match = separator.exec(item);
   if (match?.groups) {
     const node = {
-      $id: `${folder.file.path}#${idx}`,
+      $id: `${folderPath}#${idx}`,
       type: "separator",
       icon: options.resolveIcon?.(match.groups.icon),
       name: match.groups.name
@@ -80,91 +70,101 @@ function resolveFolderItem(folder, item, ctx, idx, addedNodePaths) {
   } else if (isExtract) {
     filename = item.slice(extractPrefix.length);
   }
-  const path = joinPath(folder.file.path, filename);
-  const itemNode = storage.readDir(path) ?? localeStorage?.read(path, "page") ?? storage.read(path, "page");
-  if (!itemNode) return [];
-  addedNodePaths.add(itemNode.file.path);
+  const path = resolveName(joinPath(folderPath, filename), "page");
+  restNodePaths.delete(path);
   if (isExcept) return [];
-  if ("children" in itemNode) {
-    const node = buildFolderNode(itemNode, false, ctx);
-    return isExtract ? node.children : [node];
+  const dirNode = buildFolderNode(path, false, ctx);
+  if (dirNode) {
+    return isExtract ? dirNode.children : [dirNode];
   }
-  return [buildFileNode(itemNode, ctx)];
+  const fileNode = buildFileNode(path, ctx);
+  return fileNode ? [fileNode] : [];
 }
-function buildFolderNode(folder, isGlobalRoot, ctx) {
-  const { storage, localeStorage, options } = ctx;
-  const metaPath = joinPath(folder.file.path, "meta");
-  const meta = localeStorage?.read(metaPath, "meta") ?? storage.read(metaPath, "meta");
-  const indexPath = joinPath(folder.file.path, "index");
-  const indexFile = localeStorage?.read(indexPath, "page") ?? storage.read(indexPath, "page");
+function buildFolderNode(folderPath, isGlobalRoot, ctx) {
+  const { storage, localeStorage, options, resolveName } = 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);
+  if (meta?.format !== "meta") {
+    meta = void 0;
+  }
   const isRoot = meta?.data.root ?? isGlobalRoot;
-  let index;
+  let indexDisabled = false;
   let children;
   if (!meta?.data.pages) {
-    if (indexFile) index = buildFileNode(indexFile, ctx);
-    children = buildAll(folder.children, ctx, (node2) => {
-      return node2.file.name !== "index" || isRoot;
-    });
+    children = buildAll(files, ctx, (file) => isRoot || file !== indexPath);
   } else {
-    const addedNodePaths = /* @__PURE__ */ new Set();
-    const resolved = meta.data.pages.flatMap((item, i) => resolveFolderItem(folder, item, ctx, i, addedNodePaths));
-    if (indexFile && (isRoot || !addedNodePaths.has(indexFile.file.path))) {
-      index = buildFileNode(indexFile, ctx);
+    const restItems = new Set(files);
+    const resolved = meta.data.pages.flatMap((item, i) => resolveFolderItem(folderPath, item, ctx, i, restItems));
+    if (!isRoot && !restItems.has(indexPath)) {
+      indexDisabled = true;
     }
     for (let i = 0; i < resolved.length; i++) {
-      if (resolved[i] === rest || resolved[i] === restReversed) {
-        resolved.splice(
-          i,
-          1,
-          ...buildAll(
-            folder.children,
-            ctx,
-            (node2) => {
-              if (node2.file.name === "index" && !isRoot) return false;
-              return !addedNodePaths.has(node2.file.path);
-            },
-            resolved[i] === restReversed
-          )
-        );
-        break;
-      }
+      const item = resolved[i];
+      if (item !== rest && item !== restReversed) continue;
+      const items = buildAll(
+        files,
+        ctx,
+        // index files are not included in ... unless it's a root folder
+        (file) => (file !== indexPath || isRoot) && restItems.has(file),
+        item === restReversed
+      );
+      resolved.splice(i, 1, ...items);
+      break;
     }
     children = resolved;
   }
+  const index = !indexDisabled ? buildFileNode(indexPath, ctx) : void 0;
+  let name = meta?.data.title ?? index?.name;
+  if (!name) {
+    const folderName = basename(folderPath);
+    name = pathToName(group.exec(folderName)?.[1] ?? folderName);
+  }
   const node = {
     type: "folder",
-    name: meta?.data.title ?? index?.name ?? // resolve folder groups like (group_name)
-    pathToName(group.exec(folder.file.name)?.[1] ?? folder.file.name),
+    name,
     icon: options.resolveIcon?.(meta?.data.icon) ?? index?.icon,
     root: meta?.data.root,
     defaultOpen: meta?.data.defaultOpen,
     description: meta?.data.description,
     index,
     children,
-    $id: folder.file.path,
-    $ref: !options.noRef ? {
-      metaFile: meta?.file.path
+    $id: folderPath,
+    $ref: !options.noRef && meta ? {
+      metaFile: metaPath
     } : void 0
   };
-  return options.attachFolder?.(node, folder, meta) ?? node;
+  return options.attachFolder?.(
+    node,
+    {
+      get children() {
+        return files.flatMap((file) => storage.read(file) ?? []);
+      }
+    },
+    meta
+  ) ?? node;
 }
-function buildFileNode(file, { options, getUrl, locale }) {
+function buildFileNode(path, { options, getUrl, storage, localeStorage, locale }) {
+  const page = localeStorage?.read(path) ?? storage.read(path);
+  if (page?.format !== "page") return;
+  const { title, description, icon } = page.data;
   const item = {
-    $id: file.file.path,
+    $id: path,
     type: "page",
-    name: file.data.data.title ?? pathToName(file.file.name),
-    description: file.data.data.description,
-    icon: options.resolveIcon?.(file.data.data.icon),
-    url: getUrl(file.data.slugs, locale),
+    name: title ?? pathToName(basename(path, extname(path))),
+    description,
+    icon: options.resolveIcon?.(icon),
+    url: getUrl(page.slugs, locale),
     $ref: !options.noRef ? {
-      file: file.file.path
+      file: path
     } : void 0
   };
-  return options.attachFile?.(item, file) ?? item;
+  return options.attachFile?.(item, page) ?? item;
 }
 function build(ctx) {
-  const root = ctx.storage.root();
-  const folder = buildFolderNode(root, true, ctx);
+  const folder = buildFolderNode("", true, ctx);
   return {
     $id: ctx.locale ?? "root",
     name: folder.name,
@@ -172,24 +172,45 @@ function build(ctx) {
   };
 }
 function createPageTreeBuilder(getUrl) {
+  function createFlattenPathResolver(storage) {
+    const map = /* @__PURE__ */ new Map();
+    const files = storage.getFiles();
+    for (const file of files) {
+      const content = storage.read(file);
+      const flattenPath = file.substring(0, file.length - extname(file).length);
+      map.set(flattenPath + "." + content.format, file);
+    }
+    return (name, format) => {
+      return map.get(name + "." + format);
+    };
+  }
   return {
     build(options) {
+      const resolve = createFlattenPathResolver(options.storage);
       return build({
         options,
         builder: this,
         storage: options.storage,
-        getUrl
+        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({
           options,
           getUrl,
           builder: this,
           locale: lang,
-          storage: options.storages[i18n.defaultLanguage],
-          localeStorage: options.storages[lang]
+          storage,
+          localeStorage: options.storages[lang],
+          resolveName(name, format) {
+            return resolve(name, format) ?? name;
+          }
         });
         return [lang, tree];
       });
@@ -207,118 +228,49 @@ function pathToName(name) {
   return result.join("");
 }
 
-// src/source/path.ts
-function parseFilePath(path) {
-  const segments = splitPath(slash(path));
-  const dirname = segments.slice(0, -1).join("/");
-  let name = segments.at(-1) ?? "";
-  let ext = "";
-  const dotIdx = name.lastIndexOf(".");
-  if (dotIdx !== -1) {
-    ext = name.substring(dotIdx);
-    name = name.substring(0, dotIdx);
-  }
-  return {
-    dirname,
-    name,
-    path: segments.join("/"),
-    ext,
-    get flattenedPath() {
-      return [dirname, name].filter((p) => p.length > 0).join("/");
-    }
-  };
-}
-function parseFolderPath(path) {
-  const segments = splitPath(slash(path));
-  const base = segments.at(-1) ?? "";
-  return {
-    dirname: segments.slice(0, -1).join("/"),
-    name: base,
-    path: segments.join("/")
-  };
-}
-function normalizePath(path) {
-  const segments = splitPath(slash(path));
-  if (segments[0] === "." || segments[0] === "..")
-    throw new Error("It must not start with './' or '../'");
-  return segments.join("/");
-}
-
 // src/source/file-system.ts
-var file_system_exports = {};
-__export(file_system_exports, {
-  Storage: () => Storage
-});
-var Storage = class {
+var FileSystem = class {
   constructor() {
     this.files = /* @__PURE__ */ new Map();
     this.folders = /* @__PURE__ */ new Map();
-    this.rootFolder = {
-      file: parseFolderPath(""),
-      children: []
-    };
-    this.folders.set("", this.rootFolder);
+    this.folders.set("", []);
+  }
+  read(path) {
+    return this.files.get(path);
   }
   /**
-   * @param path - flattened path
-   * @param format - file format
+   * get the direct children of folder (in virtual file path)
    */
-  read(path, format) {
-    return this.files.get(`${path}.${format}`);
-  }
   readDir(path) {
     return this.folders.get(path);
   }
-  root() {
-    return this.rootFolder;
+  write(path, file) {
+    const dir = dirname(path);
+    this.makeDir(dir);
+    this.readDir(dir)?.push(path);
+    this.files.set(path, file);
   }
-  write(path, format, data) {
-    const node = {
-      format,
-      file: parseFilePath(path),
-      data
-    };
-    this.makeDir(node.file.dirname);
-    this.readDir(node.file.dirname)?.children.push(node);
-    this.files.set(
-      joinPath(node.file.dirname, `${node.file.name}.${node.format}`),
-      node
-    );
-  }
-  list() {
-    return Array.from(this.files.values());
+  getFiles() {
+    return Array.from(this.files.keys());
   }
   makeDir(path) {
     const segments = splitPath(path);
     for (let i = 0; i < segments.length; i++) {
       const segment = segments.slice(0, i + 1).join("/");
       if (this.folders.has(segment)) continue;
-      const folder = {
-        file: parseFolderPath(segment),
-        children: []
-      };
-      this.folders.set(folder.file.path, folder);
-      this.readDir(folder.file.dirname)?.children.push(folder);
+      this.folders.set(segment, []);
+      this.readDir(dirname(segment))?.push(path);
     }
   }
 };
 
 // src/source/load-files.ts
-function loadFiles(files, options) {
+function loadFiles(files, buildFile, options) {
   const { transformers = [] } = options;
-  const storage = new Storage();
+  const storage = new FileSystem();
   for (const file of files) {
     const parsedPath = normalizePath(file.path);
-    if (file.type === "page") {
-      const slugs = file.slugs ?? options.getSlugs(parseFilePath(parsedPath));
-      storage.write(parsedPath, file.type, {
-        slugs,
-        data: file.data
-      });
-    }
-    if (file.type === "meta") {
-      storage.write(parsedPath, file.type, file.data);
-    }
+    storage.write(parsedPath, buildFile(file));
   }
   for (const transformer of transformers) {
     transformer({
@@ -328,7 +280,7 @@ function loadFiles(files, options) {
   }
   return storage;
 }
-function loadFilesI18n(files, options) {
+function loadFilesI18n(files, buildFile, options) {
   const parser = options.i18n.parser === "dir" ? dirParser : dotParser;
   const storages = {};
   for (const lang of options.i18n.languages) {
@@ -343,6 +295,7 @@ function loadFilesI18n(files, options) {
         }
         return [];
       }),
+      buildFile,
       options
     );
   }
@@ -366,39 +319,56 @@ function dotParser(path) {
   }
   return [path];
 }
+function normalizePath(path) {
+  const segments = splitPath(slash(path));
+  if (segments[0] === "." || segments[0] === "..")
+    throw new Error("It must not start with './' or '../'");
+  return segments.join("/");
+}
 
 // src/source/loader.ts
 function indexPages(storages, getUrl, i18n) {
+  const result = {
+    // (locale.slugs -> page)
+    pages: /* @__PURE__ */ new Map(),
+    // (locale.path -> page)
+    pathToMeta: /* @__PURE__ */ new Map(),
+    // (locale.path -> meta)
+    pathToPage: /* @__PURE__ */ new Map()
+  };
   const defaultLanguage = i18n?.defaultLanguage ?? "";
-  const map = /* @__PURE__ */ new Map();
-  const fileMapped = /* @__PURE__ */ new WeakMap();
-  for (const item of storages[defaultLanguage].list()) {
+  for (const filePath of storages[defaultLanguage].getFiles()) {
+    const item = storages[defaultLanguage].read(filePath);
     if (item.format === "meta") {
-      fileMapped.set(item, fileToMeta(item));
+      result.pathToMeta.set(
+        `${defaultLanguage}.${item.path}`,
+        fileToMeta(item)
+      );
     }
     if (item.format === "page") {
       const page = fileToPage(item, getUrl, defaultLanguage);
-      fileMapped.set(item, page);
-      map.set(`${defaultLanguage}.${page.slugs.join("/")}`, page);
+      result.pathToPage.set(`${defaultLanguage}.${item.path}`, page);
+      result.pages.set(`${defaultLanguage}.${page.slugs.join("/")}`, page);
       if (!i18n) continue;
-      const path = joinPath(item.file.dirname, item.file.name);
       for (const lang of i18n.languages) {
         if (lang === defaultLanguage) continue;
-        const localizedItem = storages[lang].read(path, "page");
-        const localizedPage = fileToPage(localizedItem ?? item, getUrl, lang);
+        const localizedItem = storages[lang].read(filePath);
+        const localizedPage = fileToPage(
+          localizedItem?.format === "page" ? localizedItem : item,
+          getUrl,
+          lang
+        );
         if (localizedItem) {
-          fileMapped.set(localizedItem, localizedPage);
+          result.pathToPage.set(`${lang}.${item.path}`, localizedPage);
         }
-        map.set(`${lang}.${localizedPage.slugs.join("/")}`, localizedPage);
+        result.pages.set(
+          `${lang}.${localizedPage.slugs.join("/")}`,
+          localizedPage
+        );
       }
     }
   }
-  return {
-    pages: map,
-    getResultFromFile(file) {
-      return fileMapped.get(file);
-    }
-  };
+  return result;
 }
 function createGetUrl(baseUrl, i18n) {
   const baseSlugs = baseUrl.split("/");
@@ -416,13 +386,14 @@ function createGetUrl(baseUrl, i18n) {
   };
 }
 function getSlugs(info) {
-  return [...info.dirname.split("/"), info.name].filter(
-    // filter empty folder names and file groups like (group_name)
-    (v, i, arr) => {
-      if (v.length === 0) return false;
-      return i === arr.length - 1 ? v !== "index" : !/^\(.+\)$/.test(v);
-    }
-  );
+  const slugs = [];
+  for (const seg of info.dirname.split("/")) {
+    if (seg.length > 0 && !/^\(.+\)$/.test(seg)) slugs.push(encodeURI(seg));
+  }
+  if (info.name !== "index") {
+    slugs.push(encodeURI(info.name));
+  }
+  return slugs;
 }
 function loader(options) {
   return createOutput(options);
@@ -435,18 +406,31 @@ function createOutput(options) {
   const defaultLanguage = i18n?.defaultLanguage ?? "";
   const getUrl = options.url ?? createGetUrl(options.baseUrl ?? "/", options.i18n);
   const files = typeof source.files === "function" ? source.files() : source.files;
-  const storages = i18n ? loadFilesI18n(files, {
+  function buildFile(file) {
+    if (file.type === "page") {
+      return {
+        format: "page",
+        path: file.path,
+        slugs: file.slugs ?? slugsFn(parseFilePath(file.path)),
+        data: file.data,
+        absolutePath: file.absolutePath ?? ""
+      };
+    }
+    return {
+      format: "meta",
+      path: file.path,
+      absolutePath: file.absolutePath ?? "",
+      data: file.data
+    };
+  }
+  const storages = i18n ? loadFilesI18n(files, buildFile, {
+    ...options,
     i18n: {
       ...i18n,
       parser: i18n.parser ?? "dot"
-    },
-    transformers: options.transformers,
-    getSlugs: slugsFn
+    }
   }) : {
-    "": loadFiles(files, {
-      transformers: options.transformers,
-      getSlugs: slugsFn
-    })
+    "": loadFiles(files, buildFile, options)
   };
   const walker = indexPages(storages, getUrl, i18n);
   const builder = createPageTreeBuilder(getUrl);
@@ -491,8 +475,8 @@ function createOutput(options) {
     },
     getPages(language = defaultLanguage) {
       const pages = [];
-      for (const key of walker.pages.keys()) {
-        if (key.startsWith(`${language}.`)) pages.push(walker.pages.get(key));
+      for (const [key, value] of walker.pages.entries()) {
+        if (key.startsWith(`${language}.`)) pages.push(value);
       }
       return pages;
     },
@@ -513,14 +497,12 @@ function createOutput(options) {
     getNodeMeta(node, language = defaultLanguage) {
       const ref = node.$ref?.metaFile;
       if (!ref) return;
-      const file = storages[language].list().find((v) => v.format === "meta" && v.file.path === ref);
-      if (file) return walker.getResultFromFile(file);
+      return walker.pathToMeta.get(`${language}.${ref}`);
     },
     getNodePage(node, language = defaultLanguage) {
       const ref = node.$ref?.file;
       if (!ref) return;
-      const file = storages[language].list().find((v) => v.format === "page" && v.file.path === ref);
-      if (file) return walker.getResultFromFile(file);
+      return walker.pathToPage.get(`${language}.${ref}`);
     },
     getPageTree(locale) {
       if (options.i18n) {
@@ -546,21 +528,29 @@ function createOutput(options) {
 }
 function fileToMeta(file) {
   return {
-    file: file.file,
+    path: file.path,
+    absolutePath: file.absolutePath,
+    get file() {
+      return parseFilePath(this.path);
+    },
     data: file.data
   };
 }
 function fileToPage(file, getUrl, locale) {
   return {
-    file: file.file,
-    url: getUrl(file.data.slugs, locale),
-    slugs: file.data.slugs,
-    data: file.data.data,
+    get file() {
+      return parseFilePath(this.path);
+    },
+    absolutePath: file.absolutePath,
+    path: file.path,
+    url: getUrl(file.slugs, locale),
+    slugs: file.slugs,
+    data: file.data,
     locale
   };
 }
 export {
-  file_system_exports as FileSystem,
+  FileSystem,
   createGetUrl,
   createPageTreeBuilder,
   getSlugs,