@hanzo/docs-core 16.2.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# Fumadocs Core
+
+The core library for Fumadocs.
+
+📘 Learn More: [Documentation](https://fumadocs.dev)

package/dist/algolia-IZEDLPHE.js

@@ -0,0 +1,58 @@
+import {
+  createContentHighlighter
+} from "./chunk-OTD7MV33.js";
+import "./chunk-U67V476Y.js";
+
+// src/search/client/algolia.ts
+function groupResults(hits) {
+  const grouped = [];
+  const scannedUrls = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    if (!scannedUrls.has(hit.url)) {
+      scannedUrls.add(hit.url);
+      grouped.push({
+        id: hit.url,
+        type: "page",
+        breadcrumbs: hit.breadcrumbs,
+        url: hit.url,
+        content: hit.title
+      });
+    }
+    grouped.push({
+      id: hit.objectID,
+      type: hit.content === hit.section ? "heading" : "text",
+      url: hit.section_id ? `${hit.url}#${hit.section_id}` : hit.url,
+      content: hit.content
+    });
+  }
+  return grouped;
+}
+async function searchDocs(query, { indexName, onSearch, client, locale, tag }) {
+  if (query.trim().length === 0) return [];
+  const result = onSearch ? await onSearch(query, tag, locale) : await client.searchForHits({
+    requests: [
+      {
+        type: "default",
+        indexName,
+        query,
+        distinct: 5,
+        hitsPerPage: 10,
+        filters: tag ? `tag:${tag}` : void 0
+      }
+    ]
+  });
+  const highlighter = createContentHighlighter(query);
+  return groupResults(result.results[0].hits).flatMap((hit) => {
+    if (hit.type === "page") {
+      return {
+        ...hit,
+        contentWithHighlights: hit.contentWithHighlights ?? highlighter.highlight(hit.content)
+      };
+    }
+    return [];
+  });
+}
+export {
+  groupResults,
+  searchDocs
+};

package/dist/breadcrumb.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import { R as Root, N as Node } from './definitions-pJ7PybYY.js';
+
+interface BreadcrumbItem {
+    name: ReactNode;
+    url?: string;
+}
+interface BreadcrumbOptions {
+    /**
+     * Include the root folders in the breadcrumb items array.
+     *
+     * @defaultValue false
+     */
+    includeRoot?: boolean | {
+        /**
+         * Specify the url of root
+         */
+        url: string;
+    };
+    /**
+     * Include the page itself in the breadcrumb items array
+     *
+     * @defaultValue false
+     */
+    includePage?: boolean;
+    /**
+     * Count separator as an item
+     *
+     * @defaultValue false
+     */
+    includeSeparator?: boolean;
+}
+declare function useBreadcrumb(url: string, tree: Root, options?: BreadcrumbOptions): BreadcrumbItem[];
+declare function getBreadcrumbItems(url: string, tree: Root, options?: BreadcrumbOptions): BreadcrumbItem[];
+declare function getBreadcrumbItemsFromPath(tree: Root, path: Node[], options: BreadcrumbOptions): BreadcrumbItem[];
+/**
+ * Search the path of a node in the tree by a specified url
+ *
+ * - When the page doesn't exist, return null
+ *
+ * @returns The path to the target node from root
+ * @internal Don't use this on your own
+ */
+declare function searchPath(nodes: Node[], url: string): Node[] | null;
+
+export { type BreadcrumbItem, type BreadcrumbOptions, getBreadcrumbItems, getBreadcrumbItemsFromPath, searchPath, useBreadcrumb };

package/dist/breadcrumb.js

@@ -0,0 +1,81 @@
+import {
+  normalizeUrl
+} from "./chunk-PFNP6PEB.js";
+import {
+  findPath
+} from "./chunk-L4JKQWCM.js";
+import "./chunk-U67V476Y.js";
+
+// src/breadcrumb.tsx
+import { useMemo } from "react";
+function useBreadcrumb(url, tree, options) {
+  return useMemo(
+    () => getBreadcrumbItems(url, tree, options),
+    [tree, url, options]
+  );
+}
+function getBreadcrumbItems(url, tree, options = {}) {
+  return getBreadcrumbItemsFromPath(
+    tree,
+    searchPath(tree.children, url) ?? [],
+    options
+  );
+}
+function getBreadcrumbItemsFromPath(tree, path, options) {
+  const {
+    includePage = false,
+    includeSeparator = false,
+    includeRoot = false
+  } = options;
+  let items = [];
+  for (let i = 0; i < path.length; i++) {
+    const item = path[i];
+    switch (item.type) {
+      case "page":
+        if (includePage)
+          items.push({
+            name: item.name,
+            url: item.url
+          });
+        break;
+      case "folder":
+        if (item.root && !includeRoot) {
+          items = [];
+          break;
+        }
+        if (i === path.length - 1 || item.index !== path[i + 1]) {
+          items.push({
+            name: item.name,
+            url: item.index?.url
+          });
+        }
+        break;
+      case "separator":
+        if (item.name && includeSeparator)
+          items.push({
+            name: item.name
+          });
+        break;
+    }
+  }
+  if (includeRoot) {
+    items.unshift({
+      name: tree.name,
+      url: typeof includeRoot === "object" ? includeRoot.url : void 0
+    });
+  }
+  return items;
+}
+function searchPath(nodes, url) {
+  const normalizedUrl = normalizeUrl(url);
+  return findPath(
+    nodes,
+    (node) => node.type === "page" && node.url === normalizedUrl
+  );
+}
+export {
+  getBreadcrumbItems,
+  getBreadcrumbItemsFromPath,
+  searchPath,
+  useBreadcrumb
+};

package/dist/chunk-5PMI7QDD.js

@@ -0,0 +1,220 @@
+// src/mdx-plugins/remark-image.ts
+import * as path from "path";
+import { visit } from "unist-util-visit";
+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) {
+      const attributes = [
+        {
+          type: "mdxJsxAttribute",
+          name: "alt",
+          value: node.alt ?? "image"
+        }
+      ];
+      if (node.title) {
+        attributes.push({
+          type: "mdxJsxAttribute",
+          name: "title",
+          value: node.title
+        });
+      }
+      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)
+        });
+        attributes.push({
+          type: "mdxJsxAttribute",
+          name: "src",
+          value: {
+            type: "mdxJsxAttributeValueExpression",
+            value: variableName,
+            data: {
+              estree: {
+                body: [
+                  {
+                    type: "ExpressionStatement",
+                    expression: { type: "Identifier", name: variableName }
+                  }
+                ],
+                type: "Program",
+                sourceType: "script"
+              }
+            }
+          }
+        });
+        const out = {
+          children: [],
+          type: "mdxJsxFlowElement",
+          name: "img",
+          attributes
+        };
+        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;
+      attributes.push(
+        {
+          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()
+        }
+      );
+      return {
+        type: "mdxJsxFlowElement",
+        name: "img",
+        attributes,
+        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") {
+    const { imageSizeFromFile } = await import("image-size/fromFile");
+    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()}`
+    );
+  }
+  const { imageSize } = await import("image-size");
+  return imageSize(new Uint8Array(await res.arrayBuffer()));
+}
+
+export {
+  remarkImage
+};

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-APKPSBSB.js

@@ -0,0 +1,74 @@
+// src/mdx-plugins/remark-directive-admonition.ts
+import { visit } from "unist-util-visit";
+function remarkDirectiveAdmonition({
+  tags: {
+    CalloutContainer = "CalloutContainer",
+    CalloutTitle = "CalloutTitle",
+    CalloutDescription = "CalloutDescription"
+  } = {},
+  types = {
+    note: "info",
+    tip: "info",
+    info: "info",
+    warn: "warning",
+    warning: "warning",
+    danger: "error",
+    success: "success"
+  }
+} = {}) {
+  return (tree) => {
+    visit(tree, "containerDirective", (node) => {
+      if (!(node.name in types)) return;
+      const attributes = [
+        {
+          type: "mdxJsxAttribute",
+          name: "type",
+          value: types[node.name]
+        }
+      ];
+      for (const [k, v] of Object.entries(node.attributes ?? {})) {
+        attributes.push({
+          type: "mdxJsxAttribute",
+          name: k,
+          value: v
+        });
+      }
+      const titleNodes = [];
+      const descriptionNodes = [];
+      for (const item of node.children) {
+        if (item.type === "paragraph" && item.data?.directiveLabel) {
+          titleNodes.push(...item.children);
+        } else {
+          descriptionNodes.push(item);
+        }
+      }
+      const children = [];
+      if (titleNodes.length > 0) {
+        children.push({
+          type: "mdxJsxFlowElement",
+          name: CalloutTitle,
+          attributes: [],
+          children: titleNodes
+        });
+      }
+      if (descriptionNodes.length > 0) {
+        children.push({
+          type: "mdxJsxFlowElement",
+          name: CalloutDescription,
+          attributes: [],
+          children: descriptionNodes
+        });
+      }
+      Object.assign(node, {
+        type: "mdxJsxFlowElement",
+        attributes,
+        name: CalloutContainer,
+        children
+      });
+    });
+  };
+}
+
+export {
+  remarkDirectiveAdmonition
+};