fumadocs-core 16.0.6 → 16.0.8

package/dist/breadcrumb.js

@@ -1,9 +1,9 @@
-import {
-  normalizeUrl
-} from "./chunk-PFNP6PEB.js";
 import {
   findPath
 } from "./chunk-IZPLHEX4.js";
+import {
+  normalizeUrl
+} from "./chunk-PFNP6PEB.js";
 import "./chunk-U67V476Y.js";
 
 // src/breadcrumb.tsx

package/dist/chunk-A4G5V4FQ.js

@@ -0,0 +1,47 @@
+// src/mdx-plugins/mdast-utils.ts
+import { valueToEstree } from "estree-util-value-to-estree";
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+function toMdxExport(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)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+
+export {
+  flattenNode,
+  toMdxExport
+};

package/dist/chunk-ADBHPKXG.js

@@ -0,0 +1,78 @@
+// src/mdx-plugins/remark-mdx-files.ts
+import { visit } from "unist-util-visit";
+function parseFileTree(code) {
+  const lines = code.split(/\r?\n/);
+  const stack = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    let depth = 0;
+    let name = line;
+    let match;
+    while (match = /(?:├──|│|└──)\s*/.exec(name)) {
+      name = name.slice(match[0].length);
+      depth++;
+    }
+    if (!name) continue;
+    const node = name.endsWith("/") ? { type: "folder", name, children: [], depth } : { type: "file", name, depth };
+    let parent;
+    for (let i = depth - 1; i >= 0 && !parent; i--) {
+      parent = stack.get(i);
+    }
+    stack.set(depth, node);
+    if (!parent) continue;
+    if (parent.type === "file") {
+      Object.assign(parent, {
+        type: "folder",
+        children: []
+      });
+    }
+    parent.children.push(node);
+  }
+  return stack.get(0);
+}
+function defaultToMDX(node, depth = 0) {
+  if (depth === 0) {
+    return {
+      type: "mdxJsxFlowElement",
+      name: "Files",
+      attributes: [],
+      children: [defaultToMDX(node, depth + 1)]
+    };
+  }
+  const attributes = [
+    { type: "mdxJsxAttribute", name: "name", value: node.name }
+  ];
+  if (node.type === "file") {
+    return {
+      type: "mdxJsxFlowElement",
+      attributes,
+      children: [],
+      name: "File"
+    };
+  }
+  attributes.push({
+    type: "mdxJsxAttribute",
+    name: "defaultOpen",
+    value: null
+  });
+  return {
+    type: "mdxJsxFlowElement",
+    attributes,
+    name: "Folder",
+    children: node.children.map((item) => defaultToMDX(item, depth + 1))
+  };
+}
+function remarkMdxFiles(options = {}) {
+  const { lang = "files", toMdx = defaultToMDX } = options;
+  return (tree) => {
+    visit(tree, "code", (node) => {
+      if (node.lang !== lang || !node.value) return;
+      const fileTree = parseFileTree(node.value);
+      if (!fileTree) return;
+      Object.assign(node, toMdx(fileTree));
+    });
+  };
+}
+
+export {
+  remarkMdxFiles
+};

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-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-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-QMATWJ5F.js → chunk-HNZEUF6C.js}

@@ -1,16 +1,10 @@
+import {
+  flattenNode
+} from "./chunk-A4G5V4FQ.js";
+
 // src/mdx-plugins/remark-heading.ts
 import Slugger from "github-slugger";
 import { visit } from "unist-util-visit";
-
-// src/mdx-plugins/remark-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/mdx-plugins/remark-heading.ts
 var slugger = new Slugger();
 var regex = /\s*\[#(?<slug>[^]+?)]\s*$/;
 function remarkHeading({
@@ -52,6 +46,5 @@ function remarkHeading({
 }
 
 export {
-  flattenNode,
   remarkHeading
 };

package/dist/chunk-JOXPHQ2R.js

@@ -0,0 +1,73 @@
+import {
+  flattenNode
+} from "./chunk-A4G5V4FQ.js";
+
+// src/mdx-plugins/remark-admonition.ts
+import { visit } from "unist-util-visit";
+function remarkAdmonition(options = {}) {
+  const tag = options.tag ?? ":::";
+  const typeMap = options.typeMap ?? {
+    info: "info",
+    warn: "warn",
+    note: "info",
+    tip: "info",
+    warning: "warn",
+    danger: "error"
+  };
+  function replaceNodes(nodes) {
+    if (nodes.length === 0) return;
+    let open = -1;
+    let attributes = [];
+    let hasIntercept = false;
+    for (let i = 0; i < nodes.length; i++) {
+      if (nodes[i].type !== "paragraph") continue;
+      const text = flattenNode(nodes[i]);
+      const typeName = Object.keys(typeMap).find(
+        (type) => text.startsWith(`${tag}${type}`)
+      );
+      if (typeName) {
+        if (open !== -1) {
+          hasIntercept = true;
+          continue;
+        }
+        open = i;
+        attributes.push({
+          type: "mdxJsxAttribute",
+          name: "type",
+          value: typeMap[typeName]
+        });
+        const meta = text.slice(`${tag}${typeName}`.length);
+        if (meta.startsWith("[") && meta.endsWith("]")) {
+          attributes.push({
+            type: "mdxJsxAttribute",
+            name: "title",
+            value: meta.slice(1, -1)
+          });
+        }
+      }
+      if (open !== -1 && text === tag) {
+        const children = nodes.slice(open + 1, i);
+        nodes.splice(open, i - open + 1, {
+          type: "mdxJsxFlowElement",
+          name: "Callout",
+          attributes,
+          children: hasIntercept ? replaceNodes(children) : children
+        });
+        open = -1;
+        hasIntercept = false;
+        attributes = [];
+        i = open;
+      }
+    }
+  }
+  return (tree) => {
+    visit(tree, (node) => {
+      if (!("children" in node)) return;
+      replaceNodes(node.children);
+    });
+  };
+}
+
+export {
+  remarkAdmonition
+};

package/dist/chunk-ONG4RVCR.js

@@ -0,0 +1,8 @@
+// src/mdx-plugins/remark-gfm.ts
+import {
+  default as default2
+} from "remark-gfm";
+
+export {
+  default2 as default
+};