@rescui/tooltip 0.12.1 → 0.12.3-RUI-308-Fix-select-issues-405b9fa40.12

package/lib/index.css

@@ -1,10 +1,15 @@
-._tooltip_122d23x_5{
+@property --_rs-theme-dark-coefficient{
+  syntax:'<number>';
+  inherits:true;
+  initial-value:0;
+}
+._tooltip_1o1u5fj_5{
   position:relative;
 }
-._closing_122d23x_9{
+._closing_1o1u5fj_9{
   pointer-events:none;
 }
-._content_122d23x_13{
+._content_1o1u5fj_13{
   --rs-theme-dark:1;
   --_rs-tooltip-border-width:1px;
 
@@ -63,6 +68,8 @@
   --_rs-typography-link-external-standalone-border-offset-from-text-base:1.02em;
   --_rs-typography-link-border-bottom-width-from-text:1px;
 
+  color-scheme:dark;
+
   max-width:283px;
 
   padding:calc(8px - var(--_rs-tooltip-border-width));
@@ -76,33 +83,33 @@
   transition:opacity 300ms var(--rs-transition-function, ease), transform 300ms var(--rs-transition-function, ease);
   transform:translate(0, 0);
 }
-[data-popper-placement='top-end'] ._content_122d23x_13,
-  [data-popper-placement='bottom-end'] ._content_122d23x_13{
+[data-popper-placement='top-end'] ._content_1o1u5fj_13,
+  [data-popper-placement='bottom-end'] ._content_1o1u5fj_13{
     margin-right:0;
   }
-[data-popper-placement='top-start'] ._content_122d23x_13,
-  [data-popper-placement='bottom-start'] ._content_122d23x_13{
+[data-popper-placement='top-start'] ._content_1o1u5fj_13,
+  [data-popper-placement='bottom-start'] ._content_1o1u5fj_13{
     margin-left:0;
   }
-[data-popper-placement='left-end'] ._content_122d23x_13,
-  [data-popper-placement='right-end'] ._content_122d23x_13{
+[data-popper-placement='left-end'] ._content_1o1u5fj_13,
+  [data-popper-placement='right-end'] ._content_1o1u5fj_13{
     margin-bottom:0;
   }
-[data-popper-placement='left-start'] ._content_122d23x_13,
-  [data-popper-placement='right-start'] ._content_122d23x_13{
+[data-popper-placement='left-start'] ._content_1o1u5fj_13,
+  [data-popper-placement='right-start'] ._content_1o1u5fj_13{
     margin-top:0;
   }
-._initial_122d23x_55 ._content_122d23x_13{
+._initial_1o1u5fj_57 ._content_1o1u5fj_13{
     transition:none;
   }
-._closing_122d23x_9 ._content_122d23x_13{
+._closing_1o1u5fj_9 ._content_1o1u5fj_13{
     transition-duration:200ms, 200ms;
   }
-._initial_122d23x_55 ._content_122d23x_13,
-  ._closing_122d23x_9 ._content_122d23x_13{
+._initial_1o1u5fj_57 ._content_1o1u5fj_13,
+  ._closing_1o1u5fj_9 ._content_1o1u5fj_13{
     opacity:0;
   }
-._outerThemeLight_122d23x_69 ._content_122d23x_13{
+._outerThemeLight_1o1u5fj_71 ._content_1o1u5fj_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);
@@ -113,7 +120,7 @@
       --rs-color-primary-t-fog-light-theme
     );
   }
-._outerThemeDark_122d23x_82 ._content_122d23x_13{
+._outerThemeDark_1o1u5fj_84 ._content_1o1u5fj_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);
@@ -124,20 +131,20 @@
       --rs-color-primary-t-fog-dark-theme
     );
   }
-._initial_122d23x_55[data-popper-placement^='top'] ._content_122d23x_13, ._closing_122d23x_9[data-popper-placement^='top'] ._content_122d23x_13{
+._initial_1o1u5fj_57[data-popper-placement^='top'] ._content_1o1u5fj_13, ._closing_1o1u5fj_9[data-popper-placement^='top'] ._content_1o1u5fj_13{
     transform:translate(0, 10px);
   }
-._initial_122d23x_55[data-popper-placement^='right'] ._content_122d23x_13, ._closing_122d23x_9[data-popper-placement^='right'] ._content_122d23x_13{
+._initial_1o1u5fj_57[data-popper-placement^='right'] ._content_1o1u5fj_13, ._closing_1o1u5fj_9[data-popper-placement^='right'] ._content_1o1u5fj_13{
     transform:translate(-10px, 0);
   }
-._initial_122d23x_55[data-popper-placement^='bottom'] ._content_122d23x_13, ._closing_122d23x_9[data-popper-placement^='bottom'] ._content_122d23x_13{
+._initial_1o1u5fj_57[data-popper-placement^='bottom'] ._content_1o1u5fj_13, ._closing_1o1u5fj_9[data-popper-placement^='bottom'] ._content_1o1u5fj_13{
     transform:translate(0, -10px);
   }
-._initial_122d23x_55[data-popper-placement^='left'] ._content_122d23x_13, ._closing_122d23x_9[data-popper-placement^='left'] ._content_122d23x_13{
+._initial_1o1u5fj_57[data-popper-placement^='left'] ._content_1o1u5fj_13, ._closing_1o1u5fj_9[data-popper-placement^='left'] ._content_1o1u5fj_13{
     transform:translate(10px, 0);
   }
-._trigger_122d23x_114:focus-visible,
-._trigger_122d23x_114:focus[data-focus-method='key']{
+._trigger_1o1u5fj_116:focus-visible,
+._trigger_1o1u5fj_116:focus[data-focus-method='key']{
   outline:none;
 
   box-shadow:var(--rs-color-primary-t-dim-light-theme) 0 0 0 4px;

package/lib/tooltip.js

@@ -1,11 +1,12 @@
 "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 React, { cloneElement, createElement, useState, useRef, useCallback, useContext, isValidElement } from 'react';
 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 { useResizeObserver } from '@rescui/use-resize-observer';
 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';
@@ -137,30 +138,21 @@ const Tooltip = _ref4 => {
     tooltipZIndex
   } = useLayeringContext();
   const [popperRef, setPopperRef] = useState(null);
-  const [triggerRef, setTriggerRef] = useState(null);
+  const [triggerRef, setTriggerRef] = useState(undefined);
   const [isVisibleState, setIsVisibleState] = useState(false);
   const [isTooltipHovered, setIsTooltipHovered] = useState(false);
-  const schedulePopperUpdateRef = useRef(null);
-  const contentRef = useRef(null);
+  const [contentEl, setContentEl] = useState(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 requestedVisibility = isControlled ? isVisibleFromProps : isVisibleState; // An undefined ref means that React has not committed the trigger yet. It keeps
+  // the server and first client render equal without an extra hydration state.
 
-  const [isFirstRender, setIsFirstRender] = useState(true);
-  useEffect(() => {
-    setIsFirstRender(false);
-  }, []);
-  isVisible = isFirstRender && !renderBesideTrigger ? false : isVisible;
+  const isVisible = typeof triggerRef !== 'undefined' || renderBesideTrigger ? requestedVisibility : false;
   const ownerDocument = triggerRef?.ownerDocument;
   const isOpen = isVisible || isTooltipHovered;
-  useEffect(() => {
-    if (schedulePopperUpdateRef.current) {
-      schedulePopperUpdateRef.current();
-    }
-  }, [content]);
+  const contentCanBeRendered = isNode(content);
+  const portalTargetIsAvailable = renderBesideTrigger || Boolean(ownerDocument?.body);
+  const canRenderTooltip = contentCanBeRendered && portalTargetIsAvailable;
 
   const handleMouseEnterTarget = () => {
     if (hideTimeoutRef.current) {
@@ -181,66 +173,10 @@ const Tooltip = _ref4 => {
     }
   };
 
-  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(_ref5 => {
-    let {
-      state
-    } = _ref5;
-    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); // immediately fire handleAnimationEnd event on visibility change in case transition is disabled
-  // it may happen if the user hard-disabled all transitions in his browser
-
-  useEffect(() => {
-    if (!isInitial && contentRef.current) {
-      const ownerWindow = contentRef.current.ownerDocument.defaultView;
-      const isTransitionDisabled = ownerWindow?.getComputedStyle(contentRef.current).transitionDuration === '0s';
-
-      if (isTransitionDisabled) {
-        handleAnimationEnd();
-      }
-    }
-  }, [handleAnimationEnd, isInitial]);
-  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 = ownerDocument?.defaultView?.getComputedStyle(triggerRef);
-
-    if (triggerStyles) {
-      themeFromCss = extractThemeFromCss(triggerStyles);
-      primaryColors = extractPrimaryColors(triggerStyles);
-    }
-  }
-
-  const {
-    theme: themeFromContext,
-    noProvider
-  } = useContext(ThemeContext);
-  const theme = noProvider ? themeFromCss : themeFromContext;
-  const calcOffset = useCallback(_ref6 => {
+  const calcOffset = useCallback(_ref5 => {
     let {
       placement: offsetPlacement
-    } = _ref6;
+    } = _ref5;
 
     if (_includesInstanceProperty(offsetPlacement).call(offsetPlacement, 'left') || _includesInstanceProperty(offsetPlacement).call(offsetPlacement, 'right')) {
       return [0, sparse ? 16 : 8];
@@ -252,16 +188,9 @@ const Tooltip = _ref4 => {
     styles: popperStyles,
     attributes,
     update
-  } = usePopper(triggerRef, popperRef, {
+  } = usePopper(triggerRef ?? null, popperRef, {
     placement,
-    modifiers: [// the modifier to trigger starting animation
-    {
-      name: 'disableInitialFlag',
-      enabled: true,
-      phase: 'afterWrite',
-      fn: disableInitialFlag,
-      requires: []
-    }, {
+    modifiers: [{
       name: 'flip',
       options: {
         fallbackPlacements
@@ -273,7 +202,44 @@ const Tooltip = _ref4 => {
       }
     }, ...(modifiers || [])]
   });
-  schedulePopperUpdateRef.current = update;
+  useResizeObserver(contentEl, () => {
+    update?.();
+  }, {
+    ignoreFirstCall: true
+  });
+  const resolvedPlacement = attributes.popper?.['data-popper-placement'] ?? null;
+  const tooltipState = useTooltipState({
+    isOpen,
+    canRender: canRenderTooltip,
+    contentEl,
+    popperElement: popperRef,
+    resolvedPlacement
+  });
+  const isInitial = tooltipState === TOOLTIP_STATES.OPENING_PREPARE;
+  const isClosing = tooltipState === TOOLTIP_STATES.CLOSING;
+  const isExists = tooltipState !== TOOLTIP_STATES.CLOSE;
+  const tooltipShouldBeRendered = isExists && canRenderTooltip;
+  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 = ownerDocument?.defaultView?.getComputedStyle(triggerRef);
+
+    if (triggerStyles) {
+      themeFromCss = extractThemeFromCss(triggerStyles);
+      primaryColors = extractPrimaryColors(triggerStyles);
+    }
+  }
+
+  const {
+    theme: themeFromContext,
+    noProvider
+  } = useContext(ThemeContext);
+  const theme = noProvider ? themeFromCss : themeFromContext;
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(TriggerRenderer, {
     setTriggerRef: setTriggerRef,
     targetComponent: targetComponent,
@@ -312,8 +278,7 @@ const Tooltip = _ref4 => {
     className: cn(styles.content),
     onBlur: handleMouseLeaveTarget,
     onFocus: handleMouseEnterTarget,
-    onTransitionEnd: handleAnimationEnd,
-    ref: contentRef
+    ref: setContentEl
   }, content)))));
 };
 

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

@@ -1,10 +1,10 @@
 var styles = {
-  "tooltip": "_tooltip_122d23x_5",
-  "closing": "_closing_122d23x_9",
-  "content": "_content_122d23x_13",
-  "initial": "_initial_122d23x_55",
-  "outerThemeLight": "_outerThemeLight_122d23x_69",
-  "outerThemeDark": "_outerThemeDark_122d23x_82",
-  "trigger": "_trigger_122d23x_114"
+  "tooltip": "_tooltip_1o1u5fj_5",
+  "closing": "_closing_1o1u5fj_9",
+  "content": "_content_1o1u5fj_13",
+  "initial": "_initial_1o1u5fj_57",
+  "outerThemeLight": "_outerThemeLight_1o1u5fj_71",
+  "outerThemeDark": "_outerThemeDark_1o1u5fj_84",
+  "trigger": "_trigger_1o1u5fj_116"
 };
 export { styles as default };

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

@@ -1,7 +1,16 @@
 export declare enum TOOLTIP_STATES {
+    OPENING_PREPARE = "OPENING_PREPARE",
     OPENING = "OPENING",
     OPEN = "OPEN",
     CLOSING = "CLOSING",
     CLOSE = "CLOSE"
 }
-export declare function useTooltipState(isOpen: boolean): [() => void, TOOLTIP_STATES];
+type UseTooltipStateOptions = {
+    isOpen: boolean;
+    canRender?: boolean;
+    contentEl: HTMLDivElement | null;
+    popperElement: HTMLElement | null;
+    resolvedPlacement: string | null;
+};
+export declare function useTooltipState({ isOpen, canRender, contentEl, popperElement, resolvedPlacement }: UseTooltipStateOptions): TOOLTIP_STATES;
+export {};

package/lib/use-tooltip-state.js

@@ -1,36 +1,131 @@
 "use client";
-import { useState, useRef, useCallback } from 'react';
+import { useState, useCallback, useEffect, useLayoutEffect } from 'react';
+const useIsomorphicLayoutEffect = typeof window === 'undefined' ? useEffect : useLayoutEffect;
+const TOOLTIP_TRANSITION_PROPERTIES = ['opacity', 'transform'];
+
+const getTooltipTransition = (element, property) => element.getAnimations().find(animation => animation.transitionProperty === property);
+
 var TOOLTIP_STATES;
 
 (function (TOOLTIP_STATES) {
+  TOOLTIP_STATES["OPENING_PREPARE"] = "OPENING_PREPARE";
   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
+function useTooltipState(_ref) {
+  let {
+    isOpen,
+    canRender = true,
+    contentEl,
+    popperElement,
+    resolvedPlacement
+  } = _ref;
+  const [tooltipState, setTooltipState] = useState(isOpen && canRender ? TOOLTIP_STATES.OPENING_PREPARE : TOOLTIP_STATES.CLOSE);
+  const completeTransition = useCallback(expectedState => {
+    setTooltipState(state => {
+      if (state !== expectedState) {
+        return state;
+      }
+
+      if (expectedState === TOOLTIP_STATES.CLOSING) {
+        return TOOLTIP_STATES.CLOSE;
+      }
+
+      if (expectedState === TOOLTIP_STATES.OPENING) {
+        return TOOLTIP_STATES.OPEN;
+      }
+
+      return state;
+    });
+  }, []);
+  const completeOpeningPreparation = useCallback(() => {
+    setTooltipState(state => state === TOOLTIP_STATES.OPENING_PREPARE ? TOOLTIP_STATES.OPENING : state);
+  }, []);
+  useIsomorphicLayoutEffect(() => {
+    if (tooltipState !== TOOLTIP_STATES.OPENING_PREPARE || !popperElement || !resolvedPlacement) {
+      return;
+    } // Force layout to register the initial styles with the resolved placement
+    // before starting the opening transition.
 
-      setDummyState(s => !s);
-    } else if (stateRef.current === TOOLTIP_STATES.OPENING && isOpen) {
-      stateRef.current = TOOLTIP_STATES.OPEN; //force rerender
 
-      setDummyState(s => !s);
+    popperElement.getBoundingClientRect();
+    completeOpeningPreparation();
+  }, [completeOpeningPreparation, popperElement, resolvedPlacement, tooltipState]); // Track the transitions that currently belong to the OPENING/CLOSING phase:
+  // - normally, wait for both opacity and transform before completing the phase;
+  // - a style/placement change can cancel or replace a transition without
+  //   changing the phase; follow the latest one, including a replacement that
+  //   appears just after the previous transition finishes;
+  // - if OPENING changes to CLOSING (or vice versa), cleanup invalidates these
+  //   waiters and the next phase installs its own, so a stale transition cannot
+  //   complete it;
+  // - if no transitions are created (for example, their duration is 0s),
+  //   complete the phase immediately.
+
+  useIsomorphicLayoutEffect(() => {
+    if (tooltipState !== TOOLTIP_STATES.OPENING && tooltipState !== TOOLTIP_STATES.CLOSING) {
+      return undefined;
+    }
+
+    if (!contentEl) {
+      return undefined;
     }
-  }, [isOpen]);
 
-  if (isOpen && stateRef.current !== TOOLTIP_STATES.OPEN) {
-    stateRef.current = TOOLTIP_STATES.OPENING;
-  } else if ((stateRef.current === TOOLTIP_STATES.OPEN || stateRef.current === TOOLTIP_STATES.OPENING) && !isOpen) {
-    stateRef.current = TOOLTIP_STATES.CLOSING;
+    let isCurrentPhase = true;
+
+    const completeCurrentPhase = () => {
+      if (isCurrentPhase) {
+        completeTransition(tooltipState);
+      }
+    };
+
+    const waitForCurrentTransition = (property, previousTransition) => {
+      if (!isCurrentPhase) {
+        return Promise.resolve();
+      }
+
+      const transition = getTooltipTransition(contentEl, property);
+
+      if (!transition || transition === previousTransition) {
+        return Promise.resolve();
+      }
+
+      return transition.finished.then(() => {
+        if (!isCurrentPhase) {
+          return Promise.resolve();
+        }
+
+        const replacementTransition = getTooltipTransition(contentEl, property);
+
+        if (replacementTransition && replacementTransition !== transition) {
+          return waitForCurrentTransition(property, transition);
+        }
+
+        return Promise.resolve();
+      }, () => waitForCurrentTransition(property, transition));
+    };
+
+    Promise.all(TOOLTIP_TRANSITION_PROPERTIES.map(property => waitForCurrentTransition(property))).then(completeCurrentPhase);
+    return () => {
+      isCurrentPhase = false;
+    };
+  }, [completeTransition, contentEl, popperElement, tooltipState]); // React retries this component before rendering its children when the phase changes.
+
+  if (!canRender && tooltipState !== TOOLTIP_STATES.CLOSE) {
+    setTooltipState(TOOLTIP_STATES.CLOSE);
+  } else if (isOpen && canRender && tooltipState === TOOLTIP_STATES.CLOSE) {
+    setTooltipState(TOOLTIP_STATES.OPENING_PREPARE);
+  } else if (isOpen && canRender && tooltipState === TOOLTIP_STATES.CLOSING) {
+    setTooltipState(TOOLTIP_STATES.OPENING);
+  } else if (!isOpen && tooltipState === TOOLTIP_STATES.OPENING_PREPARE) {
+    setTooltipState(TOOLTIP_STATES.CLOSE);
+  } else if (!isOpen && (tooltipState === TOOLTIP_STATES.OPEN || tooltipState === TOOLTIP_STATES.OPENING)) {
+    setTooltipState(TOOLTIP_STATES.CLOSING);
   }
 
-  return [onAnimationEnd, stateRef.current];
+  return tooltipState;
 }
 
 export { TOOLTIP_STATES, useTooltipState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rescui/tooltip",
-  "version": "0.12.1",
+  "version": "0.12.3-RUI-308-Fix-select-issues-405b9fa40.12+405b9fa40",
   "description": "",
   "license": "Apache-2.0",
   "author": "JetBrains",
@@ -18,6 +18,7 @@
   "dependencies": {
     "@babel/runtime-corejs3": "^7.26.0",
     "@popperjs/core": "^2.11.8",
+    "@rescui/use-resize-observer": "0.3.5-RUI-308-Fix-select-issues-405b9fa40.12+405b9fa40",
     "classnames": "^2.2.6",
     "react-popper": "^2.2.5"
   },
@@ -28,14 +29,14 @@
     "react-dom": ">=16.8.0 <20"
   },
   "devDependencies": {
-    "@rescui/colors": "^0.3.2",
-    "@rescui/icons": "^1.8.3",
-    "@rescui/scripts": "^0.5.2",
-    "@rescui/typography": "^0.27.3"
+    "@rescui/colors": "0.3.4-RUI-308-Fix-select-issues-405b9fa40.12+405b9fa40",
+    "@rescui/icons": "1.8.5-RUI-308-Fix-select-issues-405b9fa40.12+405b9fa40",
+    "@rescui/scripts": "0.5.2",
+    "@rescui/typography": "0.27.5-RUI-308-Fix-select-issues-405b9fa40.12+405b9fa40"
   },
   "scripts": {
     "build": "rescui-scripts build"
   },
   "nx": {},
-  "gitHead": "7614b4519a4716fbf1151d94c97fda48eab60800"
+  "gitHead": "405b9fa40886b0ab6709c9185e8214599d2d792e"
 }