fumadocs-core 16.4.1 → 16.4.2

package/dist/chunk-CH7YHH7V.js

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

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

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

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

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

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

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

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

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