@hanzo/mdx-runtime 1.5.0

package/dist/chunk-5V3MNLHP.js

@@ -0,0 +1,34 @@
+// src/render.ts
+import jsxRuntimeDefault from "react/jsx-runtime";
+var AsyncFunction = Object.getPrototypeOf(executeMdx).constructor;
+async function executeMdx(compiled, options = {}) {
+  const { opts: scopeOpts, ...scope } = options.scope ?? {};
+  const fullScope = {
+    opts: {
+      ...scopeOpts,
+      ...options.jsxRuntime ?? jsxRuntimeDefault,
+      baseUrl: options.baseUrl
+    },
+    ...scope
+  };
+  const hydrateFn = new AsyncFunction(...Object.keys(fullScope), compiled);
+  return await hydrateFn.apply(hydrateFn, Object.values(fullScope));
+}
+function executeMdxSync(compiled, options = {}) {
+  const { opts: scopeOpts, ...scope } = options.scope ?? {};
+  const fullScope = {
+    opts: {
+      ...scopeOpts,
+      ...options.jsxRuntime ?? jsxRuntimeDefault,
+      baseUrl: options.baseUrl
+    },
+    ...scope
+  };
+  const hydrateFn = new Function(...Object.keys(fullScope), compiled);
+  return hydrateFn.apply(hydrateFn, Object.values(fullScope));
+}
+
+export {
+  executeMdx,
+  executeMdxSync
+};

package/dist/client/index.d.ts

@@ -0,0 +1,22 @@
+import { MDXComponents } from 'mdx/types';
+import { TableOfContents } from '@hanzo/docs-core/toc';
+import { FC } from 'react';
+
+type MdxContent = FC<{
+    components?: MDXComponents;
+}>;
+interface Options {
+    scope?: Record<string, unknown>;
+    baseUrl?: string | URL;
+    jsxRuntime?: unknown;
+}
+declare function executeMdx(compiled: string, options?: Options): Promise<{
+    default: MdxContent;
+    toc?: TableOfContents;
+}>;
+declare function executeMdxSync(compiled: string, options?: Options): {
+    default: MdxContent;
+    toc?: TableOfContents;
+};
+
+export { type MdxContent, executeMdx, executeMdxSync };

package/dist/client/index.js

@@ -0,0 +1,8 @@
+import {
+  executeMdx,
+  executeMdxSync
+} from "../chunk-5V3MNLHP.js";
+export {
+  executeMdx,
+  executeMdxSync
+};

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import { TableOfContents } from '@hanzo/docs-core/toc';
+import { MdxContent } from './client/index.js';
+import * as Plugins from '@hanzo/docs-core/mdx-plugins';
+import { CompileOptions } from '@mdx-js/mdx';
+import { MDXComponents } from 'mdx/types';
+import { Pluggable } from 'unified';
+import { VFile, Compatible } from 'vfile';
+import 'react';
+
+type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
+/**
+ * Parse frontmatter, currently powered by `gray-matter`
+ */
+declare function parseFrontmatter(content: string): {
+    frontmatter: {
+        [key: string]: any;
+    };
+    content: string;
+};
+
+type FumadocsPresetOptions = Omit<CompileOptions, 'remarkPlugins' | 'rehypePlugins'> & {
+    preset?: 'fumadocs';
+    remarkPlugins?: ResolvePlugins;
+    rehypePlugins?: ResolvePlugins;
+    remarkHeadingOptions?: Plugins.RemarkHeadingOptions | false;
+    rehypeCodeOptions?: Plugins.RehypeCodeOptions | false;
+    rehypeTocOptions?: Plugins.RehypeTocOptions | false;
+    remarkCodeTabOptions?: Plugins.RemarkCodeTabOptions | false;
+    remarkNpmOptions?: Plugins.RemarkNpmOptions | false;
+    /**
+     * The directory to find image sizes
+     *
+     * @defaultValue './public'
+     * @deprecated Use `remarkImageOptions.publicDir` instead
+     */
+    imageDir?: string;
+    remarkImageOptions?: Plugins.RemarkImageOptions | false;
+};
+type CompilerOptions = (CompileOptions & {
+    preset: 'minimal';
+}) | FumadocsPresetOptions;
+interface CompileMDXOptions {
+    source: string;
+    /**
+     * File path of source content
+     */
+    filePath?: string;
+    components?: MDXComponents;
+    scope?: Record<string, unknown>;
+    /**
+     * @deprecated Use `compiler.compileFile` instead if you doesn't need to execute output JavaScript code.
+     */
+    skipRender?: boolean;
+}
+interface CompileMDXResult<TFrontmatter = Record<string, unknown>> {
+    body: MdxContent;
+    frontmatter: TFrontmatter;
+    toc: TableOfContents;
+    vfile: VFile;
+    compiled: string;
+    exports: Record<string, unknown> | null;
+}
+declare function createCompiler(mdxOptions?: CompilerOptions): {
+    render(compiled: string, scope?: Record<string, unknown>, filePath?: string): Promise<{
+        default: MdxContent;
+        toc?: TableOfContents;
+    }>;
+    /**
+     * Compile VFile
+     */
+    compileFile(from: Compatible): Promise<VFile>;
+    compile<Frontmatter extends object = Record<string, unknown>>(options: CompileMDXOptions): Promise<CompileMDXResult<Frontmatter>>;
+};
+/**
+ * @deprecated Use `createCompiler()` API instead, this function will always create a new compiler instance.
+ */
+declare function compileMDX<Frontmatter extends object = Record<string, unknown>>(options: CompileMDXOptions & {
+    mdxOptions?: CompilerOptions;
+}): Promise<CompileMDXResult<Frontmatter>>;
+
+/**
+ * @deprecated Use `compiler.render` instead
+ */
+declare function executeMdx(compiled: string, scope: object, baseUrl?: string | URL): Promise<{
+    default: MdxContent;
+    toc?: TableOfContents;
+}>;
+
+export { type CompileMDXOptions, type CompileMDXResult, type CompilerOptions, type FumadocsPresetOptions, type CompilerOptions as MDXOptions, compileMDX, createCompiler, executeMdx, parseFrontmatter };

package/dist/index.js

@@ -0,0 +1,169 @@
+import {
+  executeMdx
+} from "./chunk-5V3MNLHP.js";
+
+// src/compile.ts
+import * as Plugins from "@hanzo/docs-core/mdx-plugins";
+import { createProcessor } from "@mdx-js/mdx";
+
+// src/utils.ts
+import matter from "gray-matter";
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function parseFrontmatter(content) {
+  const out = matter(content);
+  return {
+    frontmatter: out.data,
+    content: out.content
+  };
+}
+
+// src/compile.ts
+import { pathToFileURL } from "url";
+function createCompiler(mdxOptions) {
+  let instance;
+  function getProcessor() {
+    if (instance) return instance;
+    let format = mdxOptions?.format;
+    if (!format || format === "detect") format = "mdx";
+    return instance = createProcessor({
+      ...mdxOptions?.preset === "minimal" ? mdxOptions : getCompileOptions(mdxOptions),
+      format
+    });
+  }
+  return {
+    async render(compiled, scope, filePath) {
+      return executeMdx(compiled, {
+        scope,
+        baseUrl: filePath ? pathToFileURL(filePath) : void 0,
+        jsxRuntime: mdxOptions?.development ? await import("react/jsx-dev-runtime") : void 0
+      });
+    },
+    /**
+     * Compile VFile
+     */
+    async compileFile(from) {
+      return getProcessor().process(from);
+    },
+    async compile(options) {
+      const { scope = {}, skipRender } = options;
+      const { frontmatter, content } = parseFrontmatter(options.source);
+      const file = await this.compileFile({
+        value: content,
+        path: options.filePath,
+        data: {
+          frontmatter
+        }
+      });
+      const compiled = String(file);
+      const exports = !skipRender ? await this.render(compiled, scope, options.filePath) : null;
+      return {
+        vfile: file,
+        compiled,
+        frontmatter,
+        async body(props) {
+          if (!exports)
+            throw new Error(
+              "Body cannot be rendered when `skipRender` is set to true"
+            );
+          return exports.default({
+            components: { ...options.components, ...props.components }
+          });
+        },
+        toc: exports?.toc ?? file.data.toc,
+        exports
+      };
+    }
+  };
+}
+async function compileMDX(options) {
+  const compiler = createCompiler(options.mdxOptions);
+  return compiler.compile(options);
+}
+function getCompileOptions({
+  preset: _,
+  rehypeCodeOptions,
+  remarkImageOptions,
+  rehypeTocOptions,
+  remarkHeadingOptions,
+  remarkCodeTabOptions,
+  remarkNpmOptions,
+  imageDir = "./public",
+  ...options
+} = {}) {
+  function getPlugin(name) {
+    return name in Plugins ? Plugins[name] : null;
+  }
+  const remarkGfm = getPlugin("remarkGfm");
+  const remarkHeading = getPlugin("remarkHeading");
+  const remarkCodeTab = getPlugin("remarkCodeTab");
+  const remarkNpm = getPlugin("remarkNpm");
+  const remarkImage = getPlugin("remarkImage");
+  const rehypeCode = getPlugin("rehypeCode");
+  const rehypeToc = getPlugin("rehypeToc");
+  return {
+    ...options,
+    outputFormat: "function-body",
+    remarkPlugins: pluginOption(
+      (v) => [
+        remarkGfm,
+        remarkHeading && remarkHeadingOptions !== false ? [remarkHeading, remarkHeadingOptions] : null,
+        remarkImage && remarkImageOptions !== false ? [
+          remarkImage,
+          {
+            useImport: false,
+            publicDir: imageDir,
+            ...remarkImageOptions
+          }
+        ] : null,
+        remarkCodeTab && remarkCodeTabOptions !== false ? [remarkCodeTab, remarkCodeTabOptions] : null,
+        remarkNpm && remarkNpmOptions !== false ? [remarkNpm, remarkNpmOptions] : null,
+        ...v
+      ],
+      options.remarkPlugins
+    ),
+    rehypePlugins: pluginOption(
+      (v) => [
+        rehypeCode && rehypeCodeOptions !== false ? [rehypeCode, rehypeCodeOptions] : null,
+        rehypeToc && rehypeTocOptions !== false ? [rehypeToc, rehypeTocOptions] : null,
+        ...v
+      ],
+      options.rehypePlugins
+    )
+  };
+}
+
+// src/index.ts
+async function executeMdx2(compiled, scope, baseUrl) {
+  let jsxRuntime;
+  if (process.env.NODE_ENV === "production") {
+    jsxRuntime = await import("react/jsx-runtime");
+  } else {
+    jsxRuntime = await import("react/jsx-dev-runtime");
+  }
+  const fullScope = {
+    opts: {
+      ...jsxRuntime,
+      baseUrl
+    },
+    ...scope
+  };
+  const values = Object.values(fullScope);
+  const params = Object.keys(fullScope);
+  params.push(`return (async () => { ${compiled} })()`);
+  const hydrateFn = new Function(...params);
+  return await hydrateFn.apply(hydrateFn, values);
+}
+export {
+  compileMDX,
+  createCompiler,
+  executeMdx2 as executeMdx,
+  parseFrontmatter
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@hanzo/mdx-runtime",
+  "version": "1.5.0",
+  "description": "Runtime MDX compilation and execution for Hanzo Docs",
+  "keywords": [
+    "Hanzo",
+    "Docs",
+    "MDX",
+    "Runtime"
+  ],
+  "homepage": "https://hanzo.ai/docs",
+  "repository": "github:hanzoai/docs",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client/index.js",
+      "types": "./dist/client/index.d.ts"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/*"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "types:check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@mdx-js/mdx": "^3.1.1",
+    "gray-matter": "^4.0.3",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/mdx": "^2.0.13",
+    "@types/node": "24.10.2",
+    "@types/react": "^19.2.7",
+    "eslint-config-custom": "workspace:*",
+    "@hanzo/docs-core": "workspace:*",
+    "react": "^19.2.3",
+    "tinyglobby": "^0.2.15",
+    "tsconfig": "workspace:*",
+    "unified": "^11.0.5",
+    "vfile": "^6.0.3"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "@hanzo/docs-core": "^15.0.0 || ^16.0.0",
+    "react": "18.x.x || 19.x.x"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}