fumadocs-mdx 13.0.2 → 13.0.4

package/dist/next/index.cjs

@@ -117,36 +117,97 @@ var init_preset = __esm({
   }
 });
 
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createMDX: () => createMDX,
+  postInstall: () => postInstall
+});
+module.exports = __toCommonJS(next_exports);
+var path7 = __toESM(require("path"), 1);
+
+// src/config/load-from-file.ts
+var path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
 // src/config/build.ts
+var import_picomatch = __toESM(require("picomatch"), 1);
+var SupportedFormats = {
+  doc: ["mdx", "md"],
+  meta: ["json", "yaml"]
+};
+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,13 +227,8 @@ function buildConfig(config) {
     }
   };
 }
-var init_build = __esm({
-  "src/config/build.ts"() {
-    "use strict";
-  }
-});
 
-// src/loaders/config/load.ts
+// src/config/load-from-file.ts
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -195,52 +251,24 @@ async function compileConfig(configPath, outDir) {
 }
 async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url.pathToFileURL)(path2.resolve(outDir, "source.config.mjs"));
+  const url = (0, import_node_url.pathToFileURL)(path.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 path2, import_node_url;
-var init_load = __esm({
-  "src/loaders/config/load.ts"() {
-    "use strict";
-    path2 = __toESM(require("path"), 1);
-    import_node_url = require("url");
-    init_build();
-  }
-});
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall
-});
-module.exports = __toCommonJS(next_exports);
-
-// src/loaders/config/index.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-function findConfigFile() {
-  return import_node_path.default.resolve("source.config.ts");
-}
-
-// src/next/index.ts
-var path9 = __toESM(require("path"), 1);
-init_load();
 
 // src/next/file-cache.ts
 var import_lru_cache = require("lru-cache");
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var map = new import_lru_cache.LRUCache({
   max: 100
 });
 function toFullPath(file) {
-  if (import_node_path2.default.isAbsolute(file)) {
-    return import_node_path2.default.relative(process.cwd(), file);
+  if (import_node_path.default.isAbsolute(file)) {
+    return import_node_path.default.relative(process.cwd(), file);
   }
   return file;
 }
@@ -248,7 +276,7 @@ async function readFileWithCache(file) {
   const fullPath = toFullPath(file);
   const cached = map.get(fullPath);
   if (cached) return cached;
-  const read = import_promises2.default.readFile(fullPath).then((s) => s.toString());
+  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
   map.set(fullPath, read);
   return read;
 }
@@ -295,12 +323,11 @@ async function validate(schema, data, context, errorMessage) {
 }
 
 // src/plugins/next.ts
-var path7 = __toESM(require("path"), 1);
+var path5 = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
-var import_js_yaml2 = require("js-yaml");
 
 // src/utils/git-timestamp.ts
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_tinyexec = require("tinyexec");
 var cache = /* @__PURE__ */ new Map();
 async function getGitTimestamp(file) {
@@ -309,7 +336,7 @@ async function getGitTimestamp(file) {
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path3.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
@@ -339,7 +366,7 @@ function fumaMatter(input) {
 }
 
 // src/utils/import-formatter.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 function getImportCode(info) {
   const specifier = JSON.stringify(info.specifier);
   if (info.type === "default") return `import ${info.name} from ${specifier}`;
@@ -354,7 +381,7 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, config) {
-  const ext = import_node_path4.default.extname(file);
+  const ext = import_node_path3.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -365,56 +392,18 @@ function toImportPath(file, config) {
   }
   let importPath;
   if ("relativeTo" in config) {
-    importPath = import_node_path4.default.relative(config.relativeTo, filename);
-    if (!import_node_path4.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = import_node_path3.default.relative(config.relativeTo, filename);
+    if (!import_node_path3.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path4.default.resolve(filename);
+    importPath = import_node_path3.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path4.default.sep, "/");
-}
-
-// src/utils/collections.ts
-var import_picomatch = __toESM(require("picomatch"), 1);
-var import_tinyglobby = require("tinyglobby");
-var import_node_path5 = __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(",")}}`];
-}
-function isFileSupported(filePath, collection) {
-  return SupportedFormats[collection.type].some(
-    (format) => filePath.endsWith(`.${format}`)
-  );
-}
-async function getCollectionFiles(collection) {
-  const files = /* @__PURE__ */ new Map();
-  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
-  const patterns = getGlobPatterns(collection);
-  await Promise.all(
-    dirs.map(async (dir) => {
-      const result = await (0, import_tinyglobby.glob)(patterns, {
-        cwd: import_node_path5.default.resolve(dir)
-      });
-      for (const item of result) {
-        if (!isFileSupported(item, collection)) continue;
-        const fullPath = import_node_path5.default.join(dir, item);
-        files.set(fullPath, {
-          path: item,
-          fullPath
-        });
-      }
-    })
-  );
-  return Array.from(files.values());
+  return importPath.replaceAll(import_node_path3.default.sep, "/");
 }
 
 // src/plugins/next.ts
+var import_js_yaml2 = require("js-yaml");
 function next() {
   let config;
   let shouldEmitOnChange = false;
@@ -422,17 +411,14 @@ function next() {
     name: "next",
     config(v) {
       config = v;
-      shouldEmitOnChange = false;
-      for (const collection of config.collections.values()) {
-        if (collection.type === "doc" && collection.async || collection.type === "docs" && collection.docs.async) {
-          shouldEmitOnChange = true;
-        }
-      }
+      shouldEmitOnChange = config.collectionList.some((collection) => {
+        return collection.type === "doc" && collection.async || collection.type === "docs" || collection.type === "meta";
+      });
     },
     configureServer(server) {
       if (!server.watcher) return;
-      server.watcher.on("all", async () => {
-        if (!shouldEmitOnChange) return;
+      server.watcher.on("all", async (event) => {
+        if (event === "change" && !shouldEmitOnChange) return;
         await this.core.emitAndWrite({
           filterPlugin: (plugin) => plugin.name === "next"
         });
@@ -450,7 +436,7 @@ function next() {
     }
   };
 }
-async function indexFile(configPath, config, importPath, configHash = false) {
+async function indexFile(configPath, config, importPath) {
   let asyncInit = false;
   const lines = [
     getImportCode({
@@ -464,14 +450,10 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       name: "_source"
     })
   ];
-  const entries = Array.from(config.collections.entries());
-  async function getDocEntries(collectionName, files) {
-    const items = files.map(async (file, i) => {
-      const importId = `${collectionName}_${i}`;
-      const params = [`collection=${collectionName}`];
-      if (configHash) {
-        params.push(`hash=${configHash}`);
-      }
+  function getDocEntries(collection, files) {
+    return files.map((file, i) => {
+      const importId = `d_${collection.name}_${i}`;
+      const params = [`collection=${collection.name}`];
       lines.unshift(
         getImportCode({
           type: "namespace",
@@ -481,7 +463,6 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       );
       return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
     });
-    return Promise.all(items);
   }
   async function getMetaEntries(collection, files) {
     const items = files.map(async (file) => {
@@ -522,7 +503,7 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       );
       asyncInit = true;
     }
-    const entries2 = files.map(async (file) => {
+    const entries = files.map(async (file) => {
       const content = await readFileWithCache(file.fullPath).catch(() => "");
       const parsed = fumaMatter(content);
       let data = parsed.data;
@@ -548,12 +529,13 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       );
       return `{ info: { ${infoStr.join(", ")} }, lastModified: ${JSON.stringify(lastModified)}, data: ${JSON.stringify(data)} }`;
     });
-    return Promise.all(entries2);
+    return Promise.all(entries);
   }
-  const declares = entries.map(async ([k, collection]) => {
+  const declares = config.collectionList.map(async (collection) => {
+    const k = collection.name;
     if (collection.type === "docs") {
-      const docs = await getCollectionFiles(collection.docs);
-      const metas = await getCollectionFiles(collection.meta);
+      const docs = await globCollectionFiles(collection.docs);
+      const metas = await globCollectionFiles(collection.meta);
       const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
@@ -563,14 +545,17 @@ async function indexFile(configPath, config, importPath, configHash = false) {
         );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getDocEntries(k, docs)).join(", ");
+      const docsEntries = getDocEntries(collection.docs, docs).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
-    const files = await getCollectionFiles(collection);
-    if (collection.type === "doc" && collection.async) {
+    const files = await globCollectionFiles(collection);
+    if (collection.type === "meta") {
+      return `export const ${k} = _runtime.meta<typeof _source.${k}>([${(await getMetaEntries(collection, files)).join(", ")}]);`;
+    }
+    if (collection.async) {
       return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
     }
-    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getDocEntries(k, files)).join(", ")}]);`;
+    return `export const ${k} = _runtime.doc<typeof _source.${k}>([${getDocEntries(collection, files).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
   return [
@@ -580,7 +565,7 @@ async function indexFile(configPath, config, importPath, configHash = false) {
   ].join("\n");
 }
 function parseMetaEntry(file, content) {
-  const extname2 = path7.extname(file);
+  const extname2 = path5.extname(file);
   try {
     if (extname2 === ".json") return JSON.parse(content);
     if (extname2 === ".yaml") return (0, import_js_yaml2.load)(content);
@@ -591,10 +576,34 @@ function parseMetaEntry(file, content) {
   }
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
+async function globCollectionFiles(collection) {
+  const { glob } = await import("tinyglobby");
+  const files = /* @__PURE__ */ new Map();
+  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
+  await Promise.all(
+    dirs.map(async (dir) => {
+      const result = await glob(collection.patterns, {
+        cwd: path5.resolve(dir)
+      });
+      for (const item of result) {
+        if (!collection.isFileSupported(item)) continue;
+        const fullPath = path5.join(dir, item);
+        files.set(fullPath, {
+          path: item,
+          fullPath
+        });
+      }
+    })
+  );
+  return Array.from(files.values());
+}
 
 // src/core.ts
-var import_node_path6 = __toESM(require("path"), 1);
-var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+function findConfigFile() {
+  return import_node_path4.default.resolve("source.config.ts");
+}
 function createCore(options, defaultPlugins = []) {
   let config;
   let plugins2;
@@ -631,13 +640,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);
@@ -655,9 +657,9 @@ function createCore(options, defaultPlugins = []) {
       );
       await Promise.all(
         out.flat().map(async (entry) => {
-          const file = import_node_path6.default.join(options.outDir, entry.path);
-          await import_promises3.default.mkdir(import_node_path6.default.dirname(file), { recursive: true });
-          await import_promises3.default.writeFile(file, entry.content);
+          const file = import_node_path4.default.join(options.outDir, entry.path);
+          await import_promises2.default.mkdir(import_node_path4.default.dirname(file), { recursive: true });
+          await import_promises2.default.writeFile(file, entry.content);
         })
       );
       console.log(`[MDX] generated files in ${performance.now() - start}ms`);
@@ -665,6 +667,9 @@ function createCore(options, defaultPlugins = []) {
   };
 }
 
+// src/loaders/index.ts
+var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+
 // src/next/index.ts
 var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
 function createMDX(createOptions = {}) {
@@ -675,7 +680,7 @@ function createMDX(createOptions = {}) {
     void init(isDev, options);
   }
   return (nextConfig = {}) => {
-    const mdxLoaderOptions = {
+    const loaderOptions = {
       ...options,
       isDev
     };
@@ -687,7 +692,7 @@ function createMDX(createOptions = {}) {
           loaders: [
             {
               loader: "fumadocs-mdx/loader-mdx",
-              options: mdxLoaderOptions
+              options: loaderOptions
             }
           ],
           as: "*.js"
@@ -703,12 +708,12 @@ function createMDX(createOptions = {}) {
         config.module ||= {};
         config.module.rules ||= [];
         config.module.rules.push({
-          test: /\.mdx?$/,
+          test: mdxLoaderGlob,
           use: [
             options2.defaultLoaders.babel,
             {
               loader: "fumadocs-mdx/loader-mdx",
-              options: mdxLoaderOptions
+              options: loaderOptions
             }
           ]
         });
@@ -734,7 +739,7 @@ async function init(dev, options) {
       ignored: [options.outDir]
     });
     watcher.add(options.configPath);
-    for (const collection of core.getConfig().collections.values()) {
+    for (const collection of core.getConfig().collectionList) {
       if (collection.type === "docs") {
         watcher.add(collection.docs.dir);
         watcher.add(collection.meta.dir);
@@ -746,9 +751,9 @@ async function init(dev, options) {
       console.log("[MDX] started dev server");
     });
     watcher.on("all", async (event, file) => {
-      const absolutePath = path9.resolve(file);
+      const absolutePath = path7.resolve(file);
       if (event === "change") removeFileCache(absolutePath);
-      if (absolutePath === path9.resolve(options.configPath)) {
+      if (absolutePath === path7.resolve(options.configPath)) {
         watcher.removeAllListeners();
         await watcher.close();
         await initOrReload();