fumadocs-mdx 11.6.0 → 13.0.1

package/dist/runtime/vite/server.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/vite/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createClientLoader: () => createClientLoader,
+  fromConfig: () => fromConfig,
+  fromConfigBase: () => fromConfigBase,
+  toClientRenderer: () => toClientRenderer
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/runtime/vite/base.ts
+var import_react = require("react");
+function fromConfigBase() {
+  function normalize(entries, base) {
+    const out = {};
+    for (const k in entries) {
+      const mappedK = k.startsWith("./") ? k.slice(2) : k;
+      if (base) Object.assign(entries[k], { base });
+      out[mappedK] = entries[k];
+    }
+    return out;
+  }
+  return {
+    doc(_, base, glob) {
+      return normalize(glob, base);
+    },
+    meta(_, base, glob) {
+      return normalize(glob, base);
+    },
+    docLazy(_, base, head, body) {
+      return {
+        base,
+        head: normalize(head),
+        body: normalize(body)
+      };
+    }
+  };
+}
+var loaderStore = /* @__PURE__ */ new Map();
+function createClientLoader(files, options) {
+  const { id = "", component } = options;
+  let renderer;
+  const store = loaderStore.get(id) ?? {
+    preloaded: /* @__PURE__ */ new Map()
+  };
+  loaderStore.set(id, store);
+  function getRenderer() {
+    if (renderer) return renderer;
+    renderer = {};
+    for (const k in files) {
+      const OnDemand = (0, import_react.lazy)(async () => {
+        const loaded = await files[k]();
+        return { default: (props) => component(loaded, props) };
+      });
+      renderer[k] = (props) => {
+        const cached = store.preloaded.get(k);
+        if (!cached) return (0, import_react.createElement)(OnDemand, props);
+        return component(cached, props);
+      };
+    }
+    return renderer;
+  }
+  return {
+    async preload(path2) {
+      const loaded = await files[path2]();
+      store.preloaded.set(path2, loaded);
+      return loaded;
+    },
+    getRenderer,
+    getComponent(path2) {
+      return getRenderer()[path2];
+    },
+    useContent(path2, props) {
+      const Comp = this.getComponent(path2);
+      return (0, import_react.createElement)(Comp, props);
+    }
+  };
+}
+function toClientRenderer(files, component) {
+  return createClientLoader(files, { component }).getRenderer();
+}
+
+// src/runtime/vite/server.ts
+var path = __toESM(require("path"), 1);
+
+// src/runtime/shared.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+function createDocMethods(info, load) {
+  return {
+    info,
+    async getText(type) {
+      if (type === "raw") {
+        return (await import_promises.default.readFile(info.fullPath)).toString();
+      }
+      const data = await load();
+      if (typeof data._markdown !== "string")
+        throw new Error(
+          "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+        );
+      return data._markdown;
+    },
+    async getMDAST() {
+      const data = await load();
+      if (!data._mdast)
+        throw new Error(
+          "getMDAST() requires `includeMDAST` to be enabled in your collection config."
+        );
+      return JSON.parse(data._mdast);
+    }
+  };
+}
+
+// src/runtime/vite/server.ts
+function fromConfig() {
+  const base = fromConfigBase();
+  function fileInfo(file, base2) {
+    return {
+      path: file,
+      fullPath: path.join(base2, file)
+    };
+  }
+  function mapDocData(entry) {
+    return {
+      body: entry.default,
+      toc: entry.toc,
+      extractedReferences: entry.extractedReferences,
+      structuredData: entry.structuredData,
+      lastModified: entry.lastModified,
+      _exports: entry
+    };
+  }
+  function mapPageData(info, entry) {
+    return {
+      ...mapDocData(entry),
+      ...entry.frontmatter,
+      ...createDocMethods(info, async () => entry)
+    };
+  }
+  function mapPageDataLazy(info, head, content) {
+    return {
+      ...head,
+      ...createDocMethods(info, content),
+      async load() {
+        return mapDocData(await content());
+      }
+    };
+  }
+  function mapMetaData(info, content) {
+    return {
+      info,
+      ...content
+    };
+  }
+  return {
+    ...base,
+    async sourceAsync(doc, meta) {
+      const virtualFiles = [
+        ...Object.entries(doc).map(async ([file, content]) => {
+          const info = fileInfo(file, content.base);
+          return {
+            type: "page",
+            path: file,
+            absolutePath: info.fullPath,
+            data: mapPageData(info, await content())
+          };
+        }),
+        ...Object.entries(meta).map(async ([file, content]) => {
+          const info = fileInfo(file, content.base);
+          return {
+            type: "meta",
+            path: info.path,
+            absolutePath: info.fullPath,
+            data: mapMetaData(info, await content())
+          };
+        })
+      ];
+      return {
+        files: await Promise.all(virtualFiles)
+      };
+    },
+    async sourceLazy(doc, meta) {
+      const virtualFiles = [
+        ...Object.entries(doc.head).map(async ([file, frontmatter]) => {
+          const info = fileInfo(file, doc.base);
+          return {
+            type: "page",
+            path: info.path,
+            absolutePath: info.fullPath,
+            data: mapPageDataLazy(info, await frontmatter(), doc.body[file])
+          };
+        }),
+        ...Object.entries(meta).map(async ([file, content]) => {
+          const info = fileInfo(file, content.base);
+          return {
+            type: "meta",
+            path: info.path,
+            absolutePath: info.fullPath,
+            data: mapMetaData(info, await content())
+          };
+        })
+      ];
+      return {
+        files: await Promise.all(virtualFiles)
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClientLoader,
+  fromConfig,
+  fromConfigBase,
+  toClientRenderer
+});

package/dist/runtime/vite/server.d.cts

@@ -0,0 +1,30 @@
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { BaseCreate, DocMap, MetaMap, LazyDocMap } from './browser.cjs';
+export { ClientLoader, ClientLoaderOptions, CompiledMDXFile, createClientLoader, fromConfig as fromConfigBase, toClientRenderer } from './browser.cjs';
+import { DocCollectionEntry, MetaCollectionEntry, AsyncDocCollectionEntry } from '../../index.cjs';
+import '../../core-B6j6Fxse.cjs';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import '../../build-mdx-D-r3_eQL.cjs';
+import 'fumadocs-core/toc';
+import 'react';
+import 'mdx/types';
+import 'mdast';
+
+interface ServerCreate<Config> extends BaseCreate<Config> {
+    sourceAsync: <DocOut extends PageData, MetaOut extends MetaData>(doc: DocMap<DocOut>, meta: MetaMap<MetaOut>) => Promise<Source<{
+        pageData: DocCollectionEntry<DocOut>;
+        metaData: MetaCollectionEntry<MetaOut>;
+    }>>;
+    sourceLazy: <DocOut extends PageData, MetaOut extends MetaData>(doc: LazyDocMap<DocOut>, meta: MetaMap<MetaOut>) => Promise<Source<{
+        pageData: AsyncDocCollectionEntry<DocOut>;
+        metaData: MetaCollectionEntry<MetaOut>;
+    }>>;
+}
+declare function fromConfig<Config>(): ServerCreate<Config>;
+
+export { BaseCreate, DocMap, LazyDocMap, MetaMap, type ServerCreate, fromConfig };

package/dist/runtime/vite/server.d.ts

@@ -0,0 +1,30 @@
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { BaseCreate, DocMap, MetaMap, LazyDocMap } from './browser.js';
+export { ClientLoader, ClientLoaderOptions, CompiledMDXFile, createClientLoader, fromConfig as fromConfigBase, toClientRenderer } from './browser.js';
+import { DocCollectionEntry, MetaCollectionEntry, AsyncDocCollectionEntry } from '../../index.js';
+import '../../core-B6j6Fxse.js';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import '../../build-mdx-CCNr86q6.js';
+import 'fumadocs-core/toc';
+import 'react';
+import 'mdx/types';
+import 'mdast';
+
+interface ServerCreate<Config> extends BaseCreate<Config> {
+    sourceAsync: <DocOut extends PageData, MetaOut extends MetaData>(doc: DocMap<DocOut>, meta: MetaMap<MetaOut>) => Promise<Source<{
+        pageData: DocCollectionEntry<DocOut>;
+        metaData: MetaCollectionEntry<MetaOut>;
+    }>>;
+    sourceLazy: <DocOut extends PageData, MetaOut extends MetaData>(doc: LazyDocMap<DocOut>, meta: MetaMap<MetaOut>) => Promise<Source<{
+        pageData: AsyncDocCollectionEntry<DocOut>;
+        metaData: MetaCollectionEntry<MetaOut>;
+    }>>;
+}
+declare function fromConfig<Config>(): ServerCreate<Config>;
+
+export { BaseCreate, DocMap, LazyDocMap, MetaMap, type ServerCreate, fromConfig };

package/dist/runtime/vite/server.js

@@ -0,0 +1,111 @@
+import {
+  createDocMethods
+} from "../../chunk-NVRDCY6Z.js";
+import {
+  createClientLoader,
+  fromConfigBase,
+  toClientRenderer
+} from "../../chunk-II3H5ZVZ.js";
+
+// src/runtime/vite/server.ts
+import * as path from "path";
+function fromConfig() {
+  const base = fromConfigBase();
+  function fileInfo(file, base2) {
+    return {
+      path: file,
+      fullPath: path.join(base2, file)
+    };
+  }
+  function mapDocData(entry) {
+    return {
+      body: entry.default,
+      toc: entry.toc,
+      extractedReferences: entry.extractedReferences,
+      structuredData: entry.structuredData,
+      lastModified: entry.lastModified,
+      _exports: entry
+    };
+  }
+  function mapPageData(info, entry) {
+    return {
+      ...mapDocData(entry),
+      ...entry.frontmatter,
+      ...createDocMethods(info, async () => entry)
+    };
+  }
+  function mapPageDataLazy(info, head, content) {
+    return {
+      ...head,
+      ...createDocMethods(info, content),
+      async load() {
+        return mapDocData(await content());
+      }
+    };
+  }
+  function mapMetaData(info, content) {
+    return {
+      info,
+      ...content
+    };
+  }
+  return {
+    ...base,
+    async sourceAsync(doc, meta) {
+      const virtualFiles = [
+        ...Object.entries(doc).map(async ([file, content]) => {
+          const info = fileInfo(file, content.base);
+          return {
+            type: "page",
+            path: file,
+            absolutePath: info.fullPath,
+            data: mapPageData(info, await content())
+          };
+        }),
+        ...Object.entries(meta).map(async ([file, content]) => {
+          const info = fileInfo(file, content.base);
+          return {
+            type: "meta",
+            path: info.path,
+            absolutePath: info.fullPath,
+            data: mapMetaData(info, await content())
+          };
+        })
+      ];
+      return {
+        files: await Promise.all(virtualFiles)
+      };
+    },
+    async sourceLazy(doc, meta) {
+      const virtualFiles = [
+        ...Object.entries(doc.head).map(async ([file, frontmatter]) => {
+          const info = fileInfo(file, doc.base);
+          return {
+            type: "page",
+            path: info.path,
+            absolutePath: info.fullPath,
+            data: mapPageDataLazy(info, await frontmatter(), doc.body[file])
+          };
+        }),
+        ...Object.entries(meta).map(async ([file, content]) => {
+          const info = fileInfo(file, content.base);
+          return {
+            type: "meta",
+            path: info.path,
+            absolutePath: info.fullPath,
+            data: mapMetaData(info, await content())
+          };
+        })
+      ];
+      return {
+        files: await Promise.all(virtualFiles)
+      };
+    }
+  };
+}
+export {
+  createClientLoader,
+  fromConfig,
+  fromConfigBase,
+  toClientRenderer
+};

package/dist/types-AGzTfBmf.d.ts

@@ -0,0 +1,45 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Source, PageData, MetaData } from 'fumadocs-core/source';
+import { L as LoadedConfig, b as DocCollection, c as DocsCollection, M as MetaCollection } from './core-B6j6Fxse.js';
+import { FileInfo, AsyncDocCollectionEntry, MetaCollectionEntry, DocCollectionEntry } from './index.js';
+
+interface RuntimeFile {
+    info: FileInfo;
+    data: Record<string, unknown>;
+}
+interface AsyncRuntimeFile {
+    info: FileInfo & {
+        hash?: string;
+        absolutePath?: string;
+    };
+    data: Record<string, unknown>;
+    lastModified?: Date;
+}
+type DocOut<Schema extends StandardSchemaV1 = StandardSchemaV1> = DocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>;
+type MetaOut<Schema extends StandardSchemaV1 = StandardSchemaV1> = MetaCollectionEntry<StandardSchemaV1.InferOutput<Schema>>;
+interface Runtime {
+    doc: <C>(files: RuntimeFile[]) => C extends DocCollection<infer Schema, false> ? DocOut<Schema>[] : never;
+    meta: <C>(files: RuntimeFile[]) => C extends MetaCollection<infer Schema> ? MetaOut<Schema>[] : never;
+    docs: <C>(docs: RuntimeFile[], metas: RuntimeFile[]) => C extends DocsCollection<infer DocSchema, infer MetaSchema, false> ? {
+        docs: DocOut<DocSchema>[];
+        meta: MetaOut<MetaSchema>[];
+        toFumadocsSource: () => Source<{
+            pageData: DocOut<DocSchema> extends PageData ? DocOut<DocSchema> : never;
+            metaData: MetaOut<MetaSchema> extends MetaData ? MetaOut<MetaSchema> : never;
+        }>;
+    } : never;
+}
+type AsyncDocOut<Schema extends StandardSchemaV1 = StandardSchemaV1> = AsyncDocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>;
+interface RuntimeAsync {
+    doc: <C>(files: AsyncRuntimeFile[], collection: string, config: LoadedConfig) => C extends DocCollection<infer Schema, true> ? AsyncDocOut<Schema>[] : never;
+    docs: <C>(docs: AsyncRuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => C extends DocsCollection<infer DocSchema, infer MetaSchema, true> ? {
+        docs: AsyncDocOut<DocSchema>[];
+        meta: MetaOut<MetaSchema>[];
+        toFumadocsSource: () => Source<{
+            pageData: AsyncDocOut<DocSchema> extends PageData ? AsyncDocOut<DocSchema> : never;
+            metaData: MetaOut<MetaSchema> extends MetaData ? MetaOut<MetaSchema> : never;
+        }>;
+    } : never;
+}
+
+export type { AsyncRuntimeFile as A, DocOut as D, MetaOut as M, Runtime as R, RuntimeFile as a, AsyncDocOut as b, RuntimeAsync as c };

package/dist/types-DKGMoay5.d.cts

@@ -0,0 +1,45 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Source, PageData, MetaData } from 'fumadocs-core/source';
+import { L as LoadedConfig, b as DocCollection, c as DocsCollection, M as MetaCollection } from './core-B6j6Fxse.cjs';
+import { FileInfo, AsyncDocCollectionEntry, MetaCollectionEntry, DocCollectionEntry } from './index.cjs';
+
+interface RuntimeFile {
+    info: FileInfo;
+    data: Record<string, unknown>;
+}
+interface AsyncRuntimeFile {
+    info: FileInfo & {
+        hash?: string;
+        absolutePath?: string;
+    };
+    data: Record<string, unknown>;
+    lastModified?: Date;
+}
+type DocOut<Schema extends StandardSchemaV1 = StandardSchemaV1> = DocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>;
+type MetaOut<Schema extends StandardSchemaV1 = StandardSchemaV1> = MetaCollectionEntry<StandardSchemaV1.InferOutput<Schema>>;
+interface Runtime {
+    doc: <C>(files: RuntimeFile[]) => C extends DocCollection<infer Schema, false> ? DocOut<Schema>[] : never;
+    meta: <C>(files: RuntimeFile[]) => C extends MetaCollection<infer Schema> ? MetaOut<Schema>[] : never;
+    docs: <C>(docs: RuntimeFile[], metas: RuntimeFile[]) => C extends DocsCollection<infer DocSchema, infer MetaSchema, false> ? {
+        docs: DocOut<DocSchema>[];
+        meta: MetaOut<MetaSchema>[];
+        toFumadocsSource: () => Source<{
+            pageData: DocOut<DocSchema> extends PageData ? DocOut<DocSchema> : never;
+            metaData: MetaOut<MetaSchema> extends MetaData ? MetaOut<MetaSchema> : never;
+        }>;
+    } : never;
+}
+type AsyncDocOut<Schema extends StandardSchemaV1 = StandardSchemaV1> = AsyncDocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>;
+interface RuntimeAsync {
+    doc: <C>(files: AsyncRuntimeFile[], collection: string, config: LoadedConfig) => C extends DocCollection<infer Schema, true> ? AsyncDocOut<Schema>[] : never;
+    docs: <C>(docs: AsyncRuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => C extends DocsCollection<infer DocSchema, infer MetaSchema, true> ? {
+        docs: AsyncDocOut<DocSchema>[];
+        meta: MetaOut<MetaSchema>[];
+        toFumadocsSource: () => Source<{
+            pageData: AsyncDocOut<DocSchema> extends PageData ? AsyncDocOut<DocSchema> : never;
+            metaData: MetaOut<MetaSchema> extends MetaData ? MetaOut<MetaSchema> : never;
+        }>;
+    } : never;
+}
+
+export type { AsyncRuntimeFile as A, DocOut as D, MetaOut as M, Runtime as R, RuntimeFile as a, AsyncDocOut as b, RuntimeAsync as c };