@hanzo/docs-mdx 14.1.0

package/dist/chunk-A3YIGE7S.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-AOTZP2TV.js

@@ -0,0 +1,152 @@
+// src/runtime/server.ts
+import * as path from "path";
+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 cleanExports = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(entry)) {
+      cleanExports[key] = entry[key];
+    }
+    const data = {
+      body: entry.default,
+      toc: entry.toc,
+      structuredData: entry.structuredData,
+      _exports: cleanExports
+    };
+    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];
+          const result = /* @__PURE__ */ Object.create(null);
+          if (data && typeof data === "object") {
+            for (const key of Object.keys(data)) {
+              result[key] = data[key];
+            }
+          }
+          const methods = createDocMethods(fileInfo(k, base), content);
+          result.info = methods.info;
+          result.getText = methods.getText;
+          result.getMDAST = methods.getMDAST;
+          result.load = async function() {
+            return mapDocData(await content());
+          };
+          return result;
+        })
+      );
+      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),
+        toDocsSource() {
+          return toDocsSource(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),
+        toDocsSource() {
+          return toDocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    }
+  };
+}
+function toDocsSource(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);
+    }
+  };
+}
+
+export {
+  server,
+  toDocsSource
+};

package/dist/chunk-AXJB5MGS.js

@@ -0,0 +1,173 @@
+import {
+  flattenNode,
+  remarkInclude
+} from "./chunk-YKRCQ42E.js";
+
+// src/loaders/mdx/build-mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+import { VFile } from "vfile";
+
+// src/loaders/mdx/remark-postprocess.ts
+import { visit } from "unist-util-visit";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { valueToEstree } from "estree-util-value-to-estree";
+import { removePosition } from "unist-util-remove-position";
+import remarkMdx from "remark-mdx";
+function remarkPostprocess({
+  _format,
+  includeProcessedMarkdown = false,
+  includeMDAST = false,
+  extractLinkReferences = false,
+  valueToExport = []
+}) {
+  let _stringifyProcessor;
+  const getStringifyProcessor = () => {
+    return _stringifyProcessor ??= _format === "mdx" ? this : (
+      // force Markdown processor to stringify MDX nodes
+      this().use(remarkMdx).freeze()
+    );
+  };
+  return (tree, file) => {
+    const frontmatter = file.data.frontmatter ??= {};
+    if (!frontmatter.title) {
+      visit(tree, "heading", (node) => {
+        if (node.depth === 1) {
+          frontmatter.title = flattenNode(node);
+          return false;
+        }
+      });
+    }
+    file.data["mdx-export"] ??= [];
+    file.data["mdx-export"].push({
+      name: "frontmatter",
+      value: frontmatter
+    });
+    if (extractLinkReferences) {
+      const urls = [];
+      visit(tree, "link", (node) => {
+        urls.push({
+          href: node.url
+        });
+        return "skip";
+      });
+      file.data["mdx-export"].push({
+        name: "extractedReferences",
+        value: urls
+      });
+    }
+    if (includeProcessedMarkdown) {
+      const processor = getStringifyProcessor();
+      const markdown = toMarkdown(tree, {
+        ...processor.data("settings"),
+        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        extensions: processor.data("toMarkdownExtensions") || []
+      });
+      file.data["mdx-export"].push({
+        name: "_markdown",
+        value: markdown
+      });
+    }
+    if (includeMDAST) {
+      const options = includeMDAST === true ? {} : includeMDAST;
+      const mdast = JSON.stringify(
+        options.removePosition ? removePosition(structuredClone(tree)) : tree
+      );
+      file.data["mdx-export"].push({
+        name: "_mdast",
+        value: mdast
+      });
+    }
+    for (const { name, value } of file.data["mdx-export"]) {
+      tree.children.unshift(getMdastExport(name, value));
+    }
+    file.data["mdx-export"] = [];
+    for (const name of valueToExport) {
+      if (!(name in file.data)) continue;
+      tree.children.unshift(getMdastExport(name, file.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            attributes: [],
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+
+// src/loaders/mdx/build-mdx.ts
+async function buildMDX(core, collection, {
+  filePath,
+  frontmatter,
+  source,
+  _compiler,
+  environment,
+  isDevelopment
+}) {
+  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
+  function getProcessor(format) {
+    const cache = core.cache;
+    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
+    let processor = cache.get(key);
+    if (!processor) {
+      const postprocessOptions = {
+        _format: format,
+        ...collection?.postprocess
+      };
+      processor = createProcessor({
+        outputFormat: "program",
+        development: isDevelopment,
+        ...mdxOptions,
+        remarkPlugins: [
+          remarkInclude,
+          ...mdxOptions.remarkPlugins ?? [],
+          [remarkPostprocess, postprocessOptions]
+        ],
+        format
+      });
+      cache.set(key, processor);
+    }
+    return processor;
+  }
+  let vfile = new VFile({
+    value: source,
+    path: filePath,
+    cwd: collection?.cwd,
+    data: { frontmatter, _compiler, _getProcessor: getProcessor }
+  });
+  if (collection) {
+    vfile = await core.transformVFile({ collection, filePath, source }, vfile);
+  }
+  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
+}
+
+export {
+  buildMDX
+};