fumadocs-mdx 14.0.3 → 14.1.0

package/dist/{chunk-DKA3EWZH.js → chunk-VITVHHR6.js}

@@ -1,42 +1,44 @@
-import {
-  fumaMatter
-} from "./chunk-VWJKRQZR.js";
 import {
   createCodegen,
   ident
-} from "./chunk-WBIHDYMN.js";
+} from "./chunk-PW2AZGGD.js";
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
 
 // src/plugins/index-file.ts
 import path2 from "path";
 import { glob } from "tinyglobby";
 
 // src/utils/fs-cache.ts
-import { LRUCache } from "lru-cache";
 import fs from "fs/promises";
 import path from "path";
-var map = new LRUCache({
-  max: 100
-});
+var map = /* @__PURE__ */ new Map();
+function createFSCache() {
+  return {
+    read(file) {
+      const fullPath = toFullPath(file);
+      const cached = map.get(fullPath);
+      if (cached) return cached;
+      const read = fs.readFile(fullPath).then((s) => s.toString());
+      map.set(fullPath, read);
+      return read;
+    },
+    delete(file) {
+      map.delete(toFullPath(file));
+    }
+  };
+}
 function toFullPath(file) {
   if (path.isAbsolute(file)) {
     return path.relative(process.cwd(), file);
   }
   return file;
 }
-function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = fs.readFile(fullPath).then((s) => s.toString());
-  map.set(fullPath, read);
-  return read;
-}
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
-}
 
 // src/plugins/index-file.ts
 import { createHash } from "crypto";
+var indexFileCache = createFSCache();
 function indexFile(options = {}) {
   const {
     target = "default",
@@ -44,7 +46,6 @@ function indexFile(options = {}) {
     browser = true,
     dynamic = true
   } = options;
-  let config;
   let dynamicCollections;
   function isDynamic(collection) {
     return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
@@ -59,8 +60,8 @@ function indexFile(options = {}) {
       const indexFilePlugin = plugin["index-file"];
       if (!indexFilePlugin) continue;
       indexFilePlugin.serverOptions?.call(ctx, serverOptions);
-      const config2 = indexFilePlugin.generateTypeConfig?.call(ctx);
-      if (config2) typeConfigs.push(config2);
+      const config = indexFilePlugin.generateTypeConfig?.call(ctx);
+      if (config) typeConfigs.push(config);
     }
     return {
       serverOptions,
@@ -69,38 +70,38 @@ function indexFile(options = {}) {
   }
   return {
     name: "index-file",
-    config(v) {
-      config = v;
-      dynamicCollections = config.collectionList.filter(isDynamic);
+    config() {
+      dynamicCollections = this.core.getCollections().filter(isDynamic);
     },
     configureServer(server) {
       if (!server.watcher) return;
       server.watcher.on("all", async (event, file) => {
-        removeFileCache(file);
+        indexFileCache.delete(file);
         if (dynamicCollections.length === 0) {
           if (target === "vite") return;
           if (target === "default" && event === "change") return;
         }
-        const updatedCollection = config.collectionList.find(
-          (collection) => collection.hasFile(file)
-        );
+        const updatedCollection = this.core.getCollections().find((collection) => collection.hasFile(file));
         if (!updatedCollection) return;
         if (!isDynamic(updatedCollection)) {
           if (target === "vite") return;
           if (target === "default" && event === "change") return;
         }
-        await this.core.emitAndWrite({
-          filterPlugin: (plugin) => plugin.name === "index-file"
+        await this.core.emit({
+          filterPlugin: (plugin) => plugin.name === "index-file",
+          filterWorkspace: () => false,
+          write: true
         });
       });
     },
     async emit() {
       const globCache = /* @__PURE__ */ new Map();
+      const { workspace, outDir } = this.core.getOptions();
       const { serverOptions, tc } = generateConfigs(this.core);
       const toEmitEntry = async (path3, content) => {
         const codegen = createCodegen({
           target,
-          outDir: this.outDir,
+          outDir,
           jsExtension: addJsExtension,
           globCache
         });
@@ -108,7 +109,8 @@ function indexFile(options = {}) {
           core: this.core,
           codegen,
           serverOptions,
-          tc
+          tc,
+          workspace: workspace?.name
         });
         return {
           path: path3,
@@ -126,12 +128,8 @@ function indexFile(options = {}) {
     }
   };
 }
-async function generateServerIndexFile({
-  core,
-  codegen,
-  serverOptions,
-  tc
-}) {
+async function generateServerIndexFile(ctx) {
+  const { core, codegen, serverOptions, tc } = ctx;
   codegen.lines.push(
     `import { server } from 'fumadocs-mdx/runtime/server';`,
     `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
@@ -139,51 +137,48 @@ async function generateServerIndexFile({
     `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
   );
   async function generateCollectionObject(collection) {
+    const base = getBase(collection);
     switch (collection.type) {
       case "docs": {
         if (collection.docs.dynamic) return;
         if (collection.docs.async) {
           const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
-            generateMetaCollectionGlob(codegen, collection.meta, true),
-            generateDocCollectionFrontmatterGlob(
-              codegen,
-              collection.docs,
-              true
-            ),
-            generateDocCollectionGlob(codegen, collection.docs)
+            generateMetaCollectionGlob(ctx, collection.meta, true),
+            generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
+            generateDocCollectionGlob(ctx, collection.docs)
           ]);
-          return `await create.docsLazy("${collection.name}", "${collection.dir}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
+          return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
         }
         const [metaGlob, docGlob] = await Promise.all([
-          generateMetaCollectionGlob(codegen, collection.meta, true),
-          generateDocCollectionGlob(codegen, collection.docs, true)
+          generateMetaCollectionGlob(ctx, collection.meta, true),
+          generateDocCollectionGlob(ctx, collection.docs, true)
         ]);
-        return `await create.docs("${collection.name}", "${collection.dir}", ${metaGlob}, ${docGlob})`;
+        return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
       }
       case "doc":
         if (collection.dynamic) return;
         if (collection.async) {
           const [headGlob, bodyGlob] = await Promise.all([
-            generateDocCollectionFrontmatterGlob(codegen, collection, true),
-            generateDocCollectionGlob(codegen, collection)
+            generateDocCollectionFrontmatterGlob(ctx, collection, true),
+            generateDocCollectionGlob(ctx, collection)
           ]);
-          return `await create.docLazy("${collection.name}", "${collection.dir}", ${headGlob}, ${bodyGlob})`;
+          return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
         }
-        return `await create.doc("${collection.name}", "${collection.dir}", ${await generateDocCollectionGlob(
-          codegen,
+        return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(
+          ctx,
           collection,
           true
         )})`;
       case "meta":
-        return `await create.meta("${collection.name}", "${collection.dir}", ${await generateMetaCollectionGlob(
-          codegen,
+        return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(
+          ctx,
           collection,
           true
         )})`;
     }
   }
   await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
+    core.getCollections().map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return `
@@ -191,22 +186,23 @@ export const ${collection.name} = ${obj};`;
     })
   );
 }
-async function generateDynamicIndexFile({
-  core,
-  codegen,
-  serverOptions,
-  tc
-}) {
-  const { configPath } = core.getOptions();
+async function generateDynamicIndexFile(ctx) {
+  const { core, codegen, serverOptions, tc } = ctx;
+  const { configPath, environment, outDir } = core.getOptions();
+  const partialOptions = {
+    configPath,
+    environment,
+    outDir
+  };
   codegen.lines.push(
     `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
     `import * as Config from '${codegen.formatImportPath(configPath)}';`,
     "",
-    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(core.getOptions())}, ${JSON.stringify(serverOptions)});`
+    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(partialOptions)}, ${JSON.stringify(serverOptions)});`
   );
-  async function generateCollectionObjectEntry(collection, file) {
-    const fullPath = path2.join(collection.dir, file);
-    const content = await readFileWithCache(fullPath).catch(() => "");
+  async function generateCollectionObjectEntry(collection, absolutePath) {
+    const fullPath = path2.relative(process.cwd(), absolutePath);
+    const content = await indexFileCache.read(fullPath).catch(() => "");
     const parsed = fumaMatter(content);
     const data = await core.transformFrontmatter(
       {
@@ -224,7 +220,7 @@ async function generateDynamicIndexFile({
     for (const [k, v] of Object.entries({
       info: {
         fullPath,
-        path: file
+        path: path2.relative(collection.dir, absolutePath)
       },
       data,
       hash
@@ -239,7 +235,8 @@ async function generateDynamicIndexFile({
     else if (parent.type === "docs") collection = parent.docs;
     if (!collection || !collection.dynamic) return;
     const files = await glob(collection.patterns, {
-      cwd: collection.dir
+      cwd: collection.dir,
+      absolute: true
     });
     const entries = await Promise.all(
       files.map((file) => generateCollectionObjectEntry(collection, file))
@@ -247,18 +244,18 @@ async function generateDynamicIndexFile({
     switch (parent.type) {
       case "docs": {
         const metaGlob = await generateMetaCollectionGlob(
-          codegen,
+          ctx,
           parent.meta,
           true
         );
-        return `await create.docs("${parent.name}", "${parent.dir}", ${metaGlob}, ${entries.join(", ")})`;
+        return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
       }
       case "doc":
-        return `await create.doc("${collection.name}", "${collection.dir}", ${entries.join(", ")})`;
+        return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
     }
   }
   await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
+    core.getCollections().map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return `
@@ -266,7 +263,8 @@ export const ${collection.name} = ${obj};`;
     })
   );
 }
-async function generateBrowserIndexFile({ core, codegen, tc }) {
+async function generateBrowserIndexFile(ctx) {
+  const { core, codegen, tc } = ctx;
   codegen.lines.push(
     `import { browser } from 'fumadocs-mdx/runtime/browser';`,
     `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
@@ -281,12 +279,12 @@ async function generateBrowserIndexFile({ core, codegen, tc }) {
       }
       case "doc":
         if (collection.dynamic) return;
-        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(codegen, collection)})`;
+        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(ctx, collection)})`;
     }
   }
   codegen.lines.push("const browserCollections = {");
   await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
+    core.getCollections().map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return ident(`${collection.name}: ${obj},`);
@@ -294,30 +292,36 @@ async function generateBrowserIndexFile({ core, codegen, tc }) {
   );
   codegen.lines.push("};", "export default browserCollections;");
 }
-function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+function getBase(collection) {
+  return path2.relative(process.cwd(), collection.dir);
+}
+function generateDocCollectionFrontmatterGlob({ codegen, workspace }, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
     query: {
       collection: collection.name,
-      only: "frontmatter"
+      only: "frontmatter",
+      workspace
     },
     import: "frontmatter",
     base: collection.dir,
     eager
   });
 }
-function generateDocCollectionGlob(codegen, collection, eager = false) {
+function generateDocCollectionGlob({ codegen, workspace }, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
     query: {
-      collection: collection.name
+      collection: collection.name,
+      workspace
     },
     base: collection.dir,
     eager
   });
 }
-function generateMetaCollectionGlob(codegen, collection, eager = false) {
+function generateMetaCollectionGlob({ codegen, workspace }, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
     query: {
-      collection: collection.name
+      collection: collection.name,
+      workspace
     },
     import: "default",
     base: collection.dir,

package/dist/{chunk-GB4W3YCZ.js → chunk-VKSHE52K.js}

@@ -1,6 +1,6 @@
 import {
   ident
-} from "./chunk-WBIHDYMN.js";
+} from "./chunk-PW2AZGGD.js";
 
 // src/utils/validation.ts
 var ValidationError = class extends Error {
@@ -13,7 +13,8 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
     this.issues = issues;
   }
   async toStringFormatted() {
-    const picocolors = await import("picocolors");
+    const picocolorsModule = await import("picocolors");
+    const picocolors = picocolorsModule.default ?? picocolorsModule;
     return [
       picocolors.bold(`[MDX] ${this.title}:`),
       ...this.issues.map(
@@ -56,9 +57,10 @@ async function getPlugins(pluginOptions) {
   }
   return plugins;
 }
-function createCore(options, defaultPlugins = []) {
+function createCore(options) {
   let config;
   let plugins;
+  const workspaces = /* @__PURE__ */ new Map();
   async function transformMetadata({
     collection,
     filePath,
@@ -74,7 +76,7 @@ function createCore(options, defaultPlugins = []) {
     }
     return data;
   }
-  const core = {
+  return {
     /**
      * Convenient cache store, reset when config changes
      */
@@ -82,15 +84,36 @@ function createCore(options, defaultPlugins = []) {
     async init({ config: newConfig }) {
       config = await newConfig;
       this.cache.clear();
+      workspaces.clear();
       plugins = await getPlugins([
         postprocessPlugin(),
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
+        options.plugins,
+        config.global.plugins
       ]);
       for (const plugin of plugins) {
-        const out = await plugin.config?.call(pluginContext, config);
+        const out = await plugin.config?.call(this.getPluginContext(), config);
         if (out) config = out;
       }
+      if (!options.workspace) {
+        await Promise.all(
+          Object.entries(config.workspaces).map(async ([name, workspace]) => {
+            const core = createCore({
+              ...options,
+              outDir: path.join(options.outDir, name),
+              workspace: {
+                name,
+                parent: this,
+                dir: workspace.dir
+              }
+            });
+            await core.init({ config: workspace.config });
+            workspaces.set(name, core);
+          })
+        );
+      }
+    },
+    getWorkspaces() {
+      return workspaces;
     },
     getOptions() {
       return options;
@@ -107,37 +130,69 @@ function createCore(options, defaultPlugins = []) {
     getPlugins() {
       return plugins;
     },
+    getCollections() {
+      return Array.from(config.collections.values());
+    },
+    getCollection(name) {
+      return config.collections.get(name);
+    },
     getPluginContext() {
-      return pluginContext;
+      return {
+        core: this
+      };
     },
     async initServer(server) {
+      const ctx = this.getPluginContext();
       for (const plugin of plugins) {
-        await plugin.configureServer?.call(pluginContext, server);
+        await plugin.configureServer?.call(ctx, server);
+      }
+      for (const workspace of workspaces.values()) {
+        await workspace.initServer(server);
       }
     },
-    async emit({ filterPlugin = () => true } = {}) {
-      return (await Promise.all(
-        plugins.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(pluginContext);
-        })
-      )).flat();
-    },
-    async emitAndWrite(emitOptions) {
+    async emit(emitOptions = {}) {
+      const { filterPlugin, filterWorkspace, write = false } = emitOptions;
       const start = performance.now();
-      const out = await this.emit(emitOptions);
-      await Promise.all(
-        out.map(async (entry) => {
-          const file = path.join(options.outDir, entry.path);
-          await fs.mkdir(path.dirname(file), { recursive: true });
-          await fs.writeFile(file, entry.content);
+      const ctx = this.getPluginContext();
+      const added = /* @__PURE__ */ new Set();
+      const out = {
+        entries: [],
+        workspaces: {}
+      };
+      for (const li of await Promise.all(
+        plugins.map((plugin) => {
+          if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
+          return plugin.emit.call(ctx);
         })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+      )) {
+        if (!li) continue;
+        for (const item of li) {
+          if (added.has(item.path)) continue;
+          out.entries.push(item);
+          added.add(item.path);
+        }
+      }
+      if (write) {
+        await Promise.all(
+          out.entries.map(async (entry) => {
+            const file = path.join(options.outDir, entry.path);
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            await fs.writeFile(file, entry.content);
+          })
+        );
+        console.log(
+          options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
+        );
+      }
+      for (const [name, workspace] of workspaces) {
+        if (filterWorkspace && !filterWorkspace(name)) continue;
+        out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
+      }
+      return out;
     },
     async transformMeta(options2, data) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       data = await transformMetadata(options2, data);
@@ -149,7 +204,7 @@ function createCore(options, defaultPlugins = []) {
     },
     async transformFrontmatter(options2, data) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       data = await transformMetadata(options2, data);
@@ -161,7 +216,7 @@ function createCore(options, defaultPlugins = []) {
     },
     async transformVFile(options2, file) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       for (const plugin of plugins) {
@@ -171,11 +226,6 @@ function createCore(options, defaultPlugins = []) {
       return file;
     }
   };
-  const pluginContext = {
-    core,
-    ...options
-  };
-  return core;
 }
 function postprocessPlugin() {
   const LinkReferenceTypes = `{
@@ -190,7 +240,7 @@ function postprocessPlugin() {
         const lines = [];
         lines.push("{");
         lines.push("  DocData: {");
-        for (const collection of this.core.getConfig().collectionList) {
+        for (const collection of this.core.getCollections()) {
           let postprocessOptions;
           switch (collection.type) {
             case "doc":

package/dist/{chunk-OLL7FM7W.js → chunk-WAAWFNDX.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-GB4W3YCZ.js";
+} from "./chunk-VKSHE52K.js";
 
 // src/loaders/adapter.ts
 import { fileURLToPath } from "url";
@@ -134,7 +134,7 @@ function createStandaloneConfigLoader({
   buildConfig,
   mode
 }) {
-  let loaded;
+  let prev;
   async function getConfigHash() {
     if (mode === "production") return "static";
     const stats = await fs2.stat(core.getOptions().configPath).catch(() => {
@@ -142,31 +142,29 @@ function createStandaloneConfigLoader({
     });
     return stats.mtime.getTime().toString();
   }
-  async function newConfig() {
-    const { loadConfig } = await import("./load-from-file-OZ5N7DXU.js");
-    await core.init({
-      config: loadConfig(core, buildConfig)
-    });
-    return core.getConfig();
-  }
   return {
-    core,
-    async getConfig() {
+    async getCore() {
       const hash = await getConfigHash();
-      if (loaded && loaded.hash === hash) return loaded.config;
-      loaded = {
-        hash,
-        config: newConfig()
-      };
-      return loaded.config;
+      if (!prev || hash !== prev.hash) {
+        prev = {
+          hash,
+          init: (async () => {
+            const { loadConfig } = await import("./load-from-file-FHW724YY.js");
+            await core.init({
+              config: loadConfig(core, buildConfig)
+            });
+          })()
+        };
+      }
+      await prev.init;
+      return core;
     }
   };
 }
 function createIntegratedConfigLoader(core) {
   return {
-    core,
-    getConfig() {
-      return core.getConfig();
+    async getCore() {
+      return core;
     }
   };
 }