@hanzo/docs-core 16.2.5

package/dist/chunk-CH7YHH7V.js

@@ -0,0 +1,222 @@
+import {
+  generateCodeBlockTabs,
+  parseCodeBlockAttributes
+} from "./chunk-TWIDBWFG.js";
+
+// src/mdx-plugins/remark-code-tab.ts
+import { visit } from "unist-util-visit";
+var Tabs = {
+  convert(processor, nodes, withMdx = false, withParent = true) {
+    const tabs = Array.from(processTabValue(nodes).entries());
+    if (!withMdx) {
+      const children2 = tabs.map(([name, codes]) => {
+        return {
+          type: "mdxJsxFlowElement",
+          name: "Tab",
+          attributes: [
+            {
+              type: "mdxJsxAttribute",
+              name: "value",
+              value: name
+            }
+          ],
+          children: codes
+        };
+      });
+      if (!withParent) return createFragment(children2);
+      return {
+        type: "mdxJsxFlowElement",
+        name: "Tabs",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "items",
+            value: {
+              type: "mdxJsxAttributeValueExpression",
+              value: tabs.map(([name]) => name).join(", "),
+              data: {
+                estree: {
+                  type: "Program",
+                  sourceType: "module",
+                  comments: [],
+                  body: [
+                    {
+                      type: "ExpressionStatement",
+                      expression: {
+                        type: "ArrayExpression",
+                        elements: tabs.map(([name]) => ({
+                          type: "Literal",
+                          value: name
+                        }))
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ],
+        children: children2
+      };
+    }
+    const children = [
+      {
+        type: "mdxJsxFlowElement",
+        name: "TabsList",
+        attributes: [],
+        children: tabs.map(([name]) => ({
+          type: "mdxJsxFlowElement",
+          name: "TabsTrigger",
+          attributes: [
+            {
+              type: "mdxJsxAttribute",
+              name: "value",
+              value: name
+            }
+          ],
+          children: [mdxToAst(processor, name)]
+        }))
+      },
+      ...tabs.map(
+        ([name, codes]) => ({
+          type: "mdxJsxFlowElement",
+          name: "TabsContent",
+          attributes: [
+            {
+              type: "mdxJsxAttribute",
+              name: "value",
+              value: name
+            }
+          ],
+          children: codes
+        })
+      )
+    ];
+    if (!withParent) return createFragment(children);
+    return {
+      type: "mdxJsxFlowElement",
+      name: "Tabs",
+      attributes: [
+        {
+          type: "mdxJsxAttribute",
+          name: "defaultValue",
+          value: tabs[0][0]
+        }
+      ],
+      children
+    };
+  }
+};
+var CodeBlockTabs = {
+  convert(processor, nodes, withMdx = false, withParent = true) {
+    const tabs = Array.from(processTabValue(nodes).entries());
+    const node = generateCodeBlockTabs({
+      defaultValue: tabs[0][0],
+      triggers: tabs.map(([name]) => ({
+        value: name,
+        children: [
+          withMdx ? mdxToAst(processor, name) : {
+            type: "text",
+            value: name
+          }
+        ]
+      })),
+      tabs: tabs.map(([name, codes]) => ({
+        value: name,
+        children: codes
+      }))
+    });
+    if (!withParent) return createFragment(node.children);
+    return node;
+  }
+};
+var Types = {
+  CodeBlockTabs,
+  Tabs
+};
+function remarkCodeTab(options = {}) {
+  const { parseMdx = false, Tabs: Tabs2 = "CodeBlockTabs" } = options;
+  return (tree) => {
+    const ignored = /* @__PURE__ */ new WeakSet();
+    visit(tree, (node) => {
+      if (!("children" in node) || ignored.has(node)) return "skip";
+      let localTabs = Tabs2;
+      let localParseMdx = parseMdx;
+      let withParent = true;
+      if (node.type === "mdxJsxFlowElement" && node.name && node.name in Types) {
+        withParent = false;
+        localTabs = node.name;
+        if (node.name === "Tabs" && localParseMdx) {
+          localParseMdx = node.attributes.every(
+            (attribute) => attribute.type !== "mdxJsxAttribute" || attribute.name !== "items"
+          );
+        }
+      }
+      let start = -1;
+      let end = 0;
+      const close = () => {
+        if (start === -1 || start === end) return;
+        const replacement = Types[localTabs].convert(
+          this,
+          node.children.slice(start, end),
+          localParseMdx,
+          withParent
+        );
+        ignored.add(replacement);
+        node.children.splice(start, end - start, replacement);
+        end = start;
+        start = -1;
+      };
+      for (; end < node.children.length; end++) {
+        const child = node.children[end];
+        if (child.type !== "code" || !child.meta) {
+          close();
+          continue;
+        }
+        const meta = parseCodeBlockAttributes(child.meta, ["tab"]);
+        if (!meta.attributes.tab) {
+          close();
+          continue;
+        }
+        if (start === -1) start = end;
+        child.meta = meta.rest;
+        child.data ??= {};
+        child.data.tab = meta.attributes.tab;
+      }
+      close();
+    });
+  };
+}
+function processTabValue(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const name = node.data?.tab ?? `Tab ${i + 1}`;
+    const li = out.get(name) ?? [];
+    li.push(node);
+    out.set(name, li);
+  }
+  return out;
+}
+function mdxToAst(processor, name) {
+  const node = processor.parse(name);
+  if (node.type === "root") {
+    node.children = node.children.flatMap((child) => {
+      if (child.type === "paragraph") return child.children;
+      return child;
+    });
+  }
+  return node;
+}
+function createFragment(children) {
+  return {
+    type: "mdxJsxFlowElement",
+    name: null,
+    attributes: [],
+    children
+  };
+}
+
+export {
+  remarkCodeTab
+};

package/dist/chunk-EFVXL2PP.js

@@ -0,0 +1,144 @@
+// src/mdx-plugins/rehype-toc.ts
+import { toEstree } from "hast-util-to-estree";
+
+// src/mdx-plugins/hast-utils.ts
+function visit(node, tagNames, handler) {
+  if (node.type === "element" && tagNames.includes(node.tagName)) {
+    const result = handler(node);
+    if (result === "skip") return;
+  }
+  if ("children" in node)
+    node.children.forEach((n) => {
+      visit(n, tagNames, handler);
+    });
+}
+
+// src/mdx-plugins/rehype-toc.ts
+var TocOnlyTag = "[toc]";
+var NoTocTag = "[!toc]";
+function rehypeToc({ exportToc = true } = {}) {
+  return (tree) => {
+    const output = [];
+    visit(tree, ["h1", "h2", "h3", "h4", "h5", "h6"], (element) => {
+      const id = element.properties.id;
+      if (typeof id !== "string") return "skip";
+      let isTocOnly = false;
+      const last = element.children.at(-1);
+      if (last?.type === "text" && last.value.endsWith(TocOnlyTag)) {
+        isTocOnly = true;
+        last.value = last.value.substring(0, last.value.length - TocOnlyTag.length).trimEnd();
+      } else if (last?.type === "text" && last.value.endsWith(NoTocTag)) {
+        last.value = last.value.substring(0, last.value.length - NoTocTag.length).trimEnd();
+        return "skip";
+      }
+      const estree = toEstree(element, {
+        elementAttributeNameCase: "react",
+        stylePropertyNameCase: "dom"
+      });
+      if (estree.body[0].type === "ExpressionStatement")
+        output.push({
+          title: estree.body[0].expression,
+          depth: Number(element.tagName.slice(1)),
+          url: `#${id}`
+        });
+      if (isTocOnly) {
+        Object.assign(element, {
+          type: "comment",
+          value: ""
+        });
+      }
+      return "skip";
+    });
+    const declaration = {
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: {
+            type: "Identifier",
+            name: "toc"
+          },
+          init: {
+            type: "ArrayExpression",
+            elements: output.map((item) => ({
+              type: "ObjectExpression",
+              properties: [
+                {
+                  type: "Property",
+                  method: false,
+                  shorthand: false,
+                  computed: false,
+                  key: {
+                    type: "Identifier",
+                    name: "depth"
+                  },
+                  value: {
+                    type: "Literal",
+                    value: item.depth
+                  },
+                  kind: "init"
+                },
+                {
+                  type: "Property",
+                  method: false,
+                  shorthand: false,
+                  computed: false,
+                  key: {
+                    type: "Identifier",
+                    name: "url"
+                  },
+                  value: {
+                    type: "Literal",
+                    value: item.url
+                  },
+                  kind: "init"
+                },
+                {
+                  type: "Property",
+                  method: false,
+                  shorthand: false,
+                  computed: false,
+                  key: {
+                    type: "Identifier",
+                    name: "title"
+                  },
+                  value: {
+                    type: "JSXFragment",
+                    openingFragment: { type: "JSXOpeningFragment" },
+                    closingFragment: { type: "JSXClosingFragment" },
+                    children: item.title.children
+                  },
+                  kind: "init"
+                }
+              ]
+            }))
+          }
+        }
+      ]
+    };
+    tree.children.push({
+      type: "mdxjsEsm",
+      value: "",
+      data: {
+        estree: {
+          type: "Program",
+          body: [
+            exportToc ? {
+              type: "ExportNamedDeclaration",
+              declaration,
+              attributes: [],
+              specifiers: []
+            } : declaration
+          ],
+          sourceType: "module",
+          comments: []
+        }
+      }
+    });
+  };
+}
+
+export {
+  rehypeToc
+};

package/dist/chunk-EMWGTXSW.js

@@ -0,0 +1,19 @@
+// src/utils/use-on-change.ts
+import { useState } from "react";
+function isDifferent(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return b.length !== a.length || a.some((v, i) => isDifferent(v, b[i]));
+  }
+  return a !== b;
+}
+function useOnChange(value, onChange, isUpdated = isDifferent) {
+  const [prev, setPrev] = useState(value);
+  if (isUpdated(prev, value)) {
+    onChange(value, prev);
+    setPrev(value);
+  }
+}
+
+export {
+  useOnChange
+};

package/dist/chunk-FAEPKD7U.js

@@ -0,0 +1,20 @@
+// src/source/plugins/icon.ts
+function iconPlugin(resolveIcon) {
+  function replaceIcon(node) {
+    if (node.icon === void 0 || typeof node.icon === "string")
+      node.icon = resolveIcon(node.icon);
+    return node;
+  }
+  return {
+    name: "fumadocs:icon",
+    transformPageTree: {
+      file: replaceIcon,
+      folder: replaceIcon,
+      separator: replaceIcon
+    }
+  };
+}
+
+export {
+  iconPlugin
+};

package/dist/chunk-FUUVPEA5.js

@@ -0,0 +1,29 @@
+// src/mdx-plugins/remark-mdx-mermaid.ts
+import { visit } from "unist-util-visit";
+function toMDX(code) {
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Mermaid",
+    attributes: [
+      {
+        type: "mdxJsxAttribute",
+        name: "chart",
+        value: code.trim()
+      }
+    ],
+    children: []
+  };
+}
+function remarkMdxMermaid(options = {}) {
+  const { lang = "mermaid" } = options;
+  return (tree) => {
+    visit(tree, "code", (node) => {
+      if (node.lang !== lang || !node.value) return;
+      Object.assign(node, toMDX(node.value));
+    });
+  };
+}
+
+export {
+  remarkMdxMermaid
+};

package/dist/chunk-GINBKBVQ.js

@@ -0,0 +1,12 @@
+// src/content/mdx/util.ts
+async function resolvePlugins(def, options = []) {
+  const list = (await Promise.all(def(Array.isArray(options) ? options : []))).filter((v) => v !== false);
+  if (typeof options === "function") {
+    return Promise.all(options(list));
+  }
+  return list;
+}
+
+export {
+  resolvePlugins
+};

package/dist/chunk-GLRQBLGN.js

@@ -0,0 +1,59 @@
+import {
+  generateCodeBlockTabs
+} from "./chunk-TWIDBWFG.js";
+
+// src/mdx-plugins/remark-npm.ts
+import { visit } from "unist-util-visit";
+import convert from "npm-to-yarn";
+var aliases = ["npm", "package-install"];
+function remarkNpm({
+  persist = false,
+  packageManagers = [
+    { command: (cmd) => convert(cmd, "npm"), name: "npm" },
+    { command: (cmd) => convert(cmd, "pnpm"), name: "pnpm" },
+    { command: (cmd) => convert(cmd, "yarn"), name: "yarn" },
+    { command: (cmd) => convert(cmd, "bun"), name: "bun" }
+  ]
+} = {}) {
+  return (tree) => {
+    visit(tree, "code", (node) => {
+      if (!node.lang || !aliases.includes(node.lang)) return;
+      let code = node.value;
+      if (node.lang === "package-install" && !code.startsWith("npm") && !code.startsWith("npx")) {
+        code = `npm install ${code}`;
+      }
+      const options = {
+        persist,
+        tabs: [],
+        triggers: []
+      };
+      for (const manager of packageManagers) {
+        const value = manager.value ?? manager.name;
+        const command = manager.command(code);
+        if (!command || command.length === 0) continue;
+        options.defaultValue ??= value;
+        options.triggers.push({
+          value,
+          children: [{ type: "text", value: manager.name }]
+        });
+        options.tabs.push({
+          value,
+          children: [
+            {
+              type: "code",
+              lang: "bash",
+              meta: node.meta,
+              value: command
+            }
+          ]
+        });
+      }
+      Object.assign(node, generateCodeBlockTabs(options));
+      return "skip";
+    });
+  };
+}
+
+export {
+  remarkNpm
+};

package/dist/chunk-JUF4WZ6G.js

@@ -0,0 +1,117 @@
+import {
+  flattenNode,
+  toMdxExport
+} from "./chunk-VLSDGCJE.js";
+
+// src/mdx-plugins/remark-structure.ts
+import Slugger from "github-slugger";
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+import { visit } from "unist-util-visit";
+var remarkStructureDefaultOptions = {
+  types: [
+    "heading",
+    "paragraph",
+    "blockquote",
+    "tableCell",
+    "mdxJsxFlowElement"
+  ],
+  allowedMdxAttributes: (node) => {
+    if (!node.name) return false;
+    return ["TypeTable", "Callout"].includes(node.name);
+  },
+  exportAs: false
+};
+function remarkStructure({
+  types = remarkStructureDefaultOptions.types,
+  allowedMdxAttributes = remarkStructureDefaultOptions.allowedMdxAttributes,
+  exportAs = remarkStructureDefaultOptions.exportAs
+} = {}) {
+  const slugger = new Slugger();
+  if (Array.isArray(allowedMdxAttributes)) {
+    const arr = allowedMdxAttributes;
+    allowedMdxAttributes = (_node, attribute) => attribute.type === "mdxJsxAttribute" && arr.includes(attribute.name);
+  }
+  if (Array.isArray(types)) {
+    const arr = types;
+    types = (node) => arr.includes(node.type);
+  }
+  return (tree, file) => {
+    slugger.reset();
+    const data = { contents: [], headings: [] };
+    let lastHeading;
+    if (file.data.frontmatter) {
+      const frontmatter = file.data.frontmatter;
+      if (frontmatter._openapi?.structuredData) {
+        data.headings.push(...frontmatter._openapi.structuredData.headings);
+        data.contents.push(...frontmatter._openapi.structuredData.contents);
+      }
+    }
+    visit(tree, (element) => {
+      if (element.type === "root" || !types(element)) return;
+      if (element.type === "heading") {
+        element.data ||= {};
+        element.data.hProperties ||= {};
+        const properties = element.data.hProperties;
+        const content2 = flattenNode(element).trim();
+        const id = properties.id ?? slugger.slug(content2);
+        data.headings.push({
+          id,
+          content: content2
+        });
+        lastHeading = id;
+        return "skip";
+      }
+      if (element.data?._string) {
+        for (const content2 of element.data._string) {
+          data.contents.push({
+            heading: lastHeading,
+            content: content2
+          });
+        }
+        return "skip";
+      }
+      if (element.type === "mdxJsxFlowElement" && element.name) {
+        data.contents.push(
+          ...element.attributes.flatMap((attribute) => {
+            const value = typeof attribute.value === "string" ? attribute.value : attribute.value?.value;
+            if (!value || value.length === 0) return [];
+            if (allowedMdxAttributes && !allowedMdxAttributes(element, attribute))
+              return [];
+            return {
+              heading: lastHeading,
+              content: attribute.type === "mdxJsxAttribute" ? `${attribute.name}: ${value}` : value
+            };
+          })
+        );
+        return;
+      }
+      const content = flattenNode(element).trim();
+      if (content.length === 0) return;
+      data.contents.push({
+        heading: lastHeading,
+        content
+      });
+      return "skip";
+    });
+    file.data.structuredData = data;
+    if (exportAs) {
+      tree.children.unshift(
+        toMdxExport(
+          typeof exportAs === "string" ? exportAs : "structuredData",
+          data
+        )
+      );
+    }
+  };
+}
+function structure(content, remarkPlugins = [], options = {}) {
+  const result = remark().use(remarkGfm).use(remarkPlugins).use(remarkStructure, options).processSync(content);
+  return result.data.structuredData;
+}
+
+export {
+  remarkStructureDefaultOptions,
+  remarkStructure,
+  structure
+};

package/dist/chunk-K4WNLOVQ.js

@@ -0,0 +1,75 @@
+// src/framework/index.tsx
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var notImplemented = () => {
+  throw new Error(
+    "You need to wrap your application inside `FrameworkProvider`."
+  );
+};
+var FrameworkContext = createContext({
+  useParams: notImplemented,
+  useRouter: notImplemented,
+  usePathname: notImplemented
+});
+function FrameworkProvider({
+  Link: Link2,
+  useRouter: useRouter2,
+  useParams: useParams2,
+  usePathname: usePathname2,
+  Image: Image2,
+  children
+}) {
+  const framework = useMemo(
+    () => ({
+      usePathname: usePathname2,
+      useRouter: useRouter2,
+      Link: Link2,
+      Image: Image2,
+      useParams: useParams2
+    }),
+    [Link2, usePathname2, useRouter2, useParams2, Image2]
+  );
+  return /* @__PURE__ */ jsx(FrameworkContext, { value: framework, children });
+}
+function usePathname() {
+  return use(FrameworkContext).usePathname();
+}
+function useRouter() {
+  return use(FrameworkContext).useRouter();
+}
+function useParams() {
+  return use(FrameworkContext).useParams();
+}
+function Image(props) {
+  const { Image: Image2 } = use(FrameworkContext);
+  if (!Image2) {
+    const { src, alt, priority, ...rest } = props;
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        alt,
+        src,
+        fetchPriority: priority ? "high" : "auto",
+        ...rest
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(Image2, { ...props });
+}
+function Link(props) {
+  const { Link: Link2 } = use(FrameworkContext);
+  if (!Link2) {
+    const { href, prefetch: _, ...rest } = props;
+    return /* @__PURE__ */ jsx("a", { href, ...rest });
+  }
+  return /* @__PURE__ */ jsx(Link2, { ...props });
+}
+
+export {
+  FrameworkProvider,
+  usePathname,
+  useRouter,
+  useParams,
+  Image,
+  Link
+};