@hanzo/docs-core 16.2.5

package/dist/mdx-plugins/remark-heading.d.ts

@@ -0,0 +1,31 @@
+import { Root, Heading } from 'mdast';
+import { Transformer } from 'unified';
+
+declare module 'mdast' {
+    interface HeadingData extends Data {
+        hProperties?: {
+            id?: string;
+        };
+    }
+}
+interface RemarkHeadingOptions {
+    slug?: (root: Root, heading: Heading, text: string) => string;
+    /**
+     * Allow custom headings ids
+     *
+     * @defaultValue true
+     */
+    customId?: boolean;
+    /**
+     * Attach an array of `TOCItemType` to `file.data.toc`
+     *
+     * @defaultValue true
+     */
+    generateToc?: boolean;
+}
+/**
+ * Add heading ids and extract TOC
+ */
+declare function remarkHeading({ slug: defaultSlug, customId, generateToc, }?: RemarkHeadingOptions): Transformer<Root, Root>;
+
+export { type RemarkHeadingOptions, remarkHeading };

package/dist/mdx-plugins/remark-heading.js

@@ -0,0 +1,8 @@
+import {
+  remarkHeading
+} from "../chunk-MA6O2UUE.js";
+import "../chunk-VLSDGCJE.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkHeading
+};

package/dist/mdx-plugins/remark-image.d.ts

@@ -0,0 +1,57 @@
+import { Root } from 'mdast';
+import { Transformer } from 'unified';
+
+type ExternalImageOptions = {
+    /**
+     * timeout for fetching remote images (in milliseconds)
+     */
+    timeout?: number;
+} | boolean;
+interface RemarkImageOptions {
+    /**
+     * Directory or base URL to resolve absolute image paths
+     */
+    publicDir?: string;
+    /**
+     * Preferred placeholder type, only available with `useImport` + local images.
+     *
+     * @defaultValue 'blur'
+     */
+    placeholder?: 'blur' | 'none';
+    /**
+     * Define how to handle errors when fetching image size.
+     *
+     * - `error` (default): throw an error.
+     * - `ignore`: do absolutely nothing (Next.js Image component may complain).
+     * - `hide`: remove that image element.
+     *
+     * @defaultValue 'error'
+     */
+    onError?: 'error' | 'hide' | 'ignore' | ((error: Error) => void);
+    /**
+     * Import images in the file, and let bundlers handle it.
+     *
+     * ```tsx
+     * import MyImage from "./public/img.png";
+     *
+     * <img src={MyImage} />
+     * ```
+     *
+     * When disabled, `placeholder` will be ignored.
+     *
+     * @defaultValue true
+     */
+    useImport?: boolean;
+    /**
+     * Fetch image size of external URLs
+     *
+     * @defaultValue true
+     */
+    external?: ExternalImageOptions;
+}
+/**
+ * Turn images into Next.js Image compatible usage.
+ */
+declare function remarkImage({ placeholder, external, useImport, onError, publicDir, }?: RemarkImageOptions): Transformer<Root, Root>;
+
+export { type RemarkImageOptions, remarkImage };

package/dist/mdx-plugins/remark-image.js

@@ -0,0 +1,7 @@
+import {
+  remarkImage
+} from "../chunk-5PMI7QDD.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkImage
+};

package/dist/mdx-plugins/remark-mdx-files.d.ts

@@ -0,0 +1,40 @@
+import { Root } from 'mdast';
+import { Transformer } from 'unified';
+import { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
+
+interface FileNode {
+    depth: number;
+    type: 'file';
+    name: string;
+}
+interface FolderNode {
+    depth: number;
+    type: 'folder';
+    name: string;
+    children: Node[];
+}
+type Node = FileNode | FolderNode;
+interface RemarkMdxFilesOptions {
+    /**
+     * @defaultValue files
+     */
+    lang?: string;
+    toMdx?: (node: Node) => MdxJsxFlowElement;
+}
+/**
+ * Convert codeblocks with `files` as lang, like:
+ *
+ * ```files
+ * project
+ * ├── src
+ * │   ├── index.js
+ * │   └── utils
+ * │       └── helper.js
+ * ├── package.json
+ * ```
+ *
+ * into MDX `<Files />` component
+ */
+declare function remarkMdxFiles(options?: RemarkMdxFilesOptions): Transformer<Root, Root>;
+
+export { type RemarkMdxFilesOptions, remarkMdxFiles };

package/dist/mdx-plugins/remark-mdx-files.js

@@ -0,0 +1,7 @@
+import {
+  remarkMdxFiles
+} from "../chunk-ADBHPKXG.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkMdxFiles
+};

package/dist/mdx-plugins/remark-mdx-mermaid.d.ts

@@ -0,0 +1,15 @@
+import { Transformer } from 'unified';
+import { Root } from 'mdast';
+
+interface RemarkMdxMermaidOptions {
+    /**
+     * @defaultValue mermaid
+     */
+    lang?: string;
+}
+/**
+ * Convert `mermaid` codeblocks into `<Mermaid />` MDX component
+ */
+declare function remarkMdxMermaid(options?: RemarkMdxMermaidOptions): Transformer<Root, Root>;
+
+export { type RemarkMdxMermaidOptions, remarkMdxMermaid };

package/dist/mdx-plugins/remark-mdx-mermaid.js

@@ -0,0 +1,7 @@
+import {
+  remarkMdxMermaid
+} from "../chunk-FUUVPEA5.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkMdxMermaid
+};

package/dist/mdx-plugins/remark-npm.d.ts

@@ -0,0 +1,31 @@
+import { Root } from 'mdast';
+import { Transformer } from 'unified';
+
+interface PackageManager {
+    name: string;
+    /**
+     * Default to `name`
+     */
+    value?: string;
+    /**
+     * Convert from npm to another package manager
+     */
+    command: (command: string) => string | undefined;
+}
+interface RemarkNpmOptions {
+    /**
+     * Persist Tab value (Fumadocs UI only)
+     *
+     * @defaultValue false
+     */
+    persist?: {
+        id: string;
+    } | false;
+    packageManagers?: PackageManager[];
+}
+/**
+ * It generates multiple tabs of codeblocks for different package managers from a npm command codeblock.
+ */
+declare function remarkNpm({ persist, packageManagers, }?: RemarkNpmOptions): Transformer<Root, Root>;
+
+export { type RemarkNpmOptions, remarkNpm };

package/dist/mdx-plugins/remark-npm.js

@@ -0,0 +1,8 @@
+import {
+  remarkNpm
+} from "../chunk-GLRQBLGN.js";
+import "../chunk-TWIDBWFG.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkNpm
+};

package/dist/mdx-plugins/remark-steps.d.ts

@@ -0,0 +1,23 @@
+import { Transformer } from 'unified';
+import { Root } from 'mdast';
+
+interface RemarkStepsOptions {
+    /**
+     * Class name for steps container
+     *
+     * @defaultValue fd-steps
+     */
+    steps?: string;
+    /**
+     * Class name for step container
+     *
+     * @defaultValue fd-step
+     */
+    step?: string;
+}
+/**
+ * Convert headings in the format of `1. Hello World` into steps.
+ */
+declare function remarkSteps({ steps, step, }?: RemarkStepsOptions): Transformer<Root, Root>;
+
+export { type RemarkStepsOptions, remarkSteps };

package/dist/mdx-plugins/remark-steps.js

@@ -0,0 +1,7 @@
+import {
+  remarkSteps
+} from "../chunk-XJ6ZQNEX.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkSteps
+};

package/dist/mdx-plugins/remark-structure.d.ts

@@ -0,0 +1,71 @@
+import { Nodes, Root } from 'mdast';
+import { Transformer, PluggableList } from 'unified';
+import { MdxJsxFlowElement, MdxJsxAttribute, MdxJsxExpressionAttribute } from 'mdast-util-mdx-jsx';
+
+interface Heading {
+    id: string;
+    content: string;
+}
+interface Content {
+    heading: string | undefined;
+    content: string;
+}
+interface StructuredData {
+    headings: Heading[];
+    /**
+     * Refer to paragraphs, a heading may contain multiple contents as well
+     */
+    contents: Content[];
+}
+interface StructureOptions {
+    /**
+     * Types to be scanned as content.
+     *
+     * @defaultValue ['heading', 'paragraph', 'blockquote', 'tableCell', 'mdxJsxFlowElement']
+     */
+    types?: string[] | ((node: Nodes) => boolean);
+    /**
+     * A list of indexable MDX attributes, either:
+     *
+     * - an array of attribute names.
+     * - a function that determines if attribute should be indexed.
+     */
+    allowedMdxAttributes?: string[] | ((node: MdxJsxFlowElement, attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => boolean);
+    /**
+     * export as `structuredData` or specified variable name.
+     */
+    exportAs?: string | boolean;
+}
+declare module 'mdast' {
+    interface Data {
+        /**
+         * [Fumadocs] Get content of unserializable element, `remarkStructure` uses it to generate search index.
+         */
+        _string?: string[];
+    }
+}
+declare module 'vfile' {
+    interface DataMap {
+        /**
+         * [Fumadocs] injected by `remarkStructure`
+         */
+        structuredData: StructuredData;
+    }
+}
+declare const remarkStructureDefaultOptions: {
+    types: string[];
+    allowedMdxAttributes: (node: MdxJsxFlowElement) => boolean;
+    exportAs: false;
+};
+/**
+ * Extract content into structured data.
+ *
+ * By default, the output is stored into VFile (`vfile.data.structuredData`), you can specify `exportAs` to export it.
+ */
+declare function remarkStructure({ types, allowedMdxAttributes, exportAs, }?: StructureOptions): Transformer<Root, Root>;
+/**
+ * Extract data from markdown/mdx content
+ */
+declare function structure(content: string, remarkPlugins?: PluggableList, options?: StructureOptions): StructuredData;
+
+export { type StructureOptions, type StructuredData, remarkStructure, remarkStructureDefaultOptions, structure };

package/dist/mdx-plugins/remark-structure.js

@@ -0,0 +1,12 @@
+import {
+  remarkStructure,
+  remarkStructureDefaultOptions,
+  structure
+} from "../chunk-JUF4WZ6G.js";
+import "../chunk-VLSDGCJE.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkStructure,
+  remarkStructureDefaultOptions,
+  structure
+};

package/dist/mixedbread-RAHDVXGJ.js

@@ -0,0 +1,118 @@
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-U67V476Y.js";
+
+// ../../node_modules/.pnpm/remove-markdown@0.6.2/node_modules/remove-markdown/index.js
+var require_remove_markdown = __commonJS({
+  "../../node_modules/.pnpm/remove-markdown@0.6.2/node_modules/remove-markdown/index.js"(exports, module) {
+    "use strict";
+    module.exports = function(md, options) {
+      options = options || {};
+      options.listUnicodeChar = options.hasOwnProperty("listUnicodeChar") ? options.listUnicodeChar : false;
+      options.stripListLeaders = options.hasOwnProperty("stripListLeaders") ? options.stripListLeaders : true;
+      options.gfm = options.hasOwnProperty("gfm") ? options.gfm : true;
+      options.useImgAltText = options.hasOwnProperty("useImgAltText") ? options.useImgAltText : true;
+      options.abbr = options.hasOwnProperty("abbr") ? options.abbr : false;
+      options.replaceLinksWithURL = options.hasOwnProperty("replaceLinksWithURL") ? options.replaceLinksWithURL : false;
+      options.htmlTagsToSkip = options.hasOwnProperty("htmlTagsToSkip") ? options.htmlTagsToSkip : [];
+      options.throwError = options.hasOwnProperty("throwError") ? options.throwError : false;
+      var output = md || "";
+      output = output.replace(/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/gm, "");
+      try {
+        if (options.stripListLeaders) {
+          if (options.listUnicodeChar)
+            output = output.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, options.listUnicodeChar + " $1");
+          else
+            output = output.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, "$1");
+        }
+        if (options.gfm) {
+          output = output.replace(/\n={2,}/g, "\n").replace(/~{3}.*\n/g, "").replace(/~~/g, "").replace(/```(?:.*)\n([\s\S]*?)```/g, (_, code) => code.trim());
+        }
+        if (options.abbr) {
+          output = output.replace(/\*\[.*\]:.*\n/, "");
+        }
+        let htmlReplaceRegex = /<[^>]*>/g;
+        if (options.htmlTagsToSkip && options.htmlTagsToSkip.length > 0) {
+          const joinedHtmlTagsToSkip = options.htmlTagsToSkip.join("|");
+          htmlReplaceRegex = new RegExp(
+            `<(?!/?(${joinedHtmlTagsToSkip})(?=>|s[^>]*>))[^>]*>`,
+            "g"
+          );
+        }
+        output = output.replace(htmlReplaceRegex, "").replace(/^[=\-]{2,}\s*$/g, "").replace(/\[\^.+?\](\: .*?$)?/g, "").replace(/\s{0,2}\[.*?\]: .*?$/g, "").replace(/\!\[(.*?)\][\[\(].*?[\]\)]/g, options.useImgAltText ? "$1" : "").replace(/\[([\s\S]*?)\]\s*[\(\[].*?[\)\]]/g, options.replaceLinksWithURL ? "$2" : "$1").replace(/^(\n)?\s{0,3}>\s?/gm, "$1").replace(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/g, "").replace(/^(\n)?\s{0,}#{1,6}\s*( (.+))? +#+$|^(\n)?\s{0,}#{1,6}\s*( (.+))?$/gm, "$1$3$4$6").replace(/([\*]+)(\S)(.*?\S)??\1/g, "$2$3").replace(/(^|\W)([_]+)(\S)(.*?\S)??\2($|\W)/g, "$1$3$4$5").replace(/(`{3,})(.*?)\1/gm, "$2").replace(/`(.+?)`/g, "$1").replace(/~(.*?)~/g, "$1");
+      } catch (e) {
+        if (options.throwError) throw e;
+        console.error("remove-markdown encountered error: %s", e);
+        return md;
+      }
+      return output;
+    };
+  }
+});
+
+// src/search/client/mixedbread.ts
+var import_remove_markdown = __toESM(require_remove_markdown(), 1);
+import Slugger from "github-slugger";
+var slugger = new Slugger();
+function extractHeadingTitle(text) {
+  const trimmedText = text.trim();
+  if (!trimmedText.startsWith("#")) {
+    return "";
+  }
+  const lines = trimmedText.split("\n");
+  const firstLine = lines[0]?.trim();
+  if (firstLine) {
+    const plainText = (0, import_remove_markdown.default)(firstLine, {
+      useImgAltText: false
+    });
+    return plainText;
+  }
+  return "";
+}
+async function search(query, options) {
+  const { client, vectorStoreId, tag } = options;
+  if (!query.trim()) {
+    return [];
+  }
+  const res = await client.vectorStores.search({
+    query,
+    vector_store_identifiers: [vectorStoreId],
+    top_k: 10,
+    filters: {
+      key: "generated_metadata.tag",
+      operator: "eq",
+      value: tag
+    },
+    search_options: {
+      return_metadata: true
+    }
+  });
+  return res.data.flatMap((item) => {
+    const metadata = item.generated_metadata;
+    const url = metadata.url || "#";
+    const title = metadata.title || "Untitled";
+    const chunkResults = [
+      {
+        id: `${item.file_id}-${item.chunk_index}-page`,
+        type: "page",
+        content: title,
+        url
+      }
+    ];
+    const headingTitle = item.type === "text" ? extractHeadingTitle(item.text) : "";
+    if (headingTitle) {
+      slugger.reset();
+      chunkResults.push({
+        id: `${item.file_id}-${item.chunk_index}-heading`,
+        type: "heading",
+        content: headingTitle,
+        url: `${url}#${slugger.slug(headingTitle)}`
+      });
+    }
+    return chunkResults;
+  });
+}
+export {
+  search
+};

package/dist/negotiation/index.d.ts

@@ -0,0 +1,19 @@
+import Negotiator from 'negotiator';
+
+declare function getNegotiator(request: Request): Negotiator;
+/**
+ * Rewrite incoming path matching the `source` pattern into the `destination` pattern.
+ *
+ * See [`path-to-regexp`](https://github.com/pillarjs/path-to-regexp) for accepted pattern formats.
+ *
+ * @param source - the original pattern of incoming paths
+ * @param destination - the target pattern to convert into
+ */
+declare function rewritePath(source: string, destination: string): {
+    rewrite(pathname: string): string | false;
+};
+declare function isMarkdownPreferred(request: Request, options?: {
+    markdownMediaTypes?: string[];
+}): boolean;
+
+export { getNegotiator, isMarkdownPreferred, rewritePath };

package/dist/negotiation/index.js

@@ -0,0 +1,11 @@
+import {
+  getNegotiator,
+  isMarkdownPreferred,
+  rewritePath
+} from "../chunk-YVVDKJ2H.js";
+import "../chunk-U67V476Y.js";
+export {
+  getNegotiator,
+  isMarkdownPreferred,
+  rewritePath
+};

package/dist/orama-cloud-UZAPMPFV.js

@@ -0,0 +1,93 @@
+import {
+  removeUndefined
+} from "./chunk-ZMWYLUDP.js";
+import {
+  createContentHighlighter
+} from "./chunk-OTD7MV33.js";
+import "./chunk-U67V476Y.js";
+
+// src/search/client/orama-cloud.ts
+async function searchDocs(query, options) {
+  const highlighter = createContentHighlighter(query);
+  const list = [];
+  const { index = "default", client, params: extraParams, tag } = options;
+  if (index === "crawler") {
+    const result2 = await client.search({
+      datasources: [],
+      ...extraParams,
+      term: query,
+      where: {
+        category: tag ? {
+          eq: tag.slice(0, 1).toUpperCase() + tag.slice(1)
+        } : void 0,
+        ...extraParams?.where
+      },
+      limit: 10
+    });
+    if (!result2) return list;
+    for (const hit of result2.hits) {
+      const doc = hit.document;
+      list.push(
+        {
+          id: hit.id,
+          type: "page",
+          content: doc.title,
+          contentWithHighlights: highlighter.highlight(doc.title),
+          url: doc.path
+        },
+        {
+          id: "page" + hit.id,
+          type: "text",
+          content: doc.content,
+          contentWithHighlights: highlighter.highlight(doc.content),
+          url: doc.path
+        }
+      );
+    }
+    return list;
+  }
+  const params = {
+    datasources: [],
+    ...extraParams,
+    term: query,
+    where: removeUndefined({
+      tag,
+      ...extraParams?.where
+    }),
+    groupBy: {
+      properties: ["page_id"],
+      max_results: 7,
+      ...extraParams?.groupBy
+    }
+  };
+  const result = await client.search(params);
+  if (!result || !result.groups) return list;
+  for (const item of result.groups) {
+    let addedHead = false;
+    for (const hit of item.result) {
+      const doc = hit.document;
+      if (!addedHead) {
+        list.push({
+          id: doc.page_id,
+          type: "page",
+          content: doc.title,
+          breadcrumbs: doc.breadcrumbs,
+          contentWithHighlights: highlighter.highlight(doc.title),
+          url: doc.url
+        });
+        addedHead = true;
+      }
+      list.push({
+        id: doc.id,
+        content: doc.content,
+        contentWithHighlights: highlighter.highlight(doc.content),
+        type: doc.content === doc.section ? "heading" : "text",
+        url: doc.section_id ? `${doc.url}#${doc.section_id}` : doc.url
+      });
+    }
+  }
+  return list;
+}
+export {
+  searchDocs
+};

package/dist/page-tree/index.d.ts

@@ -0,0 +1,33 @@
+import { N as Node, I as Item, R as Root, F as Folder } from '../definitions-pJ7PybYY.js';
+export { S as Separator } from '../definitions-pJ7PybYY.js';
+import 'react';
+
+/**
+ * Flatten tree to an array of page nodes
+ */
+declare function flattenTree(nodes: Node[]): Item[];
+/**
+ * Get neighbours of a page, useful for implementing "previous & next" buttons
+ */
+declare function findNeighbour(tree: Root, url: string, options?: {
+    separateRoot?: boolean;
+}): {
+    previous?: Item;
+    next?: Item;
+};
+declare function getPageTreeRoots(pageTree: Root | Folder): (Root | Folder)[];
+/**
+ * Get other page tree nodes that lives under the same parent
+ */
+declare function getPageTreePeers(treeOrTrees: Root | Record<string, Root>, url: string): Item[];
+/**
+ * Search the path of a node in the tree matched by the matcher.
+ *
+ * @returns The path to the target node (from starting root), or null if the page doesn't exist
+ */
+declare function findPath(nodes: Node[], matcher: (node: Node) => boolean, options?: {
+    includeSeparator?: boolean;
+}): Node[] | null;
+declare function visit<Root extends Node | Root>(root: Root, visitor: <T extends Node | Root>(node: T, parent?: Root | Folder) => 'skip' | 'break' | T | void): Root;
+
+export { Folder, Item, Node, Root, findNeighbour, findPath, flattenTree, getPageTreePeers, getPageTreeRoots, visit };

package/dist/page-tree/index.js

@@ -0,0 +1,17 @@
+import {
+  findNeighbour,
+  findPath,
+  flattenTree,
+  getPageTreePeers,
+  getPageTreeRoots,
+  visit
+} from "../chunk-L4JKQWCM.js";
+import "../chunk-U67V476Y.js";
+export {
+  findNeighbour,
+  findPath,
+  flattenTree,
+  getPageTreePeers,
+  getPageTreeRoots,
+  visit
+};