@hanzo/docs-core 16.2.5

package/dist/dynamic-link.js

@@ -0,0 +1,32 @@
+"use client";
+import {
+  Link
+} from "./chunk-SH7BNTG7.js";
+import {
+  useParams
+} from "./chunk-K4WNLOVQ.js";
+import "./chunk-U67V476Y.js";
+
+// src/dynamic-link.tsx
+import { forwardRef, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var DynamicLink = forwardRef(
+  ({ href, ...props }, ref) => {
+    const params = useParams();
+    const url = useMemo(() => {
+      return href?.replace(/\[.*]/, (key) => {
+        const mappedKey = key.slice(1, -1);
+        const value = mappedKey in params ? params[mappedKey] : void 0;
+        if (!value) return "";
+        return typeof value === "string" ? value : value.join("/");
+      });
+    }, [params, href]);
+    return /* @__PURE__ */ jsx(Link, { ref, href: url, ...props });
+  }
+);
+DynamicLink.displayName = "DynamicLink";
+var dynamic_link_default = DynamicLink;
+export {
+  DynamicLink,
+  dynamic_link_default as default
+};

package/dist/fetch-IBTWQCJR.js

@@ -0,0 +1,22 @@
+import "./chunk-U67V476Y.js";
+
+// src/search/client/fetch.ts
+var cache = /* @__PURE__ */ new Map();
+async function fetchDocs(query, { api = "/api/search", locale, tag }) {
+  const url = new URL(api, window.location.origin);
+  url.searchParams.set("query", query);
+  if (locale) url.searchParams.set("locale", locale);
+  if (tag)
+    url.searchParams.set("tag", Array.isArray(tag) ? tag.join(",") : tag);
+  const key = url.toString();
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(await res.text());
+  const result = await res.json();
+  cache.set(key, result);
+  return result;
+}
+export {
+  fetchDocs
+};

package/dist/framework/index.d.ts

@@ -0,0 +1,41 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComponentProps, FC, ReactNode } from 'react';
+import { StaticImport } from 'next/dist/shared/lib/get-img-props';
+
+interface ImageProps extends Omit<ComponentProps<'img'>, 'src'> {
+    sizes?: string;
+    /**
+     * Next.js Image component has other allowed type for `src`
+     */
+    src?: string | StaticImport;
+    /**
+     * priority of image (from Next.js)
+     */
+    priority?: boolean;
+}
+interface LinkProps extends ComponentProps<'a'> {
+    prefetch?: boolean;
+}
+interface Router {
+    push: (url: string) => void;
+    refresh: () => void;
+}
+interface Framework {
+    usePathname: () => string;
+    useParams: () => Record<string, string | string[]>;
+    useRouter: () => Router;
+    Link?: FC<ComponentProps<'a'> & {
+        prefetch?: boolean;
+    }>;
+    Image?: FC<ImageProps>;
+}
+declare function FrameworkProvider({ Link, useRouter, useParams, usePathname, Image, children, }: Framework & {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function usePathname(): string;
+declare function useRouter(): Router;
+declare function useParams(): Record<string, string | string[]>;
+declare function Image(props: ImageProps): react_jsx_runtime.JSX.Element;
+declare function Link(props: LinkProps): react_jsx_runtime.JSX.Element;
+
+export { type Framework, FrameworkProvider, Image, type ImageProps, Link, type Router, useParams, usePathname, useRouter };

package/dist/framework/index.js

@@ -0,0 +1,18 @@
+"use client";
+import {
+  FrameworkProvider,
+  Image,
+  Link,
+  useParams,
+  usePathname,
+  useRouter
+} from "../chunk-K4WNLOVQ.js";
+import "../chunk-U67V476Y.js";
+export {
+  FrameworkProvider,
+  Image,
+  Link,
+  useParams,
+  usePathname,
+  useRouter
+};

package/dist/framework/next.d.ts

@@ -0,0 +1,12 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Framework } from './index.js';
+import { ReactNode } from 'react';
+import 'next/dist/shared/lib/get-img-props';
+
+declare function NextProvider({ children, Link: CustomLink, Image: CustomImage, }: {
+    children: ReactNode;
+    Link?: Framework['Link'];
+    Image?: Framework['Image'];
+}): react_jsx_runtime.JSX.Element;
+
+export { NextProvider };

package/dist/framework/next.js

@@ -0,0 +1,31 @@
+"use client";
+import {
+  FrameworkProvider
+} from "../chunk-K4WNLOVQ.js";
+import "../chunk-U67V476Y.js";
+
+// src/framework/next.tsx
+import { useParams, usePathname, useRouter } from "next/navigation";
+import Link from "next/link";
+import Image from "next/image";
+import { jsx } from "react/jsx-runtime";
+function NextProvider({
+  children,
+  Link: CustomLink,
+  Image: CustomImage
+}) {
+  return /* @__PURE__ */ jsx(
+    FrameworkProvider,
+    {
+      usePathname,
+      useRouter,
+      useParams,
+      Link: CustomLink ?? Link,
+      Image: CustomImage ?? Image,
+      children
+    }
+  );
+}
+export {
+  NextProvider
+};

package/dist/framework/react-router.d.ts

@@ -0,0 +1,12 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { Framework } from './index.js';
+import 'next/dist/shared/lib/get-img-props';
+
+declare function ReactRouterProvider({ children, Link: CustomLink, Image: CustomImage, }: {
+    children: ReactNode;
+    Link?: Framework['Link'];
+    Image?: Framework['Image'];
+}): react_jsx_runtime.JSX.Element;
+
+export { ReactRouterProvider };

package/dist/framework/react-router.js

@@ -0,0 +1,59 @@
+import {
+  FrameworkProvider
+} from "../chunk-K4WNLOVQ.js";
+import "../chunk-U67V476Y.js";
+
+// src/framework/react-router.tsx
+import { useMemo } from "react";
+import {
+  Link,
+  useLocation,
+  useNavigate,
+  useParams,
+  useRevalidator
+} from "react-router";
+import { jsx } from "react/jsx-runtime";
+var framework = {
+  usePathname() {
+    return useLocation().pathname;
+  },
+  useParams() {
+    return useParams();
+  },
+  useRouter() {
+    const navigate = useNavigate();
+    const revalidator = useRevalidator();
+    return useMemo(
+      () => ({
+        push(url) {
+          navigate(url);
+        },
+        refresh() {
+          void revalidator.revalidate();
+        }
+      }),
+      [navigate, revalidator]
+    );
+  },
+  Link({ href, prefetch, ...props }) {
+    return /* @__PURE__ */ jsx(Link, { to: href, prefetch: prefetch ? "intent" : "none", ...props, children: props.children });
+  }
+};
+function ReactRouterProvider({
+  children,
+  Link: CustomLink,
+  Image: CustomImage
+}) {
+  return /* @__PURE__ */ jsx(
+    FrameworkProvider,
+    {
+      ...framework,
+      Link: CustomLink ?? framework.Link,
+      Image: CustomImage ?? framework.Image,
+      children
+    }
+  );
+}
+export {
+  ReactRouterProvider
+};

package/dist/framework/tanstack.d.ts

@@ -0,0 +1,15 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { Framework } from './index.js';
+import 'next/dist/shared/lib/get-img-props';
+
+/**
+ * Fumadocs adapter for Tanstack Router/Start
+ */
+declare function TanstackProvider({ children, Link: CustomLink, Image: CustomImage, }: {
+    children: ReactNode;
+    Link?: Framework['Link'];
+    Image?: Framework['Image'];
+}): react_jsx_runtime.JSX.Element;
+
+export { TanstackProvider };

package/dist/framework/tanstack.js

@@ -0,0 +1,72 @@
+import {
+  FrameworkProvider
+} from "../chunk-K4WNLOVQ.js";
+import "../chunk-U67V476Y.js";
+
+// src/framework/tanstack.tsx
+import { useRef, useMemo } from "react";
+import {
+  useParams,
+  Link,
+  useRouter,
+  useRouterState
+} from "@tanstack/react-router";
+import { jsx } from "react/jsx-runtime";
+var framework = {
+  Link({ href, prefetch = true, ...props }) {
+    return /* @__PURE__ */ jsx(Link, { to: href, preload: prefetch ? "intent" : false, ...props, children: props.children });
+  },
+  usePathname() {
+    const { isLoading, pathname } = useRouterState({
+      select: (state) => ({
+        isLoading: state.isLoading,
+        pathname: state.location.pathname
+      })
+    });
+    const activePathname = useRef(pathname);
+    return useMemo(() => {
+      if (isLoading) {
+        return activePathname.current;
+      }
+      activePathname.current = pathname;
+      return pathname;
+    }, [isLoading, pathname]);
+  },
+  useRouter() {
+    const router = useRouter();
+    return useMemo(
+      () => ({
+        push(url) {
+          void router.navigate({
+            href: url
+          });
+        },
+        refresh() {
+          void router.invalidate();
+        }
+      }),
+      [router]
+    );
+  },
+  useParams() {
+    return useParams({ strict: false });
+  }
+};
+function TanstackProvider({
+  children,
+  Link: CustomLink,
+  Image: CustomImage
+}) {
+  return /* @__PURE__ */ jsx(
+    FrameworkProvider,
+    {
+      ...framework,
+      Link: CustomLink ?? framework.Link,
+      Image: CustomImage ?? framework.Image,
+      children
+    }
+  );
+}
+export {
+  TanstackProvider
+};

package/dist/framework/waku.d.ts

@@ -0,0 +1,12 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { Framework } from './index.js';
+import 'next/dist/shared/lib/get-img-props';
+
+declare function WakuProvider({ children, Link: CustomLink, Image: CustomImage, }: {
+    children: ReactNode;
+    Link?: Framework['Link'];
+    Image?: Framework['Image'];
+}): react_jsx_runtime.JSX.Element;
+
+export { WakuProvider };

package/dist/framework/waku.js

@@ -0,0 +1,63 @@
+"use client";
+import {
+  FrameworkProvider
+} from "../chunk-K4WNLOVQ.js";
+import "../chunk-U67V476Y.js";
+
+// src/framework/waku.tsx
+import { useMemo } from "react";
+import { Link as WakuLink, useRouter } from "waku";
+import { jsx } from "react/jsx-runtime";
+var framework = {
+  usePathname() {
+    const { path } = useRouter();
+    return path;
+  },
+  useParams() {
+    const { query } = useRouter();
+    return useMemo(() => {
+      const params = new URLSearchParams(query);
+      return Object.fromEntries(
+        Array.from(params.entries()).map(([key, value]) => [
+          key,
+          Array.isArray(value) ? value[0] : value
+        ])
+      );
+    }, [query]);
+  },
+  useRouter() {
+    const router = useRouter();
+    return useMemo(
+      () => ({
+        push(url) {
+          void router.push(url);
+        },
+        refresh() {
+          void router.push(router.path);
+        }
+      }),
+      [router]
+    );
+  },
+  Link({ href, prefetch = true, ...props }) {
+    return /* @__PURE__ */ jsx(WakuLink, { to: href, unstable_prefetchOnEnter: prefetch, ...props, children: props.children });
+  }
+};
+function WakuProvider({
+  children,
+  Link: CustomLink,
+  Image: CustomImage
+}) {
+  return /* @__PURE__ */ jsx(
+    FrameworkProvider,
+    {
+      ...framework,
+      Link: CustomLink ?? framework.Link,
+      Image: CustomImage ?? framework.Image,
+      children
+    }
+  );
+}
+export {
+  WakuProvider
+};

package/dist/highlight/client.d.ts

@@ -0,0 +1,15 @@
+import { DependencyList, ReactNode } from 'react';
+import { HighlightOptions } from './index.js';
+import 'shiki';
+import 'shiki/themes';
+import 'hast-util-to-jsx-runtime';
+import 'hast';
+
+/**
+ * get highlighted results, should be used with React Suspense API.
+ *
+ * note: results are cached with (lang, code) as keys, if this is not the desired behaviour, pass a `deps` instead.
+ */
+declare function useShiki(code: string, options: HighlightOptions, deps?: DependencyList): ReactNode;
+
+export { useShiki };

package/dist/highlight/client.js

@@ -0,0 +1,18 @@
+"use client";
+import {
+  highlight
+} from "../chunk-XN2LKXFZ.js";
+import "../chunk-U67V476Y.js";
+
+// src/highlight/client.tsx
+import { use, useMemo } from "react";
+var promises = {};
+function useShiki(code, options, deps) {
+  const key = useMemo(() => {
+    return deps ? JSON.stringify(deps) : `${options.lang}:${code}`;
+  }, [code, deps, options.lang]);
+  return use(promises[key] ??= highlight(code, options));
+}
+export {
+  useShiki
+};

package/dist/highlight/index.d.ts

@@ -0,0 +1,30 @@
+import { CodeToHastOptionsCommon, BundledLanguage, CodeOptionsMeta, CodeOptionsThemes, BundledHighlighterOptions, Highlighter } from 'shiki';
+import { BundledTheme } from 'shiki/themes';
+import { Components, Options } from 'hast-util-to-jsx-runtime';
+import { ReactNode } from 'react';
+import { Root } from 'hast';
+
+type HighlightOptionsCommon = CodeToHastOptionsCommon<BundledLanguage> & CodeOptionsMeta & {
+    /**
+     * The Regex Engine for Shiki
+     *
+     * @defaultValue 'js'
+     */
+    engine?: 'js' | 'oniguruma';
+    components?: Partial<Components>;
+    fallbackLanguage?: BundledLanguage;
+};
+type HighlightOptionsThemes = CodeOptionsThemes<BundledTheme>;
+type HighlightOptions = HighlightOptionsCommon & (HighlightOptionsThemes | Record<never, never>);
+declare function highlightHast(code: string, options: HighlightOptions): Promise<Root>;
+declare function hastToJsx(hast: Root, options?: Partial<Options>): JSX.Element;
+/**
+ * Get Shiki highlighter instance of Fumadocs (mostly for internal use, you should use Shiki directly over this).
+ *
+ * @param engineType - Shiki Regex engine to use.
+ * @param options - Shiki options.
+ */
+declare function getHighlighter(engineType: 'js' | 'oniguruma', options: Omit<BundledHighlighterOptions<BundledLanguage, BundledTheme>, 'engine'>): Promise<Highlighter>;
+declare function highlight(code: string, options: HighlightOptions): Promise<ReactNode>;
+
+export { type HighlightOptions, type HighlightOptionsCommon, type HighlightOptionsThemes, getHighlighter, hastToJsx, highlight, highlightHast };

package/dist/highlight/index.js

@@ -0,0 +1,13 @@
+import {
+  getHighlighter,
+  hastToJsx,
+  highlight,
+  highlightHast
+} from "../chunk-XN2LKXFZ.js";
+import "../chunk-U67V476Y.js";
+export {
+  getHighlighter,
+  hastToJsx,
+  highlight,
+  highlightHast
+};

package/dist/i18n/index.d.ts

@@ -0,0 +1,39 @@
+interface I18nConfig<Languages extends string = string> {
+    /**
+     * Supported locale codes.
+     *
+     * A page tree will be built for each language.
+     */
+    languages: Languages[];
+    /**
+     * Default locale if not specified
+     */
+    defaultLanguage: Languages;
+    /**
+     * Don't show the locale prefix on URL.
+     *
+     * - `always`: Always hide the prefix
+     * - `default-locale`: Only hide the default locale
+     * - `never`: Never hide the prefix
+     *
+     * This API uses `NextResponse.rewrite`.
+     *
+     * @defaultValue 'never'
+     */
+    hideLocale?: 'always' | 'default-locale' | 'never';
+    /**
+     * Used by `loader()`, specify the way to parse i18n file structure.
+     *
+     * @defaultValue 'dot'
+     */
+    parser?: 'dot' | 'dir' | 'none';
+    /**
+     * the fallback language when the page has no translations available for a given locale.
+     *
+     * Default to ``defaultLanguage`, no fallback when set to `null`.
+     */
+    fallbackLanguage?: Languages | null;
+}
+declare function defineI18n<Languages extends string>(config: I18nConfig<Languages>): I18nConfig<Languages>;
+
+export { type I18nConfig, defineI18n };

package/dist/i18n/index.js

@@ -0,0 +1,9 @@
+import "../chunk-U67V476Y.js";
+
+// src/i18n/index.ts
+function defineI18n(config) {
+  return config;
+}
+export {
+  defineI18n
+};

package/dist/i18n/middleware.d.ts

@@ -0,0 +1,34 @@
+import { NextProxy } from 'next/server';
+import { I18nConfig } from './index.js';
+import { NextURL } from 'next/dist/server/web/next-url';
+
+interface MiddlewareOptions extends I18nConfig {
+    /**
+     * Either:
+     * - A formatter object
+     * - A function that adds the locale prefix to pathname
+     */
+    format?: URLFormatter | ((locale: string, pathname: string) => string);
+    /**
+     * the cookie to store locale code when `hideLocale` is set to `always`.
+     */
+    cookieName?: string;
+}
+interface URLFormatter {
+    /**
+     * get locale code from request URL
+     */
+    get: (url: NextURL) => string | undefined;
+    /**
+     * add locale code to request URL (which is missing the locale).
+     */
+    add: (url: NextURL, locale: string) => URL;
+    /**
+     * remove locale code from request URL
+     */
+    remove: (url: NextURL) => URL;
+}
+declare const DefaultFormatter: URLFormatter;
+declare function createI18nMiddleware({ languages, defaultLanguage, format, cookieName, hideLocale, }: MiddlewareOptions): NextProxy;
+
+export { DefaultFormatter, type URLFormatter, createI18nMiddleware };

package/dist/i18n/middleware.js

@@ -0,0 +1,76 @@
+import {
+  getNegotiator
+} from "../chunk-YVVDKJ2H.js";
+import "../chunk-U67V476Y.js";
+
+// src/i18n/middleware.ts
+import { match as matchLocale } from "@formatjs/intl-localematcher";
+import { NextResponse } from "next/server";
+var DefaultFormatter = {
+  get(url) {
+    const segs = url.pathname.split("/");
+    if (segs.length > 1 && segs[1]) return segs[1];
+  },
+  add(url, locale) {
+    const next = new URL(url);
+    next.pathname = `${url.basePath}/${locale}/${url.pathname}`.replaceAll(
+      /\/+/g,
+      "/"
+    );
+    return next;
+  },
+  remove(url) {
+    const next = new URL(url);
+    const pathname = url.pathname.split("/").slice(2).join("/");
+    next.pathname = `${url.basePath}/${pathname}`.replaceAll(/\/+/g, "/");
+    return next;
+  }
+};
+function createI18nMiddleware({
+  languages,
+  defaultLanguage,
+  format = DefaultFormatter,
+  cookieName = "FD_LOCALE",
+  hideLocale = "never"
+}) {
+  let formatter;
+  if (typeof format === "function") {
+    formatter = {
+      ...DefaultFormatter,
+      add(url, locale) {
+        const next = new URL(url);
+        next.pathname = format(locale, url.pathname);
+        return next;
+      }
+    };
+  } else {
+    formatter = format;
+  }
+  return (request) => {
+    const url = request.nextUrl;
+    let pathLocale = formatter.get(url);
+    if (pathLocale && !languages.includes(pathLocale)) pathLocale = void 0;
+    if (!pathLocale) {
+      if (hideLocale === "default-locale") {
+        return NextResponse.rewrite(formatter.add(url, defaultLanguage));
+      }
+      const finalLanguages = getNegotiator(request).languages(languages);
+      const preferred = matchLocale(finalLanguages, languages, defaultLanguage);
+      if (hideLocale === "always") {
+        const locale = request.cookies.get(cookieName)?.value ?? preferred;
+        return NextResponse.rewrite(formatter.add(url, locale));
+      }
+      return NextResponse.redirect(formatter.add(url, preferred));
+    }
+    if (hideLocale === "always" || hideLocale === "default-locale" && pathLocale === defaultLanguage) {
+      const res = NextResponse.redirect(formatter.remove(url));
+      res.cookies.set(cookieName, pathLocale);
+      return res;
+    }
+    return NextResponse.next();
+  };
+}
+export {
+  DefaultFormatter,
+  createI18nMiddleware
+};

package/dist/link.d.ts

@@ -0,0 +1,18 @@
+import * as react from 'react';
+import { AnchorHTMLAttributes } from 'react';
+
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /**
+     * If the href is an external URL
+     *
+     * automatically determined by default
+     */
+    external?: boolean;
+    /**
+     * Prefetch links, supported on Next.js
+     */
+    prefetch?: boolean;
+}
+declare const Link: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;
+
+export { type LinkProps, Link as default };

package/dist/link.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  Link
+} from "./chunk-SH7BNTG7.js";
+import "./chunk-K4WNLOVQ.js";
+import "./chunk-U67V476Y.js";
+export {
+  Link as default
+};