fumadocs-mdx 13.0.8 → 14.0.1

package/dist/runtime/dynamic.d.cts

@@ -0,0 +1,27 @@
+import * as fumadocs_core_source from 'fumadocs-core/source';
+import { i as CoreOptions, S as ServerOptions, D as DocCollection, a as DocsCollection, k as AsyncDocCollectionEntry, l as AsyncDocsCollectionEntry } from '../core-DTuP23zu.cjs';
+import * as _standard_schema_spec from '@standard-schema/spec';
+import { FileInfo, InternalTypeConfig } from './types.cjs';
+import '@mdx-js/mdx';
+import 'unified';
+import 'fumadocs-core/mdx-plugins';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';
+
+interface LazyEntry<Data = unknown> {
+    info: FileInfo;
+    data: Data;
+    hash?: string;
+}
+type CreateDynamic<Config, TC extends InternalTypeConfig = InternalTypeConfig> = ReturnType<typeof dynamic<Config, TC>>;
+declare function dynamic<Config, TC extends InternalTypeConfig>(configExports: Config, coreOptions: CoreOptions, serverOptions?: ServerOptions): Promise<{
+    doc<Name extends keyof Config & string>(name: Name, base: string, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<Name, _standard_schema_spec.StandardSchemaV1.InferOutput<Schema>, TC>[] : never>;
+    docs<Name extends keyof Config & string>(name: Name, base: string, meta: Record<string, unknown>, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocsCollection<infer Page extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, infer Meta extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? _standard_schema_spec.StandardSchemaV1.InferOutput<Page> extends fumadocs_core_source.PageData ? _standard_schema_spec.StandardSchemaV1.InferOutput<Meta> extends fumadocs_core_source.MetaData ? AsyncDocsCollectionEntry<Name, _standard_schema_spec.StandardSchemaV1.InferOutput<Page>, _standard_schema_spec.StandardSchemaV1.InferOutput<Meta>, TC> : never : never : never>;
+}>;
+
+export { type CreateDynamic, type LazyEntry, dynamic };

package/dist/runtime/dynamic.d.ts

@@ -0,0 +1,27 @@
+import * as fumadocs_core_source from 'fumadocs-core/source';
+import { i as CoreOptions, S as ServerOptions, D as DocCollection, a as DocsCollection, k as AsyncDocCollectionEntry, l as AsyncDocsCollectionEntry } from '../core-B9ZoS6sA.js';
+import * as _standard_schema_spec from '@standard-schema/spec';
+import { FileInfo, InternalTypeConfig } from './types.js';
+import '@mdx-js/mdx';
+import 'unified';
+import 'fumadocs-core/mdx-plugins';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';
+
+interface LazyEntry<Data = unknown> {
+    info: FileInfo;
+    data: Data;
+    hash?: string;
+}
+type CreateDynamic<Config, TC extends InternalTypeConfig = InternalTypeConfig> = ReturnType<typeof dynamic<Config, TC>>;
+declare function dynamic<Config, TC extends InternalTypeConfig>(configExports: Config, coreOptions: CoreOptions, serverOptions?: ServerOptions): Promise<{
+    doc<Name extends keyof Config & string>(name: Name, base: string, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<Name, _standard_schema_spec.StandardSchemaV1.InferOutput<Schema>, TC>[] : never>;
+    docs<Name extends keyof Config & string>(name: Name, base: string, meta: Record<string, unknown>, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocsCollection<infer Page extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, infer Meta extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? _standard_schema_spec.StandardSchemaV1.InferOutput<Page> extends fumadocs_core_source.PageData ? _standard_schema_spec.StandardSchemaV1.InferOutput<Meta> extends fumadocs_core_source.MetaData ? AsyncDocsCollectionEntry<Name, _standard_schema_spec.StandardSchemaV1.InferOutput<Page>, _standard_schema_spec.StandardSchemaV1.InferOutput<Meta>, TC> : never : never : never>;
+}>;
+
+export { type CreateDynamic, type LazyEntry, dynamic };

package/dist/runtime/dynamic.js

@@ -0,0 +1,79 @@
+import {
+  buildMDX
+} from "../chunk-SLY7WXTX.js";
+import {
+  server
+} from "../chunk-5OBUOALK.js";
+import "../chunk-FBLMK4RS.js";
+import {
+  buildConfig
+} from "../chunk-ZY6UZ7NH.js";
+import "../chunk-E5DJTSIM.js";
+import {
+  createCore
+} from "../chunk-BEBCWQC7.js";
+import "../chunk-WBIHDYMN.js";
+import {
+  fumaMatter
+} from "../chunk-VWJKRQZR.js";
+
+// src/runtime/dynamic.ts
+import { executeMdx } from "@fumadocs/mdx-remote/client";
+import { pathToFileURL } from "url";
+import fs from "fs/promises";
+async function dynamic(configExports, coreOptions, serverOptions) {
+  const core = createCore(coreOptions);
+  await core.init({
+    config: buildConfig(configExports)
+  });
+  const create = server(serverOptions);
+  function getDocCollection(name) {
+    const collection = core.getConfig().getCollection(name);
+    if (!collection) return;
+    if (collection.type === "docs") return collection.docs;
+    else if (collection.type === "doc") return collection;
+  }
+  function convertLazyEntries(collection, entries) {
+    const head = {};
+    const body = {};
+    async function compile({ info, data }) {
+      let content = (await fs.readFile(info.fullPath)).toString();
+      content = fumaMatter(content).content;
+      const compiled = await buildMDX(core, collection, {
+        filePath: info.fullPath,
+        source: content,
+        frontmatter: data,
+        isDevelopment: false,
+        environment: "runtime"
+      });
+      return await executeMdx(String(compiled.value), {
+        baseUrl: pathToFileURL(info.fullPath)
+      });
+    }
+    for (const entry of entries) {
+      head[entry.info.path] = () => entry.data;
+      let cachedResult;
+      body[entry.info.path] = () => cachedResult ??= compile(entry);
+    }
+    return { head, body };
+  }
+  return {
+    async doc(name, base, entries) {
+      const collection = getDocCollection(name);
+      if (!collection)
+        throw new Error(`the doc collection ${name} doesn't exist.`);
+      const { head, body } = convertLazyEntries(collection, entries);
+      return create.docLazy(name, base, head, body);
+    },
+    async docs(name, base, meta, entries) {
+      const collection = getDocCollection(name);
+      if (!collection)
+        throw new Error(`the doc collection ${name} doesn't exist.`);
+      const docs = convertLazyEntries(collection, entries);
+      return create.docsLazy(name, base, meta, docs.head, docs.body);
+    }
+  };
+}
+export {
+  dynamic
+};

package/dist/runtime/server.cjs

@@ -0,0 +1,176 @@
+"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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  server: () => server,
+  toFumadocsSource: () => toFumadocsSource
+});
+module.exports = __toCommonJS(server_exports);
+var path = __toESM(require("path"), 1);
+function server(options = {}) {
+  const { doc: { passthroughs: docPassthroughs = [] } = {} } = options;
+  function fileInfo(file, base) {
+    if (file.startsWith("./")) {
+      file = file.slice(2);
+    }
+    return {
+      path: file,
+      fullPath: path.join(base, file)
+    };
+  }
+  function mapDocData(entry) {
+    const data = {
+      body: entry.default,
+      toc: entry.toc,
+      structuredData: entry.structuredData,
+      _exports: entry
+    };
+    for (const key of docPassthroughs) {
+      data[key] = entry[key];
+    }
+    return data;
+  }
+  return {
+    async doc(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            ...mapDocData(data),
+            ...data.frontmatter,
+            ...createDocMethods(fileInfo(k, base), () => data)
+          };
+        })
+      );
+      return out;
+    },
+    async docLazy(_name, base, head, body) {
+      const out = await Promise.all(
+        Object.entries(head).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          const content = body[k];
+          return {
+            ...data,
+            ...createDocMethods(fileInfo(k, base), content),
+            async load() {
+              return mapDocData(await content());
+            }
+          };
+        })
+      );
+      return out;
+    },
+    async meta(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            info: fileInfo(k, base),
+            ...data
+          };
+        })
+      );
+      return out;
+    },
+    async docs(name, base, metaGlob, docGlob) {
+      const entry = {
+        docs: await this.doc(name, base, docGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    },
+    async docsLazy(name, base, metaGlob, docHeadGlob, docBodyGlob) {
+      const entry = {
+        docs: await this.docLazy(name, base, docHeadGlob, docBodyGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    }
+  };
+}
+function toFumadocsSource(pages, metas) {
+  const files = [];
+  for (const entry of pages) {
+    files.push({
+      type: "page",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  for (const entry of metas) {
+    files.push({
+      type: "meta",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  return {
+    files
+  };
+}
+function createDocMethods(info, load) {
+  return {
+    info,
+    async getText(type) {
+      if (type === "raw") {
+        const fs = await import("fs/promises");
+        return (await fs.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);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  server,
+  toFumadocsSource
+});

package/dist/runtime/server.d.cts

@@ -0,0 +1,14 @@
+import 'fumadocs-core/source';
+export { k as AsyncDocCollectionEntry, l as AsyncDocsCollectionEntry, w as DocCollectionEntry, x as DocsCollectionEntry, v as MetaCollectionEntry, y as ServerCreate, S as ServerOptions, z as server, F as toFumadocsSource } from '../core-DTuP23zu.cjs';
+import '@standard-schema/spec';
+import './types.cjs';
+import '@mdx-js/mdx';
+import 'unified';
+import 'fumadocs-core/mdx-plugins';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';

package/dist/runtime/server.d.ts

@@ -0,0 +1,14 @@
+import 'fumadocs-core/source';
+export { k as AsyncDocCollectionEntry, l as AsyncDocsCollectionEntry, w as DocCollectionEntry, x as DocsCollectionEntry, v as MetaCollectionEntry, y as ServerCreate, S as ServerOptions, z as server, F as toFumadocsSource } from '../core-B9ZoS6sA.js';
+import '@standard-schema/spec';
+import './types.js';
+import '@mdx-js/mdx';
+import 'unified';
+import 'fumadocs-core/mdx-plugins';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';

package/dist/runtime/server.js

@@ -0,0 +1,8 @@
+import {
+  server,
+  toFumadocsSource
+} from "../chunk-5OBUOALK.js";
+export {
+  server,
+  toFumadocsSource
+};

package/dist/runtime/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/runtime/types.d.cts

@@ -0,0 +1,61 @@
+import { StructuredData } from 'fumadocs-core/mdx-plugins/remark-structure';
+import { TOCItemType } from 'fumadocs-core/toc';
+import { Root } from 'mdast';
+import { MDXContent } from 'mdx/types';
+
+interface DocData {
+    /**
+     * Compiled MDX content (as component)
+     */
+    body: MDXContent;
+    /**
+     * table of contents generated from content.
+     */
+    toc: TOCItemType[];
+    /**
+     * structured data for document search indexing.
+     */
+    structuredData: StructuredData;
+    /**
+     * Raw exports from the compiled MDX file.
+     */
+    _exports: Record<string, unknown>;
+}
+interface FileInfo {
+    /**
+     * virtualized path for Source API
+     */
+    path: string;
+    /**
+     * the file path in file system
+     */
+    fullPath: string;
+}
+interface DocMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+    /**
+     * get document as text.
+     *
+     * - `type: raw` - read the original content from file system.
+     * - `type: processed` - get the processed Markdown content, only available when `includeProcessedMarkdown` is enabled on collection config.
+     */
+    getText: (type: 'raw' | 'processed') => Promise<string>;
+    getMDAST: () => Promise<Root>;
+}
+interface MetaMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+}
+interface InternalTypeConfig {
+    /**
+     * collection name -> collection properties
+     */
+    DocData: Record<string, unknown>;
+}
+
+export type { DocData, DocMethods, FileInfo, InternalTypeConfig, MetaMethods };

package/dist/runtime/types.d.ts

@@ -0,0 +1,61 @@
+import { StructuredData } from 'fumadocs-core/mdx-plugins/remark-structure';
+import { TOCItemType } from 'fumadocs-core/toc';
+import { Root } from 'mdast';
+import { MDXContent } from 'mdx/types';
+
+interface DocData {
+    /**
+     * Compiled MDX content (as component)
+     */
+    body: MDXContent;
+    /**
+     * table of contents generated from content.
+     */
+    toc: TOCItemType[];
+    /**
+     * structured data for document search indexing.
+     */
+    structuredData: StructuredData;
+    /**
+     * Raw exports from the compiled MDX file.
+     */
+    _exports: Record<string, unknown>;
+}
+interface FileInfo {
+    /**
+     * virtualized path for Source API
+     */
+    path: string;
+    /**
+     * the file path in file system
+     */
+    fullPath: string;
+}
+interface DocMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+    /**
+     * get document as text.
+     *
+     * - `type: raw` - read the original content from file system.
+     * - `type: processed` - get the processed Markdown content, only available when `includeProcessedMarkdown` is enabled on collection config.
+     */
+    getText: (type: 'raw' | 'processed') => Promise<string>;
+    getMDAST: () => Promise<Root>;
+}
+interface MetaMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+}
+interface InternalTypeConfig {
+    /**
+     * collection name -> collection properties
+     */
+    DocData: Record<string, unknown>;
+}
+
+export type { DocData, DocMethods, FileInfo, InternalTypeConfig, MetaMethods };