opin-ui 0.0.1

package/dist/components/ui/navigation-menu.d.ts

@@ -0,0 +1,30 @@
+import * as React$1 from "react";
+import * as Primitive from "@radix-ui/react-navigation-menu";
+
+//#region src/components/ui/navigation-menu.d.ts
+type NavigationMenuContentProps = Primitive.NavigationMenuContentProps;
+type NavigationMenuTriggerProps = Primitive.NavigationMenuTriggerProps;
+declare const NavigationMenu: React$1.ForwardRefExoticComponent<Primitive.NavigationMenuProps & React$1.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React$1.ForwardRefExoticComponent<Primitive.NavigationMenuListProps & React$1.RefAttributes<HTMLUListElement>>;
+declare function NavigationMenuItem({
+  className,
+  children,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.NavigationMenuItem>): React$1.JSX.Element;
+declare function NavigationMenuTrigger({
+  className,
+  children,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.Trigger>): React$1.JSX.Element;
+declare function NavigationMenuContent({
+  className,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.Content>): React$1.JSX.Element;
+declare const NavigationMenuLink: React$1.ForwardRefExoticComponent<Primitive.NavigationMenuLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+declare function NavigationMenuViewport({
+  className,
+  ref,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.Viewport>): React$1.JSX.Element;
+//#endregion
+export { NavigationMenu, NavigationMenuContent, NavigationMenuContentProps, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuTriggerProps, NavigationMenuViewport };

package/dist/components/ui/navigation-menu.js

@@ -0,0 +1,41 @@
+"use client";
+import { cn } from "../../utils/cn.js";
+import { jsx } from "react/jsx-runtime";
+import "react";
+import * as Primitive from "@radix-ui/react-navigation-menu";
+//#region src/components/ui/navigation-menu.tsx
+const NavigationMenu = Primitive.Root;
+const NavigationMenuList = Primitive.List;
+function NavigationMenuItem({ className, children, ...props }) {
+	return /* @__PURE__ */ jsx(Primitive.NavigationMenuItem, {
+		className: cn("list-none", className),
+		...props,
+		children
+	});
+}
+function NavigationMenuTrigger({ className, children, ...props }) {
+	return /* @__PURE__ */ jsx(Primitive.Trigger, {
+		className: cn("data-[state=open]:bg-fd-accent/50", className),
+		...props,
+		children
+	});
+}
+function NavigationMenuContent({ className, ...props }) {
+	return /* @__PURE__ */ jsx(Primitive.Content, {
+		className: cn("absolute inset-x-0 top-0 overflow-auto fd-scroll-container max-h-[80svh] data-[motion=from-end]:animate-fd-enterFromRight data-[motion=from-start]:animate-fd-enterFromLeft data-[motion=to-end]:animate-fd-exitToRight data-[motion=to-start]:animate-fd-exitToLeft", className),
+		...props
+	});
+}
+const NavigationMenuLink = Primitive.Link;
+function NavigationMenuViewport({ className, ref, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		ref,
+		className: "flex w-full justify-center",
+		children: /* @__PURE__ */ jsx(Primitive.Viewport, {
+			...props,
+			className: cn("relative h-(--radix-navigation-menu-viewport-height) w-full origin-[top_center] overflow-hidden transition-[width,height] duration-300 data-[state=closed]:animate-fd-nav-menu-out data-[state=open]:animate-fd-nav-menu-in", className)
+		})
+	});
+}
+//#endregion
+export { NavigationMenu, NavigationMenuContent, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport };

package/dist/components/ui/popover.d.ts

@@ -0,0 +1,15 @@
+import * as React$1 from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+
+//#region src/components/ui/popover.d.ts
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare function PopoverContent({
+  className,
+  align,
+  sideOffset,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof PopoverPrimitive.Content>): React$1.JSX.Element;
+declare const PopoverClose: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+//#endregion
+export { Popover, PopoverClose, PopoverContent, PopoverTrigger };

package/dist/components/ui/popover.js

@@ -0,0 +1,20 @@
+"use client";
+import { cn } from "../../utils/cn.js";
+import { jsx } from "react/jsx-runtime";
+import "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+//#region src/components/ui/popover.tsx
+const Popover = PopoverPrimitive.Root;
+const PopoverTrigger = PopoverPrimitive.Trigger;
+function PopoverContent({ className, align = "center", sideOffset = 4, ...props }) {
+	return /* @__PURE__ */ jsx(PopoverPrimitive.Portal, { children: /* @__PURE__ */ jsx(PopoverPrimitive.Content, {
+		align,
+		sideOffset,
+		side: "bottom",
+		className: cn("z-50 origin-(--radix-popover-content-transform-origin) overflow-y-auto max-h-(--radix-popover-content-available-height) min-w-[240px] max-w-[98vw] rounded-3xl bg-fd-popover/90 backdrop-blur-lg p-2 text-sm text-fd-popover-foreground data-[state=closed]:animate-fd-popover-out data-[state=open]:animate-fd-popover-in", className),
+		...props
+	}) });
+}
+const PopoverClose = PopoverPrimitive.PopoverClose;
+//#endregion
+export { Popover, PopoverClose, PopoverContent, PopoverTrigger };

package/dist/components/ui/scroll-area.d.ts

@@ -0,0 +1,22 @@
+import * as React$1 from "react";
+import * as Primitive from "@radix-ui/react-scroll-area";
+
+//#region src/components/ui/scroll-area.d.ts
+declare function ScrollArea({
+  className,
+  children,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.Root>): React$1.JSX.Element;
+declare function ScrollViewport({
+  className,
+  children,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.Viewport>): React$1.JSX.Element;
+declare function ScrollBar({
+  className,
+  orientation,
+  ...props
+}: React$1.ComponentPropsWithRef<typeof Primitive.Scrollbar>): React$1.JSX.Element;
+type ScrollAreaProps = Primitive.ScrollAreaProps;
+//#endregion
+export { ScrollArea, ScrollAreaProps, ScrollBar, ScrollViewport };

package/dist/components/ui/scroll-area.js

@@ -0,0 +1,34 @@
+import { cn } from "../../utils/cn.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import * as Primitive from "@radix-ui/react-scroll-area";
+//#region src/components/ui/scroll-area.tsx
+function ScrollArea({ className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(Primitive.Root, {
+		type: "scroll",
+		className: cn("overflow-hidden", className),
+		...props,
+		children: [
+			children,
+			/* @__PURE__ */ jsx(Primitive.Corner, {}),
+			/* @__PURE__ */ jsx(ScrollBar, { orientation: "vertical" })
+		]
+	});
+}
+function ScrollViewport({ className, children, ...props }) {
+	return /* @__PURE__ */ jsx(Primitive.Viewport, {
+		className: cn("size-full rounded-[inherit]", className),
+		...props,
+		children
+	});
+}
+function ScrollBar({ className, orientation = "vertical", ...props }) {
+	return /* @__PURE__ */ jsx(Primitive.Scrollbar, {
+		orientation,
+		className: cn("flex select-none data-[state=hidden]:animate-fd-fade-out", orientation === "vertical" && "h-full w-1.5", orientation === "horizontal" && "h-1.5 flex-col", className),
+		...props,
+		children: /* @__PURE__ */ jsx(Primitive.ScrollAreaThumb, { className: "relative flex-1 rounded-full bg-fd-border" })
+	});
+}
+//#endregion
+export { ScrollArea, ScrollBar, ScrollViewport };

package/dist/components/ui/tabs.d.ts

@@ -0,0 +1,36 @@
+import { ComponentProps } from "react";
+import * as Primitive from "@radix-ui/react-tabs";
+
+//#region src/components/ui/tabs.d.ts
+interface TabsProps extends ComponentProps<typeof Primitive.Tabs> {
+  /**
+   * Identifier for Sharing value of tabs
+   */
+  groupId?: string;
+  /**
+   * Enable persistent
+   */
+  persist?: boolean;
+  /**
+   * If true, updates the URL hash based on the tab's id
+   */
+  updateAnchor?: boolean;
+}
+declare const TabsList: import("react").ForwardRefExoticComponent<Primitive.TabsListProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: import("react").ForwardRefExoticComponent<Primitive.TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare function Tabs({
+  ref,
+  groupId,
+  persist,
+  updateAnchor,
+  defaultValue,
+  value: _value,
+  onValueChange: _onValueChange,
+  ...props
+}: TabsProps): import("react").JSX.Element;
+declare function TabsContent({
+  value,
+  ...props
+}: ComponentProps<typeof Primitive.TabsContent>): import("react").JSX.Element;
+//#endregion
+export { Tabs, TabsContent, TabsList, TabsProps, TabsTrigger };

package/dist/components/ui/tabs.js

@@ -0,0 +1,77 @@
+"use client";
+import { mergeRefs } from "../../utils/merge-refs.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useEffectEvent, useLayoutEffect, useMemo, useRef, useState } from "react";
+import * as Primitive from "@radix-ui/react-tabs";
+//#region src/components/ui/tabs.tsx
+const listeners = /* @__PURE__ */ new Map();
+const TabsContext = createContext(null);
+function useTabContext() {
+	const ctx = use(TabsContext);
+	if (!ctx) throw new Error("You must wrap your component in <Tabs>");
+	return ctx;
+}
+const TabsList = Primitive.TabsList;
+const TabsTrigger = Primitive.TabsTrigger;
+function Tabs({ ref, groupId, persist = false, updateAnchor = false, defaultValue, value: _value, onValueChange: _onValueChange, ...props }) {
+	const tabsRef = useRef(null);
+	const valueToIdMap = useMemo(() => /* @__PURE__ */ new Map(), []);
+	const [value, setValue] = _value === void 0 ? useState(defaultValue) : [_value, useEffectEvent((v) => _onValueChange?.(v))];
+	useLayoutEffect(() => {
+		if (!groupId) return;
+		let previous = sessionStorage.getItem(groupId);
+		if (persist) previous ??= localStorage.getItem(groupId);
+		if (previous) setValue(previous);
+		const groupListeners = listeners.get(groupId) ?? /* @__PURE__ */ new Set();
+		groupListeners.add(setValue);
+		listeners.set(groupId, groupListeners);
+		return () => {
+			groupListeners.delete(setValue);
+		};
+	}, [
+		groupId,
+		persist,
+		setValue
+	]);
+	useLayoutEffect(() => {
+		const hash = window.location.hash.slice(1);
+		if (!hash) return;
+		for (const [value, id] of valueToIdMap.entries()) if (id === hash) {
+			setValue(value);
+			tabsRef.current?.scrollIntoView();
+			break;
+		}
+	}, [setValue, valueToIdMap]);
+	return /* @__PURE__ */ jsx(Primitive.Tabs, {
+		ref: mergeRefs(ref, tabsRef),
+		value,
+		onValueChange: (v) => {
+			if (updateAnchor) {
+				const id = valueToIdMap.get(v);
+				if (id) window.history.replaceState(null, "", `#${id}`);
+			}
+			if (groupId) {
+				const groupListeners = listeners.get(groupId);
+				if (groupListeners) for (const listener of groupListeners) listener(v);
+				sessionStorage.setItem(groupId, v);
+				if (persist) localStorage.setItem(groupId, v);
+			} else setValue(v);
+		},
+		...props,
+		children: /* @__PURE__ */ jsx(TabsContext, {
+			value: useMemo(() => ({ valueToIdMap }), [valueToIdMap]),
+			children: props.children
+		})
+	});
+}
+function TabsContent({ value, ...props }) {
+	const { valueToIdMap } = useTabContext();
+	if (props.id) valueToIdMap.set(value, props.id);
+	return /* @__PURE__ */ jsx(Primitive.TabsContent, {
+		value,
+		...props,
+		children: props.children
+	});
+}
+//#endregion
+export { Tabs, TabsContent, TabsList, TabsTrigger };

package/dist/contexts/i18n.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from "react";
+
+//#region src/contexts/i18n.d.ts
+interface LocaleItem {
+  name: string;
+  locale: string;
+}
+interface LocaleContextType {
+  locale?: string;
+  onChange?: (v: string) => void;
+  locales?: LocaleItem[];
+}
+declare function useI18n(): LocaleContextType;
+interface I18nProviderProps {
+  /**
+   * Current locale
+   */
+  locale?: string;
+  /**
+   * Handle changes to the locale, redirect user when not specified.
+   */
+  onLocaleChange?: (v: string) => void;
+  /**
+   * Translations of current locale
+   */
+  translations?: Partial<Record<string, string>>;
+  /**
+   * Available languages
+   */
+  locales?: LocaleItem[];
+  children?: ReactNode;
+}
+declare function I18nProvider({
+  locales,
+  locale,
+  onLocaleChange,
+  children,
+  translations
+}: I18nProviderProps): import("react").JSX.Element;
+//#endregion
+export { I18nProvider, I18nProviderProps, useI18n };

package/dist/contexts/i18n.js

@@ -0,0 +1,37 @@
+"use client";
+import { usePathname, useRouter } from "fumadocs-core/framework";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useMemo, useRef } from "react";
+import { TranslationProvider } from "@fuma-translate/react";
+//#region src/contexts/i18n.tsx
+const LocaleContext = createContext({});
+function useI18n() {
+	return use(LocaleContext);
+}
+const Empty = {};
+function I18nProvider({ locales = [], locale, onLocaleChange, children, translations = Empty }) {
+	const router = useRouter();
+	const pathname = usePathname();
+	const onChange = (value) => {
+		if (onLocaleChange) return onLocaleChange(value);
+		const segments = pathname.split("/").filter((v) => v.length > 0);
+		if (segments.length === 0 || segments[0] !== locale) segments.unshift(value);
+		else segments[0] = value;
+		router.push(`/${segments.join("/")}`);
+	};
+	const onChangeRef = useRef(onChange);
+	onChangeRef.current = onChange;
+	return /* @__PURE__ */ jsx(LocaleContext, {
+		value: useMemo(() => ({
+			locale,
+			locales,
+			onChange: (v) => onChangeRef.current(v)
+		}), [locale, locales]),
+		children: /* @__PURE__ */ jsx(TranslationProvider, {
+			translations,
+			children
+		})
+	});
+}
+//#endregion
+export { I18nProvider, useI18n };

package/dist/contexts/search.d.ts

@@ -0,0 +1,73 @@
+import { ComponentType, ReactNode } from "react";
+
+//#region src/contexts/search.d.ts
+interface HotKey {
+  display: ReactNode;
+  /**
+   * Key code or a function determining whether the key is pressed.
+   */
+  key: string | ((e: KeyboardEvent) => boolean);
+}
+interface SharedProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+type SearchLink = [name: string, href: string];
+interface TagItem {
+  name: string;
+  value: string;
+}
+interface SearchProviderProps {
+  /**
+   * Preload search dialog before opening it
+   *
+   * @defaultValue `true`
+   */
+  preload?: boolean;
+  /**
+   * Custom links to be displayed if search is empty
+   */
+  links?: SearchLink[];
+  /**
+   * Hotkeys for triggering search dialog
+   *
+   * @defaultValue Meta/Ctrl + K
+   */
+  hotKey?: HotKey[];
+  /**
+   * Replace default search dialog, allowing you to use other solutions such as Algolia Search
+   *
+   * It receives the `open` and `onOpenChange` prop, can be lazy loaded with `React.lazy()`
+   */
+  SearchDialog?: ComponentType<SharedProps>;
+  /**
+   * Additional props to the dialog
+   */
+  options?: Partial<SharedProps & Record<string, unknown>>;
+  children?: ReactNode;
+}
+interface SearchContextType {
+  enabled: boolean;
+  open: boolean;
+  hotKey: HotKey[];
+  setOpenSearch: (value: boolean) => void;
+}
+declare function useSearchContext(): SearchContextType;
+declare function SearchProvider({
+  SearchDialog,
+  children,
+  preload,
+  options,
+  hotKey,
+  links
+}: SearchProviderProps): import("react").JSX.Element;
+/**
+ * Show children only when search is enabled via React Context
+ */
+declare function SearchOnly({
+  children
+}: {
+  children: ReactNode;
+}): ReactNode;
+//#endregion
+export { SearchLink, SearchOnly, SearchProvider, SearchProviderProps, SharedProps, TagItem, useSearchContext };

package/dist/contexts/search.js

@@ -0,0 +1,68 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Suspense, createContext, lazy, use, useEffect, useEffectEvent, useMemo, useState } from "react";
+//#region src/contexts/search.tsx
+const SearchContext = createContext({
+	enabled: false,
+	open: false,
+	hotKey: [],
+	setOpenSearch: () => void 0
+});
+function useSearchContext() {
+	return use(SearchContext);
+}
+function MetaOrControl() {
+	const [key, setKey] = useState("⌘");
+	useEffect(() => {
+		if (/Windows|Linux/i.test(window.navigator.userAgent)) setKey("Ctrl");
+	}, []);
+	return key;
+}
+const DEFAULT_HOT_KEYS = [{
+	key: (e) => e.metaKey || e.ctrlKey,
+	display: /* @__PURE__ */ jsx(MetaOrControl, {})
+}, {
+	key: "k",
+	display: "K"
+}];
+const DefaultSearchDialog = lazy(() => import("../components/dialog/search-default.js"));
+function SearchProvider({ SearchDialog = DefaultSearchDialog, children, preload = true, options, hotKey = DEFAULT_HOT_KEYS, links }) {
+	const [isOpen, setIsOpen] = useState(preload ? false : void 0);
+	const onKeyDown = useEffectEvent((e) => {
+		if (hotKey.every((v) => typeof v.key === "string" ? e.key === v.key : v.key(e))) {
+			setIsOpen((open) => !open);
+			e.preventDefault();
+		}
+	});
+	useEffect(() => {
+		window.addEventListener("keydown", onKeyDown);
+		return () => {
+			window.removeEventListener("keydown", onKeyDown);
+		};
+	}, []);
+	return /* @__PURE__ */ jsxs(SearchContext, {
+		value: useMemo(() => ({
+			enabled: true,
+			open: isOpen ?? false,
+			hotKey,
+			setOpenSearch: setIsOpen
+		}), [isOpen, hotKey]),
+		children: [/* @__PURE__ */ jsx(Suspense, {
+			fallback: null,
+			children: isOpen !== void 0 && /* @__PURE__ */ jsx(SearchDialog, {
+				open: isOpen,
+				onOpenChange: setIsOpen,
+				links,
+				...options
+			})
+		}), children]
+	});
+}
+/**
+* Show children only when search is enabled via React Context
+*/
+function SearchOnly({ children }) {
+	if (useSearchContext().enabled) return children;
+}
+//#endregion
+export { SearchOnly, SearchProvider, useSearchContext };

package/dist/contexts/tree.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from "react";
+import * as PageTree from "fumadocs-core/page-tree";
+
+//#region src/contexts/tree.d.ts
+type MakeRequired<O, K extends keyof O> = Omit<O, K> & Pick<Required<O>, K>;
+interface TreeContextType {
+  root: MakeRequired<PageTree.Root | PageTree.Folder, '$id'>;
+  full: PageTree.Root;
+}
+declare function TreeContextProvider({
+  tree: rawTree,
+  children
+}: {
+  tree: PageTree.Root;
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function useTreePath(): PageTree.Node[];
+declare function useTreeContext(): TreeContextType;
+//#endregion
+export { TreeContextProvider, useTreeContext, useTreePath };

package/dist/contexts/tree.js

@@ -0,0 +1,38 @@
+"use client";
+import { usePathname } from "fumadocs-core/framework";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useMemo, useRef } from "react";
+import { searchPath } from "fumadocs-core/breadcrumb";
+//#region src/contexts/tree.tsx
+const TreeContext = createContext(null);
+const PathContext = createContext([]);
+function TreeContextProvider({ tree: rawTree, children }) {
+	const nextIdRef = useRef(0);
+	const pathname = usePathname();
+	const tree = useMemo(() => rawTree, [rawTree.$id]);
+	const path = useMemo(() => {
+		return searchPath(tree.children, pathname) ?? (tree.fallback ? searchPath(tree.fallback.children, pathname) : null) ?? [];
+	}, [tree, pathname]);
+	const root = path.findLast((item) => item.type === "folder" && item.root) ?? tree;
+	root.$id ??= String(nextIdRef.current++);
+	return /* @__PURE__ */ jsx(TreeContext, {
+		value: useMemo(() => ({
+			root,
+			full: tree
+		}), [root, tree]),
+		children: /* @__PURE__ */ jsx(PathContext, {
+			value: path,
+			children
+		})
+	});
+}
+function useTreePath() {
+	return use(PathContext);
+}
+function useTreeContext() {
+	const ctx = use(TreeContext);
+	if (!ctx) throw new Error("You must wrap this component under <DocsLayout />");
+	return ctx;
+}
+//#endregion
+export { TreeContextProvider, useTreeContext, useTreePath };

package/dist/i18n.d.ts

@@ -0,0 +1,16 @@
+import { I18nProviderProps } from "./contexts/i18n.js";
+import { Translations } from "./.translations/index.js";
+import { I18nConfig, SingularTranslationsAPI, TranslationExtension, TranslationsAPI } from "fumadocs-core/i18n";
+
+//#region src/i18n.d.ts
+declare function uiTranslations(): TranslationExtension<keyof Translations>;
+declare function i18nProvider(translations: SingularTranslationsAPI): I18nProviderProps;
+declare function i18nProvider<Languages extends string>(translations: TranslationsAPI<Languages>, lang?: NoInfer<Languages> | (string & {})): I18nProviderProps;
+interface I18nUIConfig<Languages extends string> extends I18nConfig<Languages> {
+  provider: (locale?: Languages | (string & {})) => I18nProviderProps;
+}
+declare function defineI18nUI<Languages extends string>(config: I18nConfig<Languages>, localeTranslations?: Partial<Record<Languages, Record<string, string> & {
+  displayName?: string;
+}>>): I18nUIConfig<Languages>;
+//#endregion
+export { I18nUIConfig, type Translations, defineI18nUI, i18nProvider, uiTranslations };

package/dist/i18n.js

@@ -0,0 +1,38 @@
+import keys_default from "./.translations/keys.js";
+//#region src/i18n.tsx
+function uiTranslations() {
+	return { keys: keys_default };
+}
+function i18nProvider(translations, lang) {
+	const t = translations.extend(uiTranslations());
+	if ("config" in t) {
+		const { defaultLanguage, languages } = t.config;
+		const locale = lang ?? defaultLanguage;
+		return {
+			locale: lang,
+			translations: t.get(locale) ?? t.get(defaultLanguage),
+			locales: languages.map((code) => ({
+				locale: code,
+				name: t.get(code).displayName ?? "English"
+			}))
+		};
+	}
+	return { translations: t.get() };
+}
+function defineI18nUI(config, localeTranslations = {}) {
+	return {
+		...config,
+		provider(locale = config.defaultLanguage) {
+			return {
+				locale,
+				translations: localeTranslations[locale],
+				locales: config.languages.map((code) => ({
+					locale: code,
+					name: localeTranslations[code]?.displayName ?? code
+				}))
+			};
+		}
+	};
+}
+//#endregion
+export { defineI18nUI, i18nProvider, uiTranslations };

package/dist/layouts/docs/client.d.ts

@@ -0,0 +1,34 @@
+import { BaseSlots, BaseSlotsProps } from "../shared/client.js";
+import { LayoutTab, LinkItemType } from "../shared/index.js";
+import { SidebarProps, SidebarProviderProps } from "./slots/sidebar.js";
+import { DocsLayoutProps } from "./index.js";
+import { ComponentProps, FC } from "react";
+
+//#region src/layouts/docs/client.d.ts
+interface DocsSlots extends BaseSlots {
+  container: FC<ComponentProps<'div'>>;
+  header: FC<ComponentProps<'header'>>;
+  sidebar: {
+    provider: FC<SidebarProviderProps>;
+    root: FC<SidebarProps>;
+    trigger: FC<ComponentProps<'button'>>;
+    useSidebar: () => {
+      collapsed: boolean;
+      open: boolean;
+      setOpen: (v: boolean) => void;
+    };
+  };
+}
+interface SlotsProps extends BaseSlotsProps<DocsLayoutProps> {
+  tabs: LayoutTab[];
+  tabMode: NonNullable<DocsLayoutProps['tabMode']>;
+}
+declare function useDocsLayout(): {
+  props: SlotsProps;
+  isNavTransparent: boolean;
+  navItems: LinkItemType[];
+  menuItems: LinkItemType[];
+  slots: DocsSlots;
+};
+//#endregion
+export { DocsSlots, useDocsLayout };