@workflow/web-shared 5.0.0-beta.15 → 5.0.0-beta.16

package/dist/components/ui/context-card.js

@@ -0,0 +1,471 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Root as SlotRoot, Slottable } from '@radix-ui/react-slot';
+import { createContext, useContext, useEffect, useId, useMemo, useRef, useState, } from 'react';
+import { createPortal } from 'react-dom';
+import useMeasure from 'react-use-measure';
+import { useReducedMotion } from '../../hooks/use-reduced-motion';
+import { cn } from '../../lib/utils';
+const INACTIVE_TIMEOUT_MS = 250;
+const ENTER_DELAY_MS = 0;
+const OPEN_DELAY_MS = 150;
+const MAX_TRANSITION_DISTANCE_PX = 150;
+const MAX_OVERLAP_FOR_TRANSITION_PERCENT = 100;
+const PERSIST_TIMEOUT_MS = 1000;
+const ContextCardContext = createContext({
+    rootOrigin: { x: 0, y: 0 },
+    rootBounds: { width: 0, height: 0 },
+    portalRef: null,
+    activeId: null,
+    setActiveId: () => void 0,
+    hoveredId: null,
+    setHoveredId: () => void 0,
+    updateActiveContextCard: () => void 0,
+    skipTransition: false,
+    rootVisible: false,
+    distanceFromLast: 0,
+    lastOrigin: null,
+    isProvided: false,
+});
+ContextCardContext.displayName = 'ContextCardContext';
+/**
+ * Returns whether the current subtree is wrapped in a {@link ContextCardProvider}.
+ */
+export function useHasContextCardProvider() {
+    return useContext(ContextCardContext).isProvided;
+}
+function usePrevious(value) {
+    const ref = useRef(null);
+    useEffect(() => {
+        ref.current = value;
+    });
+    return ref.current;
+}
+function isRefObject(value) {
+    return value !== null && value !== undefined && 'current' in value;
+}
+/**
+ * Provides shared state and a portal container for {@link ContextCardTrigger}
+ * components. Must wrap any tree containing triggers; manages positioning,
+ * visibility transitions, and the animated arrow tip across all cards.
+ */
+export function ContextCardProvider({ children, portalTarget, }) {
+    const [isMounted, setIsMounted] = useState(false);
+    useEffect(() => setIsMounted(true), []);
+    const resolvedPortalTarget = isRefObject(portalTarget)
+        ? portalTarget.current
+        : portalTarget;
+    const [ref, bounds] = useMeasure();
+    const portalRef = useRef(null);
+    const [activeContextCard, setActiveContextCard] = useState(null);
+    const [visible, setVisible] = useState(false);
+    const [hoveredId, setHoveredId] = useState(null);
+    const activeId = useRef(null);
+    function setActiveId(id) {
+        activeId.current = id;
+        setVisible(id !== null);
+    }
+    const updateActiveContextCard = (update) => {
+        if (update?.id !== activeId.current && update !== null)
+            return;
+        setActiveContextCard(update);
+    };
+    const BORDER_WIDTH = 1;
+    const activeBounds = useMemo(() => {
+        if (!activeContextCard)
+            return {
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0,
+                side: 'top',
+                arrowOffset: { x: 0, y: 0 },
+            };
+        return {
+            width: activeContextCard.contentSize.width + BORDER_WIDTH * 2,
+            height: activeContextCard.contentSize.height + BORDER_WIDTH * 2,
+            x: activeContextCard.origin.x,
+            y: activeContextCard.origin.y,
+            side: activeContextCard.side,
+            arrowOffset: activeContextCard.arrowOffset,
+        };
+    }, [activeContextCard]);
+    const lastBounds = usePrevious(activeBounds);
+    const lastId = usePrevious(activeId.current);
+    const percentOverlapFromLast = useMemo(() => {
+        if (!lastBounds)
+            return 0;
+        const overlapLeft = Math.max(activeBounds.x, lastBounds.x);
+        const overlapRight = Math.min(activeBounds.x + activeBounds.width, lastBounds.x + lastBounds.width);
+        const overlapTop = Math.max(activeBounds.y, lastBounds.y);
+        const overlapBottom = Math.min(activeBounds.y + activeBounds.height, lastBounds.y + lastBounds.height);
+        if (overlapLeft < overlapRight && overlapTop < overlapBottom) {
+            const overlapArea = (overlapRight - overlapLeft) * (overlapBottom - overlapTop);
+            const activeBoundsArea = activeBounds.width * activeBounds.height;
+            if (activeBoundsArea === 0)
+                return 0;
+            return (overlapArea / activeBoundsArea) * 100;
+        }
+        return 0;
+    }, [activeBounds, lastBounds]);
+    const distanceFromLast = useMemo(() => Math.sqrt(((lastBounds?.x ?? 0) - activeBounds.x) ** 2 +
+        ((lastBounds?.y ?? 0) - activeBounds.y) ** 2), [activeBounds.x, activeBounds.y, lastBounds?.x, lastBounds?.y]);
+    const lastOrigin = useMemo(() => {
+        if (!lastBounds)
+            return null;
+        return {
+            x: lastBounds.x - activeBounds.x,
+            y: lastBounds.y - activeBounds.y,
+        };
+    }, [activeBounds, lastBounds]);
+    const [isScrolling, setIsScrolling] = useState(false);
+    const skipTransition = useMemo(() => distanceFromLast > MAX_TRANSITION_DISTANCE_PX ||
+        percentOverlapFromLast > MAX_OVERLAP_FOR_TRANSITION_PERCENT ||
+        lastId === null ||
+        isScrolling, [distanceFromLast, isScrolling, lastId, percentOverlapFromLast]);
+    useEffect(() => {
+        let isScrollingTimeout = null;
+        const onScroll = () => {
+            if (isScrollingTimeout)
+                window.clearTimeout(isScrollingTimeout);
+            isScrollingTimeout = setTimeout(() => {
+                setIsScrolling(false);
+            }, 66);
+            if (!isScrolling) {
+                setIsScrolling(true);
+            }
+        };
+        document.addEventListener('scroll', onScroll, true);
+        return () => {
+            document.removeEventListener('scroll', onScroll, true);
+        };
+    }, [isScrolling]);
+    const contextValue = useMemo(() => ({
+        updateActiveContextCard,
+        rootOrigin: { ...activeBounds },
+        rootBounds: bounds,
+        portalRef,
+        setActiveId,
+        activeId,
+        setHoveredId,
+        hoveredId,
+        skipTransition,
+        rootVisible: visible,
+        distanceFromLast,
+        lastOrigin,
+        isProvided: true,
+    }), [
+        activeBounds,
+        bounds,
+        hoveredId,
+        skipTransition,
+        visible,
+        distanceFromLast,
+        lastOrigin,
+    ]);
+    return (_jsxs(ContextCardContext.Provider, { value: contextValue, children: [children, isMounted
+                ? createPortal(_jsx("div", { className: "w-full h-full inset-0 fixed pointer-events-none z-[100000]", ref: ref, children: _jsx("div", { className: "min-w-max transition-all duration-150 ease-[easing-function:cubic-bezier(0.3,_0.57,_0.07,_0.95)] will-change-[transform,width,height] motion-reduce:!transition-none", style: {
+                            opacity: visible ? 1 : 0,
+                        }, children: _jsxs("div", { className: cn('absolute bg-background-100 bg-clip-padding rounded-[6px] overflow-visible pointer-events-none z-[1000000] shadow-[var(--ds-shadow-tooltip),0_0_0_1px_var(--ds-background-100)] w-fit [--context-card-tip-stroke:#DBDBDB] dark-theme:[--context-card-tip-stroke:#252525]', skipTransition
+                                ? '!transition-none'
+                                : 'transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none'), "data-skip-transition": skipTransition, style: {
+                                transform: `translate(${activeBounds.x}px,${activeBounds.y}px)`,
+                                width: activeBounds.width,
+                                height: activeBounds.height,
+                            }, children: [_jsx("div", { className: cn('w-[14px] h-[7px] absolute grid place-content-center z-[999999999] origin-center', {
+                                        'top-full -translate-x-1/2 rotate-0': activeBounds.side === 'top',
+                                        'right-full -translate-y-1/2 rotate-90 -mr-[3.5px]': activeBounds.side === 'right',
+                                        'bottom-full -translate-x-1/2 rotate-180': activeBounds.side === 'bottom',
+                                        'left-full -translate-y-1/2 rotate-[270deg] -ml-[3.5px]': activeBounds.side === 'left',
+                                    }, skipTransition
+                                        ? '!transition-none'
+                                        : 'transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none'), style: {
+                                        ...(activeBounds.side === 'top' ||
+                                            activeBounds.side === 'bottom'
+                                            ? {
+                                                left: `calc(50% + ${activeBounds.arrowOffset.x}px)`,
+                                            }
+                                            : {
+                                                top: `calc(50% + ${activeBounds.arrowOffset.y}px)`,
+                                            }),
+                                    }, "data-skip-transition": skipTransition, "data-side": activeBounds.side, children: _jsxs("svg", { width: "14", height: "7", viewBox: "0 0 14 7", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", children: [_jsx("g", { clipPath: "url(#context-card-tip-clip)", children: _jsx("path", { d: "M15 -0.5V0.5H12.9834L12.8184 0.508789C12.4377 0.550822 12.0853 0.738056 11.8359 1.03418L8.53027 4.95996C7.73114 5.90893 6.26886 5.90892 5.46973 4.95996L2.16406 1.03418C1.87905 0.695733 1.45907 0.5 1.0166 0.5H-1V-0.5H15Z", fill: "var(--ds-background-100)", style: {
+                                                        fill: 'var(--ds-background-100)',
+                                                        fillOpacity: 1,
+                                                        stroke: 'var(--context-card-tip-stroke)',
+                                                        strokeOpacity: 1,
+                                                    } }) }), _jsx("defs", { children: _jsx("clipPath", { id: "context-card-tip-clip", children: _jsx("rect", { width: "14", height: "7", fill: "white", style: { fill: 'white', fillOpacity: 1 } }) }) })] }) }), _jsx("div", { ref: portalRef })] }) }) }), resolvedPortalTarget ?? document.body)
+                : null] }));
+}
+/**
+ * Displays a floating context card on hover with viewport-aware collision
+ * detection and animated position transitions between triggers in the same
+ * {@link ContextCardProvider}. Persists briefly after mouse leave.
+ */
+export function ContextCardTrigger({ content, children, side = 'right', align = 'center', sideOffset = 16, alignOffset = 0, ignoreCardPointerEvents = false, noPadding, asChild, className, hide, inactiveTimeoutMs = INACTIVE_TIMEOUT_MS, }) {
+    const triggerRef = useRef(null);
+    const contentRef = useRef(null);
+    const [contentMeasureRef, contentMeasureBounds] = useMeasure();
+    const { portalRef, updateActiveContextCard, activeId, setActiveId, hoveredId, setHoveredId, skipTransition, rootVisible, } = useContext(ContextCardContext);
+    const id = useId();
+    useEffect(() => {
+        return () => {
+            // Only clear the shared active card if this trigger was the active one;
+            // otherwise an unmounting inactive trigger would hide another trigger's card.
+            if (activeId.current === id) {
+                setActiveId(null);
+            }
+        };
+    }, []);
+    const reduceMotion = useReducedMotion();
+    const [localHover, setLocalHover] = useState(false);
+    const [persisting, setPersisting] = useState(false);
+    const [visible, setVisible] = useState(false);
+    const activeTimeout = useRef(null);
+    const persistingTimeout = useRef(null);
+    const openTimeout = useRef(null);
+    useEffect(() => {
+        if (localHover &&
+            contentMeasureBounds.width > 0 &&
+            contentMeasureBounds.height > 0) {
+            if (openTimeout.current)
+                clearTimeout(openTimeout.current);
+            openTimeout.current = setTimeout(() => {
+                setActiveId(id);
+                updateBounds();
+            }, rootVisible ? 0 : OPEN_DELAY_MS);
+        }
+        return () => {
+            if (openTimeout.current)
+                clearTimeout(openTimeout.current);
+        };
+    }, [localHover, contentMeasureBounds]);
+    const enterTimeout = useRef(null);
+    useEffect(() => {
+        if (enterTimeout.current)
+            clearTimeout(enterTimeout.current);
+        if (hoveredId !== id) {
+            // Exits are instant
+            setVisible(false);
+        }
+        else {
+            // Enters can be delayed unless we wish to script the transition
+            enterTimeout.current = setTimeout(() => {
+                setVisible(true);
+            }, reduceMotion || skipTransition ? 0 : ENTER_DELAY_MS);
+        }
+    }, [hoveredId, id, reduceMotion, skipTransition]);
+    function updateBounds() {
+        if (!contentRef.current)
+            return;
+        const bounds = computeBounds();
+        updateActiveContextCard({ id, ...bounds });
+    }
+    function computeBounds(sideOverride) {
+        if (!triggerRef.current)
+            throw new Error('Trigger not found');
+        if (!contentRef.current)
+            throw new Error('Content not found');
+        const appliedSide = sideOverride ?? side;
+        const triggerRect = triggerRef.current.getBoundingClientRect();
+        const contentRect = contentRef.current.getBoundingClientRect();
+        contentRef.current.style.width = 'max-content';
+        contentRef.current.style.position = 'absolute';
+        const contentSize = {
+            width: Math.max(contentRect.width, contentRef.current.offsetWidth),
+            height: contentRect.height,
+        };
+        let origin;
+        const arrowWidth = 14;
+        const halfArrowWidth = arrowWidth / 2;
+        const halfTriggerWidth = triggerRect.width / 2;
+        const halfTriggerHeight = triggerRect.height / 2;
+        const halfContentWidth = contentSize.width / 2;
+        const halfContentHeight = contentSize.height / 2;
+        const top = triggerRect.top;
+        const left = triggerRect.left;
+        let alignX = left + halfTriggerWidth - halfContentWidth + alignOffset;
+        if (align === 'start')
+            alignX = left + alignOffset;
+        if (align === 'end')
+            alignX = left + triggerRect.width - contentRect.width + alignOffset;
+        let alignY = top + halfTriggerHeight - halfContentHeight + alignOffset;
+        if (align === 'start')
+            alignY = top + alignOffset;
+        if (align === 'end')
+            alignY = top + triggerRect.height - contentRect.height + alignOffset;
+        switch (appliedSide) {
+            case 'top':
+                origin = {
+                    x: alignX,
+                    y: top - contentRect.height - sideOffset,
+                };
+                break;
+            case 'right':
+                origin = {
+                    x: left + triggerRect.width + sideOffset,
+                    y: alignY,
+                };
+                break;
+            case 'bottom':
+                origin = {
+                    x: alignX,
+                    y: top + triggerRect.height + sideOffset,
+                };
+                break;
+            case 'left':
+                origin = {
+                    x: left - contentRect.width - sideOffset,
+                    y: alignY,
+                };
+                break;
+            default: {
+                const _exhaustive = appliedSide;
+                throw new Error(`Unknown side: ${String(_exhaustive)}`);
+            }
+        }
+        const viewportWidth = document.documentElement.clientWidth;
+        const viewportHeight = document.documentElement.clientHeight;
+        const isOffscreenLeft = origin.x < 0;
+        const isOffscreenRight = origin.x + contentRect.width > viewportWidth;
+        const isOffscreenTop = origin.y < 0;
+        const isOffscreenBottom = origin.y + contentRect.height > viewportHeight;
+        if (!sideOverride) {
+            const spaceAbove = top;
+            const spaceBelow = viewportHeight - (top + triggerRect.height);
+            const spaceLeft = left;
+            const spaceRight = viewportWidth - (left + triggerRect.width);
+            if (side === 'top' && isOffscreenTop && spaceBelow > spaceAbove) {
+                return computeBounds('bottom');
+            }
+            if (side === 'bottom' && isOffscreenBottom && spaceAbove > spaceBelow) {
+                return computeBounds('top');
+            }
+            if (side === 'right' && isOffscreenRight && spaceLeft > spaceRight) {
+                return computeBounds('left');
+            }
+            if (side === 'left' && isOffscreenLeft && spaceRight > spaceLeft) {
+                return computeBounds('right');
+            }
+            if ((side === 'top' || side === 'bottom') &&
+                isOffscreenLeft &&
+                spaceRight > contentRect.width) {
+                return computeBounds('right');
+            }
+            if ((side === 'top' || side === 'bottom') &&
+                isOffscreenRight &&
+                spaceLeft > contentRect.width) {
+                return computeBounds('left');
+            }
+            if ((side === 'left' || side === 'right') &&
+                isOffscreenTop &&
+                spaceBelow > contentRect.height) {
+                return computeBounds('bottom');
+            }
+            if ((side === 'left' || side === 'right') &&
+                isOffscreenBottom &&
+                spaceAbove > contentRect.height) {
+                return computeBounds('top');
+            }
+        }
+        const viewportPadding = 8;
+        if (appliedSide === 'left' || appliedSide === 'right') {
+            origin.y = Math.max(viewportPadding, Math.min(origin.y, viewportHeight - contentSize.height - viewportPadding));
+        }
+        else {
+            origin.x = Math.max(viewportPadding, Math.min(origin.x, viewportWidth - contentSize.width - viewportPadding));
+        }
+        // Always constrain Y position within viewport bounds
+        origin.y = Math.max(viewportPadding, Math.min(origin.y, viewportHeight - contentSize.height - viewportPadding));
+        const triggerCenterX = left + halfTriggerWidth;
+        const triggerCenterY = top + halfTriggerHeight;
+        const cardCenterX = origin.x + contentSize.width / 2;
+        const cardCenterY = origin.y + contentSize.height / 2;
+        let arrowOffsetX = triggerCenterX - cardCenterX;
+        let arrowOffsetY = triggerCenterY - cardCenterY;
+        // Clamp arrow offset to ensure it stays within card boundaries.
+        // Arrow should be at least halfArrowWidth (7px) from the card edges.
+        const maxArrowOffsetX = halfContentWidth - halfArrowWidth;
+        const maxArrowOffsetY = halfContentHeight - halfArrowWidth;
+        if (appliedSide === 'top' || appliedSide === 'bottom') {
+            arrowOffsetX = Math.max(-maxArrowOffsetX, Math.min(arrowOffsetX, maxArrowOffsetX));
+        }
+        if (appliedSide === 'left' || appliedSide === 'right') {
+            arrowOffsetY = Math.max(-maxArrowOffsetY, Math.min(arrowOffsetY, maxArrowOffsetY));
+        }
+        const arrowOffset = {
+            x: arrowOffsetX,
+            y: arrowOffsetY,
+        };
+        return { origin, contentSize, side: appliedSide, arrowOffset };
+    }
+    useEffect(() => {
+        document.addEventListener('scroll', updateBounds, true);
+        window.addEventListener('resize', updateBounds);
+        return () => {
+            document.removeEventListener('scroll', updateBounds, true);
+            window.removeEventListener('resize', updateBounds);
+        };
+    }, []);
+    function resetDestructiveTimeouts() {
+        if (activeTimeout.current)
+            clearTimeout(activeTimeout.current);
+        if (persistingTimeout.current)
+            clearTimeout(persistingTimeout.current);
+        if (openTimeout.current)
+            clearTimeout(openTimeout.current);
+    }
+    function attemptDeactivate() {
+        if (activeTimeout.current)
+            clearTimeout(activeTimeout.current);
+        activeTimeout.current = setTimeout(() => {
+            if (activeId.current !== id)
+                return;
+            setActiveId(null);
+        }, inactiveTimeoutMs);
+    }
+    function attemptPersist() {
+        setPersisting(true);
+        if (persistingTimeout.current)
+            clearTimeout(persistingTimeout.current);
+        persistingTimeout.current = setTimeout(() => {
+            setPersisting(false);
+        }, PERSIST_TIMEOUT_MS);
+    }
+    function onMouseEnter() {
+        resetDestructiveTimeouts();
+        setHoveredId(id);
+        setLocalHover(true);
+    }
+    function onMouseLeave() {
+        setLocalHover(false);
+        attemptDeactivate();
+        attemptPersist();
+    }
+    useEffect(() => {
+        // close instantly
+        if (hide) {
+            setLocalHover(false);
+            setActiveId(null);
+        }
+    }, [hide, setActiveId]);
+    function handleClick(e) {
+        // Close if clicking a link. We assume we want the card to disappear if navigating.
+        if (e.target instanceof HTMLElement && e.target.closest('a[href]')) {
+            onMouseLeave();
+        }
+    }
+    const Comp = asChild ? SlotRoot : 'div';
+    return (_jsxs(Comp, { className: cn('inline-flex cursor-pointer flex-[0_1_auto] overflow-hidden', className), onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave, onClick: handleClick, ref: triggerRef, children: [_jsx(Slottable, { children: children }), portalRef?.current && (localHover || persisting)
+                ? createPortal(_jsx("div", { className: cn('absolute top-0 p-3 left-0 max-w-max transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none', skipTransition && '!transition-none'), ref: contentRef, style: {
+                        ...(noPadding ? { padding: 0 } : {}),
+                        pointerEvents: rootVisible && visible && !ignoreCardPointerEvents
+                            ? 'all'
+                            : 'none',
+                    }, children: _jsx("div", { className: cn('min-w-max transition-all duration-150 ease-[easing-function:cubic-bezier(0.3,_0.57,_0.07,_0.95)] will-change-[transform,width,height] motion-reduce:!transition-none', skipTransition
+                            ? '!transition-none'
+                            : 'transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none'), ref: contentMeasureRef, style: {
+                            opacity: Number(visible),
+                        }, children: content }) }, id), portalRef.current)
+                : null] }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-card.js","sourceRoot":"","sources":["../../../src/components/ui/context-card.tsx"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport { Root as SlotRoot, Slottable } from '@radix-ui/react-slot';\nimport type { JSX, MutableRefObject, ReactNode, RefObject } from 'react';\nimport {\n  createContext,\n  useContext,\n  useEffect,\n  useId,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { createPortal } from 'react-dom';\nimport useMeasure from 'react-use-measure';\nimport { useReducedMotion } from '../../hooks/use-reduced-motion';\nimport { cn } from '../../lib/utils';\n\nconst INACTIVE_TIMEOUT_MS = 250;\nconst ENTER_DELAY_MS = 0;\nconst OPEN_DELAY_MS = 150;\nconst MAX_TRANSITION_DISTANCE_PX = 150;\nconst MAX_OVERLAP_FOR_TRANSITION_PERCENT = 100;\nconst PERSIST_TIMEOUT_MS = 1000;\n\ninterface Point {\n  x: number;\n  y: number;\n}\n\ninterface ContextCardData {\n  id: string;\n  origin: Point;\n  contentSize: { width: number; height: number };\n  side: Side;\n  arrowOffset: Point;\n}\n\ntype NullString = string | null;\n\ninterface ContextCardContextType {\n  rootOrigin: Point;\n  rootBounds: { width: number; height: number };\n  portalRef: RefObject<HTMLDivElement | null>;\n  activeId: RefObject<NullString | null>;\n  setActiveId: (id: NullString) => void;\n  hoveredId: NullString;\n  setHoveredId: (id: NullString) => void;\n  updateActiveContextCard: (update: ContextCardData | null) => void;\n  skipTransition: boolean;\n  rootVisible: boolean;\n  distanceFromLast: number;\n  lastOrigin: Point | null;\n  /** Whether a real {@link ContextCardProvider} is mounted above this consumer. */\n  isProvided: boolean;\n}\n\nconst ContextCardContext = createContext<ContextCardContextType>({\n  rootOrigin: { x: 0, y: 0 },\n  rootBounds: { width: 0, height: 0 },\n  portalRef: null as unknown as RefObject<HTMLDivElement | null>,\n  activeId: null as unknown as MutableRefObject<string | null>,\n  setActiveId: () => void 0,\n  hoveredId: null,\n  setHoveredId: () => void 0,\n  updateActiveContextCard: () => void 0,\n  skipTransition: false,\n  rootVisible: false,\n  distanceFromLast: 0,\n  lastOrigin: null,\n  isProvided: false,\n});\nContextCardContext.displayName = 'ContextCardContext';\n\n/**\n * Returns whether the current subtree is wrapped in a {@link ContextCardProvider}.\n */\nexport function useHasContextCardProvider(): boolean {\n  return useContext(ContextCardContext).isProvided;\n}\n\nfunction usePrevious<T>(value: T): T | null {\n  const ref = useRef<T | null>(null);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref.current;\n}\n\nfunction isRefObject(\n  value: HTMLElement | RefObject<HTMLElement | null> | null | undefined\n): value is RefObject<HTMLElement | null> {\n  return value !== null && value !== undefined && 'current' in value;\n}\n\n/**\n * Provides shared state and a portal container for {@link ContextCardTrigger}\n * components. Must wrap any tree containing triggers; manages positioning,\n * visibility transitions, and the animated arrow tip across all cards.\n */\nexport function ContextCardProvider({\n  children,\n  portalTarget,\n}: {\n  children: ReactNode;\n  /** Custom container for the portal. Accepts either an element or a ref. */\n  portalTarget?: HTMLElement | RefObject<HTMLElement | null> | null;\n}): ReactNode {\n  const [isMounted, setIsMounted] = useState(false);\n  useEffect(() => setIsMounted(true), []);\n  const resolvedPortalTarget = isRefObject(portalTarget)\n    ? portalTarget.current\n    : portalTarget;\n  const [ref, bounds] = useMeasure();\n  const portalRef = useRef<HTMLDivElement | null>(null);\n  const [activeContextCard, setActiveContextCard] =\n    useState<ContextCardData | null>(null);\n  const [visible, setVisible] = useState(false);\n  const [hoveredId, setHoveredId] = useState<NullString>(null);\n  const activeId = useRef<NullString>(null);\n\n  function setActiveId(id: NullString): void {\n    activeId.current = id;\n    setVisible(id !== null);\n  }\n  const updateActiveContextCard = (update: ContextCardData | null): void => {\n    if (update?.id !== activeId.current && update !== null) return;\n    setActiveContextCard(update);\n  };\n\n  const BORDER_WIDTH = 1;\n\n  const activeBounds = useMemo(() => {\n    if (!activeContextCard)\n      return {\n        width: 0,\n        height: 0,\n        x: 0,\n        y: 0,\n        side: 'top' as Side,\n        arrowOffset: { x: 0, y: 0 },\n      };\n    return {\n      width: activeContextCard.contentSize.width + BORDER_WIDTH * 2,\n      height: activeContextCard.contentSize.height + BORDER_WIDTH * 2,\n      x: activeContextCard.origin.x,\n      y: activeContextCard.origin.y,\n      side: activeContextCard.side,\n      arrowOffset: activeContextCard.arrowOffset,\n    };\n  }, [activeContextCard]);\n\n  const lastBounds = usePrevious(activeBounds);\n  const lastId = usePrevious(activeId.current);\n\n  const percentOverlapFromLast = useMemo(() => {\n    if (!lastBounds) return 0;\n\n    const overlapLeft = Math.max(activeBounds.x, lastBounds.x);\n    const overlapRight = Math.min(\n      activeBounds.x + activeBounds.width,\n      lastBounds.x + lastBounds.width\n    );\n    const overlapTop = Math.max(activeBounds.y, lastBounds.y);\n    const overlapBottom = Math.min(\n      activeBounds.y + activeBounds.height,\n      lastBounds.y + lastBounds.height\n    );\n\n    if (overlapLeft < overlapRight && overlapTop < overlapBottom) {\n      const overlapArea =\n        (overlapRight - overlapLeft) * (overlapBottom - overlapTop);\n\n      const activeBoundsArea = activeBounds.width * activeBounds.height;\n\n      if (activeBoundsArea === 0) return 0;\n\n      return (overlapArea / activeBoundsArea) * 100;\n    }\n\n    return 0;\n  }, [activeBounds, lastBounds]);\n\n  const distanceFromLast = useMemo(\n    () =>\n      Math.sqrt(\n        ((lastBounds?.x ?? 0) - activeBounds.x) ** 2 +\n          ((lastBounds?.y ?? 0) - activeBounds.y) ** 2\n      ),\n    [activeBounds.x, activeBounds.y, lastBounds?.x, lastBounds?.y]\n  );\n\n  const lastOrigin = useMemo(() => {\n    if (!lastBounds) return null;\n    return {\n      x: lastBounds.x - activeBounds.x,\n      y: lastBounds.y - activeBounds.y,\n    };\n  }, [activeBounds, lastBounds]);\n\n  const [isScrolling, setIsScrolling] = useState(false);\n  const skipTransition = useMemo(\n    () =>\n      distanceFromLast > MAX_TRANSITION_DISTANCE_PX ||\n      percentOverlapFromLast > MAX_OVERLAP_FOR_TRANSITION_PERCENT ||\n      lastId === null ||\n      isScrolling,\n    [distanceFromLast, isScrolling, lastId, percentOverlapFromLast]\n  );\n\n  useEffect(() => {\n    let isScrollingTimeout: ReturnType<typeof setTimeout> | null = null;\n\n    const onScroll = (): void => {\n      if (isScrollingTimeout) window.clearTimeout(isScrollingTimeout);\n\n      isScrollingTimeout = setTimeout(() => {\n        setIsScrolling(false);\n      }, 66);\n\n      if (!isScrolling) {\n        setIsScrolling(true);\n      }\n    };\n\n    document.addEventListener('scroll', onScroll, true);\n\n    return () => {\n      document.removeEventListener('scroll', onScroll, true);\n    };\n  }, [isScrolling]);\n\n  const contextValue = useMemo(\n    () => ({\n      updateActiveContextCard,\n      rootOrigin: { ...activeBounds },\n      rootBounds: bounds,\n      portalRef,\n      setActiveId,\n      activeId,\n      setHoveredId,\n      hoveredId,\n      skipTransition,\n      rootVisible: visible,\n      distanceFromLast,\n      lastOrigin,\n      isProvided: true,\n    }),\n    [\n      activeBounds,\n      bounds,\n      hoveredId,\n      skipTransition,\n      visible,\n      distanceFromLast,\n      lastOrigin,\n    ]\n  );\n\n  return (\n    <ContextCardContext.Provider value={contextValue}>\n      {children}\n      {isMounted\n        ? createPortal(\n            <div\n              className=\"w-full h-full inset-0 fixed pointer-events-none z-[100000]\"\n              ref={ref}\n            >\n              <div\n                className=\"min-w-max transition-all duration-150 ease-[easing-function:cubic-bezier(0.3,_0.57,_0.07,_0.95)] will-change-[transform,width,height] motion-reduce:!transition-none\"\n                style={{\n                  opacity: visible ? 1 : 0,\n                }}\n              >\n                <div\n                  className={cn(\n                    'absolute bg-background-100 bg-clip-padding rounded-[6px] overflow-visible pointer-events-none z-[1000000] shadow-[var(--ds-shadow-tooltip),0_0_0_1px_var(--ds-background-100)] w-fit [--context-card-tip-stroke:#DBDBDB] dark-theme:[--context-card-tip-stroke:#252525]',\n                    skipTransition\n                      ? '!transition-none'\n                      : 'transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none'\n                  )}\n                  data-skip-transition={skipTransition}\n                  style={{\n                    transform: `translate(${activeBounds.x}px,${activeBounds.y}px)`,\n                    width: activeBounds.width,\n                    height: activeBounds.height,\n                  }}\n                >\n                  <div\n                    className={cn(\n                      'w-[14px] h-[7px] absolute grid place-content-center z-[999999999] origin-center',\n                      {\n                        'top-full -translate-x-1/2 rotate-0':\n                          activeBounds.side === 'top',\n                        'right-full -translate-y-1/2 rotate-90 -mr-[3.5px]':\n                          activeBounds.side === 'right',\n                        'bottom-full -translate-x-1/2 rotate-180':\n                          activeBounds.side === 'bottom',\n                        'left-full -translate-y-1/2 rotate-[270deg] -ml-[3.5px]':\n                          activeBounds.side === 'left',\n                      },\n                      skipTransition\n                        ? '!transition-none'\n                        : 'transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none'\n                    )}\n                    style={{\n                      ...(activeBounds.side === 'top' ||\n                      activeBounds.side === 'bottom'\n                        ? {\n                            left: `calc(50% + ${activeBounds.arrowOffset.x}px)`,\n                          }\n                        : {\n                            top: `calc(50% + ${activeBounds.arrowOffset.y}px)`,\n                          }),\n                    }}\n                    data-skip-transition={skipTransition}\n                    data-side={activeBounds.side}\n                  >\n                    <svg\n                      width=\"14\"\n                      height=\"7\"\n                      viewBox=\"0 0 14 7\"\n                      fill=\"none\"\n                      xmlns=\"http://www.w3.org/2000/svg\"\n                      aria-hidden=\"true\"\n                    >\n                      <g clipPath=\"url(#context-card-tip-clip)\">\n                        <path\n                          d=\"M15 -0.5V0.5H12.9834L12.8184 0.508789C12.4377 0.550822 12.0853 0.738056 11.8359 1.03418L8.53027 4.95996C7.73114 5.90893 6.26886 5.90892 5.46973 4.95996L2.16406 1.03418C1.87905 0.695733 1.45907 0.5 1.0166 0.5H-1V-0.5H15Z\"\n                          fill=\"var(--ds-background-100)\"\n                          style={{\n                            fill: 'var(--ds-background-100)',\n                            fillOpacity: 1,\n                            stroke: 'var(--context-card-tip-stroke)',\n                            strokeOpacity: 1,\n                          }}\n                        />\n                      </g>\n                      <defs>\n                        <clipPath id=\"context-card-tip-clip\">\n                          <rect\n                            width=\"14\"\n                            height=\"7\"\n                            fill=\"white\"\n                            style={{ fill: 'white', fillOpacity: 1 }}\n                          />\n                        </clipPath>\n                      </defs>\n                    </svg>\n                  </div>\n                  <div ref={portalRef} />\n                </div>\n              </div>\n            </div>,\n            resolvedPortalTarget ?? document.body\n          )\n        : null}\n    </ContextCardContext.Provider>\n  );\n}\n\nexport type Side = 'top' | 'bottom' | 'left' | 'right';\nexport type Align = 'start' | 'center' | 'end';\n\n/** Props for the {@link ContextCardTrigger} component. */\nexport interface ContextCardTriggerProps\n  extends Omit<React.HTMLAttributes<HTMLDivElement>, 'content'> {\n  /** The content rendered inside the context card popup. */\n  content: ReactNode;\n  /** Which side of the trigger to display the card. Defaults to `\"right\"`. */\n  side?: Side;\n  /** Alignment of the card relative to the trigger. Defaults to `\"center\"`. */\n  align?: Align;\n  /** Distance in pixels between the trigger and the card. Defaults to `16`. */\n  sideOffset?: number;\n  /** Offset in pixels along the alignment axis. Defaults to `0`. */\n  alignOffset?: number;\n  /** Whether to disable pointer events on the card content. */\n  ignoreCardPointerEvents?: boolean;\n  /** Whether to remove default padding from the card content. */\n  noPadding?: boolean;\n  /** Whether the trigger uses the Slot pattern to merge props onto its child. */\n  asChild?: boolean;\n  /** Can be used to hide the card when needed. */\n  hide?: boolean;\n  /** Time in milliseconds before the card is dismissed after mouse leaves. */\n  inactiveTimeoutMs?: number;\n}\n\n/**\n * Displays a floating context card on hover with viewport-aware collision\n * detection and animated position transitions between triggers in the same\n * {@link ContextCardProvider}. Persists briefly after mouse leave.\n */\nexport function ContextCardTrigger({\n  content,\n  children,\n  side = 'right',\n  align = 'center',\n  sideOffset = 16,\n  alignOffset = 0,\n  ignoreCardPointerEvents = false,\n  noPadding,\n  asChild,\n  className,\n  hide,\n  inactiveTimeoutMs = INACTIVE_TIMEOUT_MS,\n}: ContextCardTriggerProps): JSX.Element {\n  const triggerRef = useRef<HTMLDivElement>(null);\n  const contentRef = useRef<HTMLDivElement>(null);\n  const [contentMeasureRef, contentMeasureBounds] = useMeasure();\n  const {\n    portalRef,\n    updateActiveContextCard,\n    activeId,\n    setActiveId,\n    hoveredId,\n    setHoveredId,\n    skipTransition,\n    rootVisible,\n  } = useContext(ContextCardContext);\n  const id = useId();\n\n  useEffect(() => {\n    return () => {\n      // Only clear the shared active card if this trigger was the active one;\n      // otherwise an unmounting inactive trigger would hide another trigger's card.\n      if (activeId.current === id) {\n        setActiveId(null);\n      }\n    };\n  }, []);\n\n  const reduceMotion = useReducedMotion();\n\n  const [localHover, setLocalHover] = useState(false);\n  const [persisting, setPersisting] = useState(false);\n  const [visible, setVisible] = useState(false);\n\n  const activeTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const persistingTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const openTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  useEffect(() => {\n    if (\n      localHover &&\n      contentMeasureBounds.width > 0 &&\n      contentMeasureBounds.height > 0\n    ) {\n      if (openTimeout.current) clearTimeout(openTimeout.current);\n      openTimeout.current = setTimeout(\n        () => {\n          setActiveId(id);\n          updateBounds();\n        },\n        rootVisible ? 0 : OPEN_DELAY_MS\n      );\n    }\n    return () => {\n      if (openTimeout.current) clearTimeout(openTimeout.current);\n    };\n  }, [localHover, contentMeasureBounds]);\n\n  const enterTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  useEffect(() => {\n    if (enterTimeout.current) clearTimeout(enterTimeout.current);\n    if (hoveredId !== id) {\n      // Exits are instant\n      setVisible(false);\n    } else {\n      // Enters can be delayed unless we wish to script the transition\n      enterTimeout.current = setTimeout(\n        () => {\n          setVisible(true);\n        },\n        reduceMotion || skipTransition ? 0 : ENTER_DELAY_MS\n      );\n    }\n  }, [hoveredId, id, reduceMotion, skipTransition]);\n\n  function updateBounds(): void {\n    if (!contentRef.current) return;\n    const bounds = computeBounds();\n    updateActiveContextCard({ id, ...bounds });\n  }\n\n  function computeBounds(sideOverride?: Side): {\n    origin: Point;\n    contentSize: { width: number; height: number };\n    side: Side;\n    arrowOffset: Point;\n  } {\n    if (!triggerRef.current) throw new Error('Trigger not found');\n    if (!contentRef.current) throw new Error('Content not found');\n    const appliedSide = sideOverride ?? side;\n    const triggerRect = triggerRef.current.getBoundingClientRect();\n    const contentRect = contentRef.current.getBoundingClientRect();\n    contentRef.current.style.width = 'max-content';\n    contentRef.current.style.position = 'absolute';\n    const contentSize = {\n      width: Math.max(contentRect.width, contentRef.current.offsetWidth),\n      height: contentRect.height,\n    };\n\n    let origin: Point;\n\n    const arrowWidth = 14;\n    const halfArrowWidth = arrowWidth / 2;\n    const halfTriggerWidth = triggerRect.width / 2;\n    const halfTriggerHeight = triggerRect.height / 2;\n    const halfContentWidth = contentSize.width / 2;\n    const halfContentHeight = contentSize.height / 2;\n\n    const top = triggerRect.top;\n    const left = triggerRect.left;\n\n    let alignX = left + halfTriggerWidth - halfContentWidth + alignOffset;\n    if (align === 'start') alignX = left + alignOffset;\n    if (align === 'end')\n      alignX = left + triggerRect.width - contentRect.width + alignOffset;\n\n    let alignY = top + halfTriggerHeight - halfContentHeight + alignOffset;\n    if (align === 'start') alignY = top + alignOffset;\n    if (align === 'end')\n      alignY = top + triggerRect.height - contentRect.height + alignOffset;\n\n    switch (appliedSide) {\n      case 'top':\n        origin = {\n          x: alignX,\n          y: top - contentRect.height - sideOffset,\n        };\n        break;\n      case 'right':\n        origin = {\n          x: left + triggerRect.width + sideOffset,\n          y: alignY,\n        };\n        break;\n      case 'bottom':\n        origin = {\n          x: alignX,\n          y: top + triggerRect.height + sideOffset,\n        };\n        break;\n      case 'left':\n        origin = {\n          x: left - contentRect.width - sideOffset,\n          y: alignY,\n        };\n        break;\n      default: {\n        const _exhaustive: never = appliedSide;\n        throw new Error(`Unknown side: ${String(_exhaustive)}`);\n      }\n    }\n\n    const viewportWidth = document.documentElement.clientWidth;\n    const viewportHeight = document.documentElement.clientHeight;\n\n    const isOffscreenLeft = origin.x < 0;\n    const isOffscreenRight = origin.x + contentRect.width > viewportWidth;\n    const isOffscreenTop = origin.y < 0;\n    const isOffscreenBottom = origin.y + contentRect.height > viewportHeight;\n\n    if (!sideOverride) {\n      const spaceAbove = top;\n      const spaceBelow = viewportHeight - (top + triggerRect.height);\n      const spaceLeft = left;\n      const spaceRight = viewportWidth - (left + triggerRect.width);\n\n      if (side === 'top' && isOffscreenTop && spaceBelow > spaceAbove) {\n        return computeBounds('bottom');\n      }\n      if (side === 'bottom' && isOffscreenBottom && spaceAbove > spaceBelow) {\n        return computeBounds('top');\n      }\n\n      if (side === 'right' && isOffscreenRight && spaceLeft > spaceRight) {\n        return computeBounds('left');\n      }\n      if (side === 'left' && isOffscreenLeft && spaceRight > spaceLeft) {\n        return computeBounds('right');\n      }\n\n      if (\n        (side === 'top' || side === 'bottom') &&\n        isOffscreenLeft &&\n        spaceRight > contentRect.width\n      ) {\n        return computeBounds('right');\n      }\n      if (\n        (side === 'top' || side === 'bottom') &&\n        isOffscreenRight &&\n        spaceLeft > contentRect.width\n      ) {\n        return computeBounds('left');\n      }\n\n      if (\n        (side === 'left' || side === 'right') &&\n        isOffscreenTop &&\n        spaceBelow > contentRect.height\n      ) {\n        return computeBounds('bottom');\n      }\n      if (\n        (side === 'left' || side === 'right') &&\n        isOffscreenBottom &&\n        spaceAbove > contentRect.height\n      ) {\n        return computeBounds('top');\n      }\n    }\n\n    const viewportPadding = 8;\n    if (appliedSide === 'left' || appliedSide === 'right') {\n      origin.y = Math.max(\n        viewportPadding,\n        Math.min(\n          origin.y,\n          viewportHeight - contentSize.height - viewportPadding\n        )\n      );\n    } else {\n      origin.x = Math.max(\n        viewportPadding,\n        Math.min(origin.x, viewportWidth - contentSize.width - viewportPadding)\n      );\n    }\n\n    // Always constrain Y position within viewport bounds\n    origin.y = Math.max(\n      viewportPadding,\n      Math.min(origin.y, viewportHeight - contentSize.height - viewportPadding)\n    );\n\n    const triggerCenterX = left + halfTriggerWidth;\n    const triggerCenterY = top + halfTriggerHeight;\n    const cardCenterX = origin.x + contentSize.width / 2;\n    const cardCenterY = origin.y + contentSize.height / 2;\n\n    let arrowOffsetX = triggerCenterX - cardCenterX;\n    let arrowOffsetY = triggerCenterY - cardCenterY;\n\n    // Clamp arrow offset to ensure it stays within card boundaries.\n    // Arrow should be at least halfArrowWidth (7px) from the card edges.\n    const maxArrowOffsetX = halfContentWidth - halfArrowWidth;\n    const maxArrowOffsetY = halfContentHeight - halfArrowWidth;\n\n    if (appliedSide === 'top' || appliedSide === 'bottom') {\n      arrowOffsetX = Math.max(\n        -maxArrowOffsetX,\n        Math.min(arrowOffsetX, maxArrowOffsetX)\n      );\n    }\n\n    if (appliedSide === 'left' || appliedSide === 'right') {\n      arrowOffsetY = Math.max(\n        -maxArrowOffsetY,\n        Math.min(arrowOffsetY, maxArrowOffsetY)\n      );\n    }\n\n    const arrowOffset = {\n      x: arrowOffsetX,\n      y: arrowOffsetY,\n    };\n\n    return { origin, contentSize, side: appliedSide, arrowOffset };\n  }\n\n  useEffect(() => {\n    document.addEventListener('scroll', updateBounds, true);\n    window.addEventListener('resize', updateBounds);\n    return () => {\n      document.removeEventListener('scroll', updateBounds, true);\n      window.removeEventListener('resize', updateBounds);\n    };\n  }, []);\n\n  function resetDestructiveTimeouts(): void {\n    if (activeTimeout.current) clearTimeout(activeTimeout.current);\n    if (persistingTimeout.current) clearTimeout(persistingTimeout.current);\n    if (openTimeout.current) clearTimeout(openTimeout.current);\n  }\n\n  function attemptDeactivate(): void {\n    if (activeTimeout.current) clearTimeout(activeTimeout.current);\n    activeTimeout.current = setTimeout(() => {\n      if (activeId.current !== id) return;\n      setActiveId(null);\n    }, inactiveTimeoutMs);\n  }\n\n  function attemptPersist(): void {\n    setPersisting(true);\n    if (persistingTimeout.current) clearTimeout(persistingTimeout.current);\n    persistingTimeout.current = setTimeout(() => {\n      setPersisting(false);\n    }, PERSIST_TIMEOUT_MS);\n  }\n\n  function onMouseEnter(): void {\n    resetDestructiveTimeouts();\n    setHoveredId(id);\n    setLocalHover(true);\n  }\n\n  function onMouseLeave(): void {\n    setLocalHover(false);\n    attemptDeactivate();\n    attemptPersist();\n  }\n\n  useEffect(() => {\n    // close instantly\n    if (hide) {\n      setLocalHover(false);\n      setActiveId(null);\n    }\n  }, [hide, setActiveId]);\n\n  function handleClick(e: React.MouseEvent): void {\n    // Close if clicking a link. We assume we want the card to disappear if navigating.\n    if (e.target instanceof HTMLElement && e.target.closest('a[href]')) {\n      onMouseLeave();\n    }\n  }\n\n  const Comp = asChild ? SlotRoot : 'div';\n\n  return (\n    <Comp\n      className={cn(\n        'inline-flex cursor-pointer flex-[0_1_auto] overflow-hidden',\n        className\n      )}\n      onMouseEnter={onMouseEnter}\n      onMouseLeave={onMouseLeave}\n      onClick={handleClick}\n      ref={triggerRef}\n    >\n      <Slottable>{children}</Slottable>\n      {portalRef?.current && (localHover || persisting)\n        ? createPortal(\n            <div\n              className={cn(\n                'absolute top-0 p-3 left-0 max-w-max transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none',\n                skipTransition && '!transition-none'\n              )}\n              key={id}\n              ref={contentRef}\n              style={{\n                ...(noPadding ? { padding: 0 } : {}),\n                pointerEvents:\n                  rootVisible && visible && !ignoreCardPointerEvents\n                    ? 'all'\n                    : 'none',\n              }}\n            >\n              <div\n                className={cn(\n                  'min-w-max transition-all duration-150 ease-[easing-function:cubic-bezier(0.3,_0.57,_0.07,_0.95)] will-change-[transform,width,height] motion-reduce:!transition-none',\n                  skipTransition\n                    ? '!transition-none'\n                    : 'transition-[transform,width,height] duration-250 ease-[easing-function:cubic-bezier(0.29,0.31,0.05,0.96)] will-change-[transform,width,height] motion-reduce:!transition-none'\n                )}\n                ref={contentMeasureRef}\n                style={{\n                  opacity: Number(visible),\n                }}\n              >\n                {content}\n              </div>\n            </div>,\n            portalRef.current\n          )\n        : null}\n    </Comp>\n  );\n}\n"]}

package/dist/components/ui/timestamp-tooltip.d.ts

@@ -1,6 +1,39 @@
 import type { ReactNode } from 'react';
-export declare function TimestampTooltip({ date, children, }: {
+import { type ContextCardTriggerProps } from './context-card';
+/**
+ * Detailed relative time string that auto-updates every second
+ * (e.g. "2 hours, 15 minutes, 30 seconds ago"). Used inside the hover card.
+ */
+export declare function useTimeAgo(date: number): string;
+/**
+ * Short relative time string that auto-updates every minute
+ * (e.g. "3 days ago", "5 hours ago"). Returns an empty string if `date` is
+ * nullish.
+ */
+export declare function useShortTimeAgo(date: number | null | undefined): string;
+type RelativeTimeCardProps = Omit<ContextCardTriggerProps, 'content' | 'children'> & {
+    /** Timestamp in milliseconds to display as a relative time. */
+    date?: number | null;
+    /** Custom content to render instead of the default relative time text. */
+    children?: ReactNode;
+};
+/**
+ * Relative time label that reveals a context card with detailed UTC and local
+ * timestamps on hover. Renders a default short relative time label (e.g.
+ * "3 days ago") when `children` is omitted; renders just the children without
+ * the hover card when `date` is nullish.
+ */
+export declare function RelativeTimeCard({ date, children: _children, ...props }: RelativeTimeCardProps): ReactNode;
+/**
+ * Wraps an already-formatted timestamp display with a relative-time hover
+ * card. Self-mounts a {@link ContextCardProvider} when one isn't already
+ * present so it works anywhere, but shares a provider (enabling the animated
+ * card morph between adjacent timestamps) when rendered inside one.
+ */
+export declare function TimestampTooltip({ date, children, side, }: {
     date: number | Date | string | null | undefined;
     children: ReactNode;
+    side?: ContextCardTriggerProps['side'];
 }): ReactNode;
+export {};
 //# sourceMappingURL=timestamp-tooltip.d.ts.map

package/dist/components/ui/timestamp-tooltip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp-tooltip.d.ts","sourceRoot":"","sources":["../../../src/components/ui/timestamp-tooltip.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiQvC,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,QAAQ,EAAE,SAAS,CAAC;CACrB,GAAG,SAAS,CA4DZ"}
+{"version":3,"file":"timestamp-tooltip.d.ts","sourceRoot":"","sources":["../../../src/components/ui/timestamp-tooltip.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAGL,KAAK,uBAAuB,EAE7B,MAAM,gBAAgB,CAAC;AAoCxB;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgB/C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAgCvE;AAsFD,KAAK,qBAAqB,GAAG,IAAI,CAC/B,uBAAuB,EACvB,SAAS,GAAG,UAAU,CACvB,GAAG;IACF,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,EAAE,SAAS,EACnB,GAAG,KAAK,EACT,EAAE,qBAAqB,GAAG,SAAS,CAcnC;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,EACR,IAAY,GACb,EAAE;IACD,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChD,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,CAAC,EAAE,uBAAuB,CAAC,MAAM,CAAC,CAAC;CACxC,GAAG,SAAS,CAmBZ"}