@hanzo/docs-mdx 14.1.1 → 14.2.4

package/dist/chunk-WMYYALAS.js

@@ -1,334 +0,0 @@
-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

@@ -1,216 +0,0 @@
-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
-};