@hanzo/docs-mdx 14.1.0

package/dist/runtime/dynamic.js

@@ -0,0 +1,79 @@
+import {
+  buildMDX
+} from "../chunk-AXJB5MGS.js";
+import {
+  server
+} from "../chunk-WGXYJGSZ.js";
+import "../chunk-YKRCQ42E.js";
+import {
+  buildConfig
+} from "../chunk-MYAVS2LD.js";
+import "../chunk-U5YPLCO5.js";
+import {
+  createCore
+} from "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+import {
+  fumaMatter
+} from "../chunk-VWJKRQZR.js";
+
+// src/runtime/dynamic.ts
+import { executeMdx } from "@hanzo/docs-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.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.d.ts

@@ -0,0 +1,14 @@
+import '@hanzo/docs-core/source';
+export { i as AsyncDocCollectionEntry, j as AsyncDocsCollectionEntry, v as DocCollectionEntry, w as DocsCollectionEntry, u as MetaCollectionEntry, x as ServerCreate, S as ServerOptions, y as server, z as toDocsSource } from '../core-BhWOtait.js';
+import '@standard-schema/spec';
+import './types.js';
+import '@mdx-js/mdx';
+import 'unified';
+import '@hanzo/docs-core/mdx-plugins';
+import '@hanzo/docs-core/source/schema';
+import 'chokidar';
+import 'vfile';
+import '@hanzo/docs-core/mdx-plugins/remark-structure';
+import '@hanzo/docs-core/toc';
+import 'mdast';
+import 'mdx/types';

package/dist/runtime/server.js

@@ -0,0 +1,8 @@
+import {
+  server,
+  toDocsSource
+} from "../chunk-WGXYJGSZ.js";
+export {
+  server,
+  toDocsSource
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,61 @@
+import { StructuredData } from '@hanzo/docs-core/mdx-plugins/remark-structure';
+import { TOCItemType } from '@hanzo/docs-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/vite/index.d.ts

@@ -0,0 +1,44 @@
+import { Plugin } from 'vite';
+import { I as IndexFilePluginOptions } from '../core-BhWOtait.js';
+import '@mdx-js/mdx';
+import '@standard-schema/spec';
+import 'unified';
+import '@hanzo/docs-core/mdx-plugins';
+import '@hanzo/docs-core/source/schema';
+import 'chokidar';
+import 'vfile';
+import '@hanzo/docs-core/source';
+import '../runtime/types.js';
+import '@hanzo/docs-core/mdx-plugins/remark-structure';
+import '@hanzo/docs-core/toc';
+import 'mdast';
+import 'mdx/types';
+
+interface PluginOptions {
+    /**
+     * Generate index files for accessing content.
+     *
+     * @defaultValue true
+     */
+    index?: boolean | IndexFilePluginOptions;
+    /**
+     * @defaultValue source.config.ts
+     */
+    configPath?: string;
+    /**
+     * Update Vite config to fix module resolution of Fumadocs
+     *
+     * @defaultValue true
+     */
+    updateViteConfig?: boolean;
+    /**
+     * Output directory of generated files
+     *
+     * @defaultValue '.source'
+     */
+    outDir?: string;
+}
+declare function mdx(config: Record<string, unknown>, pluginOptions?: PluginOptions): Promise<Plugin>;
+declare function postInstall(pluginOptions?: PluginOptions): Promise<void>;
+
+export { type PluginOptions, mdx as default, postInstall };

package/dist/vite/index.js

@@ -0,0 +1,122 @@
+import {
+  indexFile
+} from "../chunk-A3YIGE7S.js";
+import {
+  createMdxLoader
+} from "../chunk-JWZR25CW.js";
+import {
+  createMetaLoader
+} from "../chunk-ZAYZWFWP.js";
+import {
+  createIntegratedConfigLoader,
+  toVite
+} from "../chunk-DMIIE3XZ.js";
+import "../chunk-4JSFLXXT.js";
+import {
+  buildConfig
+} from "../chunk-MYAVS2LD.js";
+import "../chunk-U5YPLCO5.js";
+import {
+  ValidationError,
+  _Defaults,
+  createCore
+} from "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/vite/index.ts
+import { mergeConfig } from "vite";
+var FumadocsDeps = ["@hanzo/docs-core", "@hanzo/docs-ui", "@hanzo/docs-openapi"];
+async function mdx(config, pluginOptions = {}) {
+  const options = applyDefaults(pluginOptions);
+  const core = createViteCore(options);
+  await core.init({
+    config: buildConfig(config)
+  });
+  const configLoader = createIntegratedConfigLoader(core);
+  const mdxLoader = toVite(createMdxLoader(configLoader));
+  const metaLoader = toVite(
+    createMetaLoader(configLoader, {
+      // vite has built-in plugin for JSON files
+      json: "json"
+    })
+  );
+  return {
+    name: "@hanzo/docs-mdx",
+    // needed, otherwise other plugins will be executed before our `transform`.
+    enforce: "pre",
+    config(config2) {
+      if (!options.updateViteConfig) return config2;
+      return mergeConfig(config2, {
+        optimizeDeps: {
+          exclude: FumadocsDeps
+        },
+        resolve: {
+          noExternal: FumadocsDeps,
+          dedupe: FumadocsDeps
+        }
+      });
+    },
+    async buildStart() {
+      await core.emit({ write: true });
+    },
+    async configureServer(server) {
+      await core.initServer({
+        watcher: server.watcher
+      });
+    },
+    async transform(value, id) {
+      try {
+        if (metaLoader.filter(id)) {
+          return await metaLoader.transform.call(this, value, id);
+        }
+        if (mdxLoader.filter(id)) {
+          return await mdxLoader.transform.call(this, value, id);
+        }
+      } catch (e) {
+        if (e instanceof ValidationError) {
+          throw new Error(await e.toStringFormatted());
+        }
+        throw e;
+      }
+    }
+  };
+}
+async function postInstall(pluginOptions = {}) {
+  const { loadConfig } = await import("../load-from-file-S5CQ4H6T.js");
+  const core = createViteCore(applyDefaults(pluginOptions));
+  await core.init({
+    config: loadConfig(core, true)
+  });
+  await core.emit({ write: true });
+}
+function createViteCore({
+  index,
+  configPath,
+  outDir
+}) {
+  if (index === true) index = {};
+  return createCore({
+    environment: "vite",
+    configPath,
+    outDir,
+    plugins: [
+      index && indexFile({
+        ...index,
+        target: index.target ?? "vite"
+      })
+    ]
+  });
+}
+function applyDefaults(options) {
+  return {
+    updateViteConfig: options.updateViteConfig ?? true,
+    index: options.index ?? true,
+    configPath: options.configPath ?? _Defaults.configPath,
+    outDir: options.outDir ?? _Defaults.outDir
+  };
+}
+export {
+  mdx as default,
+  postInstall
+};

package/dist/webpack/mdx.d.ts

@@ -0,0 +1,6 @@
+import { LoaderContext } from 'webpack';
+import { W as WebpackLoaderOptions } from '../index-BqkSNsGO.js';
+
+declare function loader(this: LoaderContext<WebpackLoaderOptions>, source: string, callback: LoaderContext<WebpackLoaderOptions>['callback']): Promise<void>;
+
+export { loader as default };

package/dist/webpack/mdx.js

@@ -0,0 +1,37 @@
+import {
+  getCore
+} from "../chunk-WLJ6EKOZ.js";
+import {
+  createMdxLoader
+} from "../chunk-JWZR25CW.js";
+import {
+  createStandaloneConfigLoader,
+  toWebpack
+} from "../chunk-DMIIE3XZ.js";
+import "../chunk-4JSFLXXT.js";
+import "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/webpack/mdx.ts
+var instance;
+async function loader(source, callback) {
+  const options = this.getOptions();
+  this.cacheable(true);
+  this.addDependency(options.absoluteCompiledConfigPath);
+  if (!instance) {
+    instance = toWebpack(
+      createMdxLoader(
+        createStandaloneConfigLoader({
+          core: getCore(options),
+          buildConfig: false,
+          mode: options.isDev ? "dev" : "production"
+        })
+      )
+    );
+  }
+  await instance.call(this, source, callback);
+}
+export {
+  loader as default
+};

package/dist/webpack/meta.d.ts

@@ -0,0 +1,6 @@
+import { LoaderContext } from 'webpack';
+import { W as WebpackLoaderOptions } from '../index-BqkSNsGO.js';
+
+declare function loader(this: LoaderContext<WebpackLoaderOptions>, source: string, callback: LoaderContext<WebpackLoaderOptions>['callback']): Promise<void>;
+
+export { loader as default };

package/dist/webpack/meta.js

@@ -0,0 +1,40 @@
+import {
+  getCore
+} from "../chunk-WLJ6EKOZ.js";
+import {
+  createMetaLoader
+} from "../chunk-ZAYZWFWP.js";
+import {
+  createStandaloneConfigLoader,
+  toWebpack
+} from "../chunk-DMIIE3XZ.js";
+import "../chunk-4JSFLXXT.js";
+import "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+
+// src/webpack/meta.ts
+var instance;
+async function loader(source, callback) {
+  const options = this.getOptions();
+  this.cacheable(true);
+  this.addDependency(options.absoluteCompiledConfigPath);
+  if (!instance) {
+    instance = toWebpack(
+      createMetaLoader(
+        createStandaloneConfigLoader({
+          core: getCore(options),
+          buildConfig: false,
+          mode: options.isDev ? "dev" : "production"
+        }),
+        {
+          json: "json",
+          yaml: "js"
+        }
+      )
+    );
+  }
+  await instance.call(this, source, callback);
+}
+export {
+  loader as default
+};

package/loader-mdx.cjs

@@ -0,0 +1,7 @@
+module.exports = function loader(code) {
+  const callback = this.async();
+
+  import('./dist/webpack/mdx.js').then((mod) =>
+    mod.default.call(this, code, callback),
+  );
+};

package/loader-meta.cjs

@@ -0,0 +1,7 @@
+module.exports = function loader(code) {
+  const callback = this.async();
+
+  import('./dist/webpack/meta.js').then((mod) =>
+    mod.default.call(this, code, callback),
+  );
+};

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "@hanzo/docs-mdx",
+  "version": "14.1.0",
+  "description": "The built-in MDX source for Hanzo Docs",
+  "keywords": [
+    "Hanzo",
+    "Docs",
+    "MDX"
+  ],
+  "homepage": "https://hanzo.ai/docs",
+  "repository": "github:hanzoai/docs",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "type": "module",
+  "exports": {
+    "./loader-mdx": "./loader-mdx.cjs",
+    "./loader-meta": "./loader-meta.cjs",
+    "./config": {
+      "import": "./dist/config/index.js",
+      "types": "./dist/config/index.d.ts"
+    },
+    "./next": {
+      "import": "./dist/next/index.js",
+      "types": "./dist/next/index.d.ts",
+      "require": "./dist/next/index.cjs"
+    },
+    "./vite": {
+      "import": "./dist/vite/index.js",
+      "types": "./dist/vite/index.d.ts"
+    },
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./runtime/*": {
+      "import": "./dist/runtime/*.js",
+      "types": "./dist/runtime/*.d.ts"
+    },
+    "./node/loader": {
+      "import": "./dist/node/loader.js",
+      "types": "./dist/node/loader.d.ts"
+    },
+    "./bun": {
+      "import": "./dist/bun/index.js",
+      "types": "./dist/bun/index.d.ts"
+    },
+    "./plugins/*": {
+      "import": "./dist/plugins/*.js",
+      "types": "./dist/plugins/*.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "hanzo-docs": "./dist/bin.js",
+    "fumadocs-mdx": "./dist/bin.js"
+  },
+  "files": [
+    "dist/*",
+    "loader-mdx.cjs",
+    "loader-meta.cjs"
+  ],
+  "dependencies": {
+    "@mdx-js/mdx": "^3.1.1",
+    "@standard-schema/spec": "^1.0.0",
+    "chokidar": "^5.0.0",
+    "esbuild": "^0.27.1",
+    "estree-util-value-to-estree": "^3.5.0",
+    "js-yaml": "^4.1.1",
+    "mdast-util-to-markdown": "^2.1.2",
+    "picocolors": "^1.1.1",
+    "picomatch": "^4.0.3",
+    "remark-mdx": "^3.1.1",
+    "tinyexec": "^1.0.2",
+    "tinyglobby": "^0.2.15",
+    "unified": "^11.0.5",
+    "unist-util-remove-position": "^5.0.0",
+    "unist-util-visit": "^5.0.0",
+    "vfile": "^6.0.3",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mdast": "^4.0.4",
+    "@types/mdx": "^2.0.13",
+    "@types/node": "^24.10.2",
+    "@types/picomatch": "^4.0.2",
+    "@types/react": "^19.2.7",
+    "astro": "^5.16.5",
+    "mdast-util-directive": "^3.1.0",
+    "mdast-util-mdx-jsx": "^3.2.0",
+    "next": "16.0.10",
+    "react": "^19.2.3",
+    "remark": "^15.0.1",
+    "remark-directive": "^4.0.0",
+    "remark-stringify": "^11.0.0",
+    "rollup": "^4.53.3",
+    "vite": "^7.2.7",
+    "webpack": "^5.103.0",
+    "eslint-config-custom": "0.0.0",
+    "@hanzo/docs-mdx-remote": "1.4.3",
+    "@hanzo/docs-core": "16.2.5",
+    "tsconfig": "0.0.0"
+  },
+  "peerDependencies": {
+    "@hanzo/docs-mdx-remote": "^1.4.0",
+    "@hanzo/docs-core": "^15.0.0 || ^16.0.0",
+    "next": "^15.3.0 || ^16.0.0",
+    "react": "*",
+    "vite": "6.x.x || 7.x.x"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "@hanzo/docs-mdx-remote": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "types:check": "tsc --noEmit"
+  }
+}