fumadocs-mdx 13.0.2 → 13.0.4

package/dist/vite/index.d.ts

@@ -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 {

package/dist/vite/index.js

@@ -4,33 +4,33 @@ import {
 } from "../chunk-CXA4JO4Z.js";
 import {
   buildConfig
-} from "../chunk-U4MQ44TS.js";
-import {
-  toVite
-} from "../chunk-YVCR6FUH.js";
+} from "../chunk-2HXTGJBI.js";
 import {
   createMdxLoader
-} from "../chunk-XQ5O7IPO.js";
+} from "../chunk-XYGORKQA.js";
+import {
+  createMetaLoader
+} from "../chunk-YAIPHUCZ.js";
+import {
+  createIntegratedConfigLoader,
+  toVite
+} from "../chunk-ZNVPB2IR.js";
 import "../chunk-3J3WL7WN.js";
 import "../chunk-K5ZLPEIQ.js";
+import {
+  mdxLoaderGlob,
+  metaLoaderGlob
+} from "../chunk-4JSFLXXT.js";
+import "../chunk-VUEZTR2H.js";
 import {
   ValidationError,
   createCore,
-  findConfigFile,
-  validate
-} from "../chunk-EELYB2XC.js";
+  findConfigFile
+} from "../chunk-TZ5EQBFW.js";
 import "../chunk-VWJKRQZR.js";
-import {
-  getGlobPatterns
-} from "../chunk-XZY2AWJI.js";
 
 // src/vite/index.ts
-import {
-  mergeConfig
-} from "vite";
-import { parse } from "querystring";
-import * as path3 from "path";
-import { load } from "js-yaml";
+import { mergeConfig } from "vite";
 
 // src/utils/glob-import.ts
 import { globSync } from "tinyglobby";
@@ -59,27 +59,73 @@ function generateGlobImport(patterns, options) {
 
 // src/plugins/vite.ts
 import path2 from "path";
-function vite(options) {
+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
@@ -87,74 +133,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(path2.relative(outDir, options2.base))
+          ...options,
+          base: normalizeGlobPath(path2.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");
 }
@@ -164,8 +204,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(
@@ -175,54 +214,29 @@ function getCollectionDir(collection) {
   }
   return dir;
 }
-function slash(path4) {
-  const isExtendedLengthPath = path4.startsWith("\\\\?\\");
+function slash(path3) {
+  const isExtendedLengthPath = path3.startsWith("\\\\?\\");
   if (isExtendedLengthPath) {
-    return path4;
+    return path3;
   }
-  return path4.replaceAll("\\", "/");
+  return path3.replaceAll("\\", "/");
 }
 
 // src/vite/index.ts
 var FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
 async function mdx(config, pluginOptions = {}) {
-  const options = applyDefaults(pluginOptions);
+  const options = applyDefaults2(pluginOptions);
   const core = await createViteCore(options).init({
     config: buildConfig(config)
   });
-  const mdxLoader = toVite(createMdxLoader(core.creatConfigLoader()));
-  async function transformMeta(path4, query, value) {
-    const isJson = path4.endsWith(".json");
-    const parsed = parse(query);
-    const collection = parsed.collection ? core.getConfig().collections.get(parsed.collection) : void 0;
-    if (!collection) return null;
-    let schema;
-    switch (collection.type) {
-      case "meta":
-        schema = collection.schema;
-        break;
-      case "docs":
-        schema = collection.meta.schema;
-        break;
-    }
-    if (!schema) return null;
-    let data;
-    try {
-      data = isJson ? JSON.parse(value) : load(value);
-    } catch {
-      return null;
-    }
-    const out = await validate(
-      schema,
-      data,
-      { path: path4, source: value },
-      `invalid data in ${path4}`
-    );
-    return {
-      code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
-      map: null
-    };
-  }
+  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`.
@@ -248,13 +262,15 @@ async function mdx(config, pluginOptions = {}) {
       });
     },
     async transform(value, id) {
-      const [file, query = ""] = id.split("?");
-      const ext = path3.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());
@@ -265,8 +281,8 @@ async function mdx(config, pluginOptions = {}) {
   };
 }
 async function postInstall(configPath = findConfigFile(), pluginOptions = {}) {
-  const { loadConfig } = await import("../load-MNG3CLET.js");
-  const options = applyDefaults(pluginOptions);
+  const { loadConfig } = await import("../load-from-file-AVYOFOI7.js");
+  const options = applyDefaults2(pluginOptions);
   const core = await createViteCore(options).init({
     config: loadConfig(configPath, options.outDir, true)
   });
@@ -284,11 +300,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,