@hanzo/docs-core 16.2.5

package/dist/chunk-XOFXGHS4.js

@@ -0,0 +1,93 @@
+import {
+  removeUndefined
+} from "./chunk-ZMWYLUDP.js";
+import {
+  createContentHighlighter
+} from "./chunk-OTD7MV33.js";
+
+// src/search/orama/search/simple.ts
+import { search } from "@orama/orama";
+async function searchSimple(db, query, params = {}) {
+  const highlighter = createContentHighlighter(query);
+  const result = await search(db, {
+    term: query,
+    tolerance: 1,
+    ...params,
+    boost: {
+      title: 2,
+      ..."boost" in params ? params.boost : void 0
+    }
+  });
+  return result.hits.map((hit) => ({
+    type: "page",
+    content: hit.document.title,
+    breadcrumbs: hit.document.breadcrumbs,
+    contentWithHighlights: highlighter.highlight(hit.document.title),
+    id: hit.document.url,
+    url: hit.document.url
+  }));
+}
+
+// src/search/orama/search/advanced.ts
+import { getByID, search as search2 } from "@orama/orama";
+async function searchAdvanced(db, query, tag = [], {
+  mode = "fulltext",
+  ...override
+} = {}) {
+  if (typeof tag === "string") tag = [tag];
+  let params = {
+    ...override,
+    mode,
+    where: removeUndefined({
+      tags: tag.length > 0 ? {
+        containsAll: tag
+      } : void 0,
+      ...override.where
+    }),
+    groupBy: {
+      properties: ["page_id"],
+      maxResult: 8,
+      ...override.groupBy
+    }
+  };
+  if (query.length > 0) {
+    params = {
+      ...params,
+      term: query,
+      properties: mode === "fulltext" ? ["content"] : ["content", "embeddings"]
+    };
+  }
+  const highlighter = createContentHighlighter(query);
+  const result = await search2(db, params);
+  const list = [];
+  for (const item of result.groups ?? []) {
+    const pageId = item.values[0];
+    const page = getByID(db, pageId);
+    if (!page) continue;
+    list.push({
+      id: pageId,
+      type: "page",
+      content: page.content,
+      breadcrumbs: page.breadcrumbs,
+      contentWithHighlights: highlighter.highlight(page.content),
+      url: page.url
+    });
+    for (const hit of item.result) {
+      if (hit.document.type === "page") continue;
+      list.push({
+        id: hit.document.id.toString(),
+        content: hit.document.content,
+        breadcrumbs: hit.document.breadcrumbs,
+        contentWithHighlights: highlighter.highlight(hit.document.content),
+        type: hit.document.type,
+        url: hit.document.url
+      });
+    }
+  }
+  return list;
+}
+
+export {
+  searchSimple,
+  searchAdvanced
+};

package/dist/chunk-XZSI7AHE.js

@@ -0,0 +1,67 @@
+import {
+  __export
+} from "./chunk-U67V476Y.js";
+
+// src/source/path.ts
+var path_exports = {};
+__export(path_exports, {
+  basename: () => basename,
+  dirname: () => dirname,
+  extname: () => extname,
+  joinPath: () => joinPath,
+  slash: () => slash,
+  splitPath: () => splitPath
+});
+function basename(path, ext) {
+  const idx = path.lastIndexOf("/");
+  return path.substring(
+    idx === -1 ? 0 : idx + 1,
+    ext ? path.length - ext.length : path.length
+  );
+}
+function extname(path) {
+  const dotIdx = path.lastIndexOf(".");
+  if (dotIdx !== -1) {
+    return path.substring(dotIdx);
+  }
+  return "";
+}
+function dirname(path) {
+  return path.split("/").slice(0, -1).join("/");
+}
+function splitPath(path) {
+  return path.split("/").filter((p) => p.length > 0);
+}
+function joinPath(...paths) {
+  const out = [];
+  const parsed = paths.flatMap(splitPath);
+  for (const seg of parsed) {
+    switch (seg) {
+      case "..":
+        out.pop();
+        break;
+      case ".":
+        break;
+      default:
+        out.push(seg);
+    }
+  }
+  return out.join("/");
+}
+function slash(path) {
+  const isExtendedLengthPath = path.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path;
+  }
+  return path.replaceAll("\\", "/");
+}
+
+export {
+  basename,
+  extname,
+  dirname,
+  splitPath,
+  joinPath,
+  slash,
+  path_exports
+};

package/dist/chunk-YVVDKJ2H.js

@@ -0,0 +1,34 @@
+// src/negotiation/index.ts
+import Negotiator from "negotiator";
+import { compile, match } from "path-to-regexp";
+function getNegotiator(request) {
+  const headers = {};
+  request.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return new Negotiator({ headers });
+}
+function rewritePath(source, destination) {
+  const matcher = match(source, { decode: false });
+  const compiler = compile(destination, { encode: false });
+  return {
+    rewrite(pathname) {
+      const result = matcher(pathname);
+      if (!result) return false;
+      return compiler(result.params);
+    }
+  };
+}
+function isMarkdownPreferred(request, options) {
+  const {
+    markdownMediaTypes = ["text/plain", "text/markdown", "text/x-markdown"]
+  } = options ?? {};
+  const mediaTypes = getNegotiator(request).mediaTypes();
+  return markdownMediaTypes.some((type) => mediaTypes.includes(type));
+}
+
+export {
+  getNegotiator,
+  rewritePath,
+  isMarkdownPreferred
+};

package/dist/chunk-ZMWYLUDP.js

@@ -0,0 +1,21 @@
+// src/utils/remove-undefined.ts
+function removeUndefined(value, deep = false) {
+  const obj = value;
+  for (const key in obj) {
+    if (obj[key] === void 0) delete obj[key];
+    if (!deep) continue;
+    const entry = obj[key];
+    if (typeof entry === "object" && entry !== null) {
+      removeUndefined(entry, deep);
+      continue;
+    }
+    if (Array.isArray(entry)) {
+      for (const item of entry) removeUndefined(item, deep);
+    }
+  }
+  return value;
+}
+
+export {
+  removeUndefined
+};

package/dist/content/github.d.ts

@@ -0,0 +1,40 @@
+interface GetGithubLastCommitOptions {
+    /**
+     * Repository name, like "fumadocs"
+     */
+    repo: string;
+    /** Owner of repository */
+    owner: string;
+    /**
+     * Path to file
+     */
+    path: string;
+    /**
+     * GitHub access token
+     */
+    token?: string;
+    /**
+     * SHA or ref (branch or tag) name.
+     */
+    sha?: string;
+    /**
+     * Base URL for GitHub API
+     * @default "https://api.github.com"
+     * @link https://docs.github.com/en/get-started/using-github-docs/about-versions-of-github-docs#determining-which-github-product-you-use
+     */
+    baseUrl?: string;
+    /**
+     * Custom query parameters
+     */
+    params?: Record<string, string>;
+    options?: RequestInit;
+}
+/**
+ * Get the last edit time of a file using GitHub API
+ *
+ * By default, this will cache the result forever.
+ * Set `options.next.revalidate` to customise this.
+ */
+declare function getGithubLastEdit({ repo, token, owner, path, sha, baseUrl, options, params: customParams, }: GetGithubLastCommitOptions): Promise<Date | null>;
+
+export { type GetGithubLastCommitOptions, getGithubLastEdit };

package/dist/content/github.js

@@ -0,0 +1,44 @@
+import "../chunk-U67V476Y.js";
+
+// src/content/github.ts
+async function getGithubLastEdit({
+  repo,
+  token,
+  owner,
+  path,
+  sha,
+  baseUrl = "https://api.github.com",
+  options = {},
+  params: customParams = {}
+}) {
+  const headers = new Headers(options.headers);
+  const params = new URLSearchParams();
+  params.set("path", path);
+  params.set("page", "1");
+  params.set("per_page", "1");
+  if (sha) params.set("sha", sha);
+  for (const [key, value] of Object.entries(customParams)) {
+    params.set(key, value);
+  }
+  if (token) {
+    headers.append("authorization", token);
+  }
+  const res = await fetch(
+    `${baseUrl}/repos/${owner}/${repo}/commits?${params.toString()}`,
+    {
+      cache: "force-cache",
+      ...options,
+      headers
+    }
+  );
+  if (!res.ok)
+    throw new Error(
+      `Failed to fetch last edit time from Git ${await res.text()}`
+    );
+  const data = await res.json();
+  if (data.length === 0) return null;
+  return new Date(data[0].commit.committer.date);
+}
+export {
+  getGithubLastEdit
+};

package/dist/content/index.d.ts

@@ -0,0 +1,16 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Compatible } from 'vfile';
+import { Components } from 'hast-util-to-jsx-runtime';
+import { PluggableList } from 'unified';
+
+interface MarkdownProps {
+    components?: Components;
+}
+declare function Markdown({ children: content, remarkPlugins, rehypePlugins, ...options }: MarkdownProps & {
+    remarkPlugins?: PluggableList;
+    rehypePlugins?: PluggableList;
+    children: Compatible;
+}): Promise<react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | (string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined)>;
+
+export { Markdown, type MarkdownProps };

package/dist/content/index.js

@@ -0,0 +1,30 @@
+import "../chunk-U67V476Y.js";
+
+// src/content/index.ts
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+import remarkRehype from "remark-rehype";
+import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+import * as JsxRuntime from "react/jsx-runtime";
+function rehypeReact(options = {}) {
+  this.compiler = (tree, file) => {
+    return toJsxRuntime(tree, {
+      development: false,
+      filePath: file.path,
+      ...JsxRuntime,
+      ...options
+    });
+  };
+}
+async function Markdown({
+  children: content,
+  remarkPlugins = [],
+  rehypePlugins = [],
+  ...options
+}) {
+  const processor = remark().use(remarkGfm).use(remarkPlugins).use(remarkRehype).use(rehypePlugins).use(rehypeReact, options);
+  return (await processor.process(content)).result;
+}
+export {
+  Markdown
+};

package/dist/content/mdx/preset-bundler.d.ts

@@ -0,0 +1,31 @@
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { RehypeCodeOptions } from '../../mdx-plugins/rehype-code.js';
+import { RemarkImageOptions } from '../../mdx-plugins/remark-image.js';
+import { StructureOptions } from '../../mdx-plugins/remark-structure.js';
+import { RemarkHeadingOptions } from '../../mdx-plugins/remark-heading.js';
+import { RemarkCodeTabOptions } from '../../mdx-plugins/remark-code-tab.js';
+import { RemarkNpmOptions } from '../../mdx-plugins/remark-npm.js';
+import { R as ResolvePlugins } from '../../util-bZU2QeJ2.js';
+import 'hast';
+import '@shikijs/rehype';
+import 'unified';
+import 'shiki';
+import 'mdast';
+import 'mdast-util-mdx-jsx';
+
+type MDXBundlerPresetOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    remarkStructureOptions?: StructureOptions | false;
+    remarkHeadingOptions?: RemarkHeadingOptions;
+    remarkImageOptions?: RemarkImageOptions | false;
+    remarkCodeTabOptions?: RemarkCodeTabOptions | false;
+    remarkNpmOptions?: RemarkNpmOptions | false;
+    rehypeCodeOptions?: RehypeCodeOptions | false;
+};
+/**
+ * apply MDX processor presets
+ */
+declare function mdxPreset(options?: MDXBundlerPresetOptions): Promise<ProcessorOptions>;
+
+export { type MDXBundlerPresetOptions, mdxPreset };

package/dist/content/mdx/preset-bundler.js

@@ -0,0 +1,72 @@
+import {
+  resolvePlugins
+} from "../../chunk-GINBKBVQ.js";
+import "../../chunk-U67V476Y.js";
+
+// src/content/mdx/preset-bundler.ts
+async function mdxPreset(options = {}) {
+  const {
+    rehypeCodeOptions,
+    remarkImageOptions,
+    remarkHeadingOptions,
+    remarkStructureOptions,
+    remarkCodeTabOptions,
+    remarkNpmOptions,
+    ...mdxOptions
+  } = options;
+  const remarkPlugins = await resolvePlugins(
+    (v) => [
+      import("remark-gfm").then((mod) => mod.default),
+      import("../../mdx-plugins/remark-heading.js").then((mod) => [
+        mod.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ]),
+      remarkImageOptions !== false && import("../../mdx-plugins/remark-image.js").then((mod) => [
+        mod.remarkImage,
+        {
+          ...remarkImageOptions,
+          useImport: remarkImageOptions?.useImport ?? true
+        }
+      ]),
+      remarkCodeTabOptions !== false && import("../../mdx-plugins/remark-code-tab.js").then((mod) => [
+        mod.remarkCodeTab,
+        remarkCodeTabOptions
+      ]),
+      remarkNpmOptions !== false && import("../../mdx-plugins/remark-npm.js").then((mod) => [
+        mod.remarkNpm,
+        remarkNpmOptions
+      ]),
+      ...v,
+      remarkStructureOptions !== false && import("../../mdx-plugins/remark-structure.js").then((mod) => [
+        mod.remarkStructure,
+        {
+          exportAs: "structuredData",
+          ...remarkStructureOptions
+        }
+      ])
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = await resolvePlugins(
+    (v) => [
+      rehypeCodeOptions !== false && import("../../mdx-plugins/rehype-code.js").then((mod) => [
+        mod.rehypeCode,
+        rehypeCodeOptions
+      ]),
+      ...v,
+      import("../../mdx-plugins/rehype-toc.js").then((mod) => mod.rehypeToc)
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+export {
+  mdxPreset
+};

package/dist/content/mdx/preset-runtime.d.ts

@@ -0,0 +1,31 @@
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { RehypeCodeOptions } from '../../mdx-plugins/rehype-code.js';
+import { RemarkImageOptions } from '../../mdx-plugins/remark-image.js';
+import { StructureOptions } from '../../mdx-plugins/remark-structure.js';
+import { RemarkHeadingOptions } from '../../mdx-plugins/remark-heading.js';
+import { RemarkCodeTabOptions } from '../../mdx-plugins/remark-code-tab.js';
+import { RemarkNpmOptions } from '../../mdx-plugins/remark-npm.js';
+import { R as ResolvePlugins } from '../../util-bZU2QeJ2.js';
+import 'hast';
+import '@shikijs/rehype';
+import 'unified';
+import 'shiki';
+import 'mdast';
+import 'mdast-util-mdx-jsx';
+
+type MDXRuntimePresetOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    remarkStructureOptions?: StructureOptions | false;
+    remarkHeadingOptions?: RemarkHeadingOptions;
+    remarkImageOptions?: RemarkImageOptions | false;
+    remarkCodeTabOptions?: RemarkCodeTabOptions | false;
+    remarkNpmOptions?: RemarkNpmOptions | false;
+    rehypeCodeOptions?: RehypeCodeOptions | false;
+};
+/**
+ * apply MDX processor presets
+ */
+declare function mdxPreset(options?: MDXRuntimePresetOptions): Promise<ProcessorOptions>;
+
+export { type MDXRuntimePresetOptions, mdxPreset };

package/dist/content/mdx/preset-runtime.js

@@ -0,0 +1,71 @@
+import {
+  resolvePlugins
+} from "../../chunk-GINBKBVQ.js";
+import "../../chunk-U67V476Y.js";
+
+// src/content/mdx/preset-runtime.ts
+async function mdxPreset(options = {}) {
+  const {
+    rehypeCodeOptions,
+    remarkImageOptions,
+    remarkHeadingOptions,
+    remarkStructureOptions,
+    remarkCodeTabOptions,
+    remarkNpmOptions,
+    outputFormat = "function-body",
+    ...mdxOptions
+  } = options;
+  const remarkPlugins = await resolvePlugins(
+    (v) => [
+      import("remark-gfm").then((mod) => mod.default),
+      import("../../mdx-plugins/remark-heading.js").then((mod) => [
+        mod.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ]),
+      remarkImageOptions !== false && import("../../mdx-plugins/remark-image.js").then((mod) => [
+        mod.remarkImage,
+        remarkImageOptions
+      ]),
+      remarkCodeTabOptions !== false && import("../../mdx-plugins/remark-code-tab.js").then((mod) => [
+        mod.remarkCodeTab,
+        remarkCodeTabOptions
+      ]),
+      remarkNpmOptions !== false && import("../../mdx-plugins/remark-npm.js").then((mod) => [
+        mod.remarkNpm,
+        remarkNpmOptions
+      ]),
+      ...v,
+      remarkStructureOptions !== false && import("../../mdx-plugins/remark-structure.js").then((mod) => [
+        mod.remarkStructure,
+        {
+          exportAs: "structuredData",
+          ...remarkStructureOptions
+        }
+      ])
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = await resolvePlugins(
+    (v) => [
+      rehypeCodeOptions !== false && import("../../mdx-plugins/rehype-code.js").then((mod) => [
+        mod.rehypeCode,
+        rehypeCodeOptions
+      ]),
+      ...v,
+      import("../../mdx-plugins/rehype-toc.js").then((mod) => mod.rehypeToc)
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    outputFormat,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+export {
+  mdxPreset
+};

package/dist/content/toc.d.ts

@@ -0,0 +1,21 @@
+import { PluggableList } from 'unified';
+import { Compatible } from 'vfile';
+import { TOCItemType } from '../toc.js';
+import 'react/jsx-runtime';
+import 'react';
+
+/**
+ * Get Table of Contents from markdown/mdx document (using remark)
+ *
+ * @param content - Markdown content or file
+ */
+declare function getTableOfContents(content: Compatible): TOCItemType[];
+/**
+ * Get Table of Contents from markdown/mdx document (using remark)
+ *
+ * @param content - Markdown content or file
+ * @param remarkPlugins - remark plugins to be applied first
+ */
+declare function getTableOfContents(content: Compatible, remarkPlugins: PluggableList): Promise<TOCItemType[]>;
+
+export { getTableOfContents };

package/dist/content/toc.js

@@ -0,0 +1,22 @@
+import {
+  remarkHeading
+} from "../chunk-MA6O2UUE.js";
+import "../chunk-VLSDGCJE.js";
+import "../chunk-U67V476Y.js";
+
+// src/content/toc.ts
+import { remark } from "remark";
+function getTableOfContents(content, remarkPlugins) {
+  if (remarkPlugins) {
+    return remark().use(remarkPlugins).use(remarkHeading).process(content).then((result2) => {
+      if ("toc" in result2.data) return result2.data.toc;
+      return [];
+    });
+  }
+  const result = remark().use(remarkHeading).processSync(content);
+  if ("toc" in result.data) return result.data.toc;
+  return [];
+}
+export {
+  getTableOfContents
+};

package/dist/definitions-pJ7PybYY.d.ts

@@ -0,0 +1,60 @@
+import { ReactNode } from 'react';
+
+interface ID {
+    /**
+     * ID for the node, unique in all page trees (even across different locales)
+     */
+    $id?: string;
+}
+interface Root extends ID {
+    name: ReactNode;
+    children: Node[];
+    /**
+     * Another page tree that won't be displayed unless being opened.
+     */
+    fallback?: Root;
+}
+type Node = Item | Separator | Folder;
+interface Item extends ID {
+    /**
+     * @internal
+     */
+    $ref?: {
+        file: string;
+    };
+    type: 'page';
+    name: ReactNode;
+    url: string;
+    /**
+     * Whether the link should be treated as external (e.g. use HTML <a> tag).
+     *
+     * When unspecified, it depends on the value of `url`.
+     */
+    external?: boolean;
+    description?: ReactNode;
+    icon?: ReactNode;
+}
+interface Separator extends ID {
+    type: 'separator';
+    name?: ReactNode;
+    icon?: ReactNode;
+}
+interface Folder extends ID {
+    /**
+     * @internal
+     */
+    $ref?: {
+        metaFile?: string;
+    };
+    type: 'folder';
+    name: ReactNode;
+    description?: ReactNode;
+    root?: boolean;
+    defaultOpen?: boolean;
+    collapsible?: boolean;
+    index?: Item;
+    icon?: ReactNode;
+    children: Node[];
+}
+
+export type { Folder as F, Item as I, Node as N, Root as R, Separator as S };

package/dist/dynamic-link.d.ts

@@ -0,0 +1,12 @@
+import * as react from 'react';
+import { LinkProps } from './link.js';
+
+type DynamicLinkProps = LinkProps;
+/**
+ * Extends the default `Link` component
+ *
+ * It supports dynamic hrefs, which means you can use `/[lang]/my-page` with `dynamicHrefs` enabled
+ */
+declare const DynamicLink: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;
+
+export { DynamicLink, type DynamicLinkProps, DynamicLink as default };