Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

refactor(web): Unify tooltip and hover card behavior (#19303)

Ben Bachemf65227a90d44
diff --git a/web/src/components/design-system/CustomTooltip/CustomTooltip.tsx b/web/src/components/design-system/CustomTooltip/CustomTooltip.tsx
index 12eda73e9e..f529ed50e2 100644
--- a/web/src/components/design-system/CustomTooltip/CustomTooltip.tsx
+++ b/web/src/components/design-system/CustomTooltip/CustomTooltip.tsx
@@ -1,26 +1,10 @@
"use client";
-import {
- autoUpdate,
- flip,
- FloatingPortal,
- offset,
- safePolygon,
- shift,
- size,
- useDismiss,
- useFloating,
- useFocus,
- useHover,
- useInteractions,
- useRole,
- type Placement,
-} from "@floating-ui/react";
import * as React from "react";
import { cva, type VariantProps } from "class-variance-authority";
-import { useLayerContainer } from "@/src/context/LayerContext/LayerContext";
import { cn } from "@/src/utils/tailwind";
+import { FloatingController } from "../FloatingController/FloatingController";
const tooltipVariants = cva(
"bg-popover text-popover-foreground animate-in fade-in-0 zoom-in-95 max-w-xs rounded-md border text-sm shadow-md",
@@ -35,32 +19,6 @@ const tooltipVariants = cva(
},
);
-type CustomTooltipProps = {
- children: (controls: {
- getTriggerProps: (props?: {
- ref?: React.Ref<HTMLElement>;
- }) => ReturnType<ReturnType<typeof useInteractions>["getReferenceProps"]>;
- }) => React.ReactNode;
- content: React.ReactElement;
- delay?: number;
- hoverableContent?: boolean;
- placement?: Placement;
- padding?: NonNullable<VariantProps<typeof tooltipVariants>["padding"]>;
- overflow?: NonNullable<VariantProps<typeof tooltipVariants>["overflow"]>;
-};
-
-function mergeRefs<T>(...refs: Array<React.Ref<T> | undefined>) {
- return (value: T | null) => {
- refs.forEach((ref) => {
- if (typeof ref === "function") {
- ref(value);
- } else if (ref) {
- ref.current = value;
- }
- });
- };
-}
-
function CustomTooltip({
children,
content,
@@ -69,71 +27,41 @@ function CustomTooltip({
placement = "top",
padding = "default",
overflow = "hidden",
-}: CustomTooltipProps) {
- const [isOpen, setIsOpen] = React.useState(false);
- const layerContainer = useLayerContainer("tooltip");
- const { context, floatingStyles, refs } = useFloating({
- open: isOpen,
- onOpenChange: setIsOpen,
- placement,
- strategy: "fixed",
- middleware: [
- offset(4),
- flip(),
- shift({ padding: 8 }),
- ...(overflow === "scroll"
- ? [
- size({
- padding: 8,
- apply({ availableHeight, elements }) {
- elements.floating.style.maxHeight = `${Math.max(0, availableHeight)}px`;
- },
- }),
- ]
- : []),
- ],
- transform: false,
- whileElementsMounted: autoUpdate,
- });
- const hover = useHover(context, {
- delay: { open: delay, close: 0 },
- handleClose: hoverableContent ? safePolygon() : undefined,
- });
- const focus = useFocus(context);
- const dismiss = useDismiss(context);
- const role = useRole(context, { role: "tooltip" });
- const { getFloatingProps, getReferenceProps } = useInteractions([
- hover,
- focus,
- dismiss,
- role,
- ]);
+}: Pick<
+ React.ComponentProps<typeof FloatingController>,
+ "children" | "placement" | "hoverableContent"
+> & {
+ content: React.ReactElement;
+ delay?: number;
+ padding?: NonNullable<VariantProps<typeof tooltipVariants>["padding"]>;
+ overflow?: NonNullable<VariantProps<typeof tooltipVariants>["overflow"]>;
+}) {
+ const [open, setOpen] = React.useState(false);
return (
- <>
- {children({
- getTriggerProps: (props = {}) => {
- return getReferenceProps({
- ref: mergeRefs(props.ref, refs.setReference),
- });
- },
- })}
- {isOpen ? (
- <FloatingPortal root={layerContainer}>
- <div
- ref={refs.setFloating}
- className={cn(
- tooltipVariants({ padding, overflow }),
- !hoverableContent && "pointer-events-none",
- )}
- style={floatingStyles}
- {...getFloatingProps()}
- >
- {content}
- </div>
- </FloatingPortal>
- ) : null}
- </>
+ <FloatingController
+ open={open}
+ onOpenChange={setOpen}
+ role="tooltip"
+ openDelay={delay}
+ closeDelay={0}
+ placement={placement}
+ hoverableContent={hoverableContent}
+ isScrollable={overflow === "scroll"}
+ renderContent={(floatingProps) => (
+ <div
+ {...floatingProps}
+ className={cn(
+ tooltipVariants({ padding, overflow }),
+ !hoverableContent && "pointer-events-none",
+ )}
+ >
+ {content}
+ </div>
+ )}
+ >
+ {children}
+ </FloatingController>
);
}
diff --git a/web/src/components/design-system/FloatingController/FloatingController.tsx b/web/src/components/design-system/FloatingController/FloatingController.tsx
new file mode 100644
index 0000000000..1d22279f00
--- /dev/null
+++ b/web/src/components/design-system/FloatingController/FloatingController.tsx
@@ -0,0 +1,257 @@
+"use client";
+
+import {
+ autoUpdate,
+ flip,
+ FloatingFocusManager,
+ FloatingPortal,
+ hide,
+ offset,
+ safePolygon,
+ shift,
+ size,
+ useDismiss,
+ useFloating,
+ useFocus,
+ useHover,
+ useInteractions,
+ useRole,
+ type Placement,
+} from "@floating-ui/react";
+import * as React from "react";
+
+import { useLayerContainer } from "@/src/context/LayerContext/LayerContext";
+import { stopScrollPropagation } from "@/src/hooks/stopScrollPropagation";
+
+function buildMiddleware({
+ sideOffset,
+ collisionPadding,
+ hideWhenDetached,
+ isScrollable,
+}: Required<
+ Pick<
+ React.ComponentProps<typeof FloatingController>,
+ "sideOffset" | "collisionPadding" | "hideWhenDetached" | "isScrollable"
+ >
+>) {
+ return [
+ offset(sideOffset),
+ flip({ padding: collisionPadding }),
+ shift({ padding: collisionPadding }),
+ ...(hideWhenDetached ? [hide({ padding: collisionPadding })] : []),
+ ...(isScrollable
+ ? [
+ size({
+ padding: collisionPadding,
+ apply({ availableHeight, elements }) {
+ elements.floating.style.maxHeight = `${Math.max(0, availableHeight)}px`;
+ },
+ }),
+ ]
+ : []),
+ ];
+}
+
+function useStableTriggerRef(
+ setReference: ReturnType<typeof useFloating>["refs"]["setReference"],
+) {
+ return React.useMemo(() => {
+ // Stable composed refs avoid detaching the trigger on every prop-getter call.
+ const mergedRefs = new WeakMap<
+ NonNullable<React.Ref<HTMLElement>>,
+ React.RefCallback<HTMLElement>
+ >();
+
+ return (callerRef: React.Ref<HTMLElement> | undefined) => {
+ if (!callerRef) return setReference;
+ const cachedRef = mergedRefs.get(callerRef);
+ if (cachedRef) return cachedRef;
+
+ const mergedRef: React.RefCallback<HTMLElement> = (node) => {
+ setReference(node);
+ if (typeof callerRef === "function") {
+ const cleanup = callerRef(node);
+ return () => {
+ setReference(null);
+ if (cleanup) {
+ cleanup();
+ } else {
+ callerRef(null);
+ }
+ };
+ }
+
+ callerRef.current = node;
+ return () => {
+ setReference(null);
+ callerRef.current = null;
+ };
+ };
+ mergedRefs.set(callerRef, mergedRef);
+ return mergedRef;
+ };
+ }, [setReference]);
+}
+
+function getContentProps({
+ getFloatingProps,
+ setFloating,
+ placement,
+ floatingStyles,
+ middlewareData,
+ role,
+ onWheel,
+ onTouchMove,
+ ...props
+}: React.HTMLProps<HTMLDivElement> & {
+ getFloatingProps: ReturnType<typeof useInteractions>["getFloatingProps"];
+ setFloating: ReturnType<typeof useFloating>["refs"]["setFloating"];
+ placement: Placement;
+ floatingStyles: ReturnType<typeof useFloating>["floatingStyles"];
+ middlewareData: ReturnType<typeof useFloating>["middlewareData"];
+ role: NonNullable<React.ComponentProps<typeof FloatingController>["role"]>;
+}) {
+ return {
+ ...getFloatingProps({
+ ...props,
+ onWheel: role === "dialog" ? stopScrollPropagation(onWheel) : onWheel,
+ onTouchMove:
+ role === "dialog" ? stopScrollPropagation(onTouchMove) : onTouchMove,
+ }),
+ ref: setFloating,
+ "data-state": "open" as const,
+ "data-side": placement.split("-")[0] ?? placement,
+ style: {
+ ...floatingStyles,
+ ...(middlewareData.hide?.referenceHidden
+ ? { visibility: "hidden" as const }
+ : {}),
+ },
+ };
+}
+
+function FloatingController({
+ children,
+ renderContent,
+ open,
+ onOpenChange,
+ openDelay = 700,
+ closeDelay = 300,
+ placement = "bottom",
+ sideOffset = 4,
+ collisionPadding = 8,
+ hideWhenDetached = false,
+ enabled = true,
+ role: overlayRole = "dialog",
+ hoverableContent = true,
+ isScrollable = false,
+ onWheel,
+ onTouchMove,
+ ...props
+}: Omit<
+ React.ComponentPropsWithoutRef<"div">,
+ "children" | "content" | "defaultValue" | "className" | "style"
+> & {
+ children: (controls: {
+ getTriggerProps: (
+ props?: React.HTMLProps<HTMLElement>,
+ ) => ReturnType<ReturnType<typeof useInteractions>["getReferenceProps"]>;
+ }) => React.ReactNode;
+ renderContent: (
+ props: React.HTMLProps<HTMLDivElement> & {
+ "data-state": "open";
+ "data-side": string;
+ },
+ ) => React.ReactElement;
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ openDelay?: number;
+ closeDelay?: number;
+ placement?: Placement;
+ sideOffset?: number;
+ collisionPadding?: number;
+ hideWhenDetached?: boolean;
+ enabled?: boolean;
+ role?: "tooltip" | "dialog";
+ hoverableContent?: boolean;
+ isScrollable?: boolean;
+}) {
+ const isOpen = enabled && open;
+ const layerContainer = useLayerContainer(
+ overlayRole === "tooltip" ? "tooltip" : "popover",
+ );
+ const {
+ context,
+ floatingStyles,
+ middlewareData,
+ refs,
+ placement: resolvedPlacement,
+ } = useFloating({
+ open: isOpen,
+ onOpenChange,
+ placement,
+ strategy: "fixed",
+ middleware: buildMiddleware({
+ sideOffset,
+ collisionPadding,
+ hideWhenDetached,
+ isScrollable,
+ }),
+ transform: false,
+ whileElementsMounted: autoUpdate,
+ });
+ const hover = useHover(context, {
+ enabled,
+ delay: { open: openDelay, close: closeDelay },
+ handleClose: hoverableContent ? safePolygon() : undefined,
+ move: false,
+ });
+ const focus = useFocus(context, { enabled });
+ const dismiss = useDismiss(context);
+ const role = useRole(context, { role: overlayRole });
+ const { getFloatingProps, getReferenceProps } = useInteractions([
+ hover,
+ focus,
+ dismiss,
+ role,
+ ]);
+ const getTriggerRef = useStableTriggerRef(refs.setReference);
+
+ return (
+ <>
+ {children({
+ getTriggerProps: (triggerProps) =>
+ getReferenceProps({
+ ...triggerProps,
+ ref: getTriggerRef(triggerProps?.ref),
+ }),
+ })}
+ {isOpen ? (
+ <FloatingPortal root={layerContainer}>
+ <FloatingFocusManager
+ context={context}
+ disabled={overlayRole === "tooltip"}
+ modal={false}
+ initialFocus={-1}
+ >
+ {renderContent(
+ getContentProps({
+ ...props,
+ getFloatingProps,
+ setFloating: refs.setFloating,
+ placement: resolvedPlacement,
+ floatingStyles,
+ middlewareData,
+ role: overlayRole,
+ onWheel,
+ onTouchMove,
+ }),
+ )}
+ </FloatingFocusManager>
+ </FloatingPortal>
+ ) : null}
+ </>
+ );
+}
+
+export { FloatingController };
diff --git a/web/src/components/design-system/HoverCardController/HoverCardController.tsx b/web/src/components/design-system/HoverCardController/HoverCardController.tsx
index 721ab47951..665195815e 100644
--- a/web/src/components/design-system/HoverCardController/HoverCardController.tsx
+++ b/web/src/components/design-system/HoverCardController/HoverCardController.tsx
@@ -1,180 +1,29 @@
"use client";
-import {
- autoUpdate,
- flip,
- FloatingFocusManager,
- FloatingPortal,
- hide,
- offset,
- safePolygon,
- shift,
- useDismiss,
- useFloating,
- useFocus,
- useHover,
- useInteractions,
- useRole,
- type Placement,
-} from "@floating-ui/react";
import * as React from "react";
-import { useLayerContainer } from "@/src/context/LayerContext/LayerContext";
-import { stopScrollPropagation } from "@/src/hooks/stopScrollPropagation";
-
-type HoverCardControllerProps = Omit<
- React.ComponentPropsWithoutRef<"div">,
- "children" | "content" | "defaultValue" | "className" | "style"
-> & {
- children: (controls: {
- getTriggerProps: (
- props?: React.HTMLProps<HTMLElement>,
- ) => ReturnType<ReturnType<typeof useInteractions>["getReferenceProps"]>;
- }) => React.ReactNode;
- // Content owns its sizing, padding, and scroll layout inside the portaled frame.
- content: React.ReactElement;
- open: boolean;
- onOpenChange: (open: boolean) => void;
- openDelay?: number;
- closeDelay?: number;
- placement?: Placement;
- sideOffset?: number;
- collisionPadding?: number;
- hideWhenDetached?: boolean;
- enabled?: boolean;
-};
+import { FloatingController } from "../FloatingController/FloatingController";
function HoverCardController({
- children,
content,
- open,
- onOpenChange,
- openDelay = 700,
- closeDelay = 300,
- placement = "bottom",
- sideOffset = 4,
- collisionPadding = 8,
- hideWhenDetached = false,
- enabled = true,
- onWheel,
- onTouchMove,
...props
-}: HoverCardControllerProps) {
- const isOpen = enabled && open;
- const layerContainer = useLayerContainer("popover");
- const {
- context,
- floatingStyles,
- middlewareData,
- refs,
- placement: resolvedPlacement,
- } = useFloating({
- open: isOpen,
- onOpenChange,
- placement,
- strategy: "fixed",
- middleware: [
- offset(sideOffset),
- flip({ padding: collisionPadding }),
- shift({ padding: collisionPadding }),
- ...(hideWhenDetached ? [hide({ padding: collisionPadding })] : []),
- ],
- transform: false,
- whileElementsMounted: autoUpdate,
- });
- const hover = useHover(context, {
- enabled,
- delay: { open: openDelay, close: closeDelay },
- handleClose: safePolygon(),
- move: false,
- });
- const focus = useFocus(context, { enabled });
- const dismiss = useDismiss(context);
- const role = useRole(context, { role: "dialog" });
- const { getFloatingProps, getReferenceProps } = useInteractions([
- hover,
- focus,
- dismiss,
- role,
- ]);
- const { setReference } = refs;
- const getTriggerRef = React.useMemo(() => {
- // Stable composed refs avoid detaching the trigger on every prop-getter call.
- const mergedRefs = new WeakMap<
- NonNullable<React.Ref<HTMLElement>>,
- React.RefCallback<HTMLElement>
- >();
-
- return (callerRef: React.Ref<HTMLElement> | undefined) => {
- if (!callerRef) return setReference;
- const cachedRef = mergedRefs.get(callerRef);
- if (cachedRef) return cachedRef;
-
- const mergedRef: React.RefCallback<HTMLElement> = (node) => {
- setReference(node);
- if (typeof callerRef === "function") {
- const cleanup = callerRef(node);
- return () => {
- setReference(null);
- if (cleanup) {
- cleanup();
- } else {
- callerRef(null);
- }
- };
- }
-
- callerRef.current = node;
- return () => {
- setReference(null);
- callerRef.current = null;
- };
- };
- mergedRefs.set(callerRef, mergedRef);
- return mergedRef;
- };
- }, [setReference]);
-
+}: Omit<
+ React.ComponentProps<typeof FloatingController>,
+ "role" | "hoverableContent" | "isScrollable" | "renderContent"
+> & { content: React.ReactElement }) {
return (
- <>
- {children({
- getTriggerProps: (triggerProps) =>
- getReferenceProps({
- ...triggerProps,
- ref: getTriggerRef(triggerProps?.ref),
- }),
- })}
- {isOpen ? (
- <FloatingPortal root={layerContainer}>
- <FloatingFocusManager
- context={context}
- modal={false}
- initialFocus={-1}
- >
- <div
- ref={refs.setFloating}
- aria-label="Preview"
- data-state="open"
- data-side={resolvedPlacement.split("-")[0]}
- className="animate-in fade-in-0 zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 outline-hidden"
- style={{
- ...floatingStyles,
- ...(middlewareData.hide?.referenceHidden
- ? { visibility: "hidden" }
- : {}),
- }}
- {...getFloatingProps({
- ...props,
- onWheel: stopScrollPropagation(onWheel),
- onTouchMove: stopScrollPropagation(onTouchMove),
- })}
- >
- {content}
- </div>
- </FloatingFocusManager>
- </FloatingPortal>
- ) : null}
- </>
+ <FloatingController
+ {...props}
+ renderContent={(floatingProps) => (
+ <div
+ aria-label="Preview"
+ className="animate-in fade-in-0 zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 outline-hidden"
+ {...floatingProps}
+ >
+ {content}
+ </div>
+ )}
+ />
);
}