fumadocs-core 16.0.7 → 16.0.8

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
+};

package/dist/chunk-SLIKY7GW.js

@@ -0,0 +1,111 @@
+import {
+  flattenNode,
+  toMdxExport
+} from "./chunk-A4G5V4FQ.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";
+function remarkStructure({
+  types = [
+    "heading",
+    "paragraph",
+    "blockquote",
+    "tableCell",
+    "mdxJsxFlowElement"
+  ],
+  allowedMdxAttributes = (node) => {
+    if (!node.name) return false;
+    return ["TypeTable", "Callout"].includes(node.name);
+  },
+  exportAs = false
+} = {}) {
+  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 {
+  remarkStructure,
+  structure
+};

package/dist/chunk-TWIDBWFG.js

@@ -0,0 +1,84 @@
+// src/mdx-plugins/codeblock-utils.ts
+function generateCodeBlockTabs({
+  persist = false,
+  defaultValue,
+  triggers,
+  tabs,
+  ...options
+}) {
+  const attributes = [];
+  if (options.attributes) attributes.push(...options.attributes);
+  if (defaultValue) {
+    attributes.push({
+      type: "mdxJsxAttribute",
+      name: "defaultValue",
+      value: defaultValue
+    });
+  }
+  if (typeof persist === "object") {
+    attributes.push(
+      {
+        type: "mdxJsxAttribute",
+        name: "groupId",
+        value: persist.id
+      },
+      {
+        type: "mdxJsxAttribute",
+        name: "persist",
+        value: null
+      }
+    );
+  }
+  const children = [
+    {
+      type: "mdxJsxFlowElement",
+      name: "CodeBlockTabsList",
+      attributes: [],
+      children: triggers.map(
+        (trigger) => ({
+          type: "mdxJsxFlowElement",
+          attributes: [
+            { type: "mdxJsxAttribute", name: "value", value: trigger.value }
+          ],
+          name: "CodeBlockTabsTrigger",
+          children: trigger.children
+        })
+      )
+    }
+  ];
+  for (const tab of tabs) {
+    children.push({
+      type: "mdxJsxFlowElement",
+      name: "CodeBlockTab",
+      attributes: [
+        { type: "mdxJsxAttribute", name: "value", value: tab.value }
+      ],
+      children: tab.children
+    });
+  }
+  return {
+    type: "mdxJsxFlowElement",
+    name: "CodeBlockTabs",
+    attributes,
+    children
+  };
+}
+function parseCodeBlockAttributes(meta, allowedNames) {
+  let str = meta;
+  const StringRegex = /(?<=^|\s)(?<name>\w+)(?:=(?:"([^"]*)"|'([^']*)'))?/g;
+  const attributes = {};
+  str = str.replaceAll(StringRegex, (match, name, value_1, value_2) => {
+    if (allowedNames && !allowedNames.includes(name)) return match;
+    attributes[name] = value_1 ?? value_2 ?? null;
+    return "";
+  });
+  return {
+    rest: str,
+    attributes
+  };
+}
+
+export {
+  generateCodeBlockTabs,
+  parseCodeBlockAttributes
+};

package/dist/chunk-VW3XKOZZ.js

@@ -0,0 +1,214 @@
+// src/mdx-plugins/remark-image.ts
+import * as path from "path";
+import { visit } from "unist-util-visit";
+import { imageSize } from "image-size";
+import { imageSizeFromFile } from "image-size/fromFile";
+import { fileURLToPath } from "url";
+var VALID_BLUR_EXT = [".jpeg", ".png", ".webp", ".avif", ".jpg"];
+var EXTERNAL_URL_REGEX = /^https?:\/\//;
+function remarkImage({
+  placeholder = "blur",
+  external = true,
+  useImport = true,
+  onError = "error",
+  publicDir = path.join(process.cwd(), "public")
+} = {}) {
+  return async (tree, file) => {
+    const importsToInject = [];
+    const promises = [];
+    async function onImage(src, node) {
+      if (src.type === "file" && useImport) {
+        const variableName = `__img${importsToInject.length}`;
+        const hasBlur = placeholder === "blur" && VALID_BLUR_EXT.some((ext) => src.file.endsWith(ext));
+        if (!file.dirname) {
+          throw new Error(
+            "When `useImport` is enabled, you must specify `dirname` in the VFile passed to compiler."
+          );
+        }
+        importsToInject.push({
+          variableName,
+          importPath: getImportPath(src.file, file.dirname)
+        });
+        const out = {
+          children: [],
+          type: "mdxJsxFlowElement",
+          name: "img",
+          attributes: [
+            {
+              type: "mdxJsxAttribute",
+              name: "alt",
+              value: node.alt ?? "image"
+            },
+            {
+              type: "mdxJsxAttribute",
+              name: "src",
+              value: {
+                type: "mdxJsxAttributeValueExpression",
+                value: variableName,
+                data: {
+                  estree: {
+                    body: [
+                      {
+                        type: "ExpressionStatement",
+                        expression: { type: "Identifier", name: variableName }
+                      }
+                    ],
+                    type: "Program",
+                    sourceType: "script"
+                  }
+                }
+              }
+            }
+          ]
+        };
+        if (hasBlur) {
+          out.attributes.push({
+            type: "mdxJsxAttribute",
+            name: "placeholder",
+            value: "blur"
+          });
+        }
+        return out;
+      }
+      const size = await getImageSize(src, external).catch((e) => {
+        throw new Error(
+          `[Remark Image] Failed obtain image size for ${node.url} (public directory configured as ${publicDir})`,
+          {
+            cause: e
+          }
+        );
+      });
+      if (!size) return;
+      return {
+        type: "mdxJsxFlowElement",
+        name: "img",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "alt",
+            value: node.alt ?? "image"
+          },
+          {
+            type: "mdxJsxAttribute",
+            name: "src",
+            // `src` doesn't support file paths, we can use `node.url` for files and let the underlying framework handle it
+            value: src.type === "url" ? src.url.toString() : node.url
+          },
+          {
+            type: "mdxJsxAttribute",
+            name: "width",
+            value: size.width.toString()
+          },
+          {
+            type: "mdxJsxAttribute",
+            name: "height",
+            value: size.height.toString()
+          }
+        ],
+        children: []
+      };
+    }
+    visit(tree, "image", (node) => {
+      const src = parseSrc(decodeURI(node.url), publicDir, file.dirname);
+      if (!src) return;
+      const task = onImage(src, node).catch((e) => {
+        if (onError === "ignore" || node.url.endsWith(".svg")) {
+          return;
+        }
+        if (onError === "hide") {
+          return {
+            type: "mdxJsxFlowElement",
+            name: null,
+            attributes: [],
+            children: []
+          };
+        }
+        if (onError === "error") throw e;
+        onError(e);
+      }).then((res) => {
+        if (res) Object.assign(node, res);
+      });
+      promises.push(task);
+    });
+    await Promise.all(promises);
+    if (importsToInject.length === 0) return;
+    const imports = importsToInject.map(
+      ({ variableName, importPath }) => ({
+        type: "mdxjsEsm",
+        data: {
+          estree: {
+            body: [
+              {
+                type: "ImportDeclaration",
+                source: { type: "Literal", value: importPath },
+                specifiers: [
+                  {
+                    type: "ImportDefaultSpecifier",
+                    local: { type: "Identifier", name: variableName }
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      })
+    );
+    tree.children.unshift(...imports);
+  };
+}
+function getImportPath(file, dir) {
+  const relative2 = path.relative(dir, file).replaceAll(path.sep, "/");
+  return relative2.startsWith("../") ? relative2 : `./${relative2}`;
+}
+function parseSrc(src, publicDir, dir) {
+  if (src.startsWith("file:///"))
+    return { type: "file", file: fileURLToPath(src) };
+  if (EXTERNAL_URL_REGEX.test(src)) {
+    return {
+      type: "url",
+      url: new URL(src)
+    };
+  }
+  if (src.startsWith("/")) {
+    if (EXTERNAL_URL_REGEX.test(publicDir)) {
+      const url = new URL(publicDir);
+      const segs = [...url.pathname.split("/"), ...src.split("/")].filter(
+        (v) => v.length > 0
+      );
+      url.pathname = `/${segs.join("/")}`;
+      return { type: "url", url };
+    }
+    return {
+      type: "file",
+      file: path.join(publicDir, src)
+    };
+  }
+  if (!dir) {
+    console.warn(
+      `[Remark Image] found relative path ${src} but missing 'dirname' in VFile, this image will be skipped for now.`
+    );
+    return;
+  }
+  return {
+    type: "file",
+    file: path.join(dir, src)
+  };
+}
+async function getImageSize(src, onExternal) {
+  if (src.type === "file") return imageSizeFromFile(src.file);
+  if (onExternal === false) return;
+  const { timeout } = typeof onExternal === "object" ? onExternal : {};
+  const res = await fetch(src.url, {
+    signal: typeof timeout === "number" ? AbortSignal.timeout(timeout) : void 0
+  });
+  if (!res.ok) {
+    throw new Error(
+      `[Remark Image] Failed to fetch ${src.url} (${res.status}): ${await res.text()}`
+    );
+  }
+  return imageSize(new Uint8Array(await res.arrayBuffer()));
+}
+
+export {
+  remarkImage
+};