@vezham/docs-core 1.0.1

package/dist/dynamic-link.d.ts

@@ -0,0 +1,12 @@
+import { LinkProps } from "./link.js";
+//#region src/dynamic-link.d.ts
+type DynamicLinkProps = LinkProps;
+/**
+ * Extends the default `Link` component
+ *
+ * It supports dynamic hrefs, which means you can use `/[lang]/my-page` with `dynamicHrefs` enabled
+ */
+declare function DynamicLink({ href, ref, ...props }: DynamicLinkProps): import("react").JSX.Element;
+declare function updateHref(href: string, params: Record<string, string | string[]>): string;
+//#endregion
+export { DynamicLink, DynamicLink as default, DynamicLinkProps, updateHref };

package/dist/dynamic-link.js

@@ -0,0 +1,31 @@
+"use client";
+import { useParams } from "./framework/index.js";
+import { Link } from "./link.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/dynamic-link.tsx
+/**
+* Extends the default `Link` component
+*
+* It supports dynamic hrefs, which means you can use `/[lang]/my-page` with `dynamicHrefs` enabled
+*/
+function DynamicLink({ href, ref, ...props }) {
+	const params = useParams();
+	const url = useMemo(() => href ? updateHref(href, params) : href, [params, href]);
+	return /* @__PURE__ */ jsx(Link, {
+		ref,
+		href: url,
+		...props
+	});
+}
+function updateHref(href, params) {
+	return href.replace(/\[(.*)]\/?/, (match, key) => {
+		const hasEndingSlash = match[match.length - 1] === "/";
+		const value = key in params ? params[key] : void 0;
+		if (!value) return "";
+		const replacement = typeof value === "string" ? value : value.join("/");
+		return hasEndingSlash ? `${replacement}/` : replacement;
+	});
+}
+//#endregion
+export { DynamicLink, DynamicLink as default, updateHref };

package/dist/endpoint-MyoBU5IC.js

@@ -0,0 +1,28 @@
+//#region src/search/server/endpoint.ts
+function createEndpoint(server, options = {}) {
+	const { search } = server;
+	const { readOptions = defaultReadOptions } = options;
+	return {
+		...server,
+		async staticGET() {
+			return Response.json(await server.export());
+		},
+		async GET(request) {
+			const url = new URL(request.url);
+			const query = url.searchParams.get("query");
+			if (!query) return Response.json([]);
+			return Response.json(await search(query, readOptions(url, request)));
+		}
+	};
+}
+function defaultReadOptions(url) {
+	const params = url.searchParams;
+	const limit = params.has("limit") ? Number(params.get("limit")) : void 0;
+	return {
+		tag: params.get("tag")?.split(","),
+		locale: params.get("locale"),
+		limit: Number.isInteger(limit) ? limit : void 0
+	};
+}
+//#endregion
+export { defaultReadOptions as n, createEndpoint as t };

package/dist/framework/astro.d.ts

@@ -0,0 +1,21 @@
+import { Framework } from "./index.js";
+import { ReactNode } from "react";
+//#region src/framework/astro.d.ts
+type AstroParams = Record<string, string | string[] | undefined>;
+interface AstroProviderProps {
+  children: ReactNode;
+  pathname: string;
+  params?: AstroParams;
+  navigate?: (url: string) => void | Promise<void>;
+  Link?: Framework['Link'];
+  Image?: Framework['Image'];
+}
+/**
+ * Fumadocs adapter for Astro with React islands.
+ *
+ * Pass `pathname` and `params` from `Astro.url.pathname` and `Astro.params`.
+ * You can pass `navigate` from `astro:transitions/client` to preserve client navigation.
+ */
+declare function AstroProvider({ children, pathname, params, navigate, Link, Image }: AstroProviderProps): import("react").JSX.Element;
+//#endregion
+export { AstroProvider, AstroProviderProps };

package/dist/framework/astro.js

@@ -0,0 +1,52 @@
+"use client";
+import { FrameworkProvider } from "./index.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/framework/astro.tsx
+function normalizeParams(params = {}) {
+	const out = {};
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) out[key] = value;
+	return out;
+}
+/**
+* Fumadocs adapter for Astro with React islands.
+*
+* Pass `pathname` and `params` from `Astro.url.pathname` and `Astro.params`.
+* You can pass `navigate` from `astro:transitions/client` to preserve client navigation.
+*/
+function AstroProvider({ children, pathname, params, navigate, Link, Image }) {
+	const resolvedParams = useMemo(() => normalizeParams(params), [params]);
+	const framework = useMemo(() => ({
+		usePathname() {
+			return pathname;
+		},
+		useParams() {
+			return resolvedParams;
+		},
+		useRouter() {
+			return {
+				push(url) {
+					if (navigate) return navigate(url);
+					window.location.assign(url);
+				},
+				refresh() {
+					window.location.reload();
+				}
+			};
+		},
+		Link,
+		Image
+	}), [
+		Image,
+		Link,
+		navigate,
+		pathname,
+		resolvedParams
+	]);
+	return /* @__PURE__ */ jsx(FrameworkProvider, {
+		...framework,
+		children
+	});
+}
+//#endregion
+export { AstroProvider };

package/dist/framework/index.d.ts

@@ -0,0 +1,40 @@
+import { ComponentProps, FC, ReactNode } from "react";
+import { StaticImport } from "next/dist/shared/lib/get-img-props.js";
+//#region src/framework/index.d.ts
+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 | Promise<void>;
+  refresh: () => void | Promise<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;
+}): import("react").JSX.Element;
+declare function usePathname(): string;
+declare function useRouter(): Router;
+declare function useParams(): Record<string, string | string[]>;
+declare function Image(props: ImageProps): import("react").JSX.Element;
+declare function Link(props: LinkProps): import("react").JSX.Element;
+//#endregion
+export { Framework, FrameworkProvider, Image, ImageProps, Link, Router, useParams, usePathname, useRouter };

package/dist/framework/index.js

@@ -0,0 +1,66 @@
+"use client";
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/framework/index.tsx
+const notImplemented = () => {
+	throw new Error("You need to wrap your application inside `FrameworkProvider`.");
+};
+const FrameworkContext = createContext({
+	useParams: notImplemented,
+	useRouter: notImplemented,
+	usePathname: notImplemented
+});
+function FrameworkProvider({ Link, useRouter, useParams, usePathname, Image, children }) {
+	const framework = useMemo(() => ({
+		usePathname,
+		useRouter,
+		Link,
+		Image,
+		useParams
+	}), [
+		Link,
+		usePathname,
+		useRouter,
+		useParams,
+		Image
+	]);
+	return /* @__PURE__ */ jsx(FrameworkContext, {
+		value: framework,
+		children
+	});
+}
+function usePathname() {
+	return use(FrameworkContext).usePathname();
+}
+function useRouter() {
+	return use(FrameworkContext).useRouter();
+}
+function useParams() {
+	return use(FrameworkContext).useParams();
+}
+function Image(props) {
+	const { Image } = use(FrameworkContext);
+	if (!Image) {
+		const { src, alt, priority, ...rest } = props;
+		return /* @__PURE__ */ jsx("img", {
+			alt,
+			src,
+			fetchPriority: priority ? "high" : "auto",
+			...rest
+		});
+	}
+	return /* @__PURE__ */ jsx(Image, { ...props });
+}
+function Link(props) {
+	const { Link } = use(FrameworkContext);
+	if (!Link) {
+		const { href, prefetch: _, ...rest } = props;
+		return /* @__PURE__ */ jsx("a", {
+			href,
+			...rest
+		});
+	}
+	return /* @__PURE__ */ jsx(Link, { ...props });
+}
+//#endregion
+export { FrameworkProvider, Image, Link, useParams, usePathname, useRouter };

package/dist/framework/next.d.ts

@@ -0,0 +1,10 @@
+import { Framework } from "./index.js";
+import { ReactNode } from "react";
+//#region src/framework/next.d.ts
+declare function NextProvider({ children, Link: CustomLink, Image: CustomImage }: {
+  children: ReactNode;
+  Link?: Framework['Link'];
+  Image?: Framework['Image'];
+}): import("react").JSX.Element;
+//#endregion
+export { NextProvider };

package/dist/framework/next.js

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

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

@@ -0,0 +1,10 @@
+import { Framework } from "./index.js";
+import { ReactNode } from "react";
+//#region src/framework/react-router.d.ts
+declare function ReactRouterProvider({ children, Link: CustomLink, Image: CustomImage }: {
+  children: ReactNode;
+  Link?: Framework['Link'];
+  Image?: Framework['Image'];
+}): import("react").JSX.Element;
+//#endregion
+export { ReactRouterProvider };

package/dist/framework/react-router.js

@@ -0,0 +1,43 @@
+import { FrameworkProvider } from "./index.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Link, useLocation, useNavigate, useParams, useRevalidator } from "react-router";
+//#region src/framework/react-router.tsx
+const framework = {
+	usePathname() {
+		return useLocation().pathname;
+	},
+	useParams() {
+		return useParams();
+	},
+	useRouter() {
+		const navigate = useNavigate();
+		const revalidator = useRevalidator();
+		return useMemo(() => ({
+			push(url) {
+				navigate(url);
+			},
+			refresh() {
+				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
+	});
+}
+//#endregion
+export { ReactRouterProvider };

package/dist/framework/tanstack.d.ts

@@ -0,0 +1,13 @@
+import { Framework } from "./index.js";
+import { ReactNode } from "react";
+//#region src/framework/tanstack.d.ts
+/**
+ * Fumadocs adapter for Tanstack Router/Start
+ */
+declare function TanstackProvider({ children, Link: CustomLink, Image: CustomImage }: {
+  children: ReactNode;
+  Link?: Framework['Link'];
+  Image?: Framework['Image'];
+}): import("react").JSX.Element;
+//#endregion
+export { TanstackProvider };

package/dist/framework/tanstack.js

@@ -0,0 +1,54 @@
+import { FrameworkProvider } from "./index.js";
+import { useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Link, useParams, useRouter, useRouterState } from "@tanstack/react-router";
+//#region src/framework/tanstack.tsx
+const 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) {
+				router.navigate({ href: url });
+			},
+			refresh() {
+				router.invalidate();
+			}
+		}), [router]);
+	},
+	useParams() {
+		return useParams({ strict: false });
+	}
+};
+/**
+* Fumadocs adapter for Tanstack Router/Start
+*/
+function TanstackProvider({ children, Link: CustomLink, Image: CustomImage }) {
+	return /* @__PURE__ */ jsx(FrameworkProvider, {
+		...framework,
+		Link: CustomLink ?? framework.Link,
+		Image: CustomImage ?? framework.Image,
+		children
+	});
+}
+//#endregion
+export { TanstackProvider };

package/dist/framework/waku.d.ts

@@ -0,0 +1,10 @@
+import { Framework } from "./index.js";
+import { ReactNode } from "react";
+//#region src/framework/waku.d.ts
+declare function WakuProvider({ children, Link: CustomLink, Image: CustomImage }: {
+  children: ReactNode;
+  Link?: Framework['Link'];
+  Image?: Framework['Image'];
+}): import("react").JSX.Element;
+//#endregion
+export { WakuProvider };

package/dist/framework/waku.js

@@ -0,0 +1,46 @@
+"use client";
+import { FrameworkProvider } from "./index.js";
+import { useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Link, useRouter } from "waku/router/client";
+//#region src/framework/waku.tsx
+const framework = {
+	usePathname() {
+		return useRouter().path;
+	},
+	useParams() {
+		console.warn("[Fumadocs] useParams() is not supported on Waku");
+		return useMemo(() => ({}), []);
+	},
+	useRouter() {
+		const router = useRouter();
+		const routerRef = useRef(router);
+		routerRef.current = router;
+		return useMemo(() => ({
+			push(url) {
+				return routerRef.current.push(url);
+			},
+			refresh() {
+				return routerRef.current.reload();
+			}
+		}), []);
+	},
+	Link({ href, prefetch = true, ...props }) {
+		return /* @__PURE__ */ jsx(Link, {
+			to: href,
+			unstable_prefetchOnEnter: prefetch ? { mode: "once" } : void 0,
+			...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
+	});
+}
+//#endregion
+export { WakuProvider };

package/dist/highlight/client.d.ts

@@ -0,0 +1,11 @@
+import { HighlightOptions } from "./index.js";
+import { DependencyList, ReactNode } from "react";
+//#region src/highlight/client.d.ts
+/**
+ * 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;
+//#endregion
+export { useShiki };

package/dist/highlight/client.js

@@ -0,0 +1,15 @@
+"use client";
+import { t as applyDefaultThemes } from "../utils-Cgs-6U-z.js";
+import { useShiki as useShiki$1 } from "./shiki/react.js";
+import { defaultShikiFactory } from "./shiki/full.js";
+//#region src/highlight/client.ts
+/**
+* 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.
+*/
+function useShiki(code, options, deps) {
+	return useShiki$1(() => defaultShikiFactory.getOrInit(), code, applyDefaultThemes(options), deps);
+}
+//#endregion
+export { useShiki };

package/dist/highlight/index.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from "react";
+import { Components } from "hast-util-to-jsx-runtime";
+import { Root } from "hast";
+import { BundledLanguage, BundledTheme, CodeOptionsMeta, CodeOptionsThemes, CodeToHastOptionsCommon, LanguageRegistration, ThemeRegistrationAny } from "shiki";
+//#region src/highlight/index.d.ts
+type HighlightOptions = HighlightHastOptions & {
+  components?: Partial<Components>;
+};
+type HighlightHastOptions = CodeToHastOptionsCommon<BundledLanguage> & CodeOptionsMeta & {
+  fallbackLanguage?: BundledLanguage | (string & {});
+  /**
+   * The Regex Engine for Shiki
+   *
+   * @defaultValue 'js'
+   */
+  engine?: 'js' | 'oniguruma';
+} & (CodeOptionsThemes<BundledTheme> | Record<never, never>);
+declare function highlightHast(code: string, options: HighlightHastOptions): Promise<Root>;
+/**
+ * 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?: {
+  langs?: (BundledLanguage | LanguageRegistration)[];
+  themes?: (BundledTheme | ThemeRegistrationAny)[];
+}): Promise<import("shiki").HighlighterCore>;
+declare function highlight(code: string, options: HighlightOptions): Promise<ReactNode>;
+//#endregion
+export { HighlightHastOptions, HighlightOptions, getHighlighter, highlight, highlightHast };

package/dist/highlight/index.js

@@ -0,0 +1,30 @@
+import { a as loadMissingTheme, i as loadMissingLanguage, t as applyDefaultThemes } from "../utils-Cgs-6U-z.js";
+import { highlightHast as highlightHast$1 } from "./shiki/index.js";
+import { defaultShikiFactory, wasmShikiFactory } from "./shiki/full.js";
+import * as JsxRuntime from "react/jsx-runtime";
+import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+//#region src/highlight/index.ts
+async function highlightHast(code, options) {
+	const instance = await ((options.engine ?? "js") === "js" ? defaultShikiFactory : wasmShikiFactory).getOrInit();
+	return highlightHast$1(instance, code, applyDefaultThemes(options));
+}
+/**
+* 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.
+*/
+async function getHighlighter(engineType, options = {}) {
+	const instance = await (engineType === "js" ? defaultShikiFactory : wasmShikiFactory).getOrInit();
+	await Promise.all([options.langs && loadMissingLanguage(instance, options.langs), options.themes && loadMissingTheme(instance, options.themes)]);
+	return instance;
+}
+async function highlight(code, options) {
+	return toJsxRuntime(await highlightHast(code, options), {
+		...JsxRuntime,
+		development: false,
+		components: options.components
+	});
+}
+//#endregion
+export { getHighlighter, highlight, highlightHast };

package/dist/highlight/shiki/full.d.ts

@@ -0,0 +1,7 @@
+import { n as ShikiFactory } from "../../index-BMEUQz-F.js";
+//#region src/highlight/shiki/full.d.ts
+declare const defaultShikiFactory: ShikiFactory;
+/** factory using the WASM powered Regex engine */
+declare const wasmShikiFactory: ShikiFactory;
+//#endregion
+export { defaultShikiFactory, wasmShikiFactory };

package/dist/highlight/shiki/full.js

@@ -0,0 +1,23 @@
+import { createShikiFactory } from "./index.js";
+//#region src/highlight/shiki/full.ts
+const defaultShikiFactory = createShikiFactory({ async init(options) {
+	const { createHighlighter, createJavaScriptRegexEngine } = await import("shiki");
+	return createHighlighter({
+		langs: [],
+		themes: [],
+		langAlias: options?.langAlias,
+		engine: createJavaScriptRegexEngine()
+	});
+} });
+/** factory using the WASM powered Regex engine */
+const wasmShikiFactory = createShikiFactory({ async init(options) {
+	const { createHighlighter, createOnigurumaEngine } = await import("shiki");
+	return createHighlighter({
+		langs: [],
+		themes: [],
+		langAlias: options?.langAlias,
+		engine: createOnigurumaEngine(import("shiki/wasm"))
+	});
+} });
+//#endregion
+export { defaultShikiFactory, wasmShikiFactory };

package/dist/highlight/shiki/index.d.ts

@@ -0,0 +1,2 @@
+import { i as highlightHast, n as ShikiFactory, r as createShikiFactory, t as HighlightHastOptions } from "../../index-BMEUQz-F.js";
+export { HighlightHastOptions, ShikiFactory, createShikiFactory, highlightHast };

package/dist/highlight/shiki/index.js

@@ -0,0 +1,27 @@
+import { a as loadMissingTheme, r as getRequiredThemes } from "../../utils-Cgs-6U-z.js";
+//#region src/highlight/shiki/index.ts
+function createShikiFactory(config) {
+	let instance;
+	return {
+		init(options) {
+			const created = config.init(options);
+			if (created instanceof Promise) created.catch(() => {
+				if (instance === created) instance = void 0;
+			});
+			return instance = created;
+		},
+		getOrInit() {
+			return instance ?? this.init();
+		}
+	};
+}
+async function highlightHast(highlighter, code, options) {
+	const { fallbackLanguage = "text", ...resolved } = options;
+	const { isSpecialLang } = await import("shiki/core");
+	const loaded = highlighter.getLoadedLanguages();
+	if (!isSpecialLang(resolved.lang) && !(resolved.lang in highlighter.getBundledLanguages()) && !loaded.includes(resolved.lang)) resolved.lang = fallbackLanguage;
+	await Promise.all([loadMissingTheme(highlighter, getRequiredThemes(resolved)), !isSpecialLang(resolved.lang) && !loaded.includes(resolved.lang) && highlighter.loadLanguage(resolved.lang)]);
+	return highlighter.codeToHast(code, resolved);
+}
+//#endregion
+export { createShikiFactory, highlightHast };

package/dist/highlight/shiki/react.d.ts

@@ -0,0 +1,23 @@
+import { t as Awaitable } from "../../types-D89QoQR-.js";
+import { t as HighlightHastOptions } from "../../index-BMEUQz-F.js";
+import { DependencyList, ReactNode } from "react";
+import { Components } from "hast-util-to-jsx-runtime";
+import { HighlighterCore } from "shiki";
+//#region src/highlight/shiki/react.d.ts
+type UseShikiOptions = HighlightHastOptions & {
+  components?: Partial<Components>;
+};
+/**
+ * get highlighted results (uncached), use `useEffect` instead of React 19 APIs.
+ */
+declare function useShikiDynamic(highlighter: HighlighterCore | (() => Awaitable<HighlighterCore>), code: string, options: UseShikiOptions & {
+  defaultValue?: ReactNode;
+}, deps: DependencyList): ReactNode;
+/**
+ * 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(highlighter: HighlighterCore | (() => Awaitable<HighlighterCore>), code: string, options: UseShikiOptions, deps?: DependencyList): ReactNode;
+//#endregion
+export { UseShikiOptions, useShiki, useShikiDynamic };