fumadocs-mdx 11.4.1 → 11.5.0

package/dist/next/index.cjs

@@ -161,9 +161,17 @@ __export(watcher_exports, {
 });
 function watcher(configPath, config) {
   const deps = [configPath];
+  function add(dir) {
+    if (Array.isArray(dir)) deps.push(...dir);
+    else deps.push(dir);
+  }
   for (const collection of config.collections.values()) {
-    if (Array.isArray(collection.dir)) deps.push(...collection.dir);
-    else deps.push(collection.dir);
+    if (collection.type === "docs") {
+      add(collection.docs.dir);
+      add(collection.meta.dir);
+    } else {
+      add(collection.dir);
+    }
   }
   return (0, import_chokidar.watch)(deps, {
     ignoreInitial: true,
@@ -202,12 +210,15 @@ function buildConfig(config) {
     if (!v) {
       continue;
     }
-    if (typeof v === "object" && "_doc" in v && v._doc === "collections") {
-      collections.set(
-        k,
-        v
-      );
-      continue;
+    if (typeof v === "object" && "type" in v) {
+      if (v.type === "docs") {
+        collections.set(k, v);
+        continue;
+      }
+      if (v.type === "doc" || v.type === "meta") {
+        collections.set(k, v);
+        continue;
+      }
     }
     if (k === "default") {
       globalConfig = v;
@@ -277,9 +288,8 @@ async function loadConfig(configPath) {
 
 // src/map/index.ts
 var path3 = __toESM(require("path"), 1);
-var fs2 = __toESM(require("fs"), 1);
+var fs3 = __toESM(require("fs"), 1);
 var import_promises = require("fs/promises");
-var import_gray_matter = __toESM(require("gray-matter"), 1);
 
 // src/utils/config-cache.ts
 var import_node_crypto = require("crypto");
@@ -320,65 +330,89 @@ function getTypeFromPath(path6) {
 // src/map/generate.ts
 async function generateJS(configPath, config, outputPath, configHash, getFrontmatter) {
   const outDir2 = path2.dirname(outputPath);
-  const imports = [
-    {
+  let asyncInit = false;
+  const lines = [
+    getImportCode({
       type: "named",
-      names: ["toRuntime"],
+      names: ["_runtime"],
       specifier: "fumadocs-mdx"
-    }
+    }),
+    getImportCode({
+      type: "namespace",
+      specifier: toImportPath(configPath, outDir2),
+      name: "_source"
+    })
   ];
-  let asyncInit = false;
-  const lines = [];
   config._runtime.files.clear();
   const entries = Array.from(config.collections.entries());
+  async function getEntries(collectionName, collection, files) {
+    const items = files.map(async (file, i) => {
+      config._runtime.files.set(file.absolutePath, collectionName);
+      const importId = `${collectionName}_${collection.type}_${i}`;
+      lines.unshift(
+        getImportCode({
+          type: "namespace",
+          name: importId,
+          specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${collectionName}&hash=${configHash}`
+        })
+      );
+      return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
+    });
+    return Promise.all(items);
+  }
+  async function getAsyncEntries(files) {
+    if (!asyncInit) {
+      lines.unshift(
+        getImportCode({
+          type: "named",
+          specifier: "fumadocs-mdx/runtime/async",
+          names: ["_runtimeAsync", "buildConfig"]
+        }),
+        "const [err, _sourceConfig] = buildConfig(_source)",
+        "if (!_sourceConfig) throw new Error(err)"
+      );
+      asyncInit = true;
+    }
+    const entries2 = files.map(async (file) => {
+      const frontmatter = await getFrontmatter(file.absolutePath);
+      return JSON.stringify({
+        info: file,
+        data: frontmatter
+      });
+    });
+    return Promise.all(entries2);
+  }
   const declares = entries.map(async ([k, collection]) => {
-    const files = await getCollectionFiles(collection);
-    if (collection.type === "doc" && collection.async) {
-      if (!asyncInit) {
-        imports.push(
-          {
-            type: "namespace",
-            specifier: toImportPath(configPath, outDir2),
-            name: "_source"
-          },
-          {
-            type: "named",
-            specifier: "fumadocs-mdx/runtime/async",
-            names: ["asyncFiles", "buildConfig"]
-          }
-        );
-        lines.unshift(
-          "const [err, _sourceConfig] = buildConfig(_source)",
-          "if (err) throw new Error(err)"
+    if (collection.type === "docs") {
+      const docs = await getCollectionFiles(collection.docs);
+      const metas = await getCollectionFiles(collection.meta);
+      if (collection.docs.async) {
+        const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
+        const metaEntries2 = (await getEntries(k, collection.meta, metas)).join(
+          ", "
         );
-        asyncInit = true;
+        return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries2}], "${k}", _sourceConfig)`;
       }
-      const entries2 = files.map(async (file) => {
-        const frontmatter = await getFrontmatter(file.absolutePath);
-        return JSON.stringify({
-          frontmatter,
-          file
-        });
-      });
-      return `export const ${k} = asyncFiles([${(await Promise.all(entries2)).join(", ")}], "${k}", _sourceConfig)`;
+      const docsEntries = (await getEntries(k, collection.docs, docs)).join(
+        ", "
+      );
+      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
+        ", "
+      );
+      return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
-    const items = files.map(async (file, i) => {
-      config._runtime.files.set(file.absolutePath, k);
-      const importId = `${k}_${i}`;
-      imports.push({
-        type: "namespace",
-        name: importId,
-        specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${k}&hash=${configHash}`
-      });
-      return `toRuntime("${collection.type}", ${importId}, ${JSON.stringify(file)})`;
-    });
-    const resolvedItems = await Promise.all(items);
-    return `export const ${k} = [${resolvedItems.join(", ")}];`;
+    const files = await getCollectionFiles(collection);
+    if (collection.type === "doc" && collection.async) {
+      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(files)).join(", ")}], "${k}", _sourceConfig)`;
+    }
+    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getEntries(k, collection, files)).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
-  return [...imports.map(getImportCode), ...lines, ...resolvedDeclares].join(
-    "\n"
-  );
+  return [
+    `// @ts-nocheck -- skip type checking`,
+    ...lines,
+    ...resolvedDeclares
+  ].join("\n");
 }
 async function getCollectionFiles(collection) {
   const files = /* @__PURE__ */ new Map();
@@ -414,76 +448,72 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, dir) {
-  let importPath = path2.relative(dir, file);
+  const ext = path2.extname(file);
+  let importPath = path2.relative(
+    dir,
+    ext === ".ts" ? file.substring(0, file.length - ext.length) : file
+  );
   if (!path2.isAbsolute(importPath) && !importPath.startsWith(".")) {
     importPath = `./${importPath}`;
   }
   return importPath.replaceAll(path2.sep, "/");
 }
-function generateTypes(configPath, config, outputPath) {
-  const importPath = JSON.stringify(
-    toImportPath(configPath, path2.dirname(outputPath))
-  );
-  const lines = [
-    'import type { GetOutput } from "fumadocs-mdx/config"'
-  ];
-  for (const name of config.collections.keys()) {
-    lines.push(
-      `export declare const ${name}: GetOutput<typeof import(${importPath}).${name}>`
-    );
-  }
-  return lines.join("\n");
+
+// src/utils/read-frontmatter.ts
+var fs2 = __toESM(require("fs"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+async function readFrontmatter(file) {
+  const readStream = fs2.createReadStream(file, {
+    highWaterMark: 250
+  });
+  return new Promise((res, rej) => {
+    let idx = 0;
+    let str = "";
+    readStream.on("data", (_chunk) => {
+      const chunk = _chunk.toString();
+      if (idx === 0 && !chunk.startsWith("---")) {
+        res({});
+        readStream.close();
+        return;
+      }
+      str += chunk;
+      idx++;
+      if (str.includes("\n---")) {
+        res(
+          (0, import_gray_matter.default)({
+            content: str
+          }).data
+        );
+        readStream.close();
+      }
+    });
+    readStream.on("end", () => res({}));
+    readStream.on("error", (e) => rej(e));
+  });
 }
 
 // src/map/index.ts
 async function start(dev, configPath, outDir2) {
+  void (0, import_promises.rm)(path3.resolve(outDir2, `index.js`), { force: true });
+  void (0, import_promises.rm)(path3.resolve(outDir2, `index.d.ts`), { force: true });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfigCached(configPath, configHash);
-  const jsOut = path3.resolve(outDir2, `index.js`);
-  const typeOut = path3.resolve(outDir2, `index.d.ts`);
+  const outPath = path3.resolve(outDir2, `index.ts`);
   const frontmatterCache = /* @__PURE__ */ new Map();
   let hookUpdate = false;
-  async function readFrontmatter(file) {
-    hookUpdate = true;
-    const cached = frontmatterCache.get(file);
-    if (cached) return cached;
-    const readStream = fs2.createReadStream(file, {
-      highWaterMark: 250
-    });
-    return new Promise((res, rej) => {
-      let idx = 0;
-      let str = "";
-      readStream.on("data", (_chunk) => {
-        const chunk = _chunk.toString();
-        if (idx === 0 && !chunk.startsWith("---")) {
-          res({});
-          readStream.close();
-          return;
-        }
-        str += chunk;
-        idx++;
-        if (str.includes("\n---")) {
-          res(
-            (0, import_gray_matter.default)({
-              content: str
-            }).data
-          );
-          readStream.close();
-        }
+  fs3.mkdirSync(outDir2, { recursive: true });
+  fs3.writeFileSync(
+    outPath,
+    await generateJS(configPath, config, outPath, configHash, (file) => {
+      hookUpdate = true;
+      const cached = frontmatterCache.get(file);
+      if (cached) return cached;
+      return readFrontmatter(file).then((res) => {
+        frontmatterCache.set(file, res);
+        return res;
       });
-      readStream.on("end", () => res({}));
-      readStream.on("error", (e) => rej(e));
-    }).then((res) => {
-      frontmatterCache.set(file, res);
-      return res;
-    });
-  }
-  fs2.mkdirSync(outDir2, { recursive: true });
-  fs2.writeFileSync(
-    jsOut,
-    await generateJS(configPath, config, jsOut, configHash, readFrontmatter)
+    })
   );
-  fs2.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
   console.log("[MDX] initialized map file");
   if (dev) {
     const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
@@ -498,17 +528,15 @@ async function start(dev, configPath, outDir2) {
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfigCached(configPath, configHash);
-          await (0, import_promises.writeFile)(typeOut, generateTypes(configPath, config, typeOut));
-          console.log("[MDX] Updated map types");
         }
         if (isConfigFile || event !== "change" || hookUpdate) {
           if (event === "change") frontmatterCache.delete(file);
           await (0, import_promises.writeFile)(
-            jsOut,
+            outPath,
             await generateJS(
               configPath,
               config,
-              jsOut,
+              outPath,
               configHash,
               readFrontmatter
             )
@@ -588,12 +616,22 @@ function createMDX({
 
 // src/postinstall.ts
 var path5 = __toESM(require("path"), 1);
-var fs3 = __toESM(require("fs"), 1);
+var fs4 = __toESM(require("fs"), 1);
 async function postInstall(configPath = findConfigFile()) {
-  const typeOut = path5.resolve(".source/index.d.ts");
+  const jsOut = path5.resolve(".source/index.ts");
   const config = await loadConfig(configPath);
-  fs3.mkdirSync(path5.dirname(typeOut), { recursive: true });
-  fs3.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  const hash = await getConfigHash(configPath);
+  fs4.mkdirSync(path5.dirname(jsOut), { recursive: true });
+  fs4.writeFileSync(
+    jsOut,
+    await generateJS(
+      configPath,
+      config,
+      path5.resolve(".source/index.ts"),
+      hash,
+      readFrontmatter
+    )
+  );
   console.log("[MDX] types generated");
 }
 // Annotate the CommonJS export names for ESM import in node: