fumadocs-mdx 11.4.1 → 11.5.0

package/dist/next/index.js

@@ -3,17 +3,16 @@ import {
   getConfigHash,
   loadConfig,
   loadConfigCached
-} from "../chunk-IU4D6M3A.js";
-import "../chunk-2DJQ3DOD.js";
+} from "../chunk-2C4NRJ5O.js";
+import "../chunk-6ZVE73IT.js";
 
 // src/next/create.ts
 import path3 from "node:path";
 
 // src/map/index.ts
 import * as path2 from "node:path";
-import * as fs from "node:fs";
-import { writeFile } from "node:fs/promises";
-import grayMatter from "gray-matter";
+import * as fs2 from "node:fs";
+import { writeFile, rm } from "node:fs/promises";
 
 // src/map/generate.ts
 import * as path from "node:path";
@@ -32,65 +31,89 @@ function getTypeFromPath(path5) {
 // src/map/generate.ts
 async function generateJS(configPath, config, outputPath, configHash, getFrontmatter) {
   const outDir2 = path.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"]
-          }
+    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(
+          ", "
         );
-        lines.unshift(
-          "const [err, _sourceConfig] = buildConfig(_source)",
-          "if (err) throw new Error(err)"
-        );
-        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();
@@ -126,79 +149,75 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, dir) {
-  let importPath = path.relative(dir, file);
+  const ext = path.extname(file);
+  let importPath = path.relative(
+    dir,
+    ext === ".ts" ? file.substring(0, file.length - ext.length) : file
+  );
   if (!path.isAbsolute(importPath) && !importPath.startsWith(".")) {
     importPath = `./${importPath}`;
   }
   return importPath.replaceAll(path.sep, "/");
 }
-function generateTypes(configPath, config, outputPath) {
-  const importPath = JSON.stringify(
-    toImportPath(configPath, path.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
+import * as fs from "node:fs";
+import grayMatter from "gray-matter";
+async function readFrontmatter(file) {
+  const readStream = fs.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(
+          grayMatter({
+            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 rm(path2.resolve(outDir2, `index.js`), { force: true });
+  void rm(path2.resolve(outDir2, `index.d.ts`), { force: true });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfigCached(configPath, configHash);
-  const jsOut = path2.resolve(outDir2, `index.js`);
-  const typeOut = path2.resolve(outDir2, `index.d.ts`);
+  const outPath = path2.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 = fs.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(
-            grayMatter({
-              content: str
-            }).data
-          );
-          readStream.close();
-        }
+  fs2.mkdirSync(outDir2, { recursive: true });
+  fs2.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;
-    });
-  }
-  fs.mkdirSync(outDir2, { recursive: true });
-  fs.writeFileSync(
-    jsOut,
-    await generateJS(configPath, config, jsOut, configHash, readFrontmatter)
+    })
   );
-  fs.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
   console.log("[MDX] initialized map file");
   if (dev) {
-    const { watcher } = await import("../watcher-7ALL6XOY.js");
+    const { watcher } = await import("../watcher-IAZDSTU7.js");
     const instance = watcher(configPath, config);
     instance.on("ready", () => {
       console.log("[MDX] started dev server");
@@ -210,17 +229,15 @@ async function start(dev, configPath, outDir2) {
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfigCached(configPath, configHash);
-          await writeFile(typeOut, generateTypes(configPath, config, typeOut));
-          console.log("[MDX] Updated map types");
         }
         if (isConfigFile || event !== "change" || hookUpdate) {
           if (event === "change") frontmatterCache.delete(file);
           await writeFile(
-            jsOut,
+            outPath,
             await generateJS(
               configPath,
               config,
-              jsOut,
+              outPath,
               configHash,
               readFrontmatter
             )
@@ -300,12 +317,22 @@ function createMDX({
 
 // src/postinstall.ts
 import * as path4 from "node:path";
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 async function postInstall(configPath = findConfigFile()) {
-  const typeOut = path4.resolve(".source/index.d.ts");
+  const jsOut = path4.resolve(".source/index.ts");
   const config = await loadConfig(configPath);
-  fs2.mkdirSync(path4.dirname(typeOut), { recursive: true });
-  fs2.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  const hash = await getConfigHash(configPath);
+  fs3.mkdirSync(path4.dirname(jsOut), { recursive: true });
+  fs3.writeFileSync(
+    jsOut,
+    await generateJS(
+      configPath,
+      config,
+      path4.resolve(".source/index.ts"),
+      hash,
+      readFrontmatter
+    )
+  );
   console.log("[MDX] types generated");
 }
 export {

package/dist/runtime/async.cjs

@@ -157,7 +157,7 @@ var init_mdx_options = __esm({
 // src/runtime/async.ts
 var async_exports = {};
 __export(async_exports, {
-  asyncFiles: () => asyncFiles,
+  _runtimeAsync: () => _runtimeAsync,
   buildConfig: () => buildConfig
 });
 module.exports = __toCommonJS(async_exports);
@@ -217,6 +217,73 @@ function remarkInclude() {
 // src/runtime/async.ts
 var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
 
+// src/runtime/index.ts
+var _runtime = {
+  doc(files) {
+    return files.map((file) => {
+      const { default: body, frontmatter, ...exports2 } = file.data;
+      return {
+        body,
+        ...exports2,
+        ...frontmatter,
+        _exports: file.data,
+        _file: file.info
+      };
+    });
+  },
+  meta(files) {
+    return files.map((file) => {
+      return {
+        ...file.data.default,
+        _file: file.info
+      };
+    });
+  },
+  docs(docs, metas) {
+    const parsedDocs = this.doc(docs);
+    const parsedMetas = this.meta(metas);
+    return {
+      docs: parsedDocs,
+      meta: parsedMetas,
+      toFumadocsSource() {
+        return createMDXSource(parsedDocs, parsedMetas);
+      }
+    };
+  }
+};
+function createMDXSource(docs, meta = []) {
+  return {
+    files: (rootDir) => resolveFiles({
+      docs,
+      meta,
+      rootDir
+    })
+  };
+}
+function resolveFiles({
+  docs,
+  meta,
+  rootDir = ""
+}) {
+  const outputs = [];
+  for (const entry of docs) {
+    if (!entry._file.path.startsWith(rootDir)) continue;
+    outputs.push({
+      type: "page",
+      path: entry._file.path,
+      data: entry
+    });
+  }
+  for (const entry of meta) {
+    outputs.push({
+      type: "meta",
+      path: entry._file.path,
+      data: entry
+    });
+  }
+  return outputs;
+}
+
 // src/config/build.ts
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
@@ -225,12 +292,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;
@@ -266,45 +336,59 @@ function buildConfig(config) {
 }
 
 // src/runtime/async.ts
-function asyncFiles(files, collection, config) {
-  async function init() {
-    const col = config.collections.get(collection);
-    let mdxOptions;
-    if (col?.type === "doc" && col.mdxOptions) {
-      mdxOptions = col.mdxOptions;
-    } else {
-      const options = typeof config.global?.mdxOptions === "function" ? await config.global.mdxOptions() : config.global?.mdxOptions;
-      const remarkPlugins = options?.remarkPlugins ?? [];
-      mdxOptions = {
-        ...options,
-        remarkPlugins: (v) => typeof remarkPlugins === "function" ? [remarkInclude, ...remarkPlugins(v), import_mdx_plugins.remarkStructure] : [remarkInclude, ...v, ...remarkPlugins, import_mdx_plugins.remarkStructure]
-      };
-    }
-    return (0, import_mdx_remote.createCompiler)(mdxOptions);
+async function initCompiler(config, collection) {
+  let col = config.collections.get(collection);
+  if (col?.type === "docs") col = col.docs;
+  let mdxOptions;
+  if (col?.type === "doc" && col.mdxOptions) {
+    mdxOptions = col.mdxOptions;
+  } else {
+    const options = typeof config.global?.mdxOptions === "function" ? await config.global.mdxOptions() : config.global?.mdxOptions;
+    const remarkPlugins = options?.remarkPlugins ?? [];
+    mdxOptions = {
+      ...options,
+      remarkPlugins: (v) => typeof remarkPlugins === "function" ? [remarkInclude, ...remarkPlugins(v), import_mdx_plugins.remarkStructure] : [remarkInclude, ...v, ...remarkPlugins, import_mdx_plugins.remarkStructure]
+    };
   }
-  const initCompiler = init();
-  return files.map(({ file, frontmatter }) => {
+  return (0, import_mdx_remote.createCompiler)(mdxOptions);
+}
+var _runtimeAsync = {
+  doc(files, collection, config) {
+    const init = initCompiler(config, collection);
+    return files.map(({ info: file, data: frontmatter }) => {
+      return {
+        ...frontmatter,
+        _file: file,
+        async load() {
+          const compiler = await init;
+          const out = await compiler.compile({
+            source: (await fs2.readFile(file.absolutePath)).toString(),
+            filePath: file.absolutePath
+          });
+          return {
+            body: out.body,
+            toc: out.toc,
+            structuredData: out.vfile.data.structuredData,
+            _exports: out.exports ?? {}
+          };
+        }
+      };
+    });
+  },
+  docs(docs, metas, collection, config) {
+    const parsedDocs = this.doc(docs, collection, config);
+    const parsedMetas = _runtime.meta(metas);
     return {
-      ...frontmatter,
-      _file: file,
-      async load() {
-        const compiler = await initCompiler;
-        const out = await compiler.compile({
-          source: (await fs2.readFile(file.absolutePath)).toString(),
-          filePath: file.absolutePath
-        });
-        return {
-          body: out.body,
-          toc: out.toc,
-          structuredData: out.vfile.data.structuredData,
-          _exports: out.exports ?? {}
-        };
+      docs: parsedDocs,
+      meta: parsedMetas,
+      toFumadocsSource() {
+        return createMDXSource(parsedDocs, parsedMetas);
       }
     };
-  });
-}
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  asyncFiles,
+  _runtimeAsync,
   buildConfig
 });

package/dist/runtime/async.d.cts

@@ -1,15 +1,17 @@
-import { G as GlobalConfig, F as FileInfo } from '../build-mdx-o0kbHSlp.cjs';
-import { D as DocCollection, M as MetaCollection } from '../define-BB9hRiTI.cjs';
+import { D as DocCollection, c as MetaCollection, d as DocsCollection, G as GlobalConfig, e as defineCollections, B as BaseCollectionEntry, M as MarkdownProps } from '../define-_brlBG8j.cjs';
 import { ProcessorOptions } from '@mdx-js/mdx';
-import 'zod';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { RuntimeFile, _runtime } from '../index.cjs';
+import { Source, PageData, MetaData } from 'fumadocs-core/source';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';
 import 'fumadocs-core/server';
 import 'unified';
 import 'react';
+import 'zod';
 
 interface LoadedConfig {
-    collections: Map<string, InternalDocCollection | InternalMetaCollection>;
+    collections: Map<string, DocCollection | MetaCollection | DocsCollection>;
     getDefaultMDXOptions: () => Promise<ProcessorOptions>;
     global?: GlobalConfig;
     _runtime: {
@@ -19,17 +21,26 @@ interface LoadedConfig {
         files: Map<string, string>;
     };
 }
-type InternalDocCollection = DocCollection;
-type InternalMetaCollection = MetaCollection;
 
 declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];
 
-/**
- * @internal
- */
-declare function asyncFiles(files: {
-    file: FileInfo;
-    frontmatter: Record<string, unknown>;
-}[], collection: string, config: LoadedConfig): unknown[];
+interface RuntimeAsync {
+    doc: <C>(files: RuntimeFile[], collection: string, config: LoadedConfig) => C extends ReturnType<typeof defineCollections<'doc', infer Schema extends StandardSchemaV1, true>> ? (StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry & {
+        load: () => Promise<MarkdownProps>;
+    })[] : never;
+    docs: <Docs>(docs: RuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => Docs extends {
+        type: 'docs';
+        docs: unknown;
+        meta: unknown;
+    } ? {
+        docs: ReturnType<typeof _runtimeAsync.doc<Docs['docs']>>;
+        meta: ReturnType<typeof _runtime.meta<Docs['meta']>>;
+        toFumadocsSource: () => Source<{
+            pageData: ReturnType<typeof _runtimeAsync.doc<Docs['docs']>>[number] extends PageData & BaseCollectionEntry ? ReturnType<typeof _runtimeAsync.doc<Docs['docs']>>[number] : never;
+            metaData: ReturnType<typeof _runtime.meta<Docs['meta']>>[number] extends MetaData & BaseCollectionEntry ? ReturnType<typeof _runtime.meta<Docs['meta']>>[number] : never;
+        }>;
+    } : never;
+}
+declare const _runtimeAsync: RuntimeAsync;
 
-export { asyncFiles, buildConfig };
+export { type RuntimeAsync, _runtimeAsync, buildConfig };

package/dist/runtime/async.d.ts

@@ -1,15 +1,17 @@
-import { G as GlobalConfig, F as FileInfo } from '../build-mdx-o0kbHSlp.js';
-import { D as DocCollection, M as MetaCollection } from '../define-D3l733EX.js';
+import { D as DocCollection, c as MetaCollection, d as DocsCollection, G as GlobalConfig, e as defineCollections, B as BaseCollectionEntry, M as MarkdownProps } from '../define-_brlBG8j.js';
 import { ProcessorOptions } from '@mdx-js/mdx';
-import 'zod';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { RuntimeFile, _runtime } from '../index.js';
+import { Source, PageData, MetaData } from 'fumadocs-core/source';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';
 import 'fumadocs-core/server';
 import 'unified';
 import 'react';
+import 'zod';
 
 interface LoadedConfig {
-    collections: Map<string, InternalDocCollection | InternalMetaCollection>;
+    collections: Map<string, DocCollection | MetaCollection | DocsCollection>;
     getDefaultMDXOptions: () => Promise<ProcessorOptions>;
     global?: GlobalConfig;
     _runtime: {
@@ -19,17 +21,26 @@ interface LoadedConfig {
         files: Map<string, string>;
     };
 }
-type InternalDocCollection = DocCollection;
-type InternalMetaCollection = MetaCollection;
 
 declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];
 
-/**
- * @internal
- */
-declare function asyncFiles(files: {
-    file: FileInfo;
-    frontmatter: Record<string, unknown>;
-}[], collection: string, config: LoadedConfig): unknown[];
+interface RuntimeAsync {
+    doc: <C>(files: RuntimeFile[], collection: string, config: LoadedConfig) => C extends ReturnType<typeof defineCollections<'doc', infer Schema extends StandardSchemaV1, true>> ? (StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry & {
+        load: () => Promise<MarkdownProps>;
+    })[] : never;
+    docs: <Docs>(docs: RuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => Docs extends {
+        type: 'docs';
+        docs: unknown;
+        meta: unknown;
+    } ? {
+        docs: ReturnType<typeof _runtimeAsync.doc<Docs['docs']>>;
+        meta: ReturnType<typeof _runtime.meta<Docs['meta']>>;
+        toFumadocsSource: () => Source<{
+            pageData: ReturnType<typeof _runtimeAsync.doc<Docs['docs']>>[number] extends PageData & BaseCollectionEntry ? ReturnType<typeof _runtimeAsync.doc<Docs['docs']>>[number] : never;
+            metaData: ReturnType<typeof _runtime.meta<Docs['meta']>>[number] extends MetaData & BaseCollectionEntry ? ReturnType<typeof _runtime.meta<Docs['meta']>>[number] : never;
+        }>;
+    } : never;
+}
+declare const _runtimeAsync: RuntimeAsync;
 
-export { asyncFiles, buildConfig };
+export { type RuntimeAsync, _runtimeAsync, buildConfig };