fumadocs-mdx 13.0.2 → 13.0.4

package/dist/vite/index.cjs

@@ -118,35 +118,78 @@ var init_preset = __esm({
 });
 
 // src/config/build.ts
+function buildCollection(name, config) {
+  if (config.type === "docs") {
+    return {
+      ...config,
+      name,
+      meta: buildPrimitiveCollection(name, config.meta),
+      docs: buildPrimitiveCollection(name, config.docs)
+    };
+  }
+  return buildPrimitiveCollection(name, config);
+}
+function buildPrimitiveCollection(name, { files, ...config }) {
+  const supportedFormats = SupportedFormats[config.type];
+  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matchers;
+  return {
+    ...config,
+    name,
+    patterns,
+    isFileSupported(filePath) {
+      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+    },
+    hasFile(filePath) {
+      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
+        (dir) => (0, import_picomatch.default)(patterns, {
+          cwd: dir
+        })
+      );
+      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+    }
+  };
+}
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
-  let globalConfig = {};
+  const loaded = {};
   for (const [k, v] of Object.entries(config)) {
     if (!v) {
       continue;
     }
     if (typeof v === "object" && "type" in v) {
       if (v.type === "docs") {
-        collections.set(k, v);
+        collections.set(k, buildCollection(k, v));
         continue;
       }
       if (v.type === "doc" || v.type === "meta") {
-        collections.set(k, v);
+        collections.set(
+          k,
+          buildCollection(k, v)
+        );
         continue;
       }
     }
     if (k === "default" && v) {
-      globalConfig = v;
+      Object.assign(loaded, v);
       continue;
     }
     throw new Error(
       `Unknown export "${k}", you can only export collections from source configuration file.`
     );
   }
+  if (loaded.collections) {
+    for (const [k, v] of Object.entries(loaded.collections)) {
+      collections.set(k, buildCollection(k, v));
+    }
+  }
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
-    global: globalConfig,
-    collections,
+    global: loaded,
+    collectionList: Array.from(collections.values()),
+    getCollection(name) {
+      return collections.get(name);
+    },
     async getDefaultMDXOptions(mode = "default") {
       const cached = mdxOptionsCache.get(mode);
       if (cached) return cached;
@@ -166,15 +209,21 @@ function buildConfig(config) {
     }
   };
 }
+var import_picomatch, SupportedFormats;
 var init_build = __esm({
   "src/config/build.ts"() {
     "use strict";
+    import_picomatch = __toESM(require("picomatch"), 1);
+    SupportedFormats = {
+      doc: ["mdx", "md"],
+      meta: ["json", "yaml"]
+    };
   }
 });
 
-// src/loaders/config/load.ts
-var load_exports = {};
-__export(load_exports, {
+// src/config/load-from-file.ts
+var load_from_file_exports = {};
+__export(load_from_file_exports, {
   loadConfig: () => loadConfig
 });
 async function compileConfig(configPath, outDir) {
@@ -199,18 +248,18 @@ async function compileConfig(configPath, outDir) {
 }
 async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url3.pathToFileURL)(path11.resolve(outDir, "source.config.mjs"));
+  const url = (0, import_node_url3.pathToFileURL)(path9.resolve(outDir, "source.config.mjs"));
   url.searchParams.set("hash", Date.now().toString());
   const config = import(url.href).then(
     (loaded) => buildConfig(loaded)
   );
   return await config;
 }
-var path11, import_node_url3;
-var init_load = __esm({
-  "src/loaders/config/load.ts"() {
+var path9, import_node_url3;
+var init_load_from_file = __esm({
+  "src/config/load-from-file.ts"() {
     "use strict";
-    path11 = __toESM(require("path"), 1);
+    path9 = __toESM(require("path"), 1);
     import_node_url3 = require("url");
     init_build();
   }
@@ -225,7 +274,6 @@ __export(vite_exports, {
 module.exports = __toCommonJS(vite_exports);
 var import_vite = require("vite");
 init_build();
-var import_node_querystring2 = require("querystring");
 
 // src/utils/validation.ts
 var import_picocolors = __toESM(require("picocolors"), 1);
@@ -265,10 +313,6 @@ async function validate(schema, data, context, errorMessage) {
   return data;
 }
 
-// src/vite/index.ts
-var path12 = __toESM(require("path"), 1);
-var import_js_yaml2 = require("js-yaml");
-
 // src/utils/fuma-matter.ts
 var import_js_yaml = require("js-yaml");
 var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
@@ -703,7 +747,7 @@ function createMdxLoader(configLoader) {
         );
       };
     }
-    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? config.getCollection(parsed.collection) : void 0;
     let docCollection;
     switch (collection?.type) {
       case "doc":
@@ -775,18 +819,11 @@ function countLines(s) {
   return num;
 }
 
-// src/loaders/config/index.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var import_promises2 = __toESM(require("fs/promises"), 1);
-function findConfigFile() {
-  return import_node_path3.default.resolve("source.config.ts");
-}
-
 // src/loaders/adapter.ts
 var import_node_url = require("url");
-var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 function toVite(loader) {
   return async function(file, query, value) {
     const result = await loader({
@@ -800,6 +837,7 @@ function toVite(loader) {
         }
       }
     });
+    if (result === null) return null;
     return {
       code: result.code,
       map: result.map
@@ -808,9 +846,9 @@ function toVite(loader) {
 }
 
 // src/utils/import-formatter.ts
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 function toImportPath(file, config) {
-  const ext = import_node_path5.default.extname(file);
+  const ext = import_node_path4.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -821,43 +859,30 @@ function toImportPath(file, config) {
   }
   let importPath;
   if ("relativeTo" in config) {
-    importPath = import_node_path5.default.relative(config.relativeTo, filename);
-    if (!import_node_path5.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = import_node_path4.default.relative(config.relativeTo, filename);
+    if (!import_node_path4.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path5.default.resolve(filename);
+    importPath = import_node_path4.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path5.default.sep, "/");
+  return importPath.replaceAll(import_node_path4.default.sep, "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
 
-// src/utils/collections.ts
-var import_picomatch = __toESM(require("picomatch"), 1);
-var import_tinyglobby = require("tinyglobby");
-var import_node_path6 = __toESM(require("path"), 1);
-var SupportedFormats = {
-  doc: ["mdx", "md"],
-  meta: ["json", "yaml"]
-};
-function getGlobPatterns(collection) {
-  if (collection.files) return collection.files;
-  return [`**/*.{${SupportedFormats[collection.type].join(",")}}`];
-}
-
 // src/utils/glob-import.ts
-var import_tinyglobby2 = require("tinyglobby");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_tinyglobby = require("tinyglobby");
+var import_node_path5 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 function generateGlobImport(patterns, options) {
   let code = "{";
-  const result = (0, import_tinyglobby2.globSync)(patterns, {
+  const result = (0, import_tinyglobby.globSync)(patterns, {
     cwd: options.base
   });
   for (const item of result) {
-    const fullPath = import_node_path7.default.join(options.base, item);
+    const fullPath = import_node_path5.default.join(options.base, item);
     const url = (0, import_node_url2.pathToFileURL)(fullPath);
     for (const [k, v] of Object.entries(options.query ?? {})) {
       url.searchParams.set(k, v);
@@ -873,28 +898,74 @@ function generateGlobImport(patterns, options) {
 }
 
 // src/plugins/vite.ts
-var import_node_path8 = __toESM(require("path"), 1);
-function vite(options) {
+var import_node_path6 = __toESM(require("path"), 1);
+function vite({
+  index
+}) {
   let config;
+  let indexOptions;
+  if (index === false) indexOptions = false;
+  else indexOptions = applyDefaults(index === true ? {} : index);
   return {
+    name: "vite",
     config(v) {
       config = v;
     },
-    emit() {
-      return [
-        {
-          path: "index.ts",
-          content: indexFile(this.configPath, this.outDir, config, options)
+    configureServer(server) {
+      if (!server.watcher || indexOptions === false || indexOptions.runtime === false)
+        return;
+      server.watcher.on("all", (event, file) => {
+        if (event === "change") return;
+        const isUpdated = config.collectionList.some((collection) => {
+          if (collection.type === "docs")
+            return collection.docs.hasFile(file) || collection.meta.hasFile(file);
+          return collection.hasFile(file);
+        });
+        if (isUpdated) {
+          this.core.emitAndWrite({
+            filterPlugin: (plugin) => plugin.name === "vite"
+          });
         }
-      ];
+      });
+    },
+    emit() {
+      const out = [];
+      if (indexOptions === false) return out;
+      if (indexOptions.browser) {
+        out.push({
+          path: "browser.ts",
+          content: indexFile(this, config, indexOptions, "browser")
+        });
+      }
+      out.push({
+        path: "index.ts",
+        content: indexFile(
+          this,
+          config,
+          indexOptions,
+          indexOptions.browser ? "server" : "all"
+        )
+      });
+      return out;
     }
   };
 }
-function indexFile(configPath, outDir, config, options) {
-  const { addJsExtension = false, runtime } = options;
+function applyDefaults(options) {
+  return {
+    addJsExtension: options.addJsExtension ?? false,
+    browser: options.browser ?? false,
+    runtime: options.runtime ?? false
+  };
+}
+function indexFile({ configPath, outDir }, config, { addJsExtension, runtime }, environment) {
+  const runtimePath = {
+    all: "fumadocs-mdx/runtime/vite",
+    server: "fumadocs-mdx/runtime/vite.server",
+    browser: "fumadocs-mdx/runtime/vite.browser"
+  }[environment];
   const lines = [
     '/// <reference types="vite/client" />',
-    `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
+    `import { fromConfig } from '${runtimePath}';`,
     `import type * as Config from '${toImportPath(configPath, {
       relativeTo: outDir,
       jsExtension: addJsExtension
@@ -902,74 +973,68 @@ function indexFile(configPath, outDir, config, options) {
     "",
     `export const create = fromConfig<typeof Config>();`
   ];
-  function docs(name, collection) {
-    const obj = [
-      ident(`doc: ${doc(name, collection.docs)}`),
-      ident(`meta: ${meta(name, collection.meta)}`)
-    ].join(",\n");
-    return `{
+  function generateCollectionGlob(collection) {
+    if (collection.type === "docs") {
+      const obj = [
+        ident(`doc: ${generateCollectionGlob(collection.docs)}`),
+        ident(`meta: ${generateCollectionGlob(collection.meta)}`)
+      ].join(",\n");
+      return `{
 ${obj}
 }`;
-  }
-  function doc(name, collection) {
-    const patterns = getGlobPatterns(collection);
+    }
     const dir = getCollectionDir(collection);
-    const docGlob = generateGlob(patterns, {
-      query: {
-        collection: name
-      },
-      base: dir
-    });
-    if (collection.async) {
-      const headBlob = generateGlob(patterns, {
+    if (collection.type === "doc") {
+      const docGlob = generateGlob(collection.patterns, {
         query: {
-          only: "frontmatter",
-          collection: name
+          collection: collection.name
         },
-        import: "frontmatter",
         base: dir
       });
-      return `create.docLazy("${name}", "${dir}", ${headBlob}, ${docGlob})`;
+      if (collection.async) {
+        const headBlob = generateGlob(collection.patterns, {
+          query: {
+            only: "frontmatter",
+            collection: collection.name
+          },
+          import: "frontmatter",
+          base: dir
+        });
+        return `create.docLazy("${collection.name}", "${dir}", ${headBlob}, ${docGlob})`;
+      }
+      return `create.doc("${collection.name}", "${dir}", ${docGlob})`;
     }
-    return `create.doc("${name}", "${dir}", ${docGlob})`;
-  }
-  function meta(name, collection) {
-    const patterns = getGlobPatterns(collection);
-    const dir = getCollectionDir(collection);
-    return `create.meta("${name}", "${dir}", ${generateGlob(patterns, {
-      import: "default",
-      base: dir,
-      query: {
-        collection: name
+    return `create.meta("${collection.name}", "${dir}", ${generateGlob(
+      collection.patterns,
+      {
+        import: "default",
+        base: dir,
+        query: {
+          collection: collection.name
+        }
       }
-    })})`;
+    )})`;
   }
-  function generateGlob(patterns, options2) {
+  function generateGlob(patterns, options) {
     patterns = patterns.map(normalizeGlobPath);
     if (runtime === "node" || runtime === "bun") {
-      return generateGlobImport(patterns, options2);
+      return generateGlobImport(patterns, options);
     } else {
       return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
         {
-          ...options2,
-          base: normalizeGlobPath(import_node_path8.default.relative(outDir, options2.base))
+          ...options,
+          base: normalizeGlobPath(import_node_path6.default.relative(outDir, options.base))
         },
         null,
         2
       )})`;
     }
   }
-  for (const [name, collection] of config.collections.entries()) {
-    let body;
-    if (collection.type === "docs") {
-      body = docs(name, collection);
-    } else if (collection.type === "meta") {
-      body = meta(name, collection);
-    } else {
-      body = doc(name, collection);
-    }
+  for (const collection of config.collectionList) {
     lines.push("");
-    lines.push(`export const ${name} = ${body};`);
+    lines.push(
+      `export const ${collection.name} = ${generateCollectionGlob(collection)};`
+    );
   }
   return lines.join("\n");
 }
@@ -979,8 +1044,7 @@ function normalizeGlobPath(file) {
   if (file.startsWith("/")) return `.${file}`;
   return `./${file}`;
 }
-function getCollectionDir(collection) {
-  const dir = collection.dir;
+function getCollectionDir({ dir }) {
   if (Array.isArray(dir)) {
     if (dir.length !== 1)
       throw new Error(
@@ -990,17 +1054,20 @@ function getCollectionDir(collection) {
   }
   return dir;
 }
-function slash(path13) {
-  const isExtendedLengthPath = path13.startsWith("\\\\?\\");
+function slash(path10) {
+  const isExtendedLengthPath = path10.startsWith("\\\\?\\");
   if (isExtendedLengthPath) {
-    return path13;
+    return path10;
   }
-  return path13.replaceAll("\\", "/");
+  return path10.replaceAll("\\", "/");
 }
 
 // src/core.ts
-var import_node_path9 = __toESM(require("path"), 1);
-var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+function findConfigFile() {
+  return import_node_path7.default.resolve("source.config.ts");
+}
 function createCore(options, defaultPlugins = []) {
   let config;
   let plugins2;
@@ -1037,13 +1104,6 @@ function createCore(options, defaultPlugins = []) {
     getConfig() {
       return config;
     },
-    creatConfigLoader() {
-      return {
-        getConfig() {
-          return config;
-        }
-      };
-    },
     async initServer(server) {
       for (const plugin of plugins2) {
         await plugin.configureServer?.call(this.getPluginContext(), server);
@@ -1061,9 +1121,9 @@ function createCore(options, defaultPlugins = []) {
       );
       await Promise.all(
         out.flat().map(async (entry) => {
-          const file = import_node_path9.default.join(options.outDir, entry.path);
-          await import_promises4.default.mkdir(import_node_path9.default.dirname(file), { recursive: true });
-          await import_promises4.default.writeFile(file, entry.content);
+          const file = import_node_path7.default.join(options.outDir, entry.path);
+          await import_promises3.default.mkdir(import_node_path7.default.dirname(file), { recursive: true });
+          await import_promises3.default.writeFile(file, entry.content);
         })
       );
       console.log(`[MDX] generated files in ${performance.now() - start}ms`);
@@ -1071,21 +1131,37 @@ function createCore(options, defaultPlugins = []) {
   };
 }
 
-// src/vite/index.ts
-var FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
-async function mdx(config, pluginOptions = {}) {
-  const options = applyDefaults(pluginOptions);
-  const core = await createViteCore(options).init({
-    config: buildConfig(config)
-  });
-  const mdxLoader = toVite(createMdxLoader(core.creatConfigLoader()));
-  async function transformMeta(path13, query, value) {
-    const isJson = path13.endsWith(".json");
-    const parsed = (0, import_node_querystring2.parse)(query);
-    const collection = parsed.collection ? core.getConfig().collections.get(parsed.collection) : void 0;
+// src/loaders/config.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+function createIntegratedConfigLoader(core) {
+  return {
+    getConfig() {
+      return core.getConfig();
+    }
+  };
+}
+
+// src/loaders/meta.ts
+var import_js_yaml2 = require("js-yaml");
+var import_zod2 = require("zod");
+var querySchema2 = import_zod2.z.object({
+  collection: import_zod2.z.string().optional()
+}).loose();
+function createMetaLoader(configLoader, resolve3 = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve3;
+  return async ({ filePath, query, source }) => {
+    const isJson = filePath.endsWith(".json");
+    const parsed = querySchema2.parse(query);
+    const collection = parsed.collection ? (await configLoader.getConfig()).getCollection(parsed.collection) : void 0;
     if (!collection) return null;
+    let data;
+    try {
+      data = isJson ? JSON.parse(source) : (0, import_js_yaml2.load)(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
+    }
     let schema;
-    switch (collection.type) {
+    switch (collection?.type) {
       case "meta":
         schema = collection.schema;
         break;
@@ -1093,24 +1169,46 @@ async function mdx(config, pluginOptions = {}) {
         schema = collection.meta.schema;
         break;
     }
-    if (!schema) return null;
-    let data;
-    try {
-      data = isJson ? JSON.parse(value) : (0, import_js_yaml2.load)(value);
-    } catch {
-      return null;
+    if (schema) {
+      data = await validate(
+        schema,
+        data,
+        { path: filePath, source },
+        `invalid data in ${filePath}`
+      );
+    }
+    let code;
+    if (isJson) {
+      code = resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`;
+    } else {
+      code = resolveYaml === "yaml" ? (0, import_js_yaml2.dump)(data) : `export default ${JSON.stringify(data)}`;
     }
-    const out = await validate(
-      schema,
-      data,
-      { path: path13, source: value },
-      `invalid data in ${path13}`
-    );
     return {
-      code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
+      code,
       map: null
     };
-  }
+  };
+}
+
+// src/loaders/index.ts
+var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+
+// src/vite/index.ts
+var FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
+async function mdx(config, pluginOptions = {}) {
+  const options = applyDefaults2(pluginOptions);
+  const core = await createViteCore(options).init({
+    config: buildConfig(config)
+  });
+  const configLoader = createIntegratedConfigLoader(core);
+  const mdxLoader = toVite(createMdxLoader(configLoader));
+  const metaLoader = toVite(
+    createMetaLoader(configLoader, {
+      // vite has built-in plugin for JSON files
+      json: "json"
+    })
+  );
   return {
     name: "fumadocs-mdx",
     // needed, otherwise other plugins will be executed before our `transform`.
@@ -1136,13 +1234,15 @@ async function mdx(config, pluginOptions = {}) {
       });
     },
     async transform(value, id) {
-      const [file, query = ""] = id.split("?");
-      const ext = path12.extname(file);
       try {
-        if ([".yaml", ".json"].includes(ext))
-          return await transformMeta(file, query, value);
-        if ([".md", ".mdx"].includes(ext))
+        if (metaLoaderGlob.test(id)) {
+          const [file, query = ""] = id.split("?", 2);
+          return await metaLoader.call(this, file, query, value);
+        }
+        if (mdxLoaderGlob.test(id)) {
+          const [file, query = ""] = id.split("?", 2);
           return await mdxLoader.call(this, file, query, value);
+        }
       } catch (e) {
         if (e instanceof ValidationError) {
           throw new Error(e.toStringFormatted());
@@ -1153,8 +1253,8 @@ async function mdx(config, pluginOptions = {}) {
   };
 }
 async function postInstall(configPath = findConfigFile(), pluginOptions = {}) {
-  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load(), load_exports));
-  const options = applyDefaults(pluginOptions);
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
+  const options = applyDefaults2(pluginOptions);
   const core = await createViteCore(options).init({
     config: loadConfig2(configPath, options.outDir, true)
   });
@@ -1172,11 +1272,13 @@ function createViteCore({
       outDir
     },
     [
-      generateIndexFile !== false && vite(typeof generateIndexFile === "object" ? generateIndexFile : {})
+      vite({
+        index: generateIndexFile
+      })
     ]
   );
 }
-function applyDefaults(options) {
+function applyDefaults2(options) {
   return {
     updateViteConfig: options.updateViteConfig ?? true,
     generateIndexFile: options.generateIndexFile ?? true,

package/dist/vite/index.d.cts

@@ -13,6 +13,10 @@ interface IndexFileOptions {
      * add `.js` extensions to imports, needed for ESM without bundler resolution
      */
     addJsExtension?: boolean;
+    /**
+     * Generate entry point for browser environment
+     */
+    browser?: boolean;
 }
 
 interface PluginOptions {