@hanzo/docs-mdx 14.1.0

package/dist/next/index.d.ts

@@ -0,0 +1,33 @@
+import { NextConfig } from 'next';
+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 CreateMDXOptions {
+    /**
+     * Path to source configuration file
+     */
+    configPath?: string;
+    /**
+     * Directory for output files
+     *
+     * @defaultValue '.source'
+     */
+    outDir?: string;
+    index?: IndexFilePluginOptions | false;
+}
+declare function createMDX(createOptions?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
+declare function postInstall(options: CreateMDXOptions): Promise<void>;
+
+export { type CreateMDXOptions, createMDX, postInstall };

package/dist/next/index.js

@@ -0,0 +1,181 @@
+import {
+  loadConfig
+} from "../chunk-RPUM7REY.js";
+import {
+  indexFile
+} from "../chunk-A3YIGE7S.js";
+import {
+  mdxLoaderGlob,
+  metaLoaderGlob
+} from "../chunk-4JSFLXXT.js";
+import "../chunk-MYAVS2LD.js";
+import "../chunk-U5YPLCO5.js";
+import {
+  _Defaults,
+  createCore
+} from "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/next/index.ts
+import * as path from "path";
+var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
+function createMDX(createOptions = {}) {
+  const core = createNextCore(applyDefaults(createOptions));
+  const isDev = process.env.NODE_ENV === "development";
+  if (process.env._FUMADOCS_MDX !== "1") {
+    process.env._FUMADOCS_MDX = "1";
+    void init(isDev, core);
+  }
+  return (nextConfig = {}) => {
+    const { configPath, outDir } = core.getOptions();
+    const loaderOptions = {
+      configPath,
+      outDir,
+      absoluteCompiledConfigPath: path.resolve(core.getCompiledConfigPath()),
+      isDev
+    };
+    const turbopack = {
+      ...nextConfig.turbopack,
+      rules: {
+        ...nextConfig.turbopack?.rules,
+        "*.{md,mdx}": {
+          loaders: [
+            {
+              loader: "@hanzo/docs-mdx/loader-mdx",
+              options: loaderOptions
+            }
+          ],
+          as: "*.js"
+        },
+        "*.json": {
+          loaders: [
+            {
+              loader: "@hanzo/docs-mdx/loader-meta",
+              options: loaderOptions
+            }
+          ],
+          as: "*.json"
+        },
+        "*.yaml": {
+          loaders: [
+            {
+              loader: "@hanzo/docs-mdx/loader-meta",
+              options: loaderOptions
+            }
+          ],
+          as: "*.js"
+        }
+      }
+    };
+    return {
+      ...nextConfig,
+      turbopack,
+      pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
+      webpack: (config, options) => {
+        config.resolve ||= {};
+        config.module ||= {};
+        config.module.rules ||= [];
+        config.module.rules.push(
+          {
+            test: mdxLoaderGlob,
+            use: [
+              options.defaultLoaders.babel,
+              {
+                loader: "@hanzo/docs-mdx/loader-mdx",
+                options: loaderOptions
+              }
+            ]
+          },
+          {
+            test: metaLoaderGlob,
+            enforce: "pre",
+            use: [
+              {
+                loader: "@hanzo/docs-mdx/loader-meta",
+                options: loaderOptions
+              }
+            ]
+          }
+        );
+        config.plugins ||= [];
+        return nextConfig.webpack?.(config, options) ?? config;
+      }
+    };
+  };
+}
+async function init(dev, core) {
+  async function initOrReload() {
+    await core.init({
+      config: loadConfig(core, true)
+    });
+    await core.emit({ write: true });
+  }
+  async function devServer() {
+    const { FSWatcher } = await import("chokidar");
+    const { configPath, outDir } = core.getOptions();
+    const watcher = new FSWatcher({
+      ignoreInitial: true,
+      persistent: true,
+      ignored: [outDir]
+    });
+    watcher.add(configPath);
+    for (const collection of core.getCollections()) {
+      watcher.add(collection.dir);
+    }
+    for (const workspace of core.getWorkspaces().values()) {
+      for (const collection of workspace.getCollections()) {
+        watcher.add(collection.dir);
+      }
+    }
+    watcher.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    const absoluteConfigPath = path.resolve(configPath);
+    watcher.on("all", async (_event, file) => {
+      if (path.resolve(file) === absoluteConfigPath) {
+        watcher.removeAllListeners();
+        await watcher.close();
+        await initOrReload();
+        console.log("[MDX] restarting dev server");
+        await devServer();
+      }
+    });
+    process.on("exit", () => {
+      if (watcher.closed) return;
+      console.log("[MDX] closing dev server");
+      void watcher.close();
+    });
+    await core.initServer({ watcher });
+  }
+  await initOrReload();
+  if (dev) {
+    await devServer();
+  }
+}
+async function postInstall(options) {
+  const core = createNextCore(applyDefaults(options));
+  await core.init({
+    config: loadConfig(core, true)
+  });
+  await core.emit({ write: true });
+}
+function applyDefaults(options) {
+  return {
+    index: {},
+    outDir: options.outDir ?? _Defaults.outDir,
+    configPath: options.configPath ?? _Defaults.configPath
+  };
+}
+function createNextCore(options) {
+  return createCore({
+    environment: "next",
+    outDir: options.outDir,
+    configPath: options.configPath,
+    plugins: [options.index && indexFile(options.index)]
+  });
+}
+export {
+  createMDX,
+  postInstall
+};

package/dist/node/loader.d.ts

@@ -0,0 +1,5 @@
+import { LoadHook } from 'node:module';
+
+declare const load: LoadHook;
+
+export { load };

package/dist/node/loader.js

@@ -0,0 +1,41 @@
+import {
+  createMdxLoader
+} from "../chunk-JWZR25CW.js";
+import {
+  createMetaLoader
+} from "../chunk-ZAYZWFWP.js";
+import {
+  createStandaloneConfigLoader,
+  toNode
+} from "../chunk-DMIIE3XZ.js";
+import "../chunk-4JSFLXXT.js";
+import {
+  _Defaults,
+  createCore
+} from "../chunk-RR2X6AE6.js";
+import "../chunk-PW2AZGGD.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/node/loader.ts
+var core = createCore({
+  environment: "node",
+  configPath: _Defaults.configPath,
+  outDir: _Defaults.outDir
+});
+var configLoader = createStandaloneConfigLoader({
+  core,
+  buildConfig: true,
+  mode: "production"
+});
+var mdxLoader = toNode(createMdxLoader(configLoader));
+var metaLoader = toNode(createMetaLoader(configLoader));
+var load = (url, context, nextLoad) => {
+  return mdxLoader(
+    url,
+    context,
+    (v, ctx) => metaLoader(v, { ...context, ...ctx }, nextLoad)
+  );
+};
+export {
+  load
+};

package/dist/plugins/index-file.d.ts

@@ -0,0 +1,14 @@
+export { H as IndexFilePlugin, I as IndexFilePluginOptions, F as default } 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';

package/dist/plugins/index-file.js

@@ -0,0 +1,8 @@
+import {
+  indexFile
+} from "../chunk-A3YIGE7S.js";
+import "../chunk-PW2AZGGD.js";
+import "../chunk-VWJKRQZR.js";
+export {
+  indexFile as default
+};

package/dist/plugins/json-schema.d.ts

@@ -0,0 +1,31 @@
+import { k as Plugin } 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 JSONSchemaOptions {
+    /**
+     * insert `$schema` field to JSON files on creation.
+     *
+     * @defaultValue false
+     */
+    insert?: boolean;
+}
+/**
+ * Generate JSON schemas locally for collection schemas
+ *
+ * note: **it only works with Zod**
+ */
+declare function jsonSchema({ insert, }?: JSONSchemaOptions): Plugin;
+
+export { type JSONSchemaOptions, jsonSchema as default };

package/dist/plugins/json-schema.js

@@ -0,0 +1,80 @@
+// src/plugins/json-schema.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+function jsonSchema({
+  insert = false
+} = {}) {
+  function getSchemaPath(name) {
+    return `json-schema/${name}.json`;
+  }
+  return {
+    configureServer(server) {
+      const { outDir } = this.core.getOptions();
+      if (!server.watcher || !insert) return;
+      server.watcher.on("add", async (file) => {
+        let parent;
+        let match;
+        for (const collection of this.core.getCollections()) {
+          if (collection.type === "meta" && collection.hasFile(file)) {
+            match = collection;
+            break;
+          }
+          if (collection.type === "docs" && collection.meta.hasFile(file)) {
+            parent = collection;
+            match = collection.meta;
+            break;
+          }
+        }
+        if (!match) return;
+        let obj;
+        try {
+          const content = (await fs.readFile(file)).toString();
+          obj = content.length > 0 ? JSON.parse(content) : {};
+        } catch {
+          return;
+        }
+        if ("$schema" in obj) return;
+        const schemaPath = path.join(
+          outDir,
+          getSchemaPath(parent ? `${parent.name}.meta` : match.name)
+        );
+        const updated = {
+          $schema: path.relative(path.dirname(file), schemaPath),
+          ...obj
+        };
+        await fs.writeFile(file, JSON.stringify(updated, null, 2));
+      });
+    },
+    emit() {
+      const files = [];
+      function onSchema(name, schema) {
+        files.push({
+          path: getSchemaPath(name),
+          content: JSON.stringify(
+            z.toJSONSchema(schema, {
+              io: "input",
+              unrepresentable: "any"
+            })
+          )
+        });
+      }
+      for (const collection of this.core.getCollections()) {
+        if (collection.type === "docs") {
+          if (collection.meta.schema instanceof z.ZodType) {
+            onSchema(`${collection.name}.meta`, collection.meta.schema);
+          }
+          if (collection.docs.schema instanceof z.ZodType) {
+            onSchema(`${collection.name}.docs`, collection.docs.schema);
+          }
+        } else if (collection.schema instanceof z.ZodType) {
+          onSchema(collection.name, collection.schema);
+        }
+      }
+      return files;
+    }
+  };
+}
+export {
+  jsonSchema as default
+};

package/dist/plugins/last-modified.d.ts

@@ -0,0 +1,40 @@
+import { k as Plugin } 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';
+
+type VersionControlFn = (filePath: string) => Promise<Date | null | undefined>;
+interface LastModifiedPluginOptions {
+    /**
+     * Version control to obtain the last modified time.
+     *
+     * - `git`: Requires `git` to be installed.
+     *
+     *    If you are using Vercel, please set `VERCEL_DEEP_CLONE` environment variable to `true`.
+     *
+     * - A function: return the last modified time for given file path.
+     *
+     * @defaultValue 'git'
+     */
+    versionControl?: 'git' | VersionControlFn;
+    /**
+     * Filter the collections to include by names
+     */
+    filter?: (collection: string) => boolean;
+}
+/**
+ * Injects `lastModified` property to page exports.
+ */
+declare function lastModified(options?: LastModifiedPluginOptions): Plugin;
+
+export { type LastModifiedPluginOptions, lastModified as default };

package/dist/plugins/last-modified.js

@@ -0,0 +1,89 @@
+import {
+  ident
+} from "../chunk-PW2AZGGD.js";
+
+// src/plugins/last-modified.ts
+import path from "path";
+import { x } from "tinyexec";
+var cache = /* @__PURE__ */ new Map();
+var ExtendTypes = `{
+  /**
+   * Last modified date of document file, obtained from version control.
+   *
+   */
+  lastModified?: Date;
+}`;
+function lastModified(options = {}) {
+  const { versionControl = "git", filter = () => true } = options;
+  let fn;
+  return {
+    name: "last-modified",
+    "index-file": {
+      generateTypeConfig() {
+        const lines = [];
+        lines.push("{");
+        lines.push("  DocData: {");
+        for (const collection of this.core.getCollections()) {
+          if (filter(collection.name)) {
+            lines.push(ident(`${collection.name}: ${ExtendTypes},`, 2));
+          }
+        }
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      },
+      serverOptions(options2) {
+        options2.doc ??= {};
+        options2.doc.passthroughs ??= [];
+        options2.doc.passthroughs.push("lastModified");
+      }
+    },
+    config() {
+      const { workspace } = this.core.getOptions();
+      const cwd = workspace ? path.resolve(workspace.dir) : process.cwd();
+      switch (versionControl) {
+        case "git":
+          fn = (v) => getGitTimestamp(v, cwd);
+          break;
+        default:
+          fn = versionControl;
+      }
+    },
+    doc: {
+      async vfile(file) {
+        if (!filter(this.collection.name)) return;
+        const timestamp = await fn(this.filePath);
+        if (timestamp) {
+          file.data["mdx-export"] ??= [];
+          file.data["mdx-export"].push({
+            name: "lastModified",
+            value: timestamp
+          });
+        }
+      }
+    }
+  };
+}
+async function getGitTimestamp(file, cwd) {
+  const cached = cache.get(file);
+  if (cached) return cached;
+  const timePromise = (async () => {
+    const out = await x(
+      "git",
+      ["log", "-1", '--pretty="%ai"', path.relative(cwd, file)],
+      {
+        nodeOptions: {
+          cwd
+        }
+      }
+    );
+    if (out.exitCode !== 0) return null;
+    const date = new Date(out.stdout);
+    return isNaN(date.getTime()) ? null : date;
+  })();
+  cache.set(file, timePromise);
+  return timePromise;
+}
+export {
+  lastModified as default
+};

package/dist/runtime/browser.d.ts

@@ -0,0 +1,53 @@
+import { ReactNode, FC } from 'react';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { D as DocCollection, b as DocsCollection } from '../core-BhWOtait.js';
+import { CompiledMDXProperties } from '../index.js';
+import { InternalTypeConfig } from './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/source';
+import '@hanzo/docs-core/toc';
+import 'mdx/types';
+import '@hanzo/docs-core/mdx-plugins/remark-structure';
+import 'mdast';
+
+type CompiledMDXFile<Name extends string, Frontmatter, TC extends InternalTypeConfig> = CompiledMDXProperties<Frontmatter> & TC['DocData'][Name] & Record<string, unknown>;
+interface ClientLoaderOptions<Doc, 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: Doc, props: Props) => ReactNode;
+}
+interface ClientLoader<Doc, Props> {
+    preload: (path: string) => Promise<Doc>;
+    /**
+     * 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;
+}
+type BrowserCreate<Config, TC extends InternalTypeConfig> = ReturnType<typeof browser<Config, TC>>;
+interface DocCollectionEntry<Name extends string = string, Frontmatter = unknown, TC extends InternalTypeConfig = InternalTypeConfig> {
+    raw: Record<string, () => Promise<CompiledMDXFile<Name, Frontmatter, TC>>>;
+    createClientLoader: <Props extends object>(options: ClientLoaderOptions<CompiledMDXFile<Name, Frontmatter, TC>, Props>) => ClientLoader<CompiledMDXFile<Name, Frontmatter, TC>, Props>;
+}
+declare function browser<Config, TC extends InternalTypeConfig>(): {
+    doc<Name extends keyof Config & string>(_name: Name, glob: Record<string, () => Promise<unknown>>): Config[Name] extends DocCollection<infer Schema> | DocsCollection<infer Schema> ? DocCollectionEntry<Name, StandardSchemaV1.InferOutput<Schema>, TC> : never;
+};
+declare function createClientLoader<Doc = CompiledMDXProperties, Props extends object = object>(globEntries: Record<string, () => Promise<Doc>>, options: ClientLoaderOptions<Doc, Props>): ClientLoader<Doc, Props>;
+
+export { type BrowserCreate, type ClientLoader, type ClientLoaderOptions, type DocCollectionEntry, browser, createClientLoader };

package/dist/runtime/browser.js

@@ -0,0 +1,67 @@
+// src/runtime/browser.ts
+import { lazy, createElement } from "react";
+function browser() {
+  return {
+    doc(_name, glob) {
+      const out = {
+        raw: glob,
+        createClientLoader({ id = _name, ...options }) {
+          return createClientLoader(this.raw, { id, ...options });
+        }
+      };
+      return out;
+    }
+  };
+}
+var loaderStore = /* @__PURE__ */ new Map();
+function createClientLoader(globEntries, options) {
+  const { id = "", component } = options;
+  const renderers = {};
+  const loaders = /* @__PURE__ */ new Map();
+  const store = loaderStore.get(id) ?? {
+    preloaded: /* @__PURE__ */ new Map()
+  };
+  loaderStore.set(id, store);
+  for (const k in globEntries) {
+    loaders.set(k.startsWith("./") ? k.slice(2) : k, globEntries[k]);
+  }
+  function getLoader(path) {
+    const loader = loaders.get(path);
+    if (!loader)
+      throw new Error(
+        `[createClientLoader] ${path} does not exist in available entries`
+      );
+    return loader;
+  }
+  function getRenderer(path) {
+    if (path in renderers) return renderers[path];
+    const OnDemand = lazy(async () => {
+      const loaded = await getLoader(path)();
+      return { default: (props) => component(loaded, props) };
+    });
+    renderers[path] = (props) => {
+      const cached = store.preloaded.get(path);
+      if (!cached) return createElement(OnDemand, props);
+      return component(cached, props);
+    };
+    return renderers[path];
+  }
+  return {
+    async preload(path) {
+      const loaded = await getLoader(path)();
+      store.preloaded.set(path, loaded);
+      return loaded;
+    },
+    getComponent(path) {
+      return getRenderer(path);
+    },
+    useContent(path, props) {
+      const Comp = this.getComponent(path);
+      return createElement(Comp, props);
+    }
+  };
+}
+export {
+  browser,
+  createClientLoader
+};

package/dist/runtime/dynamic.d.ts

@@ -0,0 +1,27 @@
+import * as _hanzo_docs_core_source from '@hanzo/docs-core/source';
+import { C as CoreOptions, S as ServerOptions, D as DocCollection, b as DocsCollection, i as AsyncDocCollectionEntry, j as AsyncDocsCollectionEntry } from '../core-BhWOtait.js';
+import * as _standard_schema_spec from '@standard-schema/spec';
+import { FileInfo, InternalTypeConfig } from './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';
+
+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 _hanzo_docs_core_source.PageData ? _standard_schema_spec.StandardSchemaV1.InferOutput<Meta> extends _hanzo_docs_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 };