@hanzo/docs-mdx 14.1.0

package/dist/chunk-YKRCQ42E.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 "@hanzo/docs-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
+};

package/dist/chunk-ZAYZWFWP.js

@@ -0,0 +1,89 @@
+import {
+  metaLoaderGlob
+} from "./chunk-4JSFLXXT.js";
+
+// src/loaders/meta.ts
+import { dump, load } from "js-yaml";
+import { z } from "zod";
+var querySchema = z.object({
+  collection: z.string().optional(),
+  workspace: z.string().optional()
+}).loose();
+function createMetaLoader({ getCore }, resolve = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
+  function parse(filePath, source) {
+    try {
+      if (filePath.endsWith(".json")) return JSON.parse(source);
+      if (filePath.endsWith(".yaml")) return load(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
+    }
+    throw new Error("Unknown file type " + filePath);
+  }
+  function onMeta(source, { filePath, query }) {
+    const parsed = querySchema.safeParse(query);
+    if (!parsed.success || !parsed.data.collection) return null;
+    const { collection: collectionName, workspace } = parsed.data;
+    return async () => {
+      let core = await getCore();
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      const collection = core.getCollection(collectionName);
+      let metaCollection;
+      switch (collection?.type) {
+        case "meta":
+          metaCollection = collection;
+          break;
+        case "docs":
+          metaCollection = collection.meta;
+          break;
+      }
+      const data = parse(filePath, source);
+      if (!metaCollection) return data;
+      return core.transformMeta(
+        {
+          collection: metaCollection,
+          filePath,
+          source
+        },
+        data
+      );
+    };
+  }
+  return {
+    test: metaLoaderGlob,
+    async load(input) {
+      const result = onMeta(await input.getSource(), input);
+      if (result === null) return null;
+      const data = await result();
+      if (input.filePath.endsWith(".json")) {
+        return {
+          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
+        };
+      } else {
+        return {
+          code: resolveYaml === "yaml" ? dump(data) : `export default ${JSON.stringify(data)}`
+        };
+      }
+    },
+    bun: {
+      load(source, input) {
+        const result = onMeta(source, input);
+        if (result === null)
+          return {
+            loader: "object",
+            exports: parse(input.filePath, source)
+          };
+        return result().then((data) => ({
+          loader: "object",
+          exports: { default: data }
+        }));
+      }
+    }
+  };
+}
+
+export {
+  createMetaLoader
+};

package/dist/config/index.d.ts

@@ -0,0 +1,18 @@
+export { A as AnyCollection, B as BaseCollection, a as CollectionSchema, f as DefaultMDXOptions, D as DocCollection, b as DocsCollection, G as GlobalConfig, g as MDXPresetOptions, M as MetaCollection, P as PostprocessOptions, h as applyMdxPreset, d as defineCollections, e as defineConfig, c as defineDocs } from '../core-BhWOtait.js';
+import { Processor, Transformer } from 'unified';
+import { Root } from 'mdast';
+export { pageSchema as frontmatterSchema, metaSchema } from '@hanzo/docs-core/source/schema';
+import '@mdx-js/mdx';
+import '@standard-schema/spec';
+import '@hanzo/docs-core/mdx-plugins';
+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 'mdx/types';
+
+declare function remarkInclude(this: Processor): Transformer<Root, Root>;
+
+export { remarkInclude };

package/dist/config/index.js

@@ -0,0 +1,63 @@
+import {
+  remarkInclude
+} from "../chunk-YKRCQ42E.js";
+import {
+  applyMdxPreset
+} from "../chunk-U5YPLCO5.js";
+import "../chunk-VWJKRQZR.js";
+
+// ../core/dist/source/schema.js
+import { z } from "zod";
+var metaSchema = z.object({
+  title: z.string().optional(),
+  pages: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  root: z.boolean().optional(),
+  defaultOpen: z.boolean().optional(),
+  collapsible: z.boolean().optional(),
+  icon: z.string().optional()
+});
+var pageSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  full: z.boolean().optional(),
+  // Fumadocs OpenAPI generated
+  _openapi: z.looseObject({}).optional()
+});
+
+// src/config/define.ts
+function defineCollections(options) {
+  return options;
+}
+function defineDocs(options) {
+  const dir = options.dir ?? "content/docs";
+  return {
+    type: "docs",
+    dir,
+    docs: defineCollections({
+      type: "doc",
+      dir,
+      schema: pageSchema,
+      ...options?.docs
+    }),
+    meta: defineCollections({
+      type: "meta",
+      dir,
+      schema: metaSchema,
+      ...options?.meta
+    })
+  };
+}
+function defineConfig(config = {}) {
+  return config;
+}
+export {
+  applyMdxPreset,
+  defineCollections,
+  defineConfig,
+  defineDocs,
+  pageSchema as frontmatterSchema,
+  metaSchema,
+  remarkInclude
+};