@hanzo/docs-core 16.2.5

package/dist/source/plugins/lucide-icons.d.ts

@@ -0,0 +1,14 @@
+import { L as LoaderPlugin } from '../../loader-BvlPPJX0.js';
+import { icons } from 'lucide-react';
+import '../../definitions-pJ7PybYY.js';
+import 'react';
+import '../../i18n/index.js';
+
+/**
+ * Convert icon names into Lucide Icons, requires `lucide-react` to be installed.
+ */
+declare function lucideIconsPlugin(options?: {
+    defaultIcon?: keyof typeof icons;
+}): LoaderPlugin;
+
+export { lucideIconsPlugin };

package/dist/source/plugins/lucide-icons.js

@@ -0,0 +1,23 @@
+import {
+  iconPlugin
+} from "../../chunk-FAEPKD7U.js";
+import "../../chunk-U67V476Y.js";
+
+// src/source/plugins/lucide-icons.ts
+import { icons } from "lucide-react";
+import { createElement } from "react";
+function lucideIconsPlugin(options = {}) {
+  const { defaultIcon } = options;
+  return iconPlugin((icon = defaultIcon) => {
+    if (icon === void 0) return;
+    const Icon = icons[icon];
+    if (!icon) {
+      console.warn(`[lucide-icons-plugin] Unknown icon detected: ${icon}.`);
+      return;
+    }
+    return createElement(Icon);
+  });
+}
+export {
+  lucideIconsPlugin
+};

package/dist/source/schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+/**
+ * Zod 4 schema
+ */
+declare const metaSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    root: z.ZodOptional<z.ZodBoolean>;
+    defaultOpen: z.ZodOptional<z.ZodBoolean>;
+    collapsible: z.ZodOptional<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod 4 schema
+ */
+declare const pageSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+    _openapi: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strip>;
+
+export { metaSchema, pageSchema };

package/dist/source/schema.js

@@ -0,0 +1,25 @@
+import "../chunk-U67V476Y.js";
+
+// src/source/schema.ts
+import { z } from "zod";
+var metaSchema = z.object({
+  title: z.string().optional(),
+  pages: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  root: z.boolean().optional(),
+  defaultOpen: z.boolean().optional(),
+  collapsible: z.boolean().optional(),
+  icon: z.string().optional()
+});
+var pageSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  full: z.boolean().optional(),
+  // Fumadocs OpenAPI generated
+  _openapi: z.looseObject({}).optional()
+});
+export {
+  metaSchema,
+  pageSchema
+};

package/dist/static-A2YJ5TXV.js

@@ -0,0 +1,62 @@
+import {
+  searchAdvanced,
+  searchSimple
+} from "./chunk-XOFXGHS4.js";
+import "./chunk-ZMWYLUDP.js";
+import "./chunk-OTD7MV33.js";
+import "./chunk-U67V476Y.js";
+
+// src/search/client/static.ts
+import { create, load } from "@orama/orama";
+var cache = /* @__PURE__ */ new Map();
+async function loadDB({
+  from = "/api/search",
+  initOrama = (locale) => create({ schema: { _: "string" }, language: locale })
+}) {
+  const cacheKey = from;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+  async function init() {
+    const res = await fetch(from);
+    if (!res.ok)
+      throw new Error(
+        `failed to fetch exported search indexes from ${from}, make sure the search database is exported and available for client.`
+      );
+    const data = await res.json();
+    const dbs = /* @__PURE__ */ new Map();
+    if (data.type === "i18n") {
+      await Promise.all(
+        Object.entries(data.data).map(async ([k, v]) => {
+          const db2 = await initOrama(k);
+          load(db2, v);
+          dbs.set(k, {
+            type: v.type,
+            db: db2
+          });
+        })
+      );
+      return dbs;
+    }
+    const db = await initOrama();
+    load(db, data);
+    dbs.set("", {
+      type: data.type,
+      db
+    });
+    return dbs;
+  }
+  const result = init();
+  cache.set(cacheKey, result);
+  return result;
+}
+async function search(query, options) {
+  const { tag, locale } = options;
+  const db = (await loadDB(options)).get(locale ?? "");
+  if (!db) return [];
+  if (db.type === "simple")
+    return searchSimple(db, query);
+  return searchAdvanced(db.db, query, tag);
+}
+export {
+  search
+};

package/dist/toc.d.ts

@@ -0,0 +1,43 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, RefObject, ComponentProps } from 'react';
+
+interface TOCItemType {
+    title: ReactNode;
+    url: string;
+    depth: number;
+}
+type TableOfContents = TOCItemType[];
+/**
+ * The estimated active heading ID
+ */
+declare function useActiveAnchor(): string | undefined;
+/**
+ * The id of visible anchors
+ */
+declare function useActiveAnchors(): string[];
+interface AnchorProviderProps {
+    toc: TableOfContents;
+    /**
+     * Only accept one active item at most
+     *
+     * @defaultValue false
+     */
+    single?: boolean;
+    children?: ReactNode;
+}
+interface ScrollProviderProps {
+    /**
+     * Scroll into the view of container when active
+     */
+    containerRef: RefObject<HTMLElement | null>;
+    children?: ReactNode;
+}
+declare function ScrollProvider({ containerRef, children, }: ScrollProviderProps): react_jsx_runtime.JSX.Element;
+declare function AnchorProvider({ toc, single, children, }: AnchorProviderProps): react_jsx_runtime.JSX.Element;
+interface TOCItemProps extends Omit<ComponentProps<'a'>, 'href'> {
+    href: string;
+    onActiveChange?: (v: boolean) => void;
+}
+declare function TOCItem({ ref, onActiveChange, ...props }: TOCItemProps): react_jsx_runtime.JSX.Element;
+
+export { AnchorProvider, type AnchorProviderProps, ScrollProvider, type ScrollProviderProps, TOCItem, type TOCItemProps, type TOCItemType, type TableOfContents, useActiveAnchor, useActiveAnchors };

package/dist/toc.js

@@ -0,0 +1,151 @@
+"use client";
+import "./chunk-U67V476Y.js";
+
+// src/toc.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useEffectEvent,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import scrollIntoView from "scroll-into-view-if-needed";
+
+// src/utils/merge-refs.ts
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    });
+  };
+}
+
+// src/toc.tsx
+import { jsx } from "react/jsx-runtime";
+var ActiveAnchorContext = createContext([]);
+var ScrollContext = createContext({
+  current: null
+});
+function useActiveAnchor() {
+  return useContext(ActiveAnchorContext)[0];
+}
+function useActiveAnchors() {
+  return useContext(ActiveAnchorContext);
+}
+function ScrollProvider({
+  containerRef,
+  children
+}) {
+  return /* @__PURE__ */ jsx(ScrollContext.Provider, { value: containerRef, children });
+}
+function AnchorProvider({
+  toc,
+  single = false,
+  children
+}) {
+  const headings = useMemo(() => {
+    return toc.map((item) => item.url.split("#")[1]);
+  }, [toc]);
+  return /* @__PURE__ */ jsx(ActiveAnchorContext.Provider, { value: useAnchorObserver(headings, single), children });
+}
+function TOCItem({
+  ref,
+  onActiveChange = () => null,
+  ...props
+}) {
+  const containerRef = useContext(ScrollContext);
+  const anchorRef = useRef(null);
+  const activeOrder = useActiveAnchors().indexOf(props.href.slice(1));
+  const isActive = activeOrder !== -1;
+  const shouldScroll = activeOrder === 0;
+  const onActiveChangeEvent = useEffectEvent(onActiveChange);
+  useLayoutEffect(() => {
+    const anchor = anchorRef.current;
+    const container = containerRef.current;
+    if (container && anchor && shouldScroll)
+      scrollIntoView(anchor, {
+        behavior: "smooth",
+        block: "center",
+        inline: "center",
+        scrollMode: "always",
+        boundary: container
+      });
+  }, [containerRef, shouldScroll]);
+  useEffect(() => {
+    return () => onActiveChangeEvent(isActive);
+  }, [isActive]);
+  return /* @__PURE__ */ jsx("a", { ref: mergeRefs(anchorRef, ref), "data-active": isActive, ...props, children: props.children });
+}
+function useAnchorObserver(watch, single) {
+  const observerRef = useRef(null);
+  const [activeAnchor, setActiveAnchor] = useState(() => []);
+  const stateRef = useRef(null);
+  const onChange = useEffectEvent((entries) => {
+    stateRef.current ??= {
+      visible: /* @__PURE__ */ new Set()
+    };
+    const state = stateRef.current;
+    for (const entry of entries) {
+      if (entry.isIntersecting) {
+        state.visible.add(entry.target.id);
+      } else {
+        state.visible.delete(entry.target.id);
+      }
+    }
+    if (state.visible.size === 0) {
+      const viewTop = entries.length > 0 ? entries[0]?.rootBounds?.top ?? 0 : 0;
+      let fallback;
+      let min = -1;
+      for (const id of watch) {
+        const element = document.getElementById(id);
+        if (!element) continue;
+        const d = Math.abs(viewTop - element.getBoundingClientRect().top);
+        if (min === -1 || d < min) {
+          fallback = element;
+          min = d;
+        }
+      }
+      setActiveAnchor(fallback ? [fallback.id] : []);
+    } else {
+      const items = watch.filter((item) => state.visible.has(item));
+      setActiveAnchor(single ? items.slice(0, 1) : items);
+    }
+  });
+  useEffect(() => {
+    if (observerRef.current) return;
+    observerRef.current = new IntersectionObserver(onChange, {
+      rootMargin: "0px",
+      threshold: 0.98
+    });
+    return () => {
+      observerRef.current?.disconnect();
+      observerRef.current = null;
+    };
+  }, []);
+  useEffect(() => {
+    const observer = observerRef.current;
+    if (!observer) return;
+    const elements = watch.flatMap(
+      (heading) => document.getElementById(heading) ?? []
+    );
+    for (const element of elements) observer.observe(element);
+    return () => {
+      for (const element of elements) observer.unobserve(element);
+    };
+  }, [watch]);
+  return activeAnchor;
+}
+export {
+  AnchorProvider,
+  ScrollProvider,
+  TOCItem,
+  useActiveAnchor,
+  useActiveAnchors
+};

package/dist/util-bZU2QeJ2.d.ts

@@ -0,0 +1,6 @@
+import { Pluggable } from 'unified';
+
+type Thenable<T> = T | PromiseLike<T>;
+type ResolvePlugins = Thenable<Pluggable>[] | ((v: Pluggable[]) => Thenable<Pluggable>[]);
+
+export type { ResolvePlugins as R };

package/dist/utils/use-effect-event.d.ts

@@ -0,0 +1,9 @@
+type UseEffectEvent = <F extends (...params: never[]) => unknown>(callback: F) => F;
+/**
+ * Polyfill for React.js 19.2 `useEffectEvent`.
+ *
+ * @internal Don't use this, could be deleted anytime.
+ */
+declare const useEffectEvent: UseEffectEvent;
+
+export { useEffectEvent };

package/dist/utils/use-effect-event.js

@@ -0,0 +1,16 @@
+"use client";
+import "../chunk-U67V476Y.js";
+
+// src/utils/use-effect-event.ts
+import * as React from "react";
+var useEffectEvent = "useEffectEvent" in React ? { ...React }.useEffectEvent : (callback) => {
+  const ref = React.useRef(callback);
+  ref.current = callback;
+  return React.useCallback(
+    ((...params) => ref.current(...params)),
+    []
+  );
+};
+export {
+  useEffectEvent
+};

package/dist/utils/use-media-query.d.ts

@@ -0,0 +1,3 @@
+declare function useMediaQuery(query: string, disabled?: boolean): boolean | null;
+
+export { useMediaQuery };

package/dist/utils/use-media-query.js

@@ -0,0 +1,23 @@
+import "../chunk-U67V476Y.js";
+
+// src/utils/use-media-query.ts
+import { useEffect, useState } from "react";
+function useMediaQuery(query, disabled = false) {
+  const [isMatch, setMatch] = useState(null);
+  useEffect(() => {
+    if (disabled) return;
+    const mediaQueryList = window.matchMedia(query);
+    const handleChange = () => {
+      setMatch(mediaQueryList.matches);
+    };
+    handleChange();
+    mediaQueryList.addEventListener("change", handleChange);
+    return () => {
+      mediaQueryList.removeEventListener("change", handleChange);
+    };
+  }, [disabled, query]);
+  return isMatch;
+}
+export {
+  useMediaQuery
+};

package/dist/utils/use-on-change.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param value - state to watch
+ * @param onChange - when the state changed
+ * @param isUpdated - a function that determines if the state is updated
+ */
+declare function useOnChange<T>(value: T, onChange: (current: T, previous: T) => void, isUpdated?: (prev: T, current: T) => boolean): void;
+
+export { useOnChange };

package/dist/utils/use-on-change.js

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

package/package.json

@@ -0,0 +1,222 @@
+{
+  "name": "@hanzo/docs-core",
+  "version": "16.2.5",
+  "description": "The React.js library for building a documentation website",
+  "keywords": [
+    "Hanzo",
+    "Docs"
+  ],
+  "homepage": "https://hanzo.ai/docs",
+  "repository": "github:hanzoai/docs",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "type": "module",
+  "exports": {
+    "./breadcrumb": {
+      "import": "./dist/breadcrumb.js",
+      "types": "./dist/breadcrumb.d.ts"
+    },
+    "./toc": {
+      "import": "./dist/toc.js",
+      "types": "./dist/toc.d.ts"
+    },
+    "./content": {
+      "import": "./dist/content/index.js",
+      "types": "./dist/content/index.d.ts"
+    },
+    "./content/*": {
+      "import": "./dist/content/*.js",
+      "types": "./dist/content/*.d.ts"
+    },
+    "./negotiation": {
+      "import": "./dist/negotiation/index.js",
+      "types": "./dist/negotiation/index.d.ts"
+    },
+    "./page-tree": {
+      "import": "./dist/page-tree/index.js",
+      "types": "./dist/page-tree/index.d.ts"
+    },
+    "./search": {
+      "import": "./dist/search/index.js",
+      "types": "./dist/search/index.d.ts"
+    },
+    "./search/*": {
+      "import": "./dist/search/*.js",
+      "types": "./dist/search/*.d.ts"
+    },
+    "./source": {
+      "import": "./dist/source/index.js",
+      "types": "./dist/source/index.d.ts"
+    },
+    "./source/client": {
+      "import": "./dist/source/client/index.js",
+      "types": "./dist/source/client/index.d.ts"
+    },
+    "./source/schema": {
+      "import": "./dist/source/schema.js",
+      "types": "./dist/source/schema.d.ts"
+    },
+    "./source/*": {
+      "import": "./dist/source/plugins/*.js",
+      "types": "./dist/source/plugins/*.d.ts"
+    },
+    "./utils/*": {
+      "import": "./dist/utils/*.js",
+      "types": "./dist/utils/*.d.ts"
+    },
+    "./link": {
+      "import": "./dist/link.js",
+      "types": "./dist/link.d.ts"
+    },
+    "./dynamic-link": {
+      "import": "./dist/dynamic-link.js",
+      "types": "./dist/dynamic-link.d.ts"
+    },
+    "./mdx-plugins": {
+      "import": "./dist/mdx-plugins/index.js",
+      "types": "./dist/mdx-plugins/index.d.ts"
+    },
+    "./mdx-plugins/*": {
+      "import": "./dist/mdx-plugins/*.js",
+      "types": "./dist/mdx-plugins/*.d.ts"
+    },
+    "./i18n": {
+      "import": "./dist/i18n/index.js",
+      "types": "./dist/i18n/index.d.ts"
+    },
+    "./i18n/middleware": {
+      "import": "./dist/i18n/middleware.js",
+      "types": "./dist/i18n/middleware.d.ts"
+    },
+    "./highlight": {
+      "import": "./dist/highlight/index.js",
+      "types": "./dist/highlight/index.d.ts"
+    },
+    "./highlight/client": {
+      "import": "./dist/highlight/client.js",
+      "types": "./dist/highlight/client.d.ts"
+    },
+    "./framework": {
+      "import": "./dist/framework/index.js",
+      "types": "./dist/framework/index.d.ts"
+    },
+    "./framework/*": {
+      "import": "./dist/framework/*.js",
+      "types": "./dist/framework/*.d.ts"
+    }
+  },
+  "files": [
+    "dist/*"
+  ],
+  "dependencies": {
+    "@formatjs/intl-localematcher": "^0.6.2",
+    "@orama/orama": "^3.1.16",
+    "@shikijs/rehype": "^3.20.0",
+    "@shikijs/transformers": "^3.20.0",
+    "estree-util-value-to-estree": "^3.5.0",
+    "github-slugger": "^2.0.0",
+    "hast-util-to-estree": "^3.1.3",
+    "hast-util-to-jsx-runtime": "^2.3.6",
+    "image-size": "^2.0.2",
+    "negotiator": "^1.0.0",
+    "npm-to-yarn": "^3.0.1",
+    "path-to-regexp": "^8.3.0",
+    "remark": "^15.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-rehype": "^11.1.2",
+    "scroll-into-view-if-needed": "^3.1.0",
+    "shiki": "^3.20.0",
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@mdx-js/mdx": "^3.1.1",
+    "@mixedbread/sdk": "^0.46.0",
+    "@orama/core": "^1.2.14",
+    "@tanstack/react-router": "1.136.18",
+    "@types/estree-jsx": "^1.0.5",
+    "@types/hast": "^3.0.4",
+    "@types/mdast": "^4.0.4",
+    "@types/negotiator": "^0.6.4",
+    "@types/node": "24.10.2",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "algoliasearch": "5.46.0",
+    "lucide-react": "^0.561.0",
+    "mdast-util-mdx-jsx": "^3.2.0",
+    "mdast-util-mdxjs-esm": "^2.0.1",
+    "next": "16.0.10",
+    "react-router": "^7.10.1",
+    "remark-directive": "^4.0.0",
+    "remark-mdx": "^3.1.1",
+    "remove-markdown": "^0.6.2",
+    "typescript": "^5.9.3",
+    "unified": "^11.0.5",
+    "vfile": "^6.0.3",
+    "waku": "^0.27.4",
+    "zod": "^4.1.13",
+    "eslint-config-custom": "0.0.0",
+    "tsconfig": "0.0.0"
+  },
+  "peerDependencies": {
+    "@mixedbread/sdk": "^0.19.0",
+    "@orama/core": "1.x.x",
+    "@tanstack/react-router": "1.x.x",
+    "@types/react": "*",
+    "algoliasearch": "5.x.x",
+    "lucide-react": "*",
+    "next": "16.x.x",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-router": "7.x.x",
+    "waku": "^0.26.0 || ^0.27.0",
+    "zod": "*"
+  },
+  "peerDependenciesMeta": {
+    "@mixedbread/sdk": {
+      "optional": true
+    },
+    "@types/react": {
+      "optional": true
+    },
+    "@orama/core": {
+      "optional": true
+    },
+    "algoliasearch": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "react-router": {
+      "optional": true
+    },
+    "waku": {
+      "optional": true
+    },
+    "@tanstack/react-router": {
+      "optional": true
+    },
+    "lucide-react": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "types:check": "tsc --noEmit"
+  }
+}