@akinon/ui-tooltip 0.4.0 → 1.0.0

package/dist/cjs/types.d.ts

@@ -0,0 +1,966 @@
+/**
+ * Props for the Tooltip component, excluding specific attributes from AntTooltipProps.
+ */
+export type TooltipProps = Omit<
+  AntTooltipProps,
+  | 'prefixCls'
+  | 'style'
+  | 'styles'
+  | 'id'
+  | 'builtinPlacements'
+  | 'showArrow'
+  | 'onPopupAlign'
+  | 'overlay'
+  | 'getTooltipContainer'
+  | 'arrowContent'
+  | 'motion'
+>;
+
+/**
+ * Configuration for overflow adjustments in tooltip placement.
+ */
+interface AdjustOverflow {
+  /**
+   * Adjust the X position of the tooltip if it overflows.
+   */
+  adjustX?: 0 | 1;
+
+  /**
+   * Adjust the Y position of the tooltip if it overflows.
+   */
+  adjustY?: 0 | 1;
+}
+
+/**
+ * Configuration for tooltip placements.
+ */
+interface PlacementsConfig {
+  /**
+   * The width of the tooltip arrow in pixels.
+   */
+  arrowWidth: number;
+
+  /**
+   * Whether the arrow should point at the center of the target element.
+   */
+  arrowPointAtCenter?: boolean;
+
+  /**
+   * Whether to adjust the placement automatically when the tooltip overflows.
+   */
+  autoAdjustOverflow?: boolean | AdjustOverflow;
+
+  /**
+   * Offset of the tooltip relative to the target element.
+   */
+  offset: number;
+
+  /**
+   * The border radius of the tooltip in pixels.
+   */
+  borderRadius: number;
+
+  /**
+   * Whether to prioritize visibility when multiple placements are possible.
+   */
+  visibleFirst?: boolean;
+}
+
+/**
+ * Literal union type supporting both predefined and custom string values.
+ */
+type LiteralUnion<T extends string> = T | (string & {});
+
+/**
+ * Function that renders the tooltip content.
+ */
+type RenderFunction = () => React.ReactNode;
+
+interface TooltipPropsWithOverlay extends AbstractTooltipProps {
+  /**
+   * The text shown in the tooltip
+   */
+  title?: React.ReactNode | RenderFunction;
+
+  //overlay?: React.ReactNode | RenderFunction;
+}
+
+interface TooltipPropsWithTitle extends AbstractTooltipProps {
+  /**
+   * The text shown in the tooltip
+   */
+  title: React.ReactNode | RenderFunction;
+
+  //overlay?: React.ReactNode | RenderFunction;
+}
+
+export declare type AntTooltipProps =
+  | TooltipPropsWithTitle
+  | TooltipPropsWithOverlay;
+
+type PurePanelProps = Omit<TooltipProps, 'children'>;
+
+declare const PurePanel: React.FC<PurePanelProps>;
+
+/**
+ * Colors available for the tooltip's background.
+ */
+declare const PresetColors: readonly [
+  'blue',
+  'purple',
+  'cyan',
+  'green',
+  'magenta',
+  'pink',
+  'red',
+  'orange',
+  'yellow',
+  'volcano',
+  'geekblue',
+  'lime',
+  'gold'
+];
+
+/**
+ * Key type for predefined tooltip colors.
+ */
+type PresetColorKey = (typeof PresetColors)[number];
+
+/**
+ * Extended color type with inverse options.
+ */
+type InverseColor = `${PresetColorKey}-inverse`;
+
+/**
+ * Available tooltip color types, including inverse options.
+ */
+type PresetColorType = PresetColorKey | InverseColor;
+
+export type { AdjustOverflow, PlacementsConfig };
+
+export interface TooltipRef {
+  forceAlign: VoidFunction;
+}
+
+/**
+ * Positions where the tooltip can appear relative to the target element.
+ */
+export type TooltipPlacement =
+  | 'top'
+  | 'left'
+  | 'right'
+  | 'bottom'
+  | 'topLeft'
+  | 'topRight'
+  | 'bottomLeft'
+  | 'bottomRight'
+  | 'leftTop'
+  | 'leftBottom'
+  | 'rightTop'
+  | 'rightBottom';
+
+/**
+ * Configuration options for aligning the tooltip.
+ */
+export interface TooltipAlignConfig {
+  /**
+   * Points defining the source and target alignment.
+   */
+  points?: [string, string];
+
+  /**
+   * Offset values for positioning the tooltip.
+   */
+  offset?: [number | string, number | string];
+
+  /**
+   * Offset values for the target element.
+   */
+  targetOffset?: [number | string, number | string];
+
+  /**
+   * Overflow adjustment configuration.
+   */
+  overflow?: {
+    adjustX: boolean;
+    adjustY: boolean;
+  };
+
+  /**
+   * Whether to use CSS right instead of left for positioning.
+   */
+  useCssRight?: boolean;
+
+  /**
+   * Whether to use CSS bottom instead of top for positioning.
+   */
+  useCssBottom?: boolean;
+
+  /**
+   * Whether to use CSS transform for positioning if supported.
+   */
+  useCssTransform?: boolean;
+}
+
+interface LegacyTooltipProps
+  extends Partial<
+    Omit<
+      RcTooltipProps,
+      | 'children'
+      | 'visible'
+      | 'defaultVisible'
+      | 'onVisibleChange'
+      | 'afterVisibleChange'
+      | 'destroyTooltipOnHide'
+    >
+  > {
+  /**
+   * Whether the floating tooltip card is open or not
+   */
+  open?: RcTooltipProps['visible'];
+
+  /**
+   * Whether the floating tooltip card is open by default
+   */
+  defaultOpen?: boolean;
+
+  /**
+   * Callback executed when visibility of the tooltip card is changed
+   */
+  onOpenChange?: (open: boolean) => void;
+
+  //afterOpenChange?: RcTooltipProps['afterVisibleChange'];
+}
+
+/**
+ * Abstract properties for the Tooltip component.
+ */
+export interface AbstractTooltipProps extends LegacyTooltipProps {
+  /**
+   * Inline styles for the tooltip container.
+   */
+  style?: React.CSSProperties;
+
+  /**
+   * The additional css class
+   */
+  className?: string;
+
+  /**
+   * ClassName on the root element
+   */
+  rootClassName?: string;
+
+  /**
+   * The background color
+   */
+  color?: string;
+
+  /**
+   * The position of the tooltip relative to the target
+   */
+  placement?: TooltipPlacement;
+
+  //builtinPlacements?: typeof Placements;
+  //openClassName?: string;
+  /**
+   * Change arrow's visible state and change whether the arrow is pointed at the center of target
+   */
+  arrow?: boolean;
+
+  /**
+   * Whether to adjust popup placement automatically when popup is off screen
+   */
+  autoAdjustOverflow?: boolean;
+
+  /**
+   * The DOM container of the tip, the default behavior is to create a div element in body
+   */
+  getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+
+  /**
+   * The content of the tooltip.
+   */
+  children?: React.ReactNode;
+
+  /**
+   * Whether destroy tooltip when hidden
+   */
+  destroyTooltipOnHide?: boolean;
+}
+
+/**
+ * Properties for a tooltip component that supports both a title and an overlay.
+ */
+export interface TooltipPropsWithOverlay extends AbstractTooltipProps {
+  /**
+   * The main content of the tooltip. Can be a React node or a function that returns one.
+   */
+  title?: React.ReactNode | RenderFunction;
+
+  /**
+   * Custom overlay content for the tooltip. Overrides the `title` if provided.
+   */
+  overlay?: React.ReactNode | RenderFunction;
+}
+
+/**
+ * Properties for a tooltip component that requires a title and optionally supports an overlay.
+ */
+export interface TooltipPropsWithTitle extends AbstractTooltipProps {
+  /**
+   * The required main content of the tooltip. Can be a React node or a function that returns one.
+   */
+  title: React.ReactNode | RenderFunction;
+
+  /**
+   * Custom overlay content for the tooltip. Overrides the `title` if provided.
+   */
+  overlay?: React.ReactNode | RenderFunction;
+}
+
+export declare type TooltipProps =
+  | TooltipPropsWithTitle
+  | TooltipPropsWithOverlay;
+
+declare const InternalTooltip: React.ForwardRefExoticComponent<
+  TooltipProps & React.RefAttributes<TooltipRef>
+>;
+
+type ActionType = 'hover' | 'focus' | 'click' | 'contextMenu';
+
+/**
+ * Properties for configuring the core behavior and appearance of a tooltip.
+ */
+interface RcTooltipProps
+  extends Pick<
+    TriggerProps,
+    | 'onPopupAlign'
+    | 'builtinPlacements'
+    | 'fresh'
+    | 'children'
+    | 'mouseLeaveDelay'
+    | 'mouseEnterDelay'
+    | 'prefixCls'
+    | 'forceRender'
+  > {
+  /**
+   * Tooltip trigger mode. Could be multiple by passing an array
+   */
+  trigger?: ActionType | ActionType[];
+
+  /**
+   * Whether the tooltip is visible by default.
+   */
+  defaultVisible?: boolean;
+
+  /**
+   * Whether the tooltip is currently visible.
+   */
+  visible?: boolean;
+
+  /**
+   * The placement of the tooltip relative to its target.
+   */
+  placement?: string;
+
+  /**
+   * Motion configuration for animating the tooltip. Inherits from `popupMotion` in TriggerProps.
+   */
+  motion?: TriggerProps['popupMotion'];
+
+  /**
+   * Callback function executed when the tooltip's visibility changes.
+   *
+   * @param visible - Whether the tooltip is now visible.
+   */
+  onVisibleChange?: (visible: boolean) => void;
+
+  /**
+   * Callback function executed after the tooltip's visibility has changed.
+   *
+   * @param visible - Whether the tooltip is now visible.
+   */
+  afterVisibleChange?: (visible: boolean) => void;
+
+  /**
+   * The content of the tooltip. Can be a React node or a function that returns one.
+   */
+  overlay: (() => React.ReactNode) | React.ReactNode;
+
+  /**
+   * Inline styles for the tooltip card.
+   */
+  overlayStyle?: React.CSSProperties;
+
+  /**
+   * Additional CSS class for the tooltip card.
+   */
+  overlayClassName?: string;
+
+  /**
+   * Function to specify the container where the tooltip should be rendered.
+   *
+   * @param node - The DOM node triggering the tooltip.
+   * @returns - The container element for the tooltip.
+   */
+  getTooltipContainer?: (node: HTMLElement) => HTMLElement;
+
+  /**
+   * Whether to destroy the tooltip when it is hidden.
+   */
+  destroyTooltipOnHide?: boolean;
+
+  /**
+   * Alignment configuration for the tooltip. Combines placement settings with additional alignment rules.
+   * See: <a href="https://github.com/yiminghe/dom-align" target="_blank">dom-align</a>
+   */
+  align?: AlignType;
+
+  /**
+   * Whether to display an arrow in the tooltip.
+   */
+  showArrow?: boolean | ArrowType;
+
+  /**
+   * Custom content for the arrow in the tooltip.
+   */
+  arrowContent?: React.ReactNode;
+
+  /**
+   * Unique identifier for the tooltip element.
+   */
+  id?: string;
+
+  /**
+   * Inline styles for the inner content of the tooltip.
+   */
+  overlayInnerStyle?: React.CSSProperties;
+
+  /**
+   * The z-index of the tooltip.
+   */
+  zIndex?: number;
+}
+
+/**
+ * Configuration for the arrow displayed in the tooltip.
+ */
+interface ArrowType {
+  /**
+   * Additional CSS class for the arrow.
+   */
+  className?: string;
+
+  /**
+   * Custom content for the arrow.
+   */
+  content?: React.ReactNode;
+}
+
+/**
+ * Reference to the tooltip, providing utility methods for alignment and DOM access.
+ */
+interface TooltipRef {
+  /**
+   * The native DOM element of the tooltip.
+   */
+  nativeElement: HTMLElement;
+
+  /**
+   * Forces the alignment of the tooltip, recalculating its position relative to its target.
+   */
+  forceAlign: VoidFunction;
+}
+
+type TransitionNameType = string;
+
+type AnimationType = string;
+
+type BuildInPlacements = Record<string, AlignType>;
+
+type StretchType = string;
+
+type ActionType = 'hover' | 'focus' | 'click' | 'contextMenu';
+
+/**
+ * Properties for configuring a trigger that controls the visibility of a popup element.
+ */
+interface TriggerProps {
+  /**
+   * The child element that triggers the popup.
+   */
+  children: React.ReactElement;
+
+  /**
+   * The action(s) that trigger the popup. Options include 'hover', 'focus', 'click', or 'contextMenu'.
+   */
+  action?: ActionType | ActionType[];
+
+  /**
+   * Actions that explicitly show the popup.
+   */
+  showAction?: ActionType[];
+
+  /**
+   * Actions that explicitly hide the popup.
+   */
+  hideAction?: ActionType[];
+
+  /**
+   * Prefix for the popup CSS class.
+   */
+  prefixCls?: string;
+
+  /**
+   * The z-index of the popup.
+   */
+  zIndex?: number;
+
+  /**
+   * Callback function executed when the popup is aligned with its target.
+   *
+   * @param element - The popup element.
+   * @param align - The alignment configuration.
+   */
+  onPopupAlign?: (element: HTMLElement, align: AlignType) => void;
+
+  /**
+   * Determines how the popup stretches to fit its container.
+   */
+  stretch?: string;
+
+  /**
+   * Whether the popup is currently visible.
+   */
+  popupVisible?: boolean;
+
+  /**
+   * Whether the popup is visible by default.
+   */
+  defaultPopupVisible?: boolean;
+
+  /**
+   * Callback function executed when the popup visibility changes.
+   *
+   * @param visible - Whether the popup is now visible.
+   */
+  onPopupVisibleChange?: (visible: boolean) => void;
+
+  /**
+   * Callback function executed after the popup visibility has changed.
+   *
+   * @param visible - Whether the popup is now visible.
+   */
+  afterPopupVisibleChange?: (visible: boolean) => void;
+
+  /**
+   * Function to specify the container where the popup should be rendered.
+   *
+   * @param node - The DOM node triggering the popup.
+   * @returns - The container element for the popup.
+   */
+  getPopupContainer?: (node: HTMLElement) => HTMLElement;
+
+  /**
+   * Whether to force the rendering of the popup, even if it is not visible.
+   */
+  forceRender?: boolean;
+
+  /**
+   * Whether to automatically destroy the popup when it is hidden.
+   */
+  autoDestroy?: boolean;
+
+  /**
+   * Whether to display a mask behind the popup.
+   */
+  mask?: boolean;
+
+  /**
+   * Whether the popup should close when the mask is clicked.
+   */
+  maskClosable?: boolean;
+
+  /**
+   * Motion configuration for animating the popup. See `rc-motion` for more information.
+   */
+  popupMotion?: CSSMotionProps;
+
+  /**
+   * Motion configuration for animating the mask. See `rc-motion` for more information.
+   */
+  maskMotion?: CSSMotionProps;
+
+  /**
+   * Delay (in seconds) before the popup is shown on mouse enter.
+   */
+  mouseEnterDelay?: number;
+
+  /**
+   * Delay (in seconds) before the popup is hidden on mouse leave.
+   */
+  mouseLeaveDelay?: number;
+
+  /**
+   * Delay (in seconds) before the popup is shown on focus.
+   */
+  focusDelay?: number;
+
+  /**
+   * Delay (in seconds) before the popup is hidden on blur.
+   */
+  blurDelay?: number;
+
+  /**
+   * The content of the popup, which can be a React node or a function that returns one.
+   */
+  popup: React.ReactNode | (() => React.ReactNode);
+
+  /**
+   * The placement of the popup relative to its target.
+   */
+  popupPlacement?: string;
+
+  /**
+   * Custom placements for the popup, defined as a mapping of placement names to alignment configurations.
+   */
+  builtinPlacements?: BuildInPlacements;
+
+  /**
+   * Alignment configuration for the popup.
+   */
+  popupAlign?: AlignType;
+
+  /**
+   * Additional CSS class for the popup container.
+   */
+  popupClassName?: string;
+
+  /**
+   * Inline styles for the popup container.
+   */
+  popupStyle?: React.CSSProperties;
+
+  /**
+   * Function to generate the popup's class name based on its alignment.
+   *
+   * @param align - The alignment configuration.
+   * @returns - The class name for the popup.
+   */
+  getPopupClassNameFromAlign?: (align: AlignType) => string;
+
+  /**
+   * Callback function executed when the popup is clicked.
+   */
+  onPopupClick?: React.MouseEventHandler<HTMLDivElement>;
+
+  /**
+   * Whether to align the popup to a specific point instead of an element.
+   */
+  alignPoint?: boolean;
+
+  /**
+   * Whether to refresh the popup content every time it is shown.
+   * If `false`, the content is memoized and not updated between visibility changes.
+   */
+  fresh?: boolean;
+
+  /**
+   * Whether to display an arrow in the popup.
+   */
+  arrow?: boolean | ArrowTypeOuter;
+}
+
+/**
+ * Configuration for the outer arrow of the popup.
+ */
+interface ArrowTypeOuter {
+  /**
+   * Additional CSS class for the arrow.
+   */
+  className?: string;
+
+  /**
+   * Custom content for the arrow.
+   */
+  content?: React.ReactNode;
+}
+
+type MotionName =
+  | string
+  | {
+      appear?: string;
+      enter?: string;
+      leave?: string;
+      appearActive?: string;
+      enterActive?: string;
+      leaveActive?: string;
+    };
+
+/**
+ * Properties for configuring CSS-based motion animations.
+ */
+interface CSSMotionProps {
+  /**
+   * Name of the motion animation, which corresponds to a CSS class.
+   */
+  motionName?: MotionName;
+
+  /**
+   * Determines whether the motion is currently visible.
+   */
+  visible?: boolean;
+
+  /**
+   * Enables the motion to appear with an animation.
+   */
+  motionAppear?: boolean;
+
+  /**
+   * Enables the motion to enter with an animation.
+   */
+  motionEnter?: boolean;
+
+  /**
+   * Enables the motion to leave with an animation.
+   */
+  motionLeave?: boolean;
+
+  /**
+   * Forces the motion to leave immediately without waiting for the animation.
+   */
+  motionLeaveImmediately?: boolean;
+
+  /**
+   * Specifies the maximum duration (in milliseconds) for the motion.
+   */
+  motionDeadline?: number;
+
+  /**
+   * Forces the creation of the element in the DOM, even if it is not visible.
+   * Invisible elements are styled with `display: none`.
+   */
+  forceRender?: boolean;
+
+  /**
+   * Removes the element from the DOM when the motion ends.
+   * This option will not work if `forceRender` is enabled.
+   */
+  removeOnLeave?: boolean;
+
+  /**
+   * CSS class applied to elements that have completed their motion and left the viewport.
+   */
+  leavedClassName?: string;
+
+  /**
+   * Called during the preparation phase of the appear animation.
+   * Used to measure the element's properties.
+   */
+  onAppearPrepare?: MotionPrepareEventHandler;
+
+  /**
+   * Called during the preparation phase of the enter animation.
+   * Used to measure the element's properties.
+   */
+  onEnterPrepare?: MotionPrepareEventHandler;
+
+  /**
+   * Called during the preparation phase of the leave animation.
+   * Used to measure the element's properties.
+   */
+  onLeavePrepare?: MotionPrepareEventHandler;
+
+  /**
+   * Called when the appear animation starts.
+   */
+  onAppearStart?: MotionEventHandler;
+
+  /**
+   * Called when the enter animation starts.
+   */
+  onEnterStart?: MotionEventHandler;
+
+  /**
+   * Called when the leave animation starts.
+   */
+  onLeaveStart?: MotionEventHandler;
+
+  /**
+   * Called when the appear animation becomes active.
+   */
+  onAppearActive?: MotionEventHandler;
+
+  /**
+   * Called when the enter animation becomes active.
+   */
+  onEnterActive?: MotionEventHandler;
+
+  /**
+   * Called when the leave animation becomes active.
+   */
+  onLeaveActive?: MotionEventHandler;
+
+  /**
+   * Called when the appear animation ends.
+   */
+  onAppearEnd?: MotionEndEventHandler;
+
+  /**
+   * Called when the enter animation ends.
+   */
+  onEnterEnd?: MotionEndEventHandler;
+
+  /**
+   * Called when the leave animation ends.
+   */
+  onLeaveEnd?: MotionEndEventHandler;
+
+  /**
+   * Always called after the final visibility state has changed, regardless of whether a motion is configured.
+   *
+   * @param visible - Indicates whether the element is visible after the change.
+   */
+  onVisibleChanged?: (visible: boolean) => void;
+
+  /**
+   * Internal reference to the animated element.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  internalRef?: React.Ref<any>;
+
+  /**
+   * A render function for the motion's children.
+   *
+   * @param props - Props passed to the child element, including `visible`, `className`, and `style`.
+   * @param ref - Reference to the child element.
+   * @returns - A React element representing the animated child.
+   */
+  children?: (
+    props: {
+      visible?: boolean;
+      className?: string;
+      style?: React.CSSProperties;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      [key: string]: any;
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ref: (node: any) => void
+  ) => React.ReactElement;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type MotionPrepareEventHandler = (element: HTMLElement) => Promise<any> | void;
+
+/**
+ * Type definition for a handler function that executes during a motion event.
+ * The function can modify CSS properties of the animated element or perform side effects.
+ *
+ * @param element - The HTML element that is being animated.
+ * @param event - The motion event triggering this handler.
+ * @returns - Optionally returns a set of CSS properties to apply to the element.
+ */
+type MotionEventHandler = (
+  element: HTMLElement,
+  event: MotionEvent
+) => React.CSSProperties | void;
+
+/**
+ * Type definition for a handler function that executes at the end of a motion event.
+ * The function determines whether the motion was successfully completed or requires further actions.
+ *
+ * @param element - The HTML element that was animated.
+ * @param event - The motion event that has ended.
+ * @returns - Returns `true` if the motion is successfully completed, or `false` to indicate an error or retry.
+ */
+type MotionEndEventHandler = (
+  element: HTMLElement,
+  event: MotionEvent
+) => boolean | void;
+
+type OffsetType = number | `${number}%`;
+
+type AlignPointTopBottom = 't' | 'b' | 'c';
+
+type AlignPointLeftRight = 'l' | 'r' | 'c';
+
+type AlignPoint = `${AlignPointTopBottom}${AlignPointLeftRight}`;
+
+/**
+ * Configuration for aligning the tooltip or popup content relative to a target element.
+ */
+interface AlignType {
+  /**
+   * Defines the alignment points of the source and target nodes.
+   * Each point can be 't' (top), 'b' (bottom), 'c' (center), 'l' (left), or 'r' (right).
+   * For example, `['tr', 'cc']` aligns the top-right of the source node
+   * with the center of the target node.
+   */
+  points?: (string | AlignPoint)[];
+
+  /**
+   * Defines the offset for the source node in the x and y directions.
+   * If the offset contains a percentage string, it is relative to the source node's region.
+   */
+  offset?: OffsetType[];
+
+  /**
+   * Defines the offset for the target node in the x and y directions.
+   * If the targetOffset contains a percentage string, it is relative to the target node's region.
+   */
+  targetOffset?: OffsetType[];
+
+  /**
+   * Configuration for adjusting the source node's position to prevent it from being invisible.
+   * - `adjustX`: Adjusts the x position.
+   * - `adjustY`: Adjusts the y position.
+   * - `shiftX`: Shifts the x position slightly.
+   * - `shiftY`: Shifts the y position slightly.
+   */
+  overflow?: {
+    adjustX?: boolean | number;
+    adjustY?: boolean | number;
+    shiftX?: boolean | number;
+    shiftY?: boolean | number;
+  };
+
+  /**
+   * Whether to automatically adjust the arrow position based on the alignment.
+   */
+  autoArrow?: boolean;
+
+  /**
+   * Defines the visible region check for the tooltip or popup.
+   * - `visible`: Checks the visible region of the browser window (default).
+   * - `scroll`: Includes the entire scrollable region.
+   * - `visibleFirst`: Prioritizes the visible region but falls back to `scroll` if necessary.
+   */
+  htmlRegion?: 'visible' | 'scroll' | 'visibleFirst';
+
+  /**
+   * Automatically chooses a position with `top` or `bottom` based on the alignment result.
+   */
+  dynamicInset?: boolean;
+
+  /**
+   * Uses `css right` instead of `left` for positioning, if enabled.
+   */
+  useCssRight?: boolean;
+
+  /**
+   * Uses `css bottom` instead of `top` for positioning, if enabled.
+   */
+  useCssBottom?: boolean;
+
+  /**
+   * Uses `css transform` for positioning instead of absolute properties like left, top, right, or bottom.
+   * Defaults to `false`.
+   */
+  useCssTransform?: boolean;
+
+  /**
+   * Ignores minor shaking effects in tooltip alignment.
+   */
+  ignoreShake?: boolean;
+}