fumadocs-mdx 11.6.0 → 13.0.1

package/dist/runtime/next/async.d.cts

@@ -0,0 +1,21 @@
+import { c as RuntimeAsync } from '../../types-DKGMoay5.cjs';
+import { L as LoadedConfig } from '../../core-B6j6Fxse.cjs';
+import '@standard-schema/spec';
+import 'fumadocs-core/source';
+import '../../index.cjs';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+import 'mdast';
+import '../../build-mdx-D-r3_eQL.cjs';
+import '@mdx-js/mdx';
+import 'react';
+import 'unified';
+import 'zod';
+import 'chokidar';
+
+declare function buildConfig(config: Record<string, unknown>): LoadedConfig;
+
+declare const _runtimeAsync: RuntimeAsync;
+
+export { _runtimeAsync, buildConfig };

package/dist/runtime/next/async.d.ts

@@ -0,0 +1,21 @@
+import { c as RuntimeAsync } from '../../types-AGzTfBmf.js';
+import { L as LoadedConfig } from '../../core-B6j6Fxse.js';
+import '@standard-schema/spec';
+import 'fumadocs-core/source';
+import '../../index.js';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+import 'mdast';
+import '../../build-mdx-CCNr86q6.js';
+import '@mdx-js/mdx';
+import 'react';
+import 'unified';
+import 'zod';
+import 'chokidar';
+
+declare function buildConfig(config: Record<string, unknown>): LoadedConfig;
+
+declare const _runtimeAsync: RuntimeAsync;
+
+export { _runtimeAsync, buildConfig };

package/dist/runtime/next/async.js

@@ -0,0 +1,89 @@
+import {
+  _runtime,
+  createMDXSource
+} from "../../chunk-KILFIBVW.js";
+import {
+  createDocMethods
+} from "../../chunk-NVRDCY6Z.js";
+import {
+  buildConfig
+} from "../../chunk-U4MQ44TS.js";
+import {
+  buildMDX
+} from "../../chunk-3J3WL7WN.js";
+import "../../chunk-K5ZLPEIQ.js";
+import {
+  fumaMatter
+} from "../../chunk-VWJKRQZR.js";
+
+// src/runtime/next/async.ts
+import { executeMdx } from "@fumadocs/mdx-remote/client";
+import { pathToFileURL } from "url";
+import fs from "fs/promises";
+function getDocCollection(config, collection) {
+  const col = config.collections.get(collection);
+  if (col?.type === "doc" && col.mdxOptions) return col;
+  if (col?.type === "docs" && col.docs.mdxOptions) return col.docs;
+}
+async function getOptions(config, collection) {
+  return collection?.mdxOptions ?? await config.getDefaultMDXOptions("remote");
+}
+var _runtimeAsync = {
+  doc(files, collectionName, config) {
+    const collection = getDocCollection(config, collectionName);
+    const initMdxOptions = getOptions(config, collection);
+    return files.map(({ info, data, lastModified }) => {
+      let cachedResult;
+      async function compileAndLoad() {
+        if (cachedResult) return cachedResult;
+        const mdxOptions = await initMdxOptions;
+        const raw = (await fs.readFile(info.fullPath)).toString();
+        const { content } = fumaMatter(raw);
+        const compiled = await buildMDX(collectionName, content, {
+          ...mdxOptions,
+          development: false,
+          frontmatter: data,
+          postprocess: collection?.postprocess,
+          data: {
+            lastModified
+          },
+          filePath: info.fullPath
+        });
+        const result = await executeMdx(String(compiled.value), {
+          baseUrl: pathToFileURL(info.fullPath)
+        });
+        return cachedResult = result;
+      }
+      return {
+        ...data,
+        ...createDocMethods(info, () => compileAndLoad()),
+        async load() {
+          const out = await compileAndLoad();
+          return {
+            _exports: out,
+            body: out.default,
+            lastModified,
+            toc: out.toc,
+            extractedReferences: out.extractedReferences,
+            structuredData: out.structuredData
+          };
+        }
+      };
+    });
+  },
+  docs(docs, metas, collection, config) {
+    const parsedDocs = this.doc(docs, collection, config);
+    const parsedMetas = _runtime.meta(metas);
+    return {
+      docs: parsedDocs,
+      meta: parsedMetas,
+      toFumadocsSource() {
+        return createMDXSource(parsedDocs, parsedMetas);
+      }
+    };
+  }
+};
+export {
+  _runtimeAsync,
+  buildConfig
+};

package/dist/runtime/next/index.cjs

@@ -0,0 +1,136 @@
+"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/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  _runtime: () => _runtime,
+  createMDXSource: () => createMDXSource,
+  resolveFiles: () => resolveFiles
+});
+module.exports = __toCommonJS(next_exports);
+
+// 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/next/index.ts
+var _runtime = {
+  doc(files) {
+    return files.map((file) => {
+      const data = file.data;
+      return {
+        _exports: data,
+        body: data.default,
+        lastModified: data.lastModified,
+        toc: data.toc,
+        structuredData: data.structuredData,
+        extractedReferences: data.extractedReferences,
+        ...data.frontmatter,
+        ...createDocMethods(file.info, () => Promise.resolve(data))
+      };
+    });
+  },
+  meta(files) {
+    return files.map((file) => {
+      return {
+        info: file.info,
+        ...file.data
+      };
+    });
+  },
+  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: resolveFiles({
+      docs,
+      meta
+    })
+  };
+}
+function resolveFiles({ docs, meta }) {
+  const outputs = [];
+  for (const entry of docs) {
+    outputs.push({
+      type: "page",
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
+      data: entry
+    });
+  }
+  for (const entry of meta) {
+    outputs.push({
+      type: "meta",
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
+      data: entry
+    });
+  }
+  return outputs;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _runtime,
+  createMDXSource,
+  resolveFiles
+});

package/dist/runtime/next/index.d.cts

@@ -0,0 +1,33 @@
+import { PageData, MetaData, Source, VirtualFile } from 'fumadocs-core/source';
+import { R as Runtime } from '../../types-DKGMoay5.cjs';
+export { b as AsyncDocOut, A as AsyncRuntimeFile, D as DocOut, M as MetaOut, c as RuntimeAsync, a as RuntimeFile } from '../../types-DKGMoay5.cjs';
+import { FileInfo } from '../../index.cjs';
+import '@standard-schema/spec';
+import '../../core-B6j6Fxse.cjs';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+import 'mdast';
+import '../../build-mdx-D-r3_eQL.cjs';
+import 'react';
+
+declare const _runtime: Runtime;
+interface AnyCollectionEntry {
+    info: FileInfo;
+}
+declare function createMDXSource<Doc extends PageData & AnyCollectionEntry, Meta extends MetaData & AnyCollectionEntry>(docs: Doc[], meta?: Meta[]): Source<{
+    pageData: Doc;
+    metaData: Meta;
+}>;
+interface ResolveOptions {
+    docs: AnyCollectionEntry[];
+    meta: AnyCollectionEntry[];
+    rootDir?: string;
+}
+declare function resolveFiles({ docs, meta }: ResolveOptions): VirtualFile[];
+
+export { type AnyCollectionEntry, Runtime, _runtime, createMDXSource, resolveFiles };

package/dist/runtime/next/index.d.ts

@@ -0,0 +1,33 @@
+import { PageData, MetaData, Source, VirtualFile } from 'fumadocs-core/source';
+import { R as Runtime } from '../../types-AGzTfBmf.js';
+export { b as AsyncDocOut, A as AsyncRuntimeFile, D as DocOut, M as MetaOut, c as RuntimeAsync, a as RuntimeFile } from '../../types-AGzTfBmf.js';
+import { FileInfo } from '../../index.js';
+import '@standard-schema/spec';
+import '../../core-B6j6Fxse.js';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+import 'mdast';
+import '../../build-mdx-CCNr86q6.js';
+import 'react';
+
+declare const _runtime: Runtime;
+interface AnyCollectionEntry {
+    info: FileInfo;
+}
+declare function createMDXSource<Doc extends PageData & AnyCollectionEntry, Meta extends MetaData & AnyCollectionEntry>(docs: Doc[], meta?: Meta[]): Source<{
+    pageData: Doc;
+    metaData: Meta;
+}>;
+interface ResolveOptions {
+    docs: AnyCollectionEntry[];
+    meta: AnyCollectionEntry[];
+    rootDir?: string;
+}
+declare function resolveFiles({ docs, meta }: ResolveOptions): VirtualFile[];
+
+export { type AnyCollectionEntry, Runtime, _runtime, createMDXSource, resolveFiles };

package/dist/runtime/next/index.js

@@ -0,0 +1,11 @@
+import {
+  _runtime,
+  createMDXSource,
+  resolveFiles
+} from "../../chunk-KILFIBVW.js";
+import "../../chunk-NVRDCY6Z.js";
+export {
+  _runtime,
+  createMDXSource,
+  resolveFiles
+};

package/dist/runtime/vite/browser.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/vite/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  createClientLoader: () => createClientLoader,
+  fromConfig: () => fromConfigBase,
+  fromConfigBase: () => fromConfigBase,
+  toClientRenderer: () => toClientRenderer
+});
+module.exports = __toCommonJS(browser_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(path) {
+      const loaded = await files[path]();
+      store.preloaded.set(path, loaded);
+      return loaded;
+    },
+    getRenderer,
+    getComponent(path) {
+      return getRenderer()[path];
+    },
+    useContent(path, props) {
+      const Comp = this.getComponent(path);
+      return (0, import_react.createElement)(Comp, props);
+    }
+  };
+}
+function toClientRenderer(files, component) {
+  return createClientLoader(files, { component }).getRenderer();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClientLoader,
+  fromConfig,
+  fromConfigBase,
+  toClientRenderer
+});

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

@@ -0,0 +1,59 @@
+import { b as DocCollection, c as DocsCollection, M as MetaCollection } from '../../core-B6j6Fxse.cjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { C as CompiledMDXProperties } from '../../build-mdx-D-r3_eQL.cjs';
+import { ReactNode, FC } from 'react';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+
+type CompiledMDXFile<Frontmatter> = CompiledMDXProperties<Frontmatter> & Record<string, unknown>;
+type DocMap<Frontmatter> = Record<string, (() => Promise<CompiledMDXFile<Frontmatter>>) & {
+    base: string;
+}>;
+type MetaMap<Data> = Record<string, (() => Promise<Data>) & {
+    base: string;
+}>;
+interface LazyDocMap<Frontmatter> {
+    base: string;
+    head: Record<string, () => Promise<Frontmatter>>;
+    body: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>;
+}
+interface BaseCreate<Config> {
+    doc: <Name extends keyof Config>(name: Name, base: string, glob: Record<string, () => Promise<unknown>>) => Config[Name] extends DocCollection<infer Schema> | DocsCollection<infer Schema> ? DocMap<StandardSchemaV1.InferOutput<Schema>> : never;
+    docLazy: <Name extends keyof Config>(name: Name, base: string, headGlob: Record<string, () => Promise<unknown>>, bodyGlob: Record<string, () => Promise<unknown>>) => Config[Name] extends DocCollection<infer Schema> | DocsCollection<infer Schema> ? LazyDocMap<StandardSchemaV1.InferOutput<Schema>> : never;
+    meta: <Name extends keyof Config>(name: Name, base: string, glob: Record<string, () => Promise<unknown>>) => Config[Name] extends MetaCollection<infer Schema> | DocsCollection<StandardSchemaV1, infer Schema> ? MetaMap<StandardSchemaV1.InferOutput<Schema>> : never;
+}
+declare function fromConfigBase<Config>(): BaseCreate<Config>;
+interface ClientLoaderOptions<Frontmatter, Props> {
+    /**
+     * Loader ID (usually your collection name)
+     *
+     * The code splitting strategy of frameworks like Tanstack Start may duplicate `createClientLoader()` into different chunks.
+     *
+     * We use loader ID to share cache between multiple instances of client loader.
+     *
+     * @defaultValue ''
+     */
+    id?: string;
+    component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode;
+}
+interface ClientLoader<Frontmatter, Props> {
+    preload: (path: string) => Promise<CompiledMDXFile<Frontmatter>>;
+    /**
+     * Get a component that renders content with `React.lazy`.
+     */
+    getComponent: (path: string) => FC<Props>;
+    /**
+     * Get react nodes that renders content with `React.lazy`.
+     */
+    useContent: (path: string, props: Props) => ReactNode;
+    getRenderer: () => Record<string, FC<Props>>;
+}
+declare function createClientLoader<Frontmatter, Props extends object = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, options: ClientLoaderOptions<Frontmatter, Props>): ClientLoader<Frontmatter, Props>;
+declare function toClientRenderer<Frontmatter, Props extends object = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode): Record<string, FC<Props>>;
+
+export { type BaseCreate, type ClientLoader, type ClientLoaderOptions, type CompiledMDXFile, type DocMap, type LazyDocMap, type MetaMap, createClientLoader, fromConfigBase as fromConfig, fromConfigBase, toClientRenderer };

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

@@ -0,0 +1,59 @@
+import { b as DocCollection, c as DocsCollection, M as MetaCollection } from '../../core-B6j6Fxse.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { C as CompiledMDXProperties } from '../../build-mdx-CCNr86q6.js';
+import { ReactNode, FC } from 'react';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+
+type CompiledMDXFile<Frontmatter> = CompiledMDXProperties<Frontmatter> & Record<string, unknown>;
+type DocMap<Frontmatter> = Record<string, (() => Promise<CompiledMDXFile<Frontmatter>>) & {
+    base: string;
+}>;
+type MetaMap<Data> = Record<string, (() => Promise<Data>) & {
+    base: string;
+}>;
+interface LazyDocMap<Frontmatter> {
+    base: string;
+    head: Record<string, () => Promise<Frontmatter>>;
+    body: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>;
+}
+interface BaseCreate<Config> {
+    doc: <Name extends keyof Config>(name: Name, base: string, glob: Record<string, () => Promise<unknown>>) => Config[Name] extends DocCollection<infer Schema> | DocsCollection<infer Schema> ? DocMap<StandardSchemaV1.InferOutput<Schema>> : never;
+    docLazy: <Name extends keyof Config>(name: Name, base: string, headGlob: Record<string, () => Promise<unknown>>, bodyGlob: Record<string, () => Promise<unknown>>) => Config[Name] extends DocCollection<infer Schema> | DocsCollection<infer Schema> ? LazyDocMap<StandardSchemaV1.InferOutput<Schema>> : never;
+    meta: <Name extends keyof Config>(name: Name, base: string, glob: Record<string, () => Promise<unknown>>) => Config[Name] extends MetaCollection<infer Schema> | DocsCollection<StandardSchemaV1, infer Schema> ? MetaMap<StandardSchemaV1.InferOutput<Schema>> : never;
+}
+declare function fromConfigBase<Config>(): BaseCreate<Config>;
+interface ClientLoaderOptions<Frontmatter, Props> {
+    /**
+     * Loader ID (usually your collection name)
+     *
+     * The code splitting strategy of frameworks like Tanstack Start may duplicate `createClientLoader()` into different chunks.
+     *
+     * We use loader ID to share cache between multiple instances of client loader.
+     *
+     * @defaultValue ''
+     */
+    id?: string;
+    component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode;
+}
+interface ClientLoader<Frontmatter, Props> {
+    preload: (path: string) => Promise<CompiledMDXFile<Frontmatter>>;
+    /**
+     * Get a component that renders content with `React.lazy`.
+     */
+    getComponent: (path: string) => FC<Props>;
+    /**
+     * Get react nodes that renders content with `React.lazy`.
+     */
+    useContent: (path: string, props: Props) => ReactNode;
+    getRenderer: () => Record<string, FC<Props>>;
+}
+declare function createClientLoader<Frontmatter, Props extends object = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, options: ClientLoaderOptions<Frontmatter, Props>): ClientLoader<Frontmatter, Props>;
+declare function toClientRenderer<Frontmatter, Props extends object = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode): Record<string, FC<Props>>;
+
+export { type BaseCreate, type ClientLoader, type ClientLoaderOptions, type CompiledMDXFile, type DocMap, type LazyDocMap, type MetaMap, createClientLoader, fromConfigBase as fromConfig, fromConfigBase, toClientRenderer };

package/dist/runtime/vite/browser.js

@@ -0,0 +1,11 @@
+import {
+  createClientLoader,
+  fromConfigBase,
+  toClientRenderer
+} from "../../chunk-II3H5ZVZ.js";
+export {
+  createClientLoader,
+  fromConfigBase as fromConfig,
+  fromConfigBase,
+  toClientRenderer
+};