@akinon/ui-tooltip 0.5.0 → 1.0.0

package/dist/cjs/types.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Props for the Tooltip component, excluding specific attributes from AntTooltipProps.
+ */
 export type TooltipProps = Omit<
   AntTooltipProps,
   | 'prefixCls'
@@ -13,22 +16,64 @@ export type TooltipProps = Omit<
   | '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 {
@@ -36,6 +81,7 @@ interface TooltipPropsWithOverlay extends AbstractTooltipProps {
    * The text shown in the tooltip
    */
   title?: React.ReactNode | RenderFunction;
+
   //overlay?: React.ReactNode | RenderFunction;
 }
 
@@ -44,6 +90,7 @@ interface TooltipPropsWithTitle extends AbstractTooltipProps {
    * The text shown in the tooltip
    */
   title: React.ReactNode | RenderFunction;
+
   //overlay?: React.ReactNode | RenderFunction;
 }
 
@@ -55,6 +102,9 @@ type PurePanelProps = Omit<TooltipProps, 'children'>;
 
 declare const PurePanel: React.FC<PurePanelProps>;
 
+/**
+ * Colors available for the tooltip's background.
+ */
 declare const PresetColors: readonly [
   'blue',
   'purple',
@@ -71,10 +121,19 @@ declare const PresetColors: readonly [
   '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 };
@@ -83,6 +142,9 @@ export interface TooltipRef {
   forceAlign: VoidFunction;
 }
 
+/**
+ * Positions where the tooltip can appear relative to the target element.
+ */
 export type TooltipPlacement =
   | 'top'
   | 'left'
@@ -97,16 +159,46 @@ export type TooltipPlacement =
   | '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;
 }
 
@@ -126,63 +218,104 @@ interface LegacyTooltipProps
    * 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;
 }
 
@@ -196,6 +329,9 @@ declare const InternalTooltip: React.ForwardRefExoticComponent<
 
 type ActionType = 'hover' | 'focus' | 'click' | 'contextMenu';
 
+/**
+ * Properties for configuring the core behavior and appearance of a tooltip.
+ */
 interface RcTooltipProps
   extends Pick<
     TriggerProps,
@@ -212,48 +348,128 @@ interface RcTooltipProps
    * 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;
-  /** Config popup motion */
+
+  /**
+   * 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;
+
   /**
-   * Style of the tooltip card
+   * Inline styles for the tooltip card.
    */
   overlayStyle?: React.CSSProperties;
+
   /**
-   * Class name of the tooltip card
+   * 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;
+
   /**
-   * This value will be merged into placement's config, please refer to the settings <a href="https://github.com/yiminghe/dom-align" target="_blank">dom-align</a>
+   * 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;
+
   /**
-   * Style of the tooltip inner content
+   * Inline styles for the inner content of the tooltip.
    */
   overlayInnerStyle?: React.CSSProperties;
+
   /**
-   * Config z-index of Tooltip
+   * 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;
 }
 
@@ -267,58 +483,207 @@ 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;
-  /** Set popup motion. You can ref `rc-motion` for more info. */
+
+  /**
+   * Motion configuration for animating the popup. See `rc-motion` for more information.
+   */
   popupMotion?: CSSMotionProps;
-  /** Set mask motion. You can ref `rc-motion` for more info. */
+
+  /**
+   * Motion configuration for animating the mask. See `rc-motion` for more information.
+   */
   maskMotion?: CSSMotionProps;
+
   /**
-   * Delay in seconds, before tooltip is shown on mouse enter
+   * Delay (in seconds) before the popup is shown on mouse enter.
    */
   mouseEnterDelay?: number;
+
   /**
-   * Delay in seconds, before tooltip is hidden on mouse leave
+   * 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;
+
   /**
-   * Trigger will memo content when close.
-   * This may affect the case if want to keep content update.
-   * Set `fresh` to `false` will always keep update.
+   * 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;
 }
 
@@ -333,43 +698,145 @@ type MotionName =
       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;
+
   /**
-   * Create element in view even the element is invisible.
-   * Will patch `display: none` style on it.
+   * Forces the creation of the element in the DOM, even if it is not visible.
+   * Invisible elements are styled with `display: none`.
    */
   forceRender?: boolean;
+
   /**
-   * Remove element when motion end. This will not work when `forceRender` is set.
+   * 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;
-  /** Prepare phase is used for measure element info. It will always trigger even motion is off */
+
+  /**
+   * Called during the preparation phase of the appear animation.
+   * Used to measure the element's properties.
+   */
   onAppearPrepare?: MotionPrepareEventHandler;
-  /** Prepare phase is used for measure element info. It will always trigger even motion is off */
+
+  /**
+   * Called during the preparation phase of the enter animation.
+   * Used to measure the element's properties.
+   */
   onEnterPrepare?: MotionPrepareEventHandler;
-  /** Prepare phase is used for measure element info. It will always trigger even motion is off */
+
+  /**
+   * 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;
-  /** This will always trigger after final visible changed. Even if no motion configured. */
+
+  /**
+   * 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;
@@ -386,11 +853,27 @@ interface CSSMotionProps {
 // 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
@@ -404,25 +887,36 @@ type AlignPointLeftRight = 'l' | 'r' | 'c';
 
 type AlignPoint = `${AlignPointTopBottom}${AlignPointLeftRight}`;
 
+/**
+ * Configuration for aligning the tooltip or popup content relative to a target element.
+ */
 interface AlignType {
   /**
-   * move point of source node to align with point of target node.
-   * Such as ['tr','cc'], align top right point of source node with center point of target node.
-   * Point can be 't'(top), 'b'(bottom), 'c'(center), 'l'(left), 'r'(right) */
+   * 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)[];
+
   /**
-   * offset source node by offset[0] in x and offset[1] in y.
-   * If offset contains percentage string value, it is relative to sourceNode region.
+   * 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[];
+
   /**
-   * offset target node by offset[0] in x and offset[1] in y.
-   * If targetOffset contains percentage string value, it is relative to targetNode region.
+   * 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[];
+
   /**
-   * If adjustX field is true, will adjust source node in x direction if source node is invisible.
-   * If adjustY field is true, will adjust source node in y direction if source node is invisible.
+   * 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;
@@ -430,37 +924,43 @@ interface AlignType {
     shiftX?: boolean | number;
     shiftY?: boolean | number;
   };
-  /** Auto adjust arrow position */
+
+  /**
+   * Whether to automatically adjust the arrow position based on the alignment.
+   */
   autoArrow?: boolean;
+
   /**
-   * Config visible region check of html node. Default `visible`:
-   *  - `visible`:
-   *    The visible region of user browser window.
-   *    Use `clientHeight` for check.
-   *    If `visible` region not satisfy, fallback to `scroll`.
-   *  - `scroll`:
-   *    The whole region of the html scroll area.
-   *    Use `scrollHeight` for check.
-   *  - `visibleFirst`:
-   *    Similar to `visible`, but if `visible` region not satisfy, fallback to `scroll`.
+   * 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';
+
   /**
-   * Auto chose position with `top` or `bottom` by the align result
+   * Automatically chooses a position with `top` or `bottom` based on the alignment result.
    */
   dynamicInset?: boolean;
+
   /**
-   * Whether use css right instead of left to position
+   * Uses `css right` instead of `left` for positioning, if enabled.
    */
   useCssRight?: boolean;
+
   /**
-   * Whether use css bottom instead of top to position
+   * Uses `css bottom` instead of `top` for positioning, if enabled.
    */
   useCssBottom?: boolean;
+
   /**
-   * Whether use css transform instead of left/top/right/bottom to position if browser supports.
-   * Defaults to false.
+   * 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;
 }