datocms-react-ui 2.1.0-alpha.0 → 2.1.0-alpha.2

package/dist/esm/Tooltip/TooltipDelayGroup/index.d.ts

@@ -0,0 +1,118 @@
+import * as React from 'react';
+export declare type TooltipDelayGroupProps = {
+    children?: React.ReactNode;
+    /** The delay in milliseconds before a tooltip opens on hover (default: 1000) */
+    delay?: number | {
+        open?: number;
+        close?: number;
+    };
+    /** How long to wait in milliseconds before closing the group (default: 0) */
+    timeoutMs?: number;
+};
+/**
+ * TooltipDelayGroup synchronizes hover delays across multiple tooltips.
+ *
+ * When tooltips are wrapped in a delay group, hovering over the first tooltip
+ * will use the configured delay, but subsequent tooltips in the group will
+ * open instantly. This creates a smoother UX when users explore multiple
+ * interactive elements with tooltips.
+ *
+ * @example Basic delay group
+ *
+ * Group multiple tooltips together so they open instantly after the first one:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <TooltipDelayGroup delay={500}>
+ *     <div style={{ display: 'flex', gap: 'var(--spacing-m)' }}>
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button leftIcon={<SaveIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Save changes</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button leftIcon={<UndoIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Undo</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button leftIcon={<RedoIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Redo</TooltipContent>
+ *       </Tooltip>
+ *     </div>
+ *   </TooltipDelayGroup>
+ * </Canvas>;
+ * ```
+ *
+ * @example Custom delay configuration
+ *
+ * Configure different delays for opening and closing tooltips in the group:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <TooltipDelayGroup delay={{ open: 800, close: 200 }} timeoutMs={500}>
+ *     <div style={{ display: 'flex', gap: 'var(--spacing-s)' }}>
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button>Action 1</Button>
+ *         </TooltipTrigger>
+ *         <TooltipContent>First action</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button>Action 2</Button>
+ *         </TooltipTrigger>
+ *         <TooltipContent>Second action</TooltipContent>
+ *       </Tooltip>
+ *     </div>
+ *   </TooltipDelayGroup>
+ * </Canvas>;
+ * ```
+ *
+ * @example Toolbar with grouped tooltips
+ *
+ * Create a toolbar where hovering between tools feels instant and responsive:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <TooltipDelayGroup delay={600}>
+ *     <div style={{
+ *       display: 'flex',
+ *       gap: 'var(--spacing-xs)',
+ *       padding: 'var(--spacing-s)',
+ *       borderRadius: 'var(--border-radius-m)',
+ *       backgroundColor: 'var(--light-bg-color)'
+ *     }}>
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button buttonSize="s" leftIcon={<BoldIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Bold</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button buttonSize="s" leftIcon={<ItalicIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Italic</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button buttonSize="s" leftIcon={<UnderlineIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Underline</TooltipContent>
+ *       </Tooltip>
+ *     </div>
+ *   </TooltipDelayGroup>
+ * </Canvas>;
+ * ```
+ */
+export declare function TooltipDelayGroup({ children, delay, timeoutMs, }: TooltipDelayGroupProps): JSX.Element;

package/dist/esm/Tooltip/TooltipDelayGroup/index.js

@@ -0,0 +1,113 @@
+import { FloatingDelayGroup } from '@floating-ui/react';
+import * as React from 'react';
+/**
+ * TooltipDelayGroup synchronizes hover delays across multiple tooltips.
+ *
+ * When tooltips are wrapped in a delay group, hovering over the first tooltip
+ * will use the configured delay, but subsequent tooltips in the group will
+ * open instantly. This creates a smoother UX when users explore multiple
+ * interactive elements with tooltips.
+ *
+ * @example Basic delay group
+ *
+ * Group multiple tooltips together so they open instantly after the first one:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <TooltipDelayGroup delay={500}>
+ *     <div style={{ display: 'flex', gap: 'var(--spacing-m)' }}>
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button leftIcon={<SaveIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Save changes</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button leftIcon={<UndoIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Undo</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button leftIcon={<RedoIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Redo</TooltipContent>
+ *       </Tooltip>
+ *     </div>
+ *   </TooltipDelayGroup>
+ * </Canvas>;
+ * ```
+ *
+ * @example Custom delay configuration
+ *
+ * Configure different delays for opening and closing tooltips in the group:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <TooltipDelayGroup delay={{ open: 800, close: 200 }} timeoutMs={500}>
+ *     <div style={{ display: 'flex', gap: 'var(--spacing-s)' }}>
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button>Action 1</Button>
+ *         </TooltipTrigger>
+ *         <TooltipContent>First action</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button>Action 2</Button>
+ *         </TooltipTrigger>
+ *         <TooltipContent>Second action</TooltipContent>
+ *       </Tooltip>
+ *     </div>
+ *   </TooltipDelayGroup>
+ * </Canvas>;
+ * ```
+ *
+ * @example Toolbar with grouped tooltips
+ *
+ * Create a toolbar where hovering between tools feels instant and responsive:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <TooltipDelayGroup delay={600}>
+ *     <div style={{
+ *       display: 'flex',
+ *       gap: 'var(--spacing-xs)',
+ *       padding: 'var(--spacing-s)',
+ *       borderRadius: 'var(--border-radius-m)',
+ *       backgroundColor: 'var(--light-bg-color)'
+ *     }}>
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button buttonSize="s" leftIcon={<BoldIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Bold</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button buttonSize="s" leftIcon={<ItalicIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Italic</TooltipContent>
+ *       </Tooltip>
+ *
+ *       <Tooltip>
+ *         <TooltipTrigger>
+ *           <Button buttonSize="s" leftIcon={<UnderlineIcon />} />
+ *         </TooltipTrigger>
+ *         <TooltipContent>Underline</TooltipContent>
+ *       </Tooltip>
+ *     </div>
+ *   </TooltipDelayGroup>
+ * </Canvas>;
+ * ```
+ */
+export function TooltipDelayGroup(_a) {
+    var children = _a.children, _b = _a.delay, delay = _b === void 0 ? 1000 : _b, _c = _a.timeoutMs, timeoutMs = _c === void 0 ? 0 : _c;
+    return (React.createElement(FloatingDelayGroup, { delay: delay, timeoutMs: timeoutMs }, children));
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/Tooltip/TooltipDelayGroup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Tooltip/TooltipDelayGroup/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAU/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAIT;QAHvB,QAAQ,cAAA,EACR,aAAY,EAAZ,KAAK,mBAAG,IAAI,KAAA,EACZ,iBAAa,EAAb,SAAS,mBAAG,CAAC,KAAA;IAEb,OAAO,CACL,oBAAC,kBAAkB,IAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,IACnD,QAAQ,CACU,CACtB,CAAC;AACJ,CAAC"}

package/dist/esm/Tooltip/TooltipTrigger/index.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+export declare type TooltipTriggerProps = {
+    children: React.ReactElement;
+};
+/**
+ * TooltipTrigger wraps the element that triggers the tooltip on hover/focus.
+ *
+ * The child must be a single React element that accepts ref and event handler props.
+ * Common triggers include buttons, icons, or other interactive elements.
+ *
+ * @example With Button component
+ *
+ * Wrap a button to show a tooltip when the user hovers over it:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <Tooltip>
+ *     <TooltipTrigger>
+ *       <Button>Hover for info</Button>
+ *     </TooltipTrigger>
+ *     <TooltipContent>
+ *       Additional information appears here
+ *     </TooltipContent>
+ *   </Tooltip>
+ * </Canvas>;
+ * ```
+ *
+ * @example With icon button
+ *
+ * Use tooltips with icon-only buttons to explain their purpose:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <Tooltip placement="bottom">
+ *     <TooltipTrigger>
+ *       <Button buttonSize="s" leftIcon={<InfoIcon />} />
+ *     </TooltipTrigger>
+ *     <TooltipContent>
+ *       Click for more details
+ *     </TooltipContent>
+ *   </Tooltip>
+ * </Canvas>;
+ * ```
+ */
+export declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipTriggerProps & React.RefAttributes<HTMLElement>>;

package/dist/esm/Tooltip/TooltipTrigger/index.js

@@ -0,0 +1,76 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useMergeRefs } from '@floating-ui/react';
+import * as React from 'react';
+import { useTooltipState } from '../utils';
+/**
+ * TooltipTrigger wraps the element that triggers the tooltip on hover/focus.
+ *
+ * The child must be a single React element that accepts ref and event handler props.
+ * Common triggers include buttons, icons, or other interactive elements.
+ *
+ * @example With Button component
+ *
+ * Wrap a button to show a tooltip when the user hovers over it:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <Tooltip>
+ *     <TooltipTrigger>
+ *       <Button>Hover for info</Button>
+ *     </TooltipTrigger>
+ *     <TooltipContent>
+ *       Additional information appears here
+ *     </TooltipContent>
+ *   </Tooltip>
+ * </Canvas>;
+ * ```
+ *
+ * @example With icon button
+ *
+ * Use tooltips with icon-only buttons to explain their purpose:
+ *
+ * ```js
+ * <Canvas ctx={ctx}>
+ *   <Tooltip placement="bottom">
+ *     <TooltipTrigger>
+ *       <Button buttonSize="s" leftIcon={<InfoIcon />} />
+ *     </TooltipTrigger>
+ *     <TooltipContent>
+ *       Click for more details
+ *     </TooltipContent>
+ *   </Tooltip>
+ * </Canvas>;
+ * ```
+ */
+export var TooltipTrigger = React.forwardRef(function TooltipTrigger(_a, propRef) {
+    var children = _a.children, props = __rest(_a, ["children"]);
+    var state = useTooltipState();
+    var childrenRef = children.ref;
+    var ref = useMergeRefs([state.refs.setReference, propRef, childrenRef]);
+    if (!React.isValidElement(children)) {
+        throw new Error('TooltipTrigger children must be a valid React element');
+    }
+    return React.cloneElement(children, state.getReferenceProps(__assign(__assign(__assign({ ref: ref }, props), children.props), { 'data-state': state.open ? 'open' : 'closed' })));
+});
+//# sourceMappingURL=index.js.map

package/dist/esm/Tooltip/TooltipTrigger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Tooltip/TooltipTrigger/index.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,IAAM,cAAc,GAAG,KAAK,CAAC,UAAU,CAG5C,SAAS,cAAc,CAAC,EAAsB,EAAE,OAAO;IAA7B,IAAA,QAAQ,cAAA,EAAK,KAAK,cAApB,YAAsB,CAAF;IAC5C,IAAM,KAAK,GAAG,eAAe,EAAE,CAAC;IAEhC,IAAM,WAAW,GAAI,QAAgB,CAAC,GAAG,CAAC;IAC1C,IAAM,GAAG,GAAG,YAAY,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;IAE1E,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;QACnC,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;KAC1E;IAED,OAAO,KAAK,CAAC,YAAY,CACvB,QAAQ,EACR,KAAK,CAAC,iBAAiB,8BACrB,GAAG,KAAA,IACA,KAAK,GACL,QAAQ,CAAC,KAAK,KACjB,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,IAC5C,CACH,CAAC;AACJ,CAAC,CAAC,CAAC"}

package/dist/esm/Tooltip/index.d.ts

@@ -0,0 +1,8 @@
+export { Tooltip } from './Tooltip';
+export type { TooltipProps } from './Tooltip';
+export { TooltipContent } from './TooltipContent';
+export type { TooltipContentProps } from './TooltipContent';
+export { TooltipDelayGroup } from './TooltipDelayGroup';
+export type { TooltipDelayGroupProps } from './TooltipDelayGroup';
+export { TooltipTrigger } from './TooltipTrigger';
+export type { TooltipTriggerProps } from './TooltipTrigger';

package/dist/esm/Tooltip/index.js

@@ -0,0 +1,5 @@
+export { Tooltip } from './Tooltip';
+export { TooltipContent } from './TooltipContent';
+export { TooltipDelayGroup } from './TooltipDelayGroup';
+export { TooltipTrigger } from './TooltipTrigger';
+//# sourceMappingURL=index.js.map

package/dist/esm/Tooltip/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Tooltip/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/esm/Tooltip/utils.d.ts

@@ -0,0 +1,166 @@
+import type { Placement } from '@floating-ui/react';
+import * as React from 'react';
+export declare function getSharedPortalRoot(): HTMLDivElement;
+export declare function releaseSharedPortalRoot(): void;
+export interface TooltipOptions {
+    /** Whether the tooltip is initially open (uncontrolled mode) */
+    initialOpen?: boolean;
+    /** Placement of the tooltip relative to its trigger */
+    placement?: Placement;
+    /** Controlled open state */
+    open?: boolean;
+    /** Callback when open state changes (controlled mode) */
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * Hook that manages tooltip state and positioning logic.
+ *
+ * This hook provides the core tooltip behavior including hover/focus detection,
+ * positioning, and accessibility features. Use this when you need full control
+ * over the tooltip structure.
+ *
+ * @example Basic tooltip hook usage
+ *
+ * Build a custom tooltip implementation using the hook directly for maximum flexibility:
+ *
+ * ```js
+ * function MyComponent() {
+ *   const tooltip = useTooltip({ placement: 'top' });
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         ref={tooltip.refs.setReference}
+ *         {...tooltip.getReferenceProps()}
+ *       >
+ *         Hover me
+ *       </button>
+ *
+ *       {tooltip.open && (
+ *         <div
+ *           ref={tooltip.refs.setFloating}
+ *           style={tooltip.floatingStyles}
+ *           {...tooltip.getFloatingProps()}
+ *         >
+ *           Tooltip content
+ *         </div>
+ *       )}
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @example Controlled tooltip
+ *
+ * Control the tooltip's open state programmatically for click-to-toggle behavior:
+ *
+ * ```js
+ * function ControlledTooltip() {
+ *   const [open, setOpen] = React.useState(false);
+ *   const tooltip = useTooltip({ open, onOpenChange: setOpen });
+ *
+ *   return (
+ *     <Canvas ctx={ctx}>
+ *       <button onClick={() => setOpen(!open)}>
+ *         Toggle tooltip
+ *       </button>
+ *     </Canvas>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTooltip({ initialOpen, placement, open: controlledOpen, onOpenChange: setControlledOpen, }?: TooltipOptions): {
+    placement: Placement;
+    strategy: import("@floating-ui/utils").Strategy;
+    middlewareData: import("@floating-ui/core").MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    elements: {
+        reference: import("@floating-ui/react-dom").ReferenceType | null;
+        floating: HTMLElement | null;
+    } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: import("@floating-ui/react").OpenChangeReason | undefined) => void;
+        events: import("@floating-ui/react").FloatingEvents;
+        dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+declare type ContextType = ReturnType<typeof useTooltip> | null;
+export declare const TooltipContext: React.Context<ContextType>;
+export declare const useTooltipState: () => {
+    placement: Placement;
+    strategy: import("@floating-ui/utils").Strategy;
+    middlewareData: import("@floating-ui/core").MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    elements: {
+        reference: import("@floating-ui/react-dom").ReferenceType | null;
+        floating: HTMLElement | null;
+    } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: import("@floating-ui/react").OpenChangeReason | undefined) => void;
+        events: import("@floating-ui/react").FloatingEvents;
+        dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+export {};

package/dist/esm/Tooltip/utils.js

@@ -0,0 +1,135 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { autoUpdate, flip, offset, shift, useDelayGroupContext, useDismiss, useFloating, useFocus, useHover, useInteractions, useRole, } from '@floating-ui/react';
+import * as React from 'react';
+// Create a single shared portal root for all tooltips
+var sharedPortalRoot = null;
+var portalRefCount = 0;
+export function getSharedPortalRoot() {
+    if (!sharedPortalRoot) {
+        sharedPortalRoot = document.createElement('div');
+        sharedPortalRoot.style.position = 'relative';
+        sharedPortalRoot.style.zIndex = '100000';
+        sharedPortalRoot.style.height = '0px';
+        // Insert as the first child of body
+        if (document.body.firstChild) {
+            document.body.insertBefore(sharedPortalRoot, document.body.firstChild);
+        }
+        else {
+            document.body.appendChild(sharedPortalRoot);
+        }
+    }
+    portalRefCount++;
+    return sharedPortalRoot;
+}
+export function releaseSharedPortalRoot() {
+    portalRefCount--;
+    if (portalRefCount === 0 && sharedPortalRoot) {
+        if (sharedPortalRoot.parentNode) {
+            sharedPortalRoot.parentNode.removeChild(sharedPortalRoot);
+        }
+        sharedPortalRoot = null;
+    }
+}
+/**
+ * Hook that manages tooltip state and positioning logic.
+ *
+ * This hook provides the core tooltip behavior including hover/focus detection,
+ * positioning, and accessibility features. Use this when you need full control
+ * over the tooltip structure.
+ *
+ * @example Basic tooltip hook usage
+ *
+ * Build a custom tooltip implementation using the hook directly for maximum flexibility:
+ *
+ * ```js
+ * function MyComponent() {
+ *   const tooltip = useTooltip({ placement: 'top' });
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         ref={tooltip.refs.setReference}
+ *         {...tooltip.getReferenceProps()}
+ *       >
+ *         Hover me
+ *       </button>
+ *
+ *       {tooltip.open && (
+ *         <div
+ *           ref={tooltip.refs.setFloating}
+ *           style={tooltip.floatingStyles}
+ *           {...tooltip.getFloatingProps()}
+ *         >
+ *           Tooltip content
+ *         </div>
+ *       )}
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @example Controlled tooltip
+ *
+ * Control the tooltip's open state programmatically for click-to-toggle behavior:
+ *
+ * ```js
+ * function ControlledTooltip() {
+ *   const [open, setOpen] = React.useState(false);
+ *   const tooltip = useTooltip({ open, onOpenChange: setOpen });
+ *
+ *   return (
+ *     <Canvas ctx={ctx}>
+ *       <button onClick={() => setOpen(!open)}>
+ *         Toggle tooltip
+ *       </button>
+ *     </Canvas>
+ *   );
+ * }
+ * ```
+ */
+export function useTooltip(_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.initialOpen, initialOpen = _c === void 0 ? false : _c, _d = _b.placement, placement = _d === void 0 ? 'top' : _d, controlledOpen = _b.open, setControlledOpen = _b.onOpenChange;
+    var _e = React.useState(initialOpen), uncontrolledOpen = _e[0], setUncontrolledOpen = _e[1];
+    var open = controlledOpen !== null && controlledOpen !== void 0 ? controlledOpen : uncontrolledOpen;
+    var setOpen = setControlledOpen !== null && setControlledOpen !== void 0 ? setControlledOpen : setUncontrolledOpen;
+    var delay = useDelayGroupContext().delay;
+    var data = useFloating({
+        placement: placement,
+        open: open,
+        onOpenChange: setOpen,
+        whileElementsMounted: autoUpdate,
+        middleware: [offset(5), flip(), shift()],
+    });
+    var context = data.context;
+    var hover = useHover(context, {
+        move: false,
+        enabled: controlledOpen == null,
+        delay: delay,
+    });
+    var focus = useFocus(context, {
+        enabled: controlledOpen == null,
+    });
+    var dismiss = useDismiss(context);
+    var role = useRole(context, { role: 'tooltip' });
+    var interactions = useInteractions([hover, focus, dismiss, role]);
+    return React.useMemo(function () { return (__assign(__assign({ open: open, setOpen: setOpen }, interactions), data)); }, [open, setOpen, interactions, data]);
+}
+export var TooltipContext = React.createContext(null);
+export var useTooltipState = function () {
+    var context = React.useContext(TooltipContext);
+    if (context == null) {
+        throw new Error('Tooltip components must be wrapped in <Tooltip />');
+    }
+    return context;
+};
+//# sourceMappingURL=utils.js.map