@hanzo/docs-mdx 14.1.0

package/dist/chunk-WMYYALAS.js

@@ -0,0 +1,334 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+import {
+  createCodegen,
+  ident
+} from "./chunk-PW2AZGGD.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-Y7ISNZ7X.js

@@ -0,0 +1,216 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/loaders/mdx/remark-include.ts
+import { unified } from "unified";
+import { visit as visit2 } from "unist-util-visit";
+import * as path from "path";
+import * as fs from "fs/promises";
+import { remarkHeading } from "fumadocs-core/mdx-plugins";
+import { VFile } from "vfile";
+
+// src/loaders/mdx/remark-unravel.ts
+import { visit } from "unist-util-visit";
+function remarkMarkAndUnravel() {
+  return (tree) => {
+    visit(tree, function(node, index, parent) {
+      let offset = -1;
+      let all = true;
+      let oneOrMore = false;
+      if (parent && typeof index === "number" && node.type === "paragraph") {
+        const children = node.children;
+        while (++offset < children.length) {
+          const child = children[offset];
+          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
+            oneOrMore = true;
+          } else if (child.type === "text" && child.value.trim().length === 0) {
+          } else {
+            all = false;
+            break;
+          }
+        }
+        if (all && oneOrMore) {
+          offset = -1;
+          const newChildren = [];
+          while (++offset < children.length) {
+            const child = children[offset];
+            if (child.type === "mdxJsxTextElement") {
+              child.type = "mdxJsxFlowElement";
+            }
+            if (child.type === "mdxTextExpression") {
+              child.type = "mdxFlowExpression";
+            }
+            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
+            } else {
+              newChildren.push(child);
+            }
+          }
+          parent.children.splice(index, 1, ...newChildren);
+          return index;
+        }
+      }
+    });
+  };
+}
+
+// src/loaders/mdx/mdast-utils.ts
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+
+// src/loaders/mdx/remark-include.ts
+var ElementLikeTypes = [
+  "mdxJsxFlowElement",
+  "mdxJsxTextElement",
+  "containerDirective",
+  "textDirective",
+  "leafDirective"
+];
+function isElementLike(node) {
+  return ElementLikeTypes.includes(node.type);
+}
+function parseElementAttributes(element) {
+  if (Array.isArray(element.attributes)) {
+    const attributes = {};
+    for (const attr of element.attributes) {
+      if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
+        attributes[attr.name] = attr.value;
+      }
+    }
+    return attributes;
+  }
+  return element.attributes ?? {};
+}
+function parseSpecifier(specifier) {
+  const idx = specifier.lastIndexOf("#");
+  if (idx === -1) return { file: specifier };
+  return {
+    file: specifier.slice(0, idx),
+    section: specifier.slice(idx + 1)
+  };
+}
+function extractSection(root, section) {
+  let nodes;
+  let capturingHeadingContent = false;
+  visit2(root, (node) => {
+    if (node.type === "heading") {
+      if (capturingHeadingContent) {
+        return false;
+      }
+      if (node.data?.hProperties?.id === section) {
+        capturingHeadingContent = true;
+        nodes = [node];
+        return "skip";
+      }
+      return;
+    }
+    if (capturingHeadingContent) {
+      nodes?.push(node);
+      return "skip";
+    }
+    if (isElementLike(node) && node.name === "section") {
+      const attributes = parseElementAttributes(node);
+      if (attributes.id === section) {
+        nodes = node.children;
+        return false;
+      }
+    }
+  });
+  if (nodes)
+    return {
+      type: "root",
+      children: nodes
+    };
+}
+function remarkInclude() {
+  const TagName = "include";
+  const embedContent = async (targetPath, heading, params, parent) => {
+    const { _getProcessor = () => this, _compiler } = parent.data;
+    let content;
+    try {
+      content = (await fs.readFile(targetPath)).toString();
+    } catch (e) {
+      throw new Error(
+        `failed to read file ${targetPath}
+${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      );
+    }
+    const ext = path.extname(targetPath);
+    _compiler?.addDependency(targetPath);
+    if (params.lang || ext !== ".md" && ext !== ".mdx") {
+      const lang = params.lang ?? ext.slice(1);
+      return {
+        type: "code",
+        lang,
+        meta: params.meta,
+        value: content,
+        data: {}
+      };
+    }
+    const parser = _getProcessor(ext === ".mdx" ? "mdx" : "md");
+    const parsed = fumaMatter(content);
+    const targetFile = new VFile({
+      path: targetPath,
+      value: parsed.content,
+      data: {
+        ...parent.data,
+        frontmatter: parsed.data
+      }
+    });
+    let mdast = parser.parse(targetFile);
+    const baseProcessor = unified().use(remarkMarkAndUnravel);
+    if (heading) {
+      const extracted = extractSection(
+        await baseProcessor.use(remarkHeading).run(mdast),
+        heading
+      );
+      if (!extracted)
+        throw new Error(
+          `Cannot find section ${heading} in ${targetPath}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
+        );
+      mdast = extracted;
+    } else {
+      mdast = await baseProcessor.run(mdast);
+    }
+    await update(mdast, targetFile);
+    return mdast;
+  };
+  async function update(tree, file) {
+    const queue = [];
+    visit2(tree, ElementLikeTypes, (_node, _, parent) => {
+      const node = _node;
+      if (node.name !== TagName) return;
+      const specifier = flattenNode(node);
+      if (specifier.length === 0) return "skip";
+      const attributes = parseElementAttributes(node);
+      const { file: relativePath, section } = parseSpecifier(specifier);
+      const targetPath = path.resolve(
+        "cwd" in attributes ? file.cwd : file.dirname,
+        relativePath
+      );
+      queue.push(
+        embedContent(targetPath, section, attributes, file).then((replace) => {
+          Object.assign(
+            parent && parent.type === "paragraph" ? parent : node,
+            replace
+          );
+        })
+      );
+      return "skip";
+    });
+    await Promise.all(queue);
+  }
+  return async (tree, file) => {
+    await update(tree, file);
+  };
+}
+
+export {
+  flattenNode,
+  remarkInclude
+};