@hanzo/docs-mdx 14.1.0

package/dist/chunk-STUCUTJQ.js

@@ -0,0 +1,334 @@
+import {
+  createCodegen,
+  ident
+} from "./chunk-PW2AZGGD.js";
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/plugins/index-file.ts
+import path2 from "path";
+import { glob } from "tinyglobby";
+
+// src/utils/fs-cache.ts
+import fs from "fs/promises";
+import path from "path";
+var map = /* @__PURE__ */ new Map();
+function createFSCache() {
+  return {
+    read(file) {
+      const fullPath = toFullPath(file);
+      const cached = map.get(fullPath);
+      if (cached) return cached;
+      const read = fs.readFile(fullPath).then((s) => s.toString());
+      map.set(fullPath, read);
+      return read;
+    },
+    delete(file) {
+      map.delete(toFullPath(file));
+    }
+  };
+}
+function toFullPath(file) {
+  if (path.isAbsolute(file)) {
+    return path.relative(process.cwd(), file);
+  }
+  return file;
+}
+
+// src/plugins/index-file.ts
+import { createHash } from "crypto";
+var indexFileCache = createFSCache();
+function indexFile(options = {}) {
+  const {
+    target = "default",
+    addJsExtension,
+    browser = true,
+    dynamic = true
+  } = options;
+  let dynamicCollections;
+  function isDynamic(collection) {
+    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
+  }
+  function generateConfigs(core) {
+    const serverOptions = {};
+    const typeConfigs = [
+      'import("@hanzo/docs-mdx/runtime/types").InternalTypeConfig'
+    ];
+    const ctx = core.getPluginContext();
+    for (const plugin of core.getPlugins()) {
+      const indexFilePlugin = plugin["index-file"];
+      if (!indexFilePlugin) continue;
+      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
+      const config = indexFilePlugin.generateTypeConfig?.call(ctx);
+      if (config) typeConfigs.push(config);
+    }
+    return {
+      serverOptions,
+      tc: typeConfigs.join(" & ")
+    };
+  }
+  return {
+    name: "index-file",
+    config() {
+      dynamicCollections = this.core.getCollections().filter(isDynamic);
+    },
+    configureServer(server) {
+      if (!server.watcher) return;
+      server.watcher.on("all", async (event, file) => {
+        indexFileCache.delete(file);
+        if (dynamicCollections.length === 0) {
+          if (target === "vite") return;
+          if (target === "default" && event === "change") return;
+        }
+        const updatedCollection = this.core.getCollections().find((collection) => collection.hasFile(file));
+        if (!updatedCollection) return;
+        if (!isDynamic(updatedCollection)) {
+          if (target === "vite") return;
+          if (target === "default" && event === "change") return;
+        }
+        await this.core.emit({
+          filterPlugin: (plugin) => plugin.name === "index-file",
+          filterWorkspace: () => false,
+          write: true
+        });
+      });
+    },
+    async emit() {
+      const globCache = /* @__PURE__ */ new Map();
+      const { workspace, outDir } = this.core.getOptions();
+      const { serverOptions, tc } = generateConfigs(this.core);
+      const toEmitEntry = async (path3, content) => {
+        const codegen = createCodegen({
+          target,
+          outDir,
+          jsExtension: addJsExtension,
+          globCache
+        });
+        await content({
+          core: this.core,
+          codegen,
+          serverOptions,
+          tc,
+          workspace: workspace?.name
+        });
+        return {
+          path: path3,
+          content: codegen.toString()
+        };
+      };
+      const out = [
+        toEmitEntry("server.ts", generateServerIndexFile)
+      ];
+      if (dynamic)
+        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
+      if (browser)
+        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
+      return await Promise.all(out);
+    }
+  };
+}
+async function generateServerIndexFile(ctx) {
+  const { core, codegen, serverOptions, tc } = ctx;
+  codegen.lines.push(
+    `import { server } from '@hanzo/docs/mdx/runtime/server';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
+    "",
+    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
+  );
+  async function generateCollectionObject(collection) {
+    const base = getBase(collection);
+    switch (collection.type) {
+      case "docs": {
+        if (collection.docs.dynamic) return;
+        if (collection.docs.async) {
+          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
+            generateMetaCollectionGlob(ctx, collection.meta, true),
+            generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
+            generateDocCollectionGlob(ctx, collection.docs)
+          ]);
+          return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
+        }
+        const [metaGlob, docGlob] = await Promise.all([
+          generateMetaCollectionGlob(ctx, collection.meta, true),
+          generateDocCollectionGlob(ctx, collection.docs, true)
+        ]);
+        return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
+      }
+      case "doc":
+        if (collection.dynamic) return;
+        if (collection.async) {
+          const [headGlob, bodyGlob] = await Promise.all([
+            generateDocCollectionFrontmatterGlob(ctx, collection, true),
+            generateDocCollectionGlob(ctx, collection)
+          ]);
+          return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
+        }
+        return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(
+          ctx,
+          collection,
+          true
+        )})`;
+      case "meta":
+        return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(
+          ctx,
+          collection,
+          true
+        )})`;
+    }
+  }
+  await codegen.pushAsync(
+    core.getCollections().map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
+}
+async function generateDynamicIndexFile(ctx) {
+  const { core, codegen, serverOptions, tc } = ctx;
+  const { configPath, environment, outDir } = core.getOptions();
+  const partialOptions = {
+    configPath,
+    environment,
+    outDir
+  };
+  codegen.lines.push(
+    `import { dynamic } from '@hanzo/docs/mdx/runtime/dynamic';`,
+    `import * as Config from '${codegen.formatImportPath(configPath)}';`,
+    "",
+    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(partialOptions)}, ${JSON.stringify(serverOptions)});`
+  );
+  async function generateCollectionObjectEntry(collection, absolutePath) {
+    const fullPath = path2.relative(process.cwd(), absolutePath);
+    const content = await indexFileCache.read(fullPath).catch(() => "");
+    const parsed = fumaMatter(content);
+    const data = await core.transformFrontmatter(
+      {
+        collection,
+        filePath: fullPath,
+        source: content
+      },
+      parsed.data
+    );
+    const hash = createHash("md5").update(content).digest("hex");
+    const infoStr = [
+      // make sure it's included in vercel/nft
+      `absolutePath: path.resolve(${JSON.stringify(fullPath)})`
+    ];
+    for (const [k, v] of Object.entries({
+      info: {
+        fullPath,
+        path: path2.relative(collection.dir, absolutePath)
+      },
+      data,
+      hash
+    })) {
+      infoStr.push(`${k}: ${JSON.stringify(v)}`);
+    }
+    return `{ ${infoStr.join(", ")} }`;
+  }
+  async function generateCollectionObject(parent) {
+    let collection;
+    if (parent.type === "doc") collection = parent;
+    else if (parent.type === "docs") collection = parent.docs;
+    if (!collection || !collection.dynamic) return;
+    const files = await glob(collection.patterns, {
+      cwd: collection.dir,
+      absolute: true
+    });
+    const entries = await Promise.all(
+      files.map((file) => generateCollectionObjectEntry(collection, file))
+    );
+    switch (parent.type) {
+      case "docs": {
+        const metaGlob = await generateMetaCollectionGlob(
+          ctx,
+          parent.meta,
+          true
+        );
+        return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
+      }
+      case "doc":
+        return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
+    }
+  }
+  await codegen.pushAsync(
+    core.getCollections().map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
+}
+async function generateBrowserIndexFile(ctx) {
+  const { core, codegen, tc } = ctx;
+  codegen.lines.push(
+    `import { browser } from '@hanzo/docs/mdx/runtime/browser';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
+    "",
+    `const create = browser<typeof Config, ${tc}>();`
+  );
+  async function generateCollectionObject(collection) {
+    switch (collection.type) {
+      case "docs": {
+        if (collection.docs.dynamic) return;
+        return generateCollectionObject(collection.docs);
+      }
+      case "doc":
+        if (collection.dynamic) return;
+        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(ctx, collection)})`;
+    }
+  }
+  codegen.lines.push("const browserCollections = {");
+  await codegen.pushAsync(
+    core.getCollections().map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return ident(`${collection.name}: ${obj},`);
+    })
+  );
+  codegen.lines.push("};", "export default browserCollections;");
+}
+function getBase(collection) {
+  return path2.relative(process.cwd(), collection.dir);
+}
+function generateDocCollectionFrontmatterGlob({ codegen, workspace }, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name,
+      only: "frontmatter",
+      workspace
+    },
+    import: "frontmatter",
+    base: collection.dir,
+    eager
+  });
+}
+function generateDocCollectionGlob({ codegen, workspace }, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name,
+      workspace
+    },
+    base: collection.dir,
+    eager
+  });
+}
+function generateMetaCollectionGlob({ codegen, workspace }, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name,
+      workspace
+    },
+    import: "default",
+    base: collection.dir,
+    eager
+  });
+}
+
+export {
+  indexFile
+};

package/dist/chunk-T6G5VOED.js

@@ -0,0 +1,116 @@
+import {
+  mdxLoaderGlob
+} from "./chunk-4JSFLXXT.js";
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/loaders/mdx/index.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+var querySchema = z.object({
+  only: z.literal(["frontmatter", "all"]).default("all"),
+  collection: z.string().optional(),
+  workspace: z.string().optional()
+}).loose();
+var cacheEntry = z.object({
+  code: z.string(),
+  map: z.any().optional(),
+  hash: z.string().optional()
+});
+function createMdxLoader({ getCore }) {
+  return {
+    test: mdxLoaderGlob,
+    async load({
+      getSource,
+      development: isDevelopment,
+      query,
+      compiler,
+      filePath
+    }) {
+      let core = await getCore();
+      const value = await getSource();
+      const matter = fumaMatter(value);
+      const {
+        collection: collectionName,
+        workspace,
+        only
+      } = querySchema.parse(query);
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      let after;
+      const { experimentalBuildCache = false } = core.getConfig().global;
+      if (!isDevelopment && experimentalBuildCache) {
+        const cacheDir = experimentalBuildCache;
+        const cacheKey = `${collectionName ?? "global"}_${generateCacheHash(filePath)}`;
+        const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+        if (cached && cached.hash === generateCacheHash(value)) return cached;
+        after = async () => {
+          await fs.mkdir(cacheDir, { recursive: true });
+          await fs.writeFile(
+            path.join(cacheDir, cacheKey),
+            JSON.stringify({
+              ...out,
+              hash: generateCacheHash(value)
+            })
+          );
+        };
+      }
+      const collection = collectionName ? core.getCollection(collectionName) : void 0;
+      let docCollection;
+      switch (collection?.type) {
+        case "doc":
+          docCollection = collection;
+          break;
+        case "docs":
+          docCollection = collection.docs;
+          break;
+      }
+      if (docCollection) {
+        matter.data = await core.transformFrontmatter(
+          { collection: docCollection, filePath, source: value },
+          matter.data
+        );
+      }
+      if (only === "frontmatter") {
+        return {
+          code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+          map: null
+        };
+      }
+      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+      const { buildMDX } = await import("./build-mdx-RXJZQXGA.js");
+      const compiled = await buildMDX(core, docCollection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
+      const out = {
+        code: String(compiled.value),
+        map: compiled.map
+      };
+      await after?.();
+      return out;
+    }
+  };
+}
+function generateCacheHash(input) {
+  return createHash("md5").update(input).digest("hex");
+}
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+export {
+  createMdxLoader
+};

package/dist/chunk-U5YPLCO5.js

@@ -0,0 +1,89 @@
+// src/config/preset.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function applyMdxPreset(options = {}) {
+  return async (environment = "bundler") => {
+    if (options.preset === "minimal") return options;
+    const plugins = await import("@hanzo/docs-core/mdx-plugins");
+    const {
+      valueToExport = [],
+      rehypeCodeOptions,
+      remarkImageOptions,
+      remarkHeadingOptions,
+      remarkStructureOptions,
+      remarkCodeTabOptions,
+      remarkNpmOptions,
+      ...mdxOptions
+    } = options;
+    const remarkPlugins = pluginOption(
+      (v) => [
+        plugins.remarkGfm,
+        [
+          plugins.remarkHeading,
+          {
+            generateToc: false,
+            ...remarkHeadingOptions
+          }
+        ],
+        remarkImageOptions !== false && [
+          plugins.remarkImage,
+          {
+            ...remarkImageOptions,
+            useImport: remarkImageOptions?.useImport ?? environment === "bundler"
+          }
+        ],
+        "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+          plugins.remarkCodeTab,
+          remarkCodeTabOptions
+        ],
+        "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+        ...v,
+        remarkStructureOptions !== false && [
+          plugins.remarkStructure,
+          {
+            exportAs: "structuredData",
+            ...remarkStructureOptions
+          }
+        ],
+        valueToExport.length > 0 && (() => {
+          return (_, file) => {
+            file.data["mdx-export"] ??= [];
+            for (const name of valueToExport) {
+              if (!(name in file.data)) continue;
+              file.data["mdx-export"].push({
+                name,
+                value: file.data[name]
+              });
+            }
+          };
+        })
+      ],
+      mdxOptions.remarkPlugins
+    );
+    const rehypePlugins = pluginOption(
+      (v) => [
+        rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+        ...v,
+        plugins.rehypeToc
+      ],
+      mdxOptions.rehypePlugins
+    );
+    return {
+      ...mdxOptions,
+      outputFormat: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
+      remarkPlugins,
+      rehypePlugins
+    };
+  };
+}
+
+export {
+  applyMdxPreset
+};