@rescui/tooltip 0.10.4-RUI-262-Migrate-to-GH-Actions-Release-dummy-8695a904.3 → 0.10.4-RUI-262-Migrate-to-GH-Actions-Release-dummy-8840066a.12

package/lib/css-vars-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const extractPrimaryColors: (styles: CSSStyleDeclaration) => Record<string, string>;
+/** Check out `@rescui/colors/src/public-api.p.css` file */
+export declare const extractThemeFromCss: (styles: CSSStyleDeclaration) => "dark" | "light";

package/lib/css-vars-utils.js

@@ -0,0 +1,20 @@
+const PRIMARY_COLORS = ['--rs-color-primary-light-theme', '--rs-color-primary-dim-light-theme', '--rs-color-primary-fog-light-theme', '--rs-color-primary-t-dim-light-theme', '--rs-color-primary-t-fog-light-theme', '--rs-color-primary-dark-theme', '--rs-color-primary-dim-dark-theme', '--rs-color-primary-fog-dark-theme', '--rs-color-primary-t-dim-dark-theme', '--rs-color-primary-t-fog-dark-theme'];
+
+const extractPrimaryColors = styles => {
+  const colors = {};
+  PRIMARY_COLORS.forEach(varName => {
+    colors[varName] = styles.getPropertyValue(varName) || 'initial';
+  });
+  return colors;
+};
+/** Check out `@rescui/colors/src/public-api.p.css` file */
+
+
+const extractThemeFromCss = styles => {
+  const themeDark = parseInt(styles.getPropertyValue('--rs-theme-dark'), 10) || 0;
+  const themeFlip = parseInt(styles.getPropertyValue('--rs-theme-flip'), 10) || 0;
+  const themeDarkCoefficient = themeDark * (1 - themeFlip) + themeFlip * (1 - themeDark);
+  return themeDarkCoefficient === 1 ? 'dark' : 'light';
+};
+
+export { extractPrimaryColors, extractThemeFromCss };

package/lib/index.css

@@ -0,0 +1,143 @@
+._tooltip_1nfo2no_5{
+  position:relative;
+}
+._closing_1nfo2no_9{
+  pointer-events:none;
+}
+._content_1nfo2no_13{
+  --rs-theme-dark:1;
+  --_rs-tooltip-border-width:1px;
+
+  --_rs-theme-dark:var(
+    --_rs-internal-force-theme-dark-consult-rescui-before-using,
+    var(--rs-theme-dark, 0)
+  );
+
+  --_rs-theme-flip:var(--rs-theme-flip, 0);
+
+  --_rs-theme-dark-coefficient:calc(var(--_rs-theme-dark)*(1 - var(--_rs-theme-flip)) + var(--_rs-theme-flip)*(1 - var(--_rs-theme-dark)));
+
+  --_rs-theme-light-coefficient:calc(1 - var(--_rs-theme-dark-coefficient));
+  letter-spacing:var(
+    --rs-text-base-letter-spacing,
+    var(--_rs-typography-letter-spacing)
+  );
+  text-transform:var(--_rs-typography-text-transform);
+  font-family:var(--_rs-typography-font-family);
+  font-size:var(--_rs-typography-font-size);
+  font-weight:var(--_rs-typography-font-weight);
+  line-height:var(--_rs-typography-line-height);
+  font-variant-numeric:var(--_rs-typography-font-variant-numeric);
+  font-feature-settings:'kern', 'liga', 'calt';
+  --_rs-typography-letter-spacing:var(--rs-text-3-letter-spacing, 0.0045em);
+  --_rs-typography-text-transform:initial;
+  --_rs-typography-font-variant-numeric:initial;
+  --_rs-typography-font-family:var(
+    --rs-font-family-ui,
+    var(--rs-font-family-jb-sans, 'JetBrains Sans', Inter, system-ui, -apple-system,
+  BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell,
+  'Droid Sans', 'Helvetica Neue', Arial, sans-serif)
+  );
+  --_rs-typography-font-size:var(--rs-text-3-font-size, 13px);
+  --_rs-typography-font-weight:var(
+    --rs-font-weight-regular,
+    400
+  );
+  --_rs-typography-line-height:var(
+    --rs-text-3-line-height,
+    20px
+  );
+  --_rs-typography-base-color:var(
+    --_rs-typography-hardness-color,
+    var(
+  --rs-color-average,
+  rgba(calc(25 + var(--_rs-theme-dark-coefficient, 0)*230), calc(25 + var(--_rs-theme-dark-coefficient, 0)*230), calc(28 + var(--_rs-theme-dark-coefficient, 0)*227), 0.7)
+)
+  );
+  --_rs-typography-text-auto-offset:8px;
+  --_rs-typography-ul-list-li-padding-left:28px;
+  --_rs-typography-ol-list-li-padding-left:21px;
+  --_rs-typography-list-li-margin-top-from-text:8px;
+  --_rs-typography-link-standalone-border-offset-from-text-base:1.15em;
+  --_rs-typography-link-external-standalone-border-offset-from-text-base:1.02em;
+  --_rs-typography-link-border-bottom-width-from-text:1px;
+
+  max-width:283px;
+
+  padding:calc(8px - var(--_rs-tooltip-border-width));
+
+  border:var(--_rs-tooltip-border-width) solid rgba(255,255,255,0.1);
+  border-radius:4px;
+
+  color:#FFFFFF;
+  background-color:#303033;
+
+  transition:opacity 300ms, transform 300ms;
+  transform:translate(0, 0);
+}
+[data-popper-placement='top-end'] ._content_1nfo2no_13,
+  [data-popper-placement='bottom-end'] ._content_1nfo2no_13{
+    margin-right:0;
+  }
+[data-popper-placement='top-start'] ._content_1nfo2no_13,
+  [data-popper-placement='bottom-start'] ._content_1nfo2no_13{
+    margin-left:0;
+  }
+[data-popper-placement='left-end'] ._content_1nfo2no_13,
+  [data-popper-placement='right-end'] ._content_1nfo2no_13{
+    margin-bottom:0;
+  }
+[data-popper-placement='left-start'] ._content_1nfo2no_13,
+  [data-popper-placement='right-start'] ._content_1nfo2no_13{
+    margin-top:0;
+  }
+._initial_1nfo2no_54 ._content_1nfo2no_13{
+    transition:none;
+  }
+._closing_1nfo2no_9 ._content_1nfo2no_13{
+    transition-duration:200ms, 200ms;
+  }
+._initial_1nfo2no_54 ._content_1nfo2no_13,
+  ._closing_1nfo2no_9 ._content_1nfo2no_13{
+    opacity:0;
+  }
+._outerThemeLight_1nfo2no_68 ._content_1nfo2no_13{
+    --rs-color-primary-dark-theme:var(--rs-color-primary-light-theme);
+    --rs-color-primary-dim-dark-theme:var(--rs-color-primary-dim-light-theme);
+    --rs-color-primary-fog-dark-theme:var(--rs-color-primary-fog-light-theme);
+    --rs-color-primary-t-dim-dark-theme:var(
+      --rs-color-primary-t-dim-light-theme
+    );
+    --rs-color-primary-t-fog-dark-theme:var(
+      --rs-color-primary-t-fog-light-theme
+    );
+  }
+._outerThemeDark_1nfo2no_81 ._content_1nfo2no_13{
+    --rs-color-primary-light-theme:var(--rs-color-primary-dark-theme);
+    --rs-color-primary-dim-light-theme:var(--rs-color-primary-dim-dark-theme);
+    --rs-color-primary-fog-light-theme:var(--rs-color-primary-fog-dark-theme);
+    --rs-color-primary-t-dim-light-theme:var(
+      --rs-color-primary-t-dim-dark-theme
+    );
+    --rs-color-primary-t-fog-light-theme:var(
+      --rs-color-primary-t-fog-dark-theme
+    );
+  }
+._initial_1nfo2no_54[data-popper-placement^='top'] ._content_1nfo2no_13, ._closing_1nfo2no_9[data-popper-placement^='top'] ._content_1nfo2no_13{
+    transform:translate(0, 10px);
+  }
+._initial_1nfo2no_54[data-popper-placement^='right'] ._content_1nfo2no_13, ._closing_1nfo2no_9[data-popper-placement^='right'] ._content_1nfo2no_13{
+    transform:translate(-10px, 0);
+  }
+._initial_1nfo2no_54[data-popper-placement^='bottom'] ._content_1nfo2no_13, ._closing_1nfo2no_9[data-popper-placement^='bottom'] ._content_1nfo2no_13{
+    transform:translate(0, -10px);
+  }
+._initial_1nfo2no_54[data-popper-placement^='left'] ._content_1nfo2no_13, ._closing_1nfo2no_9[data-popper-placement^='left'] ._content_1nfo2no_13{
+    transform:translate(10px, 0);
+  }
+._trigger_1nfo2no_113:focus-visible,
+._trigger_1nfo2no_113:focus[data-focus-method='key']{
+  outline:none;
+
+  box-shadow:var(--rs-color-primary-t-dim-light-theme) 0 0 0 4px;
+}

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/**
+ * @deprecated use named import instead
+ */
+declare const DefaultTooltip: import("react").FC<import("./tooltip").TooltipProps>;
+export default DefaultTooltip;
+export { Tooltip } from './tooltip';
+export type { TooltipProps, TooltipPlacement } from './tooltip';

package/lib/index.js

@@ -0,0 +1,9 @@
+import './index.css';
+import { Tooltip } from './tooltip.js';
+export { Tooltip } from './tooltip.js';
+/**
+ * @deprecated use named import instead
+ */
+
+const DefaultTooltip = Tooltip;
+export { DefaultTooltip as default };

package/lib/tooltip.d.ts

@@ -0,0 +1,68 @@
+import React from 'react';
+import { StrictModifiers } from '@popperjs/core/lib/types';
+import type { Placement } from '@popperjs/core/lib/enums';
+interface TriggerTargetRequiredProps {
+    ref: React.Ref<HTMLElement>;
+}
+interface TriggerTargetAdditionalProps {
+    onBlur: (...args: unknown[]) => void;
+    tabIndex: number;
+    onMouseEnter: (...args: unknown[]) => void;
+    onMouseLeave: (...args: unknown[]) => void;
+    onFocus: (...args: unknown[]) => void;
+}
+declare type TriggerTargetProps = TriggerTargetRequiredProps | (TriggerTargetRequiredProps & TriggerTargetAdditionalProps);
+declare type ChildrenFunc = (arg: {
+    targetProps: TriggerTargetProps;
+}) => React.ReactNode;
+export declare type TooltipChildren = ChildrenFunc | React.ReactNode;
+export declare type TooltipPlacement = 'auto-start' | 'auto' | 'auto-end' | 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-end' | 'bottom' | 'bottom-start' | 'left-end' | 'left' | 'left-start';
+export interface TooltipProps {
+    /**
+     * Target node or `({targetProps}) => node` function
+     * @type (arg: { targetProps: TriggerTargetProps; }) => ReactNode | ReactNode
+     */
+    children: TooltipChildren;
+    /**
+     * Wrapper component type if children is not a function
+     */
+    targetComponent?: string;
+    /**
+     * Tooltip content
+     */
+    content?: React.ReactNode;
+    className?: string;
+    /**
+     * "External" state control
+     */
+    isVisible?: boolean;
+    /**
+     * Pooper.js [modifiers](https://popper.js.org/docs/v2/modifiers/) config
+     */
+    modifiers?: StrictModifiers[];
+    /**
+     * Please use only `auto`, `top-end`, `right`, `left`, `right-start` or `left-start` to be compliant with styleguide
+     */
+    placement?: TooltipPlacement;
+    /**
+     * When no space is available on the preferred placement, the tooltip will test
+     * the ones provided in the list, and use the first useful one.
+     * See [docs](https://popper.js.org/docs/v2/modifiers/flip/#fallbackplacements).
+     */
+    fallbackPlacements?: Placement[];
+    /**
+     * Disable timeout before hide tooltip after mouse left target,
+     * use with cation, it can make impossible to click on links inside tooltip
+     */
+    disableHideDelay?: boolean;
+    /** increase offset from the target */
+    sparse?: boolean;
+    /**
+     * If set to true, the tooltip will be rendered adjacent to its triggering element.
+     * If false or undefined, the tooltip will render at the end of the `document.body` element.
+     * Should be used when the tooltip content contains interactive elements (e.g. links).
+     */
+    renderBesideTrigger?: boolean;
+}
+export declare const Tooltip: React.FC<TooltipProps>;
+export default Tooltip;

package/lib/tooltip.js

@@ -0,0 +1,296 @@
+"use client";
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
+import React, { cloneElement, createElement, useState, useRef, useEffect, useCallback, useContext, isValidElement } from 'react';
+import { Element, ForwardRef, typeOf } from 'react-is';
+import cn from 'classnames';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import { usePopper } from 'react-popper';
+import { useLayeringContext, ThemeContext, ThemeProvider } from '@rescui/ui-contexts';
+import styles from './tooltip.p.module.css.js';
+import { useTooltipState, TOOLTIP_STATES } from './use-tooltip-state.js';
+import { extractThemeFromCss, extractPrimaryColors } from './css-vars-utils.js';
+const HIDE_TIMEOUT = 500;
+
+const Portal = _ref => {
+  let {
+    children,
+    target = typeof window !== 'undefined' ? document.body : undefined
+  } = _ref;
+  return target ? /*#__PURE__*/ReactDOM.createPortal(children, target) : null;
+};
+
+const isNode = maybeNode => {
+  switch (typeof maybeNode) {
+    case 'string':
+    case 'number':
+      return true;
+
+    case 'object':
+      if ( /*#__PURE__*/isValidElement(maybeNode)) {
+        return true;
+      }
+
+      if (Array.isArray(maybeNode)) {
+        return maybeNode.every(isNode);
+      }
+
+      return false;
+
+    default:
+      return false;
+  }
+};
+
+const OUTER_THEME_STYLES = {
+  light: styles.outerThemeLight,
+  dark: styles.outerThemeDark
+};
+const TriggerRenderer = /*#__PURE__*/React.forwardRef((_ref2, ref) => {
+  var _children$props, _context;
+
+  let {
+    setTriggerRef,
+    targetComponent,
+    isControlled,
+    handleMouseEnterTarget,
+    handleMouseLeaveTarget,
+    children
+  } = _ref2;
+  const eventListeners = !isControlled ? {
+    onMouseEnter: handleMouseEnterTarget,
+    onMouseLeave: handleMouseLeaveTarget,
+    onFocus: handleMouseEnterTarget,
+    onBlur: handleMouseLeaveTarget,
+    tabIndex: 0
+  } : {};
+  const childrenRef = (children === null || children === void 0 ? void 0 : children.ref) ?? (children === null || children === void 0 || (_children$props = children.props) === null || _children$props === void 0 ? void 0 : _children$props.ref);
+  const tooltipTargetProps = Object.assign({}, {
+    ref: el => {
+      setTriggerRef(el);
+
+      if (childrenRef) {
+        if (typeof childrenRef === 'function') {
+          childrenRef(el);
+        } else {
+          childrenRef.current = el;
+        }
+      }
+
+      if (ref) {
+        if (typeof ref === 'function') {
+          ref(el);
+        } else {
+          ref.current = el;
+        }
+      }
+    }
+  }, eventListeners);
+
+  if (typeof children === 'function') {
+    return children({
+      targetProps: tooltipTargetProps
+    });
+  } else if (_includesInstanceProperty(_context = [Element, ForwardRef]).call(_context, typeOf(children))) {
+    return /*#__PURE__*/cloneElement(children, {
+      className: cn(styles.trigger, children.props.className),
+      ...tooltipTargetProps
+    });
+  } // create trigger-wrapper to bind tooltip
+
+
+  return /*#__PURE__*/createElement(targetComponent, {
+    className: styles.trigger,
+    ...tooltipTargetProps
+  }, children);
+});
+TriggerRenderer.displayName = 'TriggerRenderer'; // eslint-disable-next-line complexity
+
+const Tooltip = _ref3 => {
+  let {
+    children,
+    targetComponent = 'span',
+    content,
+    className,
+    isVisible: isVisibleFromProps,
+    modifiers,
+    placement = 'auto',
+    sparse = true,
+    fallbackPlacements = ['top', 'bottom'],
+    disableHideDelay,
+    renderBesideTrigger = false
+  } = _ref3;
+  const {
+    tooltipZIndex
+  } = useLayeringContext();
+  const [popperRef, setPopperRef] = useState(null);
+  const [triggerRef, setTriggerRef] = useState(null);
+  const [isVisibleState, setIsVisibleState] = useState(false);
+  const [isTooltipHovered, setIsTooltipHovered] = useState(false);
+  const schedulePopperUpdateRef = useRef(null);
+  const contentRef = useRef(null);
+  const hideTimeoutRef = useRef(null);
+  const isControlled = typeof isVisibleFromProps !== 'undefined';
+  let isVisible = isControlled ? isVisibleFromProps : isVisibleState; // We set isVisible this way to avoid hydration issue due to
+  // the Portal to document.body which does not exist on the server.
+  // So even if isVisible prop is used, the tooltip will not render on the server, and
+  // it's the same on the first client render, so there is no hydration issue.
+
+  const [isFirstRender, setIsFirstRender] = useState(true);
+  useEffect(() => {
+    setIsFirstRender(false);
+  }, []);
+  isVisible = isFirstRender && !renderBesideTrigger ? false : isVisible;
+  const isOpen = isVisible || isTooltipHovered;
+  const PortalResolved = renderBesideTrigger ? React.Fragment : Portal;
+  useEffect(() => {
+    if (schedulePopperUpdateRef.current) {
+      schedulePopperUpdateRef.current();
+    }
+  }, [content]);
+
+  const handleMouseEnterTarget = () => {
+    if (hideTimeoutRef.current) {
+      clearTimeout(hideTimeoutRef.current);
+      hideTimeoutRef.current = null;
+    }
+
+    setIsVisibleState(true);
+  };
+
+  const handleMouseLeaveTarget = () => {
+    if (disableHideDelay) {
+      setIsVisibleState(false);
+    } else {
+      hideTimeoutRef.current = setTimeout(() => {
+        setIsVisibleState(false);
+      }, HIDE_TIMEOUT);
+    }
+  };
+
+  const [handleAnimationEnd, tooltipState] = useTooltipState(isOpen);
+  const isClosing = tooltipState === TOOLTIP_STATES.CLOSING;
+  const isExists = tooltipState !== TOOLTIP_STATES.CLOSE; // a state to toggle the starting transition
+
+  const [isInitial, setIsInitial] = useState(true); // reset the initial flag when the closing transition ends and the state switches to CLOSED
+
+  useEffect(() => {
+    if (!isExists) {
+      setIsInitial(true);
+    }
+  }, [isExists]);
+  const disableInitialFlag = useCallback(_ref4 => {
+    let {
+      state
+    } = _ref4;
+    const el = state.elements.popper; // force layout phase
+    // to make sure that the dom has registered the initial
+    // styles with resolved placement (for `auto` placement)
+
+    el.getBoundingClientRect();
+    setIsInitial(false);
+  }, []);
+  const tooltipShouldBeRendered = isExists && isNode(content);
+  let primaryColors = {};
+  let themeFromCss = 'light';
+
+  if (triggerRef && tooltipShouldBeRendered) {
+    // In theory this part of the code might cause issues with SSR.
+    // But in this specific context, because of the nature of the state-ref "triggerRef",
+    // we are sure that the tooltip wouldn't be rendered on the first client render.
+    // Therefore, the first render on the client will be the same as on the server.
+    const triggerStyles = getComputedStyle(triggerRef);
+    themeFromCss = extractThemeFromCss(triggerStyles);
+    primaryColors = extractPrimaryColors(triggerStyles);
+  }
+
+  const {
+    theme: themeFromContext,
+    noProvider
+  } = useContext(ThemeContext);
+  const theme = noProvider ? themeFromCss : themeFromContext;
+  const calcOffset = useCallback(_ref5 => {
+    let {
+      placement: offsetPlacement
+    } = _ref5;
+
+    if (_includesInstanceProperty(offsetPlacement).call(offsetPlacement, 'left') || _includesInstanceProperty(offsetPlacement).call(offsetPlacement, 'right')) {
+      return [0, sparse ? 16 : 8];
+    } else {
+      return [0, sparse ? 12 : 8];
+    }
+  }, [sparse]);
+  const {
+    styles: popperStyles,
+    attributes,
+    update
+  } = usePopper(triggerRef, popperRef, {
+    placement,
+    modifiers: [// the modifier to trigger starting animation
+    {
+      name: 'disableInitialFlag',
+      enabled: true,
+      phase: 'afterWrite',
+      fn: disableInitialFlag,
+      requires: []
+    }, {
+      name: 'flip',
+      options: {
+        fallbackPlacements
+      }
+    }, {
+      name: 'offset',
+      options: {
+        offset: calcOffset
+      }
+    }, ...(modifiers || [])]
+  });
+  schedulePopperUpdateRef.current = update;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(TriggerRenderer, {
+    setTriggerRef: setTriggerRef,
+    targetComponent: targetComponent,
+    isControlled: isControlled,
+    handleMouseEnterTarget: handleMouseEnterTarget,
+    handleMouseLeaveTarget: handleMouseLeaveTarget
+  }, children), tooltipShouldBeRendered && /*#__PURE__*/React.createElement(PortalResolved, null, /*#__PURE__*/React.createElement("span", {
+    className: cn(styles.tooltip, isInitial && styles.initial, isClosing && styles.closing, OUTER_THEME_STYLES[theme], className),
+    ref: setPopperRef,
+    style: { ...popperStyles.popper,
+      ...primaryColors,
+      zIndex: tooltipZIndex
+    },
+    onMouseEnter: () => setIsTooltipHovered(true),
+    onMouseLeave: () => {
+      setIsVisibleState(false);
+      setIsTooltipHovered(false);
+    },
+    "data-placement": placement,
+    "data-test": "tooltip",
+    ...attributes.popper
+  }, /*#__PURE__*/React.createElement(ThemeProvider, {
+    theme: "dark",
+    ignoreThemeValueForCSSApi: noProvider
+  }, /*#__PURE__*/React.createElement("div", {
+    className: cn(styles.content),
+    onBlur: handleMouseLeaveTarget,
+    onFocus: handleMouseEnterTarget,
+    onTransitionEnd: handleAnimationEnd,
+    onAnimationEnd: handleAnimationEnd,
+    ref: contentRef
+  }, content)))));
+};
+
+Tooltip.propTypes = {
+  children: PropTypes.oneOfType([PropTypes.func, PropTypes.node]).isRequired,
+  targetComponent: PropTypes.string,
+  content: PropTypes.node,
+  className: PropTypes.string,
+  isVisible: PropTypes.bool,
+  modifiers: PropTypes.array,
+  placement: PropTypes.oneOf(['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start']),
+  fallbackPlacements: PropTypes.arrayOf(PropTypes.oneOf(['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'])),
+  sparse: PropTypes.bool,
+  disableHideDelay: PropTypes.bool,
+  renderBesideTrigger: PropTypes.bool
+};
+export { Tooltip, Tooltip as default };

package/lib/tooltip.p.module.css.js

@@ -0,0 +1,10 @@
+var styles = {
+  "tooltip": "_tooltip_1nfo2no_5",
+  "closing": "_closing_1nfo2no_9",
+  "content": "_content_1nfo2no_13",
+  "initial": "_initial_1nfo2no_54",
+  "outerThemeLight": "_outerThemeLight_1nfo2no_68",
+  "outerThemeDark": "_outerThemeDark_1nfo2no_81",
+  "trigger": "_trigger_1nfo2no_113"
+};
+export { styles as default };

package/lib/use-tooltip-state.d.ts

@@ -0,0 +1,7 @@
+export declare enum TOOLTIP_STATES {
+    OPENING = "OPENING",
+    OPEN = "OPEN",
+    CLOSING = "CLOSING",
+    CLOSE = "CLOSE"
+}
+export declare function useTooltipState(isOpen: boolean): [() => void, TOOLTIP_STATES];

package/lib/use-tooltip-state.js

@@ -0,0 +1,36 @@
+"use client";
+import { useState, useRef, useCallback } from 'react';
+var TOOLTIP_STATES;
+
+(function (TOOLTIP_STATES) {
+  TOOLTIP_STATES["OPENING"] = "OPENING";
+  TOOLTIP_STATES["OPEN"] = "OPEN";
+  TOOLTIP_STATES["CLOSING"] = "CLOSING";
+  TOOLTIP_STATES["CLOSE"] = "CLOSE";
+})(TOOLTIP_STATES || (TOOLTIP_STATES = {}));
+
+function useTooltipState(isOpen) {
+  const [, setDummyState] = useState(false);
+  const stateRef = useRef(TOOLTIP_STATES.CLOSE);
+  const onAnimationEnd = useCallback(() => {
+    if ((stateRef.current === TOOLTIP_STATES.CLOSING || stateRef.current === TOOLTIP_STATES.OPENING) && !isOpen) {
+      stateRef.current = TOOLTIP_STATES.CLOSE; //force rerender
+
+      setDummyState(s => !s);
+    } else if (stateRef.current === TOOLTIP_STATES.OPENING && isOpen) {
+      stateRef.current = TOOLTIP_STATES.OPEN; //force rerender
+
+      setDummyState(s => !s);
+    }
+  }, [isOpen]);
+
+  if (isOpen && stateRef.current !== TOOLTIP_STATES.OPEN) {
+    stateRef.current = TOOLTIP_STATES.OPENING;
+  } else if (stateRef.current === TOOLTIP_STATES.OPEN && !isOpen) {
+    stateRef.current = TOOLTIP_STATES.CLOSING;
+  }
+
+  return [onAnimationEnd, stateRef.current];
+}
+
+export { TOOLTIP_STATES, useTooltipState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rescui/tooltip",
-  "version": "0.10.4-RUI-262-Migrate-to-GH-Actions-Release-dummy-8695a904.3+8695a904",
+  "version": "0.10.4-RUI-262-Migrate-to-GH-Actions-Release-dummy-8840066a.12+8840066a",
   "description": "",
   "license": "Apache-2.0",
   "author": "JetBrains",
@@ -28,15 +28,15 @@
     "react-dom": ">=16.8.0 <20"
   },
   "devDependencies": {
-    "@rescui/colors": "0.2.11-RUI-262-Migrate-to-GH-Actions-Release-dummy-8695a904.19+8695a904",
-    "@rescui/icons": "1.6.1-RUI-262-Migrate-to-GH-Actions-Release-dummy-8695a904.3+8695a904",
+    "@rescui/colors": "0.2.11-RUI-262-Migrate-to-GH-Actions-Release-dummy-8840066a.28+8840066a",
+    "@rescui/icons": "1.6.1-RUI-262-Migrate-to-GH-Actions-Release-dummy-8840066a.12+8840066a",
     "@rescui/scripts": "0.5.1",
-    "@rescui/typography": "0.24.1-RUI-262-Migrate-to-GH-Actions-Release-dummy-8695a904.19+8695a904",
+    "@rescui/typography": "0.24.1-RUI-262-Migrate-to-GH-Actions-Release-dummy-8840066a.28+8840066a",
     "@types/react-is": "^17.0.3"
   },
   "scripts": {
     "build": "rescui-scripts build"
   },
   "nx": {},
-  "gitHead": "8695a9042a55369f8df8f03ffd61c988cd3d3df4"
+  "gitHead": "8840066a6441a9b7a6d42ca35d3f3fbccc983457"
 }