@ultraviolet/ui 1.51.1 → 1.51.3

package/dist/components/Popup/index.d.ts

@@ -0,0 +1,72 @@
+import type { HTMLAttributes, KeyboardEventHandler, ReactNode, Ref, RefObject } from 'react';
+import type { PopupPlacement } from './helpers';
+type PopupProps = {
+    /**
+     * Id is automatically generated if not set. It is used for associating popup wrapper with popup portal.
+     */
+    id?: string;
+    children: ReactNode | ((renderProps: {
+        className?: string;
+        onBlur: () => void;
+        onFocus: () => void;
+        onPointerEnter: () => void;
+        onPointerLeave: () => void;
+        ref: RefObject<HTMLDivElement>;
+    }) => ReactNode);
+    maxWidth?: number | string;
+    /**
+     * `auto` placement will change the position of the popup if it doesn't fit in the viewport.
+     */
+    placement?: PopupPlacement;
+    /**
+     * Content of the popup, preferably text inside.
+     */
+    text?: ReactNode;
+    className?: string;
+    /**
+     * It will add `width: 100%` to the popup container.
+     */
+    containerFullWidth?: boolean;
+    /**
+     * It will force display popup. This can be useful if you need to always display the popup without hover needed.
+     */
+    visible?: boolean;
+    innerRef?: Ref<HTMLDivElement | null>;
+    role?: string;
+    'data-testid'?: string;
+    hasArrow?: boolean;
+    onClose?: () => void;
+    tabIndex?: number;
+    onKeyDown?: KeyboardEventHandler;
+    'aria-haspopup'?: HTMLAttributes<HTMLDivElement>['aria-haspopup'];
+    hideOnClickOutside?: boolean;
+    /**
+     * If you set debounceTime to false, the popup will not debounce the hover event and will be displayed instantly.
+     * If set to 0 it will disable debounce.
+     */
+    debounceDelay?: number;
+    /**
+     * If you set a max height keep in mind that the animation is disabled, or it will not work properly on some browsers.
+     */
+    maxHeight?: string | number;
+    /**
+     * Will remove the animation on the popup if set to false.
+     */
+    disableAnimation?: boolean;
+    /**
+     * By default, the portal target is children container or document.body if children is a function. You can override this
+     * behavior by setting a portalTarget prop.
+     */
+    portalTarget?: HTMLElement;
+    /**
+     * If you set this to true, the popup will be rendered in the DOM only when it is visible.
+     * When set to false, the popup will always be rendered in the DOM. By default this value is set to `true`, if for some
+     * reason you need to disable it, you can set it to `false`.
+     */
+    dynamicDomRendering?: boolean;
+};
+/**
+ * @experimental This component is experimental and may be subject to breaking changes in the future.
+ */
+export declare const Popup: import("react").ForwardRefExoticComponent<PopupProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/Popup/index.js

@@ -0,0 +1,297 @@
+import { jsx, Fragment, jsxs } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { css } from "@emotion/react";
+import { forwardRef, useRef, useImperativeHandle, useMemo, useState, useId, useCallback, useEffect } from "react";
+import { createPortal } from "react-dom";
+import { animation, exitAnimation } from "./animations.js";
+import { ARROW_WIDTH, DEFAULT_POSITIONS, computePositions } from "./helpers.js";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+const DEFAULT_ANIMATION_DURATION = 230;
+const DEFAULT_DEBOUNCE_DURATION = 200;
+function noop() {
+}
+const StyledPopup = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["maxWidth", "positions", "reverseAnimation", "maxHeight", "animationDuration", "isDialog"].includes(prop),
+  target: "e4h1g861"
+} : {
+  shouldForwardProp: (prop) => !["maxWidth", "positions", "reverseAnimation", "maxHeight", "animationDuration", "isDialog"].includes(prop),
+  target: "e4h1g861",
+  label: "StyledPopup"
+})("background:", ({
+  theme
+}) => theme.colors.neutral.backgroundStronger, ";color:", ({
+  theme
+}) => theme.colors.neutral.textStronger, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";padding:", ({
+  theme
+}) => `${theme.space["0.5"]} ${theme.space["1"]}`, ";text-align:center;position:absolute;max-width:", ({
+  maxWidth
+}) => typeof maxWidth === "number" ? `${maxWidth}px` : maxWidth, ";max-height:", ({
+  maxHeight
+}) => typeof maxHeight === "number" ? `${maxHeight}px` : maxHeight, ";overflow:", ({
+  maxHeight
+}) => maxHeight ? "auto" : void 0, ";overflow-wrap:break-word;font-size:0.8rem;inset:0 auto auto 0;top:0;left:0;opacity:0;z-index:1;transform:", ({
+  positions
+}) => positions.popupPosition, ";animation:", ({
+  positions,
+  reverseAnimation,
+  maxHeight,
+  animationDuration
+}) => maxHeight || animationDuration === 0 || animationDuration === void 0 ? void 0 : /* @__PURE__ */ css(animationDuration, "ms ", !reverseAnimation ? animation(positions) : exitAnimation(positions), " forwards;" + (process.env.NODE_ENV === "production" ? "" : ";label:StyledPopup;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Popup/index.tsx"],"names":[],"mappings":"AA8EW","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Popup/index.tsx","sourcesContent":["import { css } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport type {\n  HTMLAttributes,\n  KeyboardEventHandler,\n  MouseEventHandler,\n  ReactNode,\n  Ref,\n  RefObject,\n} from 'react'\nimport {\n  forwardRef,\n  useCallback,\n  useEffect,\n  useId,\n  useImperativeHandle,\n  useMemo,\n  useRef,\n  useState,\n} from 'react'\nimport { createPortal } from 'react-dom'\nimport type { PositionsType } from './animations'\nimport { animation, exitAnimation } from './animations'\nimport type { PopupPlacement } from './helpers'\nimport { ARROW_WIDTH, DEFAULT_POSITIONS, computePositions } from './helpers'\n\nconst DEFAULT_ANIMATION_DURATION = 230 // in ms\nconst DEFAULT_DEBOUNCE_DURATION = 200 // in ms\n\nfunction noop() {}\n\ntype StyledPopupProps = {\n  maxWidth: number | string\n  positions: PositionsType\n  reverseAnimation: boolean\n  maxHeight?: number | string\n  animationDuration?: number\n  isDialog: boolean\n}\n\nconst StyledPopup = styled('div', {\n  shouldForwardProp: prop =>\n    ![\n      'maxWidth',\n      'positions',\n      'reverseAnimation',\n      'maxHeight',\n      'animationDuration',\n      'isDialog',\n    ].includes(prop),\n})<StyledPopupProps>`\n  background: ${({ theme }) => theme.colors.neutral.backgroundStronger};\n  color: ${({ theme }) => theme.colors.neutral.textStronger};\n  border-radius: ${({ theme }) => theme.radii.default};\n  padding: ${({ theme }) => `${theme.space['0.5']} ${theme.space['1']}`};\n  text-align: center;\n  position: absolute;\n  max-width: ${({ maxWidth }) =>\n    typeof maxWidth === 'number' ? `${maxWidth}px` : maxWidth};\n  max-height: ${({ maxHeight }) =>\n    typeof maxHeight === 'number' ? `${maxHeight}px` : maxHeight};\n  overflow: ${({ maxHeight }) => (maxHeight ? 'auto' : undefined)};\n  overflow-wrap: break-word;\n  font-size: 0.8rem;\n  inset: 0 auto auto 0;\n  top: 0;\n  left: 0;\n  opacity: 0;\n  z-index: 1;\n  transform: ${({ positions }) => positions.popupPosition};\n  animation: ${({\n    positions,\n    reverseAnimation,\n    maxHeight,\n    animationDuration,\n  }) =>\n    maxHeight || animationDuration === 0 || animationDuration === undefined\n      ? undefined\n      : css`\n          ${animationDuration}ms ${!reverseAnimation\n            ? animation(positions)\n            : exitAnimation(positions)} forwards\n        `};\n\n  &[data-has-arrow='true'] {\n    &::after {\n      content: ' ';\n      position: absolute;\n      top: ${({ positions }) => positions.arrowTop}px;\n      left: ${({ positions }) => positions.arrowLeft}px;\n      transform: ${({ positions }) => positions.arrowTransform}\n        rotate(${({ positions }) => positions.rotate}deg);\n      margin-left: -${ARROW_WIDTH}px;\n      border-width: ${ARROW_WIDTH}px;\n      border-style: solid;\n      border-color: ${({ theme }) => theme.colors.neutral.backgroundStronger}\n        transparent transparent transparent;\n      pointer-events: none;\n    }\n  }\n\n  &[data-visible-in-dom='false'] {\n    display: none;\n  }\n`\n\nconst StyledChildrenContainer = styled.div`\n  display: inherit;\n\n  &[data-container-full-width='true'] {\n    width: 100%;\n  }\n`\n\ntype PopupProps = {\n  /**\n   * Id is automatically generated if not set. It is used for associating popup wrapper with popup portal.\n   */\n  id?: string\n  children:\n    | ReactNode\n    | ((renderProps: {\n        className?: string\n        onBlur: () => void\n        onFocus: () => void\n        onPointerEnter: () => void\n        onPointerLeave: () => void\n        ref: RefObject<HTMLDivElement>\n      }) => ReactNode)\n  maxWidth?: number | string\n  /**\n   * `auto` placement will change the position of the popup if it doesn't fit in the viewport.\n   */\n  placement?: PopupPlacement\n  /**\n   * Content of the popup, preferably text inside.\n   */\n  text?: ReactNode\n  className?: string\n  /**\n   * It will add `width: 100%` to the popup container.\n   */\n  containerFullWidth?: boolean\n  /**\n   * It will force display popup. This can be useful if you need to always display the popup without hover needed.\n   */\n  visible?: boolean\n  innerRef?: Ref<HTMLDivElement | null>\n  role?: string\n  'data-testid'?: string\n  hasArrow?: boolean\n  onClose?: () => void\n  tabIndex?: number\n  onKeyDown?: KeyboardEventHandler\n  'aria-haspopup'?: HTMLAttributes<HTMLDivElement>['aria-haspopup']\n  hideOnClickOutside?: boolean\n  /**\n   * If you set debounceTime to false, the popup will not debounce the hover event and will be displayed instantly.\n   * If set to 0 it will disable debounce.\n   */\n  debounceDelay?: number\n  /**\n   * If you set a max height keep in mind that the animation is disabled, or it will not work properly on some browsers.\n   */\n  maxHeight?: string | number\n  /**\n   * Will remove the animation on the popup if set to false.\n   */\n  disableAnimation?: boolean\n  /**\n   * By default, the portal target is children container or document.body if children is a function. You can override this\n   * behavior by setting a portalTarget prop.\n   */\n  portalTarget?: HTMLElement\n  /**\n   * If you set this to true, the popup will be rendered in the DOM only when it is visible.\n   * When set to false, the popup will always be rendered in the DOM. By default this value is set to `true`, if for some\n   * reason you need to disable it, you can set it to `false`.\n   */\n  dynamicDomRendering?: boolean\n}\n\n/**\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const Popup = forwardRef(\n  (\n    {\n      children,\n      text = '',\n      placement = 'auto',\n      id,\n      className,\n      containerFullWidth,\n      maxWidth = 232,\n      maxHeight,\n      visible,\n      innerRef,\n      role = 'popup',\n      'data-testid': dataTestId,\n      hasArrow = true,\n      onClose,\n      tabIndex = 0,\n      onKeyDown,\n      'aria-haspopup': ariaHasPopup,\n      hideOnClickOutside = false,\n      debounceDelay = DEFAULT_DEBOUNCE_DURATION,\n      disableAnimation = false,\n      portalTarget,\n      dynamicDomRendering = true,\n    }: PopupProps,\n    ref: Ref<HTMLDivElement>,\n  ) => {\n    const childrenRef = useRef<HTMLDivElement>(null)\n    useImperativeHandle(innerRef, () => childrenRef.current)\n\n    const innerPopupRef = useRef<HTMLDivElement>(null)\n    useImperativeHandle(ref, () => innerPopupRef.current as HTMLDivElement)\n\n    const timer = useRef<ReturnType<typeof setTimeout> | undefined>()\n    const popupPortalTarget = useMemo(() => {\n      if (portalTarget) return portalTarget\n\n      if (role === 'dialog') {\n        if (childrenRef.current) return childrenRef.current\n        if (typeof window !== 'undefined') return document.body\n\n        return null\n      }\n\n      // We check if window exists for SSR\n      if (typeof window !== 'undefined') {\n        return document.body\n      }\n\n      return null\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [portalTarget, role, childrenRef.current])\n\n    // There are some issue when mixing animation and maxHeight on some browsers, so we disable animation if maxHeight is set.\n    const animationDuration =\n      disableAnimation || maxHeight ? 0 : DEFAULT_ANIMATION_DURATION\n\n    // Debounce timer will be used to prevent the popup from flickering when the user moves the mouse out and in the children element.\n    const debounceTimer = useRef<ReturnType<typeof setTimeout> | undefined>()\n    const [visibleInDom, setVisibleInDom] = useState(false)\n    const [reverseAnimation, setReverseAnimation] = useState(false)\n    const [positions, setPositions] = useState<PositionsType>({\n      ...DEFAULT_POSITIONS,\n    })\n    const uniqueId = useId()\n    const generatedId = id ?? uniqueId\n    const isControlled = visible !== undefined\n\n    const generatePopupPositions = useCallback(() => {\n      if (childrenRef.current && innerPopupRef.current) {\n        setPositions(\n          computePositions({\n            childrenRef,\n            placement,\n            popupRef: innerPopupRef,\n            popupPortalTarget: popupPortalTarget as HTMLElement,\n          }),\n        )\n      }\n    }, [placement, popupPortalTarget])\n\n    /**\n     * This function is called when we need to recompute positions of popup due to window scroll or resize.\n     */\n    const onWindowChangeDetected = useCallback(() => {\n      // We remove animation on scroll or the animation will restart on every scroll\n      if (innerPopupRef.current) {\n        innerPopupRef.current.style.animation = 'none'\n      }\n\n      generatePopupPositions()\n    }, [generatePopupPositions, innerPopupRef])\n\n    /**\n     * This function is called when we need to remove popup portal from DOM and remove event listener to it.\n     */\n    const unmountPopupFromDom = useCallback(() => {\n      setVisibleInDom(false)\n      setReverseAnimation(false)\n\n      window.removeEventListener('scroll', onWindowChangeDetected, true)\n    }, [onWindowChangeDetected])\n\n    /**\n     * This function is called when we need to hide popup. A timeout is set to allow animation end, then remove\n     * popup from dom.\n     */\n    const closePopup = useCallback(() => {\n      debounceTimer.current = setTimeout(\n        () => {\n          setReverseAnimation(true)\n          timer.current = setTimeout(() => {\n            unmountPopupFromDom()\n            onClose?.()\n          }, animationDuration)\n        },\n        debounceDelay && !disableAnimation ? debounceDelay : 0,\n      )\n    }, [\n      animationDuration,\n      disableAnimation,\n      debounceDelay,\n      onClose,\n      unmountPopupFromDom,\n    ])\n\n    /**\n     * When mouse hover or stop hovering children this function display or hide popup. A timeout is set to allow animation\n     * end, then remove popup from dom.\n     */\n    const onPointerEvent = useCallback(\n      (isVisible: boolean) => () => {\n        // If there is a debounceDelay and the popup is not visible, we clear the debounce timer\n        if (!visible && debounceDelay > 0 && debounceTimer.current) {\n          clearTimeout(debounceTimer.current)\n          debounceTimer.current = undefined\n        }\n\n        // This condition is for when we want to unmount the popup\n        // There is debounce in order to avoid popup to flicker when we move the mouse from children to popup\n        // Timer is used to follow the animation duration\n        if (!isVisible && innerPopupRef.current && !debounceTimer.current) {\n          closePopup()\n        } else if (isVisible) {\n          // This condition is for when we want to mount the popup\n          // If the timer exists it means the popup was about to umount, but we hovered the children again,\n          // so we clear the timer and the popup will not be unmounted\n          if (timer.current) {\n            setReverseAnimation(false)\n            clearTimeout(timer.current)\n            timer.current = undefined\n          }\n          // And here is when we currently are in a debounce timer, it means popup was hovered during\n          // that period, and so we can clear debounce timer\n          if (debounceTimer.current) {\n            clearTimeout(debounceTimer.current)\n            debounceTimer.current = undefined\n          }\n          if (debounceDelay > 0) {\n            debounceTimer.current = setTimeout(() => {\n              setVisibleInDom(true)\n            }, debounceDelay)\n          } else {\n            setVisibleInDom(true)\n          }\n        }\n      },\n      [closePopup, debounceDelay, visible],\n    )\n\n    /**\n     * Once popup is visible in the dom we can compute positions, then set it visible on screen and add event to\n     * recompute positions on scroll or screen resize.\n     */\n    useEffect(() => {\n      if (visibleInDom) {\n        generatePopupPositions()\n\n        if (popupPortalTarget === document.body) {\n          // We want to detect scroll and resize in order to recompute positions of popup\n          // Adding true as third parameter to event listener will detect nested scrolls.\n          window.addEventListener('scroll', onWindowChangeDetected, true)\n        }\n        window.addEventListener('resize', onWindowChangeDetected, true)\n      }\n\n      return () => {\n        window.removeEventListener('scroll', onWindowChangeDetected, true)\n        window.removeEventListener('resize', onWindowChangeDetected, true)\n        if (timer.current) {\n          clearTimeout(timer.current)\n          timer.current = undefined\n        }\n      }\n    }, [\n      generatePopupPositions,\n      onWindowChangeDetected,\n      visibleInDom,\n      maxWidth,\n      popupPortalTarget,\n    ])\n\n    // This will be triggered when positions are computed and popup is visible in the dom.\n    useEffect(\n      () => {\n        if (visibleInDom && innerPopupRef.current) {\n          innerPopupRef.current.style.opacity = '1'\n        }\n      },\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      [positions],\n    )\n\n    /**\n     * If popup has `visible` prop it means the popup is manually controlled through this prop.\n     * In this cas we don't want to display popup on hover, but only when `visible` is true.\n     */\n    useEffect(() => {\n      if (isControlled) {\n        onPointerEvent(visible)()\n      }\n    }, [isControlled, onPointerEvent, visible])\n\n    // Handle hide on esc press and hide on click outside\n    useEffect(() => {\n      const handleEscPress = (event: KeyboardEvent) => {\n        if (event.key === 'Escape') {\n          event.preventDefault()\n          event.stopPropagation()\n          closePopup()\n        }\n      }\n\n      const handleClickOutside = (event: MouseEvent) => {\n        const popupCurrent = innerPopupRef.current\n        const childrenCurrent = childrenRef.current\n\n        if (popupCurrent && hideOnClickOutside && !event.defaultPrevented) {\n          if (\n            event.target &&\n            event.target !== popupCurrent &&\n            event.target !== childrenCurrent &&\n            !childrenCurrent?.contains(event.target as Node) &&\n            !popupCurrent.contains(event.target as Node)\n          ) {\n            event.preventDefault()\n            event.stopPropagation()\n            closePopup()\n          }\n        }\n      }\n      if (visibleInDom) {\n        document.body.addEventListener('keyup', handleEscPress)\n        document.body.addEventListener('click', handleClickOutside)\n      }\n\n      return () => {\n        document.body.removeEventListener('keyup', handleEscPress)\n        document.body.removeEventListener('click', handleClickOutside)\n      }\n    }, [\n      closePopup,\n      visibleInDom,\n      innerPopupRef,\n      childrenRef,\n      hideOnClickOutside,\n    ])\n\n    /**\n     * This event will occur only for dialog and will trap focus inside the dialog.\n     */\n    const handleFocusTrap: KeyboardEventHandler = useCallback(event => {\n      const isTabPressed = event.key === 'Tab'\n      if (!isTabPressed) {\n        return\n      }\n      event.stopPropagation()\n\n      const focusableEls =\n        innerPopupRef.current?.querySelectorAll(\n          'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled])',\n        ) ?? []\n\n      // Handle case when no interactive element are within the modal (including close icon)\n      if (focusableEls.length === 0) {\n        event.preventDefault()\n      }\n\n      const firstFocusableEl = focusableEls[0] as HTMLElement\n      const lastFocusableEl = focusableEls[\n        focusableEls.length - 1\n      ] as HTMLElement\n\n      if (event.shiftKey) {\n        if (\n          document.activeElement === firstFocusableEl ||\n          document.activeElement === innerPopupRef.current\n        ) {\n          lastFocusableEl.focus()\n          event.preventDefault()\n        }\n      } else if (\n        document.activeElement === lastFocusableEl ||\n        document.activeElement === innerPopupRef.current\n      ) {\n        firstFocusableEl.focus()\n        event.preventDefault()\n      }\n    }, [])\n\n    /**\n     * Will render children conditionally if children is a function or not.\n     */\n    const renderChildren = useCallback(() => {\n      if (typeof children === 'function') {\n        return children({\n          onBlur: !isControlled ? onPointerEvent(false) : noop,\n          onFocus: !isControlled ? onPointerEvent(true) : noop,\n          onPointerEnter: !isControlled ? onPointerEvent(true) : noop,\n          onPointerLeave: !isControlled ? onPointerEvent(false) : noop,\n          ref: childrenRef,\n        })\n      }\n\n      return (\n        <StyledChildrenContainer\n          aria-describedby={generatedId}\n          aria-controls={generatedId}\n          onBlur={!isControlled ? onPointerEvent(false) : noop}\n          onFocus={!isControlled ? onPointerEvent(true) : noop}\n          onPointerEnter={!isControlled ? onPointerEvent(true) : noop}\n          onPointerLeave={!isControlled ? onPointerEvent(false) : noop}\n          ref={childrenRef}\n          tabIndex={tabIndex}\n          onKeyDown={event => {\n            onKeyDown?.(event)\n          }}\n          data-container-full-width={containerFullWidth}\n          aria-haspopup={ariaHasPopup}\n        >\n          {children}\n        </StyledChildrenContainer>\n      )\n    }, [\n      ariaHasPopup,\n      children,\n      containerFullWidth,\n      generatedId,\n      isControlled,\n      onKeyDown,\n      onPointerEvent,\n      tabIndex,\n    ])\n\n    const shouldRender = useMemo(() => {\n      if (!dynamicDomRendering) {\n        return true\n      }\n\n      if (dynamicDomRendering && visibleInDom) {\n        return true\n      }\n\n      return false\n    }, [dynamicDomRendering, visibleInDom])\n\n    if (!text) {\n      if (typeof children === 'function') return null\n\n      return <>{children}</>\n    }\n\n    /**\n     * This event handle allow us to not bubble the event to document.body like this react-select works fine\n     */\n    const stopClickPropagation: MouseEventHandler = event => {\n      event.nativeEvent.stopImmediatePropagation()\n    }\n\n    return (\n      <>\n        {renderChildren()}\n        {shouldRender\n          ? createPortal(\n              <StyledPopup\n                ref={innerPopupRef}\n                positions={positions}\n                maxWidth={maxWidth}\n                maxHeight={maxHeight}\n                role={role}\n                id={generatedId}\n                className={className}\n                reverseAnimation={reverseAnimation}\n                data-testid={dataTestId}\n                data-has-arrow={hasArrow}\n                onClick={stopClickPropagation}\n                onPointerEnter={!isControlled ? onPointerEvent(true) : noop}\n                onPointerLeave={!isControlled ? onPointerEvent(false) : noop}\n                animationDuration={animationDuration}\n                onKeyDown={role === 'dialog' ? handleFocusTrap : undefined}\n                isDialog={role === 'dialog'}\n                data-visible-in-dom={\n                  !dynamicDomRendering ? visibleInDom : undefined\n                }\n              >\n                {text}\n              </StyledPopup>,\n              popupPortalTarget as HTMLElement,\n            )\n          : null}\n      </>\n    )\n  },\n)\n"]} */"), ";&[data-has-arrow='true']{&::after{content:' ';position:absolute;top:", ({
+  positions
+}) => positions.arrowTop, "px;left:", ({
+  positions
+}) => positions.arrowLeft, "px;transform:", ({
+  positions
+}) => positions.arrowTransform, " rotate(", ({
+  positions
+}) => positions.rotate, "deg);margin-left:-", ARROW_WIDTH, "px;border-width:", ARROW_WIDTH, "px;border-style:solid;border-color:", ({
+  theme
+}) => theme.colors.neutral.backgroundStronger, " transparent transparent transparent;pointer-events:none;}}&[data-visible-in-dom='false']{display:none;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Popup/index.tsx"],"names":[],"mappings":"AAkDoB","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Popup/index.tsx","sourcesContent":["import { css } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport type {\n  HTMLAttributes,\n  KeyboardEventHandler,\n  MouseEventHandler,\n  ReactNode,\n  Ref,\n  RefObject,\n} from 'react'\nimport {\n  forwardRef,\n  useCallback,\n  useEffect,\n  useId,\n  useImperativeHandle,\n  useMemo,\n  useRef,\n  useState,\n} from 'react'\nimport { createPortal } from 'react-dom'\nimport type { PositionsType } from './animations'\nimport { animation, exitAnimation } from './animations'\nimport type { PopupPlacement } from './helpers'\nimport { ARROW_WIDTH, DEFAULT_POSITIONS, computePositions } from './helpers'\n\nconst DEFAULT_ANIMATION_DURATION = 230 // in ms\nconst DEFAULT_DEBOUNCE_DURATION = 200 // in ms\n\nfunction noop() {}\n\ntype StyledPopupProps = {\n  maxWidth: number | string\n  positions: PositionsType\n  reverseAnimation: boolean\n  maxHeight?: number | string\n  animationDuration?: number\n  isDialog: boolean\n}\n\nconst StyledPopup = styled('div', {\n  shouldForwardProp: prop =>\n    ![\n      'maxWidth',\n      'positions',\n      'reverseAnimation',\n      'maxHeight',\n      'animationDuration',\n      'isDialog',\n    ].includes(prop),\n})<StyledPopupProps>`\n  background: ${({ theme }) => theme.colors.neutral.backgroundStronger};\n  color: ${({ theme }) => theme.colors.neutral.textStronger};\n  border-radius: ${({ theme }) => theme.radii.default};\n  padding: ${({ theme }) => `${theme.space['0.5']} ${theme.space['1']}`};\n  text-align: center;\n  position: absolute;\n  max-width: ${({ maxWidth }) =>\n    typeof maxWidth === 'number' ? `${maxWidth}px` : maxWidth};\n  max-height: ${({ maxHeight }) =>\n    typeof maxHeight === 'number' ? `${maxHeight}px` : maxHeight};\n  overflow: ${({ maxHeight }) => (maxHeight ? 'auto' : undefined)};\n  overflow-wrap: break-word;\n  font-size: 0.8rem;\n  inset: 0 auto auto 0;\n  top: 0;\n  left: 0;\n  opacity: 0;\n  z-index: 1;\n  transform: ${({ positions }) => positions.popupPosition};\n  animation: ${({\n    positions,\n    reverseAnimation,\n    maxHeight,\n    animationDuration,\n  }) =>\n    maxHeight || animationDuration === 0 || animationDuration === undefined\n      ? undefined\n      : css`\n          ${animationDuration}ms ${!reverseAnimation\n            ? animation(positions)\n            : exitAnimation(positions)} forwards\n        `};\n\n  &[data-has-arrow='true'] {\n    &::after {\n      content: ' ';\n      position: absolute;\n      top: ${({ positions }) => positions.arrowTop}px;\n      left: ${({ positions }) => positions.arrowLeft}px;\n      transform: ${({ positions }) => positions.arrowTransform}\n        rotate(${({ positions }) => positions.rotate}deg);\n      margin-left: -${ARROW_WIDTH}px;\n      border-width: ${ARROW_WIDTH}px;\n      border-style: solid;\n      border-color: ${({ theme }) => theme.colors.neutral.backgroundStronger}\n        transparent transparent transparent;\n      pointer-events: none;\n    }\n  }\n\n  &[data-visible-in-dom='false'] {\n    display: none;\n  }\n`\n\nconst StyledChildrenContainer = styled.div`\n  display: inherit;\n\n  &[data-container-full-width='true'] {\n    width: 100%;\n  }\n`\n\ntype PopupProps = {\n  /**\n   * Id is automatically generated if not set. It is used for associating popup wrapper with popup portal.\n   */\n  id?: string\n  children:\n    | ReactNode\n    | ((renderProps: {\n        className?: string\n        onBlur: () => void\n        onFocus: () => void\n        onPointerEnter: () => void\n        onPointerLeave: () => void\n        ref: RefObject<HTMLDivElement>\n      }) => ReactNode)\n  maxWidth?: number | string\n  /**\n   * `auto` placement will change the position of the popup if it doesn't fit in the viewport.\n   */\n  placement?: PopupPlacement\n  /**\n   * Content of the popup, preferably text inside.\n   */\n  text?: ReactNode\n  className?: string\n  /**\n   * It will add `width: 100%` to the popup container.\n   */\n  containerFullWidth?: boolean\n  /**\n   * It will force display popup. This can be useful if you need to always display the popup without hover needed.\n   */\n  visible?: boolean\n  innerRef?: Ref<HTMLDivElement | null>\n  role?: string\n  'data-testid'?: string\n  hasArrow?: boolean\n  onClose?: () => void\n  tabIndex?: number\n  onKeyDown?: KeyboardEventHandler\n  'aria-haspopup'?: HTMLAttributes<HTMLDivElement>['aria-haspopup']\n  hideOnClickOutside?: boolean\n  /**\n   * If you set debounceTime to false, the popup will not debounce the hover event and will be displayed instantly.\n   * If set to 0 it will disable debounce.\n   */\n  debounceDelay?: number\n  /**\n   * If you set a max height keep in mind that the animation is disabled, or it will not work properly on some browsers.\n   */\n  maxHeight?: string | number\n  /**\n   * Will remove the animation on the popup if set to false.\n   */\n  disableAnimation?: boolean\n  /**\n   * By default, the portal target is children container or document.body if children is a function. You can override this\n   * behavior by setting a portalTarget prop.\n   */\n  portalTarget?: HTMLElement\n  /**\n   * If you set this to true, the popup will be rendered in the DOM only when it is visible.\n   * When set to false, the popup will always be rendered in the DOM. By default this value is set to `true`, if for some\n   * reason you need to disable it, you can set it to `false`.\n   */\n  dynamicDomRendering?: boolean\n}\n\n/**\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const Popup = forwardRef(\n  (\n    {\n      children,\n      text = '',\n      placement = 'auto',\n      id,\n      className,\n      containerFullWidth,\n      maxWidth = 232,\n      maxHeight,\n      visible,\n      innerRef,\n      role = 'popup',\n      'data-testid': dataTestId,\n      hasArrow = true,\n      onClose,\n      tabIndex = 0,\n      onKeyDown,\n      'aria-haspopup': ariaHasPopup,\n      hideOnClickOutside = false,\n      debounceDelay = DEFAULT_DEBOUNCE_DURATION,\n      disableAnimation = false,\n      portalTarget,\n      dynamicDomRendering = true,\n    }: PopupProps,\n    ref: Ref<HTMLDivElement>,\n  ) => {\n    const childrenRef = useRef<HTMLDivElement>(null)\n    useImperativeHandle(innerRef, () => childrenRef.current)\n\n    const innerPopupRef = useRef<HTMLDivElement>(null)\n    useImperativeHandle(ref, () => innerPopupRef.current as HTMLDivElement)\n\n    const timer = useRef<ReturnType<typeof setTimeout> | undefined>()\n    const popupPortalTarget = useMemo(() => {\n      if (portalTarget) return portalTarget\n\n      if (role === 'dialog') {\n        if (childrenRef.current) return childrenRef.current\n        if (typeof window !== 'undefined') return document.body\n\n        return null\n      }\n\n      // We check if window exists for SSR\n      if (typeof window !== 'undefined') {\n        return document.body\n      }\n\n      return null\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [portalTarget, role, childrenRef.current])\n\n    // There are some issue when mixing animation and maxHeight on some browsers, so we disable animation if maxHeight is set.\n    const animationDuration =\n      disableAnimation || maxHeight ? 0 : DEFAULT_ANIMATION_DURATION\n\n    // Debounce timer will be used to prevent the popup from flickering when the user moves the mouse out and in the children element.\n    const debounceTimer = useRef<ReturnType<typeof setTimeout> | undefined>()\n    const [visibleInDom, setVisibleInDom] = useState(false)\n    const [reverseAnimation, setReverseAnimation] = useState(false)\n    const [positions, setPositions] = useState<PositionsType>({\n      ...DEFAULT_POSITIONS,\n    })\n    const uniqueId = useId()\n    const generatedId = id ?? uniqueId\n    const isControlled = visible !== undefined\n\n    const generatePopupPositions = useCallback(() => {\n      if (childrenRef.current && innerPopupRef.current) {\n        setPositions(\n          computePositions({\n            childrenRef,\n            placement,\n            popupRef: innerPopupRef,\n            popupPortalTarget: popupPortalTarget as HTMLElement,\n          }),\n        )\n      }\n    }, [placement, popupPortalTarget])\n\n    /**\n     * This function is called when we need to recompute positions of popup due to window scroll or resize.\n     */\n    const onWindowChangeDetected = useCallback(() => {\n      // We remove animation on scroll or the animation will restart on every scroll\n      if (innerPopupRef.current) {\n        innerPopupRef.current.style.animation = 'none'\n      }\n\n      generatePopupPositions()\n    }, [generatePopupPositions, innerPopupRef])\n\n    /**\n     * This function is called when we need to remove popup portal from DOM and remove event listener to it.\n     */\n    const unmountPopupFromDom = useCallback(() => {\n      setVisibleInDom(false)\n      setReverseAnimation(false)\n\n      window.removeEventListener('scroll', onWindowChangeDetected, true)\n    }, [onWindowChangeDetected])\n\n    /**\n     * This function is called when we need to hide popup. A timeout is set to allow animation end, then remove\n     * popup from dom.\n     */\n    const closePopup = useCallback(() => {\n      debounceTimer.current = setTimeout(\n        () => {\n          setReverseAnimation(true)\n          timer.current = setTimeout(() => {\n            unmountPopupFromDom()\n            onClose?.()\n          }, animationDuration)\n        },\n        debounceDelay && !disableAnimation ? debounceDelay : 0,\n      )\n    }, [\n      animationDuration,\n      disableAnimation,\n      debounceDelay,\n      onClose,\n      unmountPopupFromDom,\n    ])\n\n    /**\n     * When mouse hover or stop hovering children this function display or hide popup. A timeout is set to allow animation\n     * end, then remove popup from dom.\n     */\n    const onPointerEvent = useCallback(\n      (isVisible: boolean) => () => {\n        // If there is a debounceDelay and the popup is not visible, we clear the debounce timer\n        if (!visible && debounceDelay > 0 && debounceTimer.current) {\n          clearTimeout(debounceTimer.current)\n          debounceTimer.current = undefined\n        }\n\n        // This condition is for when we want to unmount the popup\n        // There is debounce in order to avoid popup to flicker when we move the mouse from children to popup\n        // Timer is used to follow the animation duration\n        if (!isVisible && innerPopupRef.current && !debounceTimer.current) {\n          closePopup()\n        } else if (isVisible) {\n          // This condition is for when we want to mount the popup\n          // If the timer exists it means the popup was about to umount, but we hovered the children again,\n          // so we clear the timer and the popup will not be unmounted\n          if (timer.current) {\n            setReverseAnimation(false)\n            clearTimeout(timer.current)\n            timer.current = undefined\n          }\n          // And here is when we currently are in a debounce timer, it means popup was hovered during\n          // that period, and so we can clear debounce timer\n          if (debounceTimer.current) {\n            clearTimeout(debounceTimer.current)\n            debounceTimer.current = undefined\n          }\n          if (debounceDelay > 0) {\n            debounceTimer.current = setTimeout(() => {\n              setVisibleInDom(true)\n            }, debounceDelay)\n          } else {\n            setVisibleInDom(true)\n          }\n        }\n      },\n      [closePopup, debounceDelay, visible],\n    )\n\n    /**\n     * Once popup is visible in the dom we can compute positions, then set it visible on screen and add event to\n     * recompute positions on scroll or screen resize.\n     */\n    useEffect(() => {\n      if (visibleInDom) {\n        generatePopupPositions()\n\n        if (popupPortalTarget === document.body) {\n          // We want to detect scroll and resize in order to recompute positions of popup\n          // Adding true as third parameter to event listener will detect nested scrolls.\n          window.addEventListener('scroll', onWindowChangeDetected, true)\n        }\n        window.addEventListener('resize', onWindowChangeDetected, true)\n      }\n\n      return () => {\n        window.removeEventListener('scroll', onWindowChangeDetected, true)\n        window.removeEventListener('resize', onWindowChangeDetected, true)\n        if (timer.current) {\n          clearTimeout(timer.current)\n          timer.current = undefined\n        }\n      }\n    }, [\n      generatePopupPositions,\n      onWindowChangeDetected,\n      visibleInDom,\n      maxWidth,\n      popupPortalTarget,\n    ])\n\n    // This will be triggered when positions are computed and popup is visible in the dom.\n    useEffect(\n      () => {\n        if (visibleInDom && innerPopupRef.current) {\n          innerPopupRef.current.style.opacity = '1'\n        }\n      },\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      [positions],\n    )\n\n    /**\n     * If popup has `visible` prop it means the popup is manually controlled through this prop.\n     * In this cas we don't want to display popup on hover, but only when `visible` is true.\n     */\n    useEffect(() => {\n      if (isControlled) {\n        onPointerEvent(visible)()\n      }\n    }, [isControlled, onPointerEvent, visible])\n\n    // Handle hide on esc press and hide on click outside\n    useEffect(() => {\n      const handleEscPress = (event: KeyboardEvent) => {\n        if (event.key === 'Escape') {\n          event.preventDefault()\n          event.stopPropagation()\n          closePopup()\n        }\n      }\n\n      const handleClickOutside = (event: MouseEvent) => {\n        const popupCurrent = innerPopupRef.current\n        const childrenCurrent = childrenRef.current\n\n        if (popupCurrent && hideOnClickOutside && !event.defaultPrevented) {\n          if (\n            event.target &&\n            event.target !== popupCurrent &&\n            event.target !== childrenCurrent &&\n            !childrenCurrent?.contains(event.target as Node) &&\n            !popupCurrent.contains(event.target as Node)\n          ) {\n            event.preventDefault()\n            event.stopPropagation()\n            closePopup()\n          }\n        }\n      }\n      if (visibleInDom) {\n        document.body.addEventListener('keyup', handleEscPress)\n        document.body.addEventListener('click', handleClickOutside)\n      }\n\n      return () => {\n        document.body.removeEventListener('keyup', handleEscPress)\n        document.body.removeEventListener('click', handleClickOutside)\n      }\n    }, [\n      closePopup,\n      visibleInDom,\n      innerPopupRef,\n      childrenRef,\n      hideOnClickOutside,\n    ])\n\n    /**\n     * This event will occur only for dialog and will trap focus inside the dialog.\n     */\n    const handleFocusTrap: KeyboardEventHandler = useCallback(event => {\n      const isTabPressed = event.key === 'Tab'\n      if (!isTabPressed) {\n        return\n      }\n      event.stopPropagation()\n\n      const focusableEls =\n        innerPopupRef.current?.querySelectorAll(\n          'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled])',\n        ) ?? []\n\n      // Handle case when no interactive element are within the modal (including close icon)\n      if (focusableEls.length === 0) {\n        event.preventDefault()\n      }\n\n      const firstFocusableEl = focusableEls[0] as HTMLElement\n      const lastFocusableEl = focusableEls[\n        focusableEls.length - 1\n      ] as HTMLElement\n\n      if (event.shiftKey) {\n        if (\n          document.activeElement === firstFocusableEl ||\n          document.activeElement === innerPopupRef.current\n        ) {\n          lastFocusableEl.focus()\n          event.preventDefault()\n        }\n      } else if (\n        document.activeElement === lastFocusableEl ||\n        document.activeElement === innerPopupRef.current\n      ) {\n        firstFocusableEl.focus()\n        event.preventDefault()\n      }\n    }, [])\n\n    /**\n     * Will render children conditionally if children is a function or not.\n     */\n    const renderChildren = useCallback(() => {\n      if (typeof children === 'function') {\n        return children({\n          onBlur: !isControlled ? onPointerEvent(false) : noop,\n          onFocus: !isControlled ? onPointerEvent(true) : noop,\n          onPointerEnter: !isControlled ? onPointerEvent(true) : noop,\n          onPointerLeave: !isControlled ? onPointerEvent(false) : noop,\n          ref: childrenRef,\n        })\n      }\n\n      return (\n        <StyledChildrenContainer\n          aria-describedby={generatedId}\n          aria-controls={generatedId}\n          onBlur={!isControlled ? onPointerEvent(false) : noop}\n          onFocus={!isControlled ? onPointerEvent(true) : noop}\n          onPointerEnter={!isControlled ? onPointerEvent(true) : noop}\n          onPointerLeave={!isControlled ? onPointerEvent(false) : noop}\n          ref={childrenRef}\n          tabIndex={tabIndex}\n          onKeyDown={event => {\n            onKeyDown?.(event)\n          }}\n          data-container-full-width={containerFullWidth}\n          aria-haspopup={ariaHasPopup}\n        >\n          {children}\n        </StyledChildrenContainer>\n      )\n    }, [\n      ariaHasPopup,\n      children,\n      containerFullWidth,\n      generatedId,\n      isControlled,\n      onKeyDown,\n      onPointerEvent,\n      tabIndex,\n    ])\n\n    const shouldRender = useMemo(() => {\n      if (!dynamicDomRendering) {\n        return true\n      }\n\n      if (dynamicDomRendering && visibleInDom) {\n        return true\n      }\n\n      return false\n    }, [dynamicDomRendering, visibleInDom])\n\n    if (!text) {\n      if (typeof children === 'function') return null\n\n      return <>{children}</>\n    }\n\n    /**\n     * This event handle allow us to not bubble the event to document.body like this react-select works fine\n     */\n    const stopClickPropagation: MouseEventHandler = event => {\n      event.nativeEvent.stopImmediatePropagation()\n    }\n\n    return (\n      <>\n        {renderChildren()}\n        {shouldRender\n          ? createPortal(\n              <StyledPopup\n                ref={innerPopupRef}\n                positions={positions}\n                maxWidth={maxWidth}\n                maxHeight={maxHeight}\n                role={role}\n                id={generatedId}\n                className={className}\n                reverseAnimation={reverseAnimation}\n                data-testid={dataTestId}\n                data-has-arrow={hasArrow}\n                onClick={stopClickPropagation}\n                onPointerEnter={!isControlled ? onPointerEvent(true) : noop}\n                onPointerLeave={!isControlled ? onPointerEvent(false) : noop}\n                animationDuration={animationDuration}\n                onKeyDown={role === 'dialog' ? handleFocusTrap : undefined}\n                isDialog={role === 'dialog'}\n                data-visible-in-dom={\n                  !dynamicDomRendering ? visibleInDom : undefined\n                }\n              >\n                {text}\n              </StyledPopup>,\n              popupPortalTarget as HTMLElement,\n            )\n          : null}\n      </>\n    )\n  },\n)\n"]} */"));
+const StyledChildrenContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e4h1g860"
+} : {
+  target: "e4h1g860",
+  label: "StyledChildrenContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "jhu4ja",
+  styles: "display:inherit;&[data-container-full-width='true']{width:100%;}"
+} : {
+  name: "jhu4ja",
+  styles: "display:inherit;&[data-container-full-width='true']{width:100%;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Popup/index.tsx"],"names":[],"mappings":"AA0G0C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Popup/index.tsx","sourcesContent":["import { css } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport type {\n  HTMLAttributes,\n  KeyboardEventHandler,\n  MouseEventHandler,\n  ReactNode,\n  Ref,\n  RefObject,\n} from 'react'\nimport {\n  forwardRef,\n  useCallback,\n  useEffect,\n  useId,\n  useImperativeHandle,\n  useMemo,\n  useRef,\n  useState,\n} from 'react'\nimport { createPortal } from 'react-dom'\nimport type { PositionsType } from './animations'\nimport { animation, exitAnimation } from './animations'\nimport type { PopupPlacement } from './helpers'\nimport { ARROW_WIDTH, DEFAULT_POSITIONS, computePositions } from './helpers'\n\nconst DEFAULT_ANIMATION_DURATION = 230 // in ms\nconst DEFAULT_DEBOUNCE_DURATION = 200 // in ms\n\nfunction noop() {}\n\ntype StyledPopupProps = {\n  maxWidth: number | string\n  positions: PositionsType\n  reverseAnimation: boolean\n  maxHeight?: number | string\n  animationDuration?: number\n  isDialog: boolean\n}\n\nconst StyledPopup = styled('div', {\n  shouldForwardProp: prop =>\n    ![\n      'maxWidth',\n      'positions',\n      'reverseAnimation',\n      'maxHeight',\n      'animationDuration',\n      'isDialog',\n    ].includes(prop),\n})<StyledPopupProps>`\n  background: ${({ theme }) => theme.colors.neutral.backgroundStronger};\n  color: ${({ theme }) => theme.colors.neutral.textStronger};\n  border-radius: ${({ theme }) => theme.radii.default};\n  padding: ${({ theme }) => `${theme.space['0.5']} ${theme.space['1']}`};\n  text-align: center;\n  position: absolute;\n  max-width: ${({ maxWidth }) =>\n    typeof maxWidth === 'number' ? `${maxWidth}px` : maxWidth};\n  max-height: ${({ maxHeight }) =>\n    typeof maxHeight === 'number' ? `${maxHeight}px` : maxHeight};\n  overflow: ${({ maxHeight }) => (maxHeight ? 'auto' : undefined)};\n  overflow-wrap: break-word;\n  font-size: 0.8rem;\n  inset: 0 auto auto 0;\n  top: 0;\n  left: 0;\n  opacity: 0;\n  z-index: 1;\n  transform: ${({ positions }) => positions.popupPosition};\n  animation: ${({\n    positions,\n    reverseAnimation,\n    maxHeight,\n    animationDuration,\n  }) =>\n    maxHeight || animationDuration === 0 || animationDuration === undefined\n      ? undefined\n      : css`\n          ${animationDuration}ms ${!reverseAnimation\n            ? animation(positions)\n            : exitAnimation(positions)} forwards\n        `};\n\n  &[data-has-arrow='true'] {\n    &::after {\n      content: ' ';\n      position: absolute;\n      top: ${({ positions }) => positions.arrowTop}px;\n      left: ${({ positions }) => positions.arrowLeft}px;\n      transform: ${({ positions }) => positions.arrowTransform}\n        rotate(${({ positions }) => positions.rotate}deg);\n      margin-left: -${ARROW_WIDTH}px;\n      border-width: ${ARROW_WIDTH}px;\n      border-style: solid;\n      border-color: ${({ theme }) => theme.colors.neutral.backgroundStronger}\n        transparent transparent transparent;\n      pointer-events: none;\n    }\n  }\n\n  &[data-visible-in-dom='false'] {\n    display: none;\n  }\n`\n\nconst StyledChildrenContainer = styled.div`\n  display: inherit;\n\n  &[data-container-full-width='true'] {\n    width: 100%;\n  }\n`\n\ntype PopupProps = {\n  /**\n   * Id is automatically generated if not set. It is used for associating popup wrapper with popup portal.\n   */\n  id?: string\n  children:\n    | ReactNode\n    | ((renderProps: {\n        className?: string\n        onBlur: () => void\n        onFocus: () => void\n        onPointerEnter: () => void\n        onPointerLeave: () => void\n        ref: RefObject<HTMLDivElement>\n      }) => ReactNode)\n  maxWidth?: number | string\n  /**\n   * `auto` placement will change the position of the popup if it doesn't fit in the viewport.\n   */\n  placement?: PopupPlacement\n  /**\n   * Content of the popup, preferably text inside.\n   */\n  text?: ReactNode\n  className?: string\n  /**\n   * It will add `width: 100%` to the popup container.\n   */\n  containerFullWidth?: boolean\n  /**\n   * It will force display popup. This can be useful if you need to always display the popup without hover needed.\n   */\n  visible?: boolean\n  innerRef?: Ref<HTMLDivElement | null>\n  role?: string\n  'data-testid'?: string\n  hasArrow?: boolean\n  onClose?: () => void\n  tabIndex?: number\n  onKeyDown?: KeyboardEventHandler\n  'aria-haspopup'?: HTMLAttributes<HTMLDivElement>['aria-haspopup']\n  hideOnClickOutside?: boolean\n  /**\n   * If you set debounceTime to false, the popup will not debounce the hover event and will be displayed instantly.\n   * If set to 0 it will disable debounce.\n   */\n  debounceDelay?: number\n  /**\n   * If you set a max height keep in mind that the animation is disabled, or it will not work properly on some browsers.\n   */\n  maxHeight?: string | number\n  /**\n   * Will remove the animation on the popup if set to false.\n   */\n  disableAnimation?: boolean\n  /**\n   * By default, the portal target is children container or document.body if children is a function. You can override this\n   * behavior by setting a portalTarget prop.\n   */\n  portalTarget?: HTMLElement\n  /**\n   * If you set this to true, the popup will be rendered in the DOM only when it is visible.\n   * When set to false, the popup will always be rendered in the DOM. By default this value is set to `true`, if for some\n   * reason you need to disable it, you can set it to `false`.\n   */\n  dynamicDomRendering?: boolean\n}\n\n/**\n * @experimental This component is experimental and may be subject to breaking changes in the future.\n */\nexport const Popup = forwardRef(\n  (\n    {\n      children,\n      text = '',\n      placement = 'auto',\n      id,\n      className,\n      containerFullWidth,\n      maxWidth = 232,\n      maxHeight,\n      visible,\n      innerRef,\n      role = 'popup',\n      'data-testid': dataTestId,\n      hasArrow = true,\n      onClose,\n      tabIndex = 0,\n      onKeyDown,\n      'aria-haspopup': ariaHasPopup,\n      hideOnClickOutside = false,\n      debounceDelay = DEFAULT_DEBOUNCE_DURATION,\n      disableAnimation = false,\n      portalTarget,\n      dynamicDomRendering = true,\n    }: PopupProps,\n    ref: Ref<HTMLDivElement>,\n  ) => {\n    const childrenRef = useRef<HTMLDivElement>(null)\n    useImperativeHandle(innerRef, () => childrenRef.current)\n\n    const innerPopupRef = useRef<HTMLDivElement>(null)\n    useImperativeHandle(ref, () => innerPopupRef.current as HTMLDivElement)\n\n    const timer = useRef<ReturnType<typeof setTimeout> | undefined>()\n    const popupPortalTarget = useMemo(() => {\n      if (portalTarget) return portalTarget\n\n      if (role === 'dialog') {\n        if (childrenRef.current) return childrenRef.current\n        if (typeof window !== 'undefined') return document.body\n\n        return null\n      }\n\n      // We check if window exists for SSR\n      if (typeof window !== 'undefined') {\n        return document.body\n      }\n\n      return null\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [portalTarget, role, childrenRef.current])\n\n    // There are some issue when mixing animation and maxHeight on some browsers, so we disable animation if maxHeight is set.\n    const animationDuration =\n      disableAnimation || maxHeight ? 0 : DEFAULT_ANIMATION_DURATION\n\n    // Debounce timer will be used to prevent the popup from flickering when the user moves the mouse out and in the children element.\n    const debounceTimer = useRef<ReturnType<typeof setTimeout> | undefined>()\n    const [visibleInDom, setVisibleInDom] = useState(false)\n    const [reverseAnimation, setReverseAnimation] = useState(false)\n    const [positions, setPositions] = useState<PositionsType>({\n      ...DEFAULT_POSITIONS,\n    })\n    const uniqueId = useId()\n    const generatedId = id ?? uniqueId\n    const isControlled = visible !== undefined\n\n    const generatePopupPositions = useCallback(() => {\n      if (childrenRef.current && innerPopupRef.current) {\n        setPositions(\n          computePositions({\n            childrenRef,\n            placement,\n            popupRef: innerPopupRef,\n            popupPortalTarget: popupPortalTarget as HTMLElement,\n          }),\n        )\n      }\n    }, [placement, popupPortalTarget])\n\n    /**\n     * This function is called when we need to recompute positions of popup due to window scroll or resize.\n     */\n    const onWindowChangeDetected = useCallback(() => {\n      // We remove animation on scroll or the animation will restart on every scroll\n      if (innerPopupRef.current) {\n        innerPopupRef.current.style.animation = 'none'\n      }\n\n      generatePopupPositions()\n    }, [generatePopupPositions, innerPopupRef])\n\n    /**\n     * This function is called when we need to remove popup portal from DOM and remove event listener to it.\n     */\n    const unmountPopupFromDom = useCallback(() => {\n      setVisibleInDom(false)\n      setReverseAnimation(false)\n\n      window.removeEventListener('scroll', onWindowChangeDetected, true)\n    }, [onWindowChangeDetected])\n\n    /**\n     * This function is called when we need to hide popup. A timeout is set to allow animation end, then remove\n     * popup from dom.\n     */\n    const closePopup = useCallback(() => {\n      debounceTimer.current = setTimeout(\n        () => {\n          setReverseAnimation(true)\n          timer.current = setTimeout(() => {\n            unmountPopupFromDom()\n            onClose?.()\n          }, animationDuration)\n        },\n        debounceDelay && !disableAnimation ? debounceDelay : 0,\n      )\n    }, [\n      animationDuration,\n      disableAnimation,\n      debounceDelay,\n      onClose,\n      unmountPopupFromDom,\n    ])\n\n    /**\n     * When mouse hover or stop hovering children this function display or hide popup. A timeout is set to allow animation\n     * end, then remove popup from dom.\n     */\n    const onPointerEvent = useCallback(\n      (isVisible: boolean) => () => {\n        // If there is a debounceDelay and the popup is not visible, we clear the debounce timer\n        if (!visible && debounceDelay > 0 && debounceTimer.current) {\n          clearTimeout(debounceTimer.current)\n          debounceTimer.current = undefined\n        }\n\n        // This condition is for when we want to unmount the popup\n        // There is debounce in order to avoid popup to flicker when we move the mouse from children to popup\n        // Timer is used to follow the animation duration\n        if (!isVisible && innerPopupRef.current && !debounceTimer.current) {\n          closePopup()\n        } else if (isVisible) {\n          // This condition is for when we want to mount the popup\n          // If the timer exists it means the popup was about to umount, but we hovered the children again,\n          // so we clear the timer and the popup will not be unmounted\n          if (timer.current) {\n            setReverseAnimation(false)\n            clearTimeout(timer.current)\n            timer.current = undefined\n          }\n          // And here is when we currently are in a debounce timer, it means popup was hovered during\n          // that period, and so we can clear debounce timer\n          if (debounceTimer.current) {\n            clearTimeout(debounceTimer.current)\n            debounceTimer.current = undefined\n          }\n          if (debounceDelay > 0) {\n            debounceTimer.current = setTimeout(() => {\n              setVisibleInDom(true)\n            }, debounceDelay)\n          } else {\n            setVisibleInDom(true)\n          }\n        }\n      },\n      [closePopup, debounceDelay, visible],\n    )\n\n    /**\n     * Once popup is visible in the dom we can compute positions, then set it visible on screen and add event to\n     * recompute positions on scroll or screen resize.\n     */\n    useEffect(() => {\n      if (visibleInDom) {\n        generatePopupPositions()\n\n        if (popupPortalTarget === document.body) {\n          // We want to detect scroll and resize in order to recompute positions of popup\n          // Adding true as third parameter to event listener will detect nested scrolls.\n          window.addEventListener('scroll', onWindowChangeDetected, true)\n        }\n        window.addEventListener('resize', onWindowChangeDetected, true)\n      }\n\n      return () => {\n        window.removeEventListener('scroll', onWindowChangeDetected, true)\n        window.removeEventListener('resize', onWindowChangeDetected, true)\n        if (timer.current) {\n          clearTimeout(timer.current)\n          timer.current = undefined\n        }\n      }\n    }, [\n      generatePopupPositions,\n      onWindowChangeDetected,\n      visibleInDom,\n      maxWidth,\n      popupPortalTarget,\n    ])\n\n    // This will be triggered when positions are computed and popup is visible in the dom.\n    useEffect(\n      () => {\n        if (visibleInDom && innerPopupRef.current) {\n          innerPopupRef.current.style.opacity = '1'\n        }\n      },\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      [positions],\n    )\n\n    /**\n     * If popup has `visible` prop it means the popup is manually controlled through this prop.\n     * In this cas we don't want to display popup on hover, but only when `visible` is true.\n     */\n    useEffect(() => {\n      if (isControlled) {\n        onPointerEvent(visible)()\n      }\n    }, [isControlled, onPointerEvent, visible])\n\n    // Handle hide on esc press and hide on click outside\n    useEffect(() => {\n      const handleEscPress = (event: KeyboardEvent) => {\n        if (event.key === 'Escape') {\n          event.preventDefault()\n          event.stopPropagation()\n          closePopup()\n        }\n      }\n\n      const handleClickOutside = (event: MouseEvent) => {\n        const popupCurrent = innerPopupRef.current\n        const childrenCurrent = childrenRef.current\n\n        if (popupCurrent && hideOnClickOutside && !event.defaultPrevented) {\n          if (\n            event.target &&\n            event.target !== popupCurrent &&\n            event.target !== childrenCurrent &&\n            !childrenCurrent?.contains(event.target as Node) &&\n            !popupCurrent.contains(event.target as Node)\n          ) {\n            event.preventDefault()\n            event.stopPropagation()\n            closePopup()\n          }\n        }\n      }\n      if (visibleInDom) {\n        document.body.addEventListener('keyup', handleEscPress)\n        document.body.addEventListener('click', handleClickOutside)\n      }\n\n      return () => {\n        document.body.removeEventListener('keyup', handleEscPress)\n        document.body.removeEventListener('click', handleClickOutside)\n      }\n    }, [\n      closePopup,\n      visibleInDom,\n      innerPopupRef,\n      childrenRef,\n      hideOnClickOutside,\n    ])\n\n    /**\n     * This event will occur only for dialog and will trap focus inside the dialog.\n     */\n    const handleFocusTrap: KeyboardEventHandler = useCallback(event => {\n      const isTabPressed = event.key === 'Tab'\n      if (!isTabPressed) {\n        return\n      }\n      event.stopPropagation()\n\n      const focusableEls =\n        innerPopupRef.current?.querySelectorAll(\n          'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled])',\n        ) ?? []\n\n      // Handle case when no interactive element are within the modal (including close icon)\n      if (focusableEls.length === 0) {\n        event.preventDefault()\n      }\n\n      const firstFocusableEl = focusableEls[0] as HTMLElement\n      const lastFocusableEl = focusableEls[\n        focusableEls.length - 1\n      ] as HTMLElement\n\n      if (event.shiftKey) {\n        if (\n          document.activeElement === firstFocusableEl ||\n          document.activeElement === innerPopupRef.current\n        ) {\n          lastFocusableEl.focus()\n          event.preventDefault()\n        }\n      } else if (\n        document.activeElement === lastFocusableEl ||\n        document.activeElement === innerPopupRef.current\n      ) {\n        firstFocusableEl.focus()\n        event.preventDefault()\n      }\n    }, [])\n\n    /**\n     * Will render children conditionally if children is a function or not.\n     */\n    const renderChildren = useCallback(() => {\n      if (typeof children === 'function') {\n        return children({\n          onBlur: !isControlled ? onPointerEvent(false) : noop,\n          onFocus: !isControlled ? onPointerEvent(true) : noop,\n          onPointerEnter: !isControlled ? onPointerEvent(true) : noop,\n          onPointerLeave: !isControlled ? onPointerEvent(false) : noop,\n          ref: childrenRef,\n        })\n      }\n\n      return (\n        <StyledChildrenContainer\n          aria-describedby={generatedId}\n          aria-controls={generatedId}\n          onBlur={!isControlled ? onPointerEvent(false) : noop}\n          onFocus={!isControlled ? onPointerEvent(true) : noop}\n          onPointerEnter={!isControlled ? onPointerEvent(true) : noop}\n          onPointerLeave={!isControlled ? onPointerEvent(false) : noop}\n          ref={childrenRef}\n          tabIndex={tabIndex}\n          onKeyDown={event => {\n            onKeyDown?.(event)\n          }}\n          data-container-full-width={containerFullWidth}\n          aria-haspopup={ariaHasPopup}\n        >\n          {children}\n        </StyledChildrenContainer>\n      )\n    }, [\n      ariaHasPopup,\n      children,\n      containerFullWidth,\n      generatedId,\n      isControlled,\n      onKeyDown,\n      onPointerEvent,\n      tabIndex,\n    ])\n\n    const shouldRender = useMemo(() => {\n      if (!dynamicDomRendering) {\n        return true\n      }\n\n      if (dynamicDomRendering && visibleInDom) {\n        return true\n      }\n\n      return false\n    }, [dynamicDomRendering, visibleInDom])\n\n    if (!text) {\n      if (typeof children === 'function') return null\n\n      return <>{children}</>\n    }\n\n    /**\n     * This event handle allow us to not bubble the event to document.body like this react-select works fine\n     */\n    const stopClickPropagation: MouseEventHandler = event => {\n      event.nativeEvent.stopImmediatePropagation()\n    }\n\n    return (\n      <>\n        {renderChildren()}\n        {shouldRender\n          ? createPortal(\n              <StyledPopup\n                ref={innerPopupRef}\n                positions={positions}\n                maxWidth={maxWidth}\n                maxHeight={maxHeight}\n                role={role}\n                id={generatedId}\n                className={className}\n                reverseAnimation={reverseAnimation}\n                data-testid={dataTestId}\n                data-has-arrow={hasArrow}\n                onClick={stopClickPropagation}\n                onPointerEnter={!isControlled ? onPointerEvent(true) : noop}\n                onPointerLeave={!isControlled ? onPointerEvent(false) : noop}\n                animationDuration={animationDuration}\n                onKeyDown={role === 'dialog' ? handleFocusTrap : undefined}\n                isDialog={role === 'dialog'}\n                data-visible-in-dom={\n                  !dynamicDomRendering ? visibleInDom : undefined\n                }\n              >\n                {text}\n              </StyledPopup>,\n              popupPortalTarget as HTMLElement,\n            )\n          : null}\n      </>\n    )\n  },\n)\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const Popup = forwardRef(({
+  children,
+  text = "",
+  placement = "auto",
+  id,
+  className,
+  containerFullWidth,
+  maxWidth = 232,
+  maxHeight,
+  visible,
+  innerRef,
+  role = "popup",
+  "data-testid": dataTestId,
+  hasArrow = true,
+  onClose,
+  tabIndex = 0,
+  onKeyDown,
+  "aria-haspopup": ariaHasPopup,
+  hideOnClickOutside = false,
+  debounceDelay = DEFAULT_DEBOUNCE_DURATION,
+  disableAnimation = false,
+  portalTarget,
+  dynamicDomRendering = true
+}, ref) => {
+  const childrenRef = useRef(null);
+  useImperativeHandle(innerRef, () => childrenRef.current);
+  const innerPopupRef = useRef(null);
+  useImperativeHandle(ref, () => innerPopupRef.current);
+  const timer = useRef();
+  const popupPortalTarget = useMemo(() => {
+    if (portalTarget)
+      return portalTarget;
+    if (role === "dialog") {
+      if (childrenRef.current)
+        return childrenRef.current;
+      if (typeof window !== "undefined")
+        return document.body;
+      return null;
+    }
+    if (typeof window !== "undefined") {
+      return document.body;
+    }
+    return null;
+  }, [portalTarget, role, childrenRef.current]);
+  const animationDuration = disableAnimation || maxHeight ? 0 : DEFAULT_ANIMATION_DURATION;
+  const debounceTimer = useRef();
+  const [visibleInDom, setVisibleInDom] = useState(false);
+  const [reverseAnimation, setReverseAnimation] = useState(false);
+  const [positions, setPositions] = useState({
+    ...DEFAULT_POSITIONS
+  });
+  const uniqueId = useId();
+  const generatedId = id ?? uniqueId;
+  const isControlled = visible !== void 0;
+  const generatePopupPositions = useCallback(() => {
+    if (childrenRef.current && innerPopupRef.current) {
+      setPositions(computePositions({
+        childrenRef,
+        placement,
+        popupRef: innerPopupRef,
+        popupPortalTarget
+      }));
+    }
+  }, [placement, popupPortalTarget]);
+  const onWindowChangeDetected = useCallback(() => {
+    if (innerPopupRef.current) {
+      innerPopupRef.current.style.animation = "none";
+    }
+    generatePopupPositions();
+  }, [generatePopupPositions, innerPopupRef]);
+  const unmountPopupFromDom = useCallback(() => {
+    setVisibleInDom(false);
+    setReverseAnimation(false);
+    window.removeEventListener("scroll", onWindowChangeDetected, true);
+  }, [onWindowChangeDetected]);
+  const closePopup = useCallback(() => {
+    debounceTimer.current = setTimeout(() => {
+      setReverseAnimation(true);
+      timer.current = setTimeout(() => {
+        unmountPopupFromDom();
+        onClose?.();
+      }, animationDuration);
+    }, debounceDelay && !disableAnimation ? debounceDelay : 0);
+  }, [animationDuration, disableAnimation, debounceDelay, onClose, unmountPopupFromDom]);
+  const onPointerEvent = useCallback((isVisible) => () => {
+    if (!visible && debounceDelay > 0 && debounceTimer.current) {
+      clearTimeout(debounceTimer.current);
+      debounceTimer.current = void 0;
+    }
+    if (!isVisible && innerPopupRef.current && !debounceTimer.current) {
+      closePopup();
+    } else if (isVisible) {
+      if (timer.current) {
+        setReverseAnimation(false);
+        clearTimeout(timer.current);
+        timer.current = void 0;
+      }
+      if (debounceTimer.current) {
+        clearTimeout(debounceTimer.current);
+        debounceTimer.current = void 0;
+      }
+      if (debounceDelay > 0) {
+        debounceTimer.current = setTimeout(() => {
+          setVisibleInDom(true);
+        }, debounceDelay);
+      } else {
+        setVisibleInDom(true);
+      }
+    }
+  }, [closePopup, debounceDelay, visible]);
+  useEffect(() => {
+    if (visibleInDom) {
+      generatePopupPositions();
+      if (popupPortalTarget === document.body) {
+        window.addEventListener("scroll", onWindowChangeDetected, true);
+      }
+      window.addEventListener("resize", onWindowChangeDetected, true);
+    }
+    return () => {
+      window.removeEventListener("scroll", onWindowChangeDetected, true);
+      window.removeEventListener("resize", onWindowChangeDetected, true);
+      if (timer.current) {
+        clearTimeout(timer.current);
+        timer.current = void 0;
+      }
+    };
+  }, [generatePopupPositions, onWindowChangeDetected, visibleInDom, maxWidth, popupPortalTarget]);
+  useEffect(
+    () => {
+      if (visibleInDom && innerPopupRef.current) {
+        innerPopupRef.current.style.opacity = "1";
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [positions]
+  );
+  useEffect(() => {
+    if (isControlled) {
+      onPointerEvent(visible)();
+    }
+  }, [isControlled, onPointerEvent, visible]);
+  useEffect(() => {
+    const handleEscPress = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        closePopup();
+      }
+    };
+    const handleClickOutside = (event) => {
+      const popupCurrent = innerPopupRef.current;
+      const childrenCurrent = childrenRef.current;
+      if (popupCurrent && hideOnClickOutside && !event.defaultPrevented) {
+        if (event.target && event.target !== popupCurrent && event.target !== childrenCurrent && !childrenCurrent?.contains(event.target) && !popupCurrent.contains(event.target)) {
+          event.preventDefault();
+          event.stopPropagation();
+          closePopup();
+        }
+      }
+    };
+    if (visibleInDom) {
+      document.body.addEventListener("keyup", handleEscPress);
+      document.body.addEventListener("click", handleClickOutside);
+    }
+    return () => {
+      document.body.removeEventListener("keyup", handleEscPress);
+      document.body.removeEventListener("click", handleClickOutside);
+    };
+  }, [closePopup, visibleInDom, innerPopupRef, childrenRef, hideOnClickOutside]);
+  const handleFocusTrap = useCallback((event) => {
+    const isTabPressed = event.key === "Tab";
+    if (!isTabPressed) {
+      return;
+    }
+    event.stopPropagation();
+    const focusableEls = innerPopupRef.current?.querySelectorAll("a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled])") ?? [];
+    if (focusableEls.length === 0) {
+      event.preventDefault();
+    }
+    const firstFocusableEl = focusableEls[0];
+    const lastFocusableEl = focusableEls[focusableEls.length - 1];
+    if (event.shiftKey) {
+      if (document.activeElement === firstFocusableEl || document.activeElement === innerPopupRef.current) {
+        lastFocusableEl.focus();
+        event.preventDefault();
+      }
+    } else if (document.activeElement === lastFocusableEl || document.activeElement === innerPopupRef.current) {
+      firstFocusableEl.focus();
+      event.preventDefault();
+    }
+  }, []);
+  const renderChildren = useCallback(() => {
+    if (typeof children === "function") {
+      return children({
+        onBlur: !isControlled ? onPointerEvent(false) : noop,
+        onFocus: !isControlled ? onPointerEvent(true) : noop,
+        onPointerEnter: !isControlled ? onPointerEvent(true) : noop,
+        onPointerLeave: !isControlled ? onPointerEvent(false) : noop,
+        ref: childrenRef
+      });
+    }
+    return /* @__PURE__ */ jsx(StyledChildrenContainer, { "aria-describedby": generatedId, "aria-controls": generatedId, onBlur: !isControlled ? onPointerEvent(false) : noop, onFocus: !isControlled ? onPointerEvent(true) : noop, onPointerEnter: !isControlled ? onPointerEvent(true) : noop, onPointerLeave: !isControlled ? onPointerEvent(false) : noop, ref: childrenRef, tabIndex, onKeyDown: (event) => {
+      onKeyDown?.(event);
+    }, "data-container-full-width": containerFullWidth, "aria-haspopup": ariaHasPopup, children });
+  }, [ariaHasPopup, children, containerFullWidth, generatedId, isControlled, onKeyDown, onPointerEvent, tabIndex]);
+  const shouldRender = useMemo(() => {
+    if (!dynamicDomRendering) {
+      return true;
+    }
+    if (dynamicDomRendering && visibleInDom) {
+      return true;
+    }
+    return false;
+  }, [dynamicDomRendering, visibleInDom]);
+  if (!text) {
+    if (typeof children === "function")
+      return null;
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  const stopClickPropagation = (event) => {
+    event.nativeEvent.stopImmediatePropagation();
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    renderChildren(),
+    shouldRender ? createPortal(/* @__PURE__ */ jsx(StyledPopup, { ref: innerPopupRef, positions, maxWidth, maxHeight, role, id: generatedId, className, reverseAnimation, "data-testid": dataTestId, "data-has-arrow": hasArrow, onClick: stopClickPropagation, onPointerEnter: !isControlled ? onPointerEvent(true) : noop, onPointerLeave: !isControlled ? onPointerEvent(false) : noop, animationDuration, onKeyDown: role === "dialog" ? handleFocusTrap : void 0, isDialog: role === "dialog", "data-visible-in-dom": !dynamicDomRendering ? visibleInDom : void 0, children: text }), popupPortalTarget) : null
+  ] });
+});
+export {
+  Popup
+};

package/dist/components/ProgressBar/index.d.ts

@@ -0,0 +1,14 @@
+export declare const progressBarSentiments: readonly ["primary", "success", "warning", "info", "danger"];
+type ProgressBarProps = {
+    sentiment?: (typeof progressBarSentiments)[number];
+    value?: number;
+    /** Put ProgressBar in a loading state */
+    progress?: boolean;
+    className?: string;
+    'data-testid'?: string;
+};
+/**
+ * Progress bar component to display progress of a task. Can be used to display progress of a form or a loading state.
+ */
+export declare const ProgressBar: ({ progress, value, sentiment, className, "data-testid": dataTestId, }: ProgressBarProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ProgressBar/index.js

@@ -0,0 +1,53 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { keyframes } from "@emotion/react";
+const shineAnimation = keyframes`
+  from {
+    left: -25%;
+  }
+
+  to {
+    left: 100%;
+  }
+`;
+const StyledProgressContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1b95x8r2"
+} : {
+  target: "e1b95x8r2",
+  label: "StyledProgressContainer"
+})("overflow:hidden;position:relative;height:4px;margin-left:0;margin-right:0;border-radius:", ({
+  theme
+}) => theme.radii.default, ";background-color:", ({
+  theme
+}) => theme.colors.neutral.backgroundStrong, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL3VsdHJhdmlvbGV0L3VsdHJhdmlvbGV0L3BhY2thZ2VzL3VpL3NyYy9jb21wb25lbnRzL1Byb2dyZXNzQmFyL2luZGV4LnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQjBDIiwiZmlsZSI6Ii9ob21lL3J1bm5lci93b3JrL3VsdHJhdmlvbGV0L3VsdHJhdmlvbGV0L3BhY2thZ2VzL3VpL3NyYy9jb21wb25lbnRzL1Byb2dyZXNzQmFyL2luZGV4LnRzeCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGtleWZyYW1lcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0J1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnXG5pbXBvcnQgdHlwZSB7IENvbG9yIH0gZnJvbSAnLi4vLi4vdGhlbWUnXG5cbmNvbnN0IHNoaW5lQW5pbWF0aW9uID0ga2V5ZnJhbWVzYFxuICBmcm9tIHtcbiAgICBsZWZ0OiAtMjUlO1xuICB9XG5cbiAgdG8ge1xuICAgIGxlZnQ6IDEwMCU7XG4gIH1cbmBcblxuZXhwb3J0IGNvbnN0IHByb2dyZXNzQmFyU2VudGltZW50cyA9IFtcbiAgJ3ByaW1hcnknLFxuICAnc3VjY2VzcycsXG4gICd3YXJuaW5nJyxcbiAgJ2luZm8nLFxuICAnZGFuZ2VyJyxcbl0gYXMgY29uc3RcblxuY29uc3QgU3R5bGVkUHJvZ3Jlc3NDb250YWluZXIgPSBzdHlsZWQuZGl2YFxuICBvdmVyZmxvdzogaGlkZGVuO1xuICBwb3NpdGlvbjogcmVsYXRpdmU7XG4gIGhlaWdodDogNHB4O1xuICBtYXJnaW4tbGVmdDogMDtcbiAgbWFyZ2luLXJpZ2h0OiAwO1xuICBib3JkZXItcmFkaXVzOiAkeyh7IHRoZW1lIH0pID0+IHRoZW1lLnJhZGlpLmRlZmF1bHR9O1xuICBiYWNrZ3JvdW5kLWNvbG9yOiAkeyh7IHRoZW1lIH0pID0+IHRoZW1lLmNvbG9ycy5uZXV0cmFsLmJhY2tncm91bmRTdHJvbmd9O1xuYFxuXG5jb25zdCBTdHlsZWRQcm9ncmVzcyA9IHN0eWxlZC5kaXZgXG4gIHBvc2l0aW9uOiBhYnNvbHV0ZTtcbiAgdG9wOiAwO1xuICBsZWZ0OiAwO1xuICBib3R0b206IDA7XG4gIHdpZHRoOiAyNSU7XG4gIG9wYWNpdHk6IDAuODtcbiAgYmFja2dyb3VuZDogbGluZWFyLWdyYWRpZW50KFxuICAgIDkwZGVnLFxuICAgIHJnYmEoMjU1LCAyNTUsIDI1NSwgMCksXG4gICAgcmdiYSgyNTUsIDI1NSwgMjU1LCAwLjMpLFxuICAgIHJnYmEoMjU1LCAyNTUsIDI1NSwgMC40KSxcbiAgICByZ2JhKDI1NSwgMjU1LCAyNTUsIDAuMyksXG4gICAgcmdiYSgyNTUsIDI1NSwgMjU1LCAwKVxuICApO1xuICBhbmltYXRpb246ICR7c2hpbmVBbmltYXRpb259IDFzIGxpbmVhciBpbmZpbml0ZTtcbmBcblxuY29uc3QgU3R5bGVkRmlsbGVkID0gc3R5bGVkKCdkaXYnLCB7XG4gIHNob3VsZEZvcndhcmRQcm9wOiBwcm9wID0+ICFbJ3NlbnRpbWVudCcsICd2YWx1ZSddLmluY2x1ZGVzKHByb3ApLFxufSk8eyBzZW50aW1lbnQ6IHN0cmluZzsgdmFsdWU6IG51bWJlciB9PmBcbiAgYm9yZGVyLXJhZGl1czogJHsoeyB0aGVtZSB9KSA9PiB0aGVtZS5yYWRpaS5kZWZhdWx0fTtcbiAgcG9zaXRpb246IGFic29sdXRlO1xuICB0b3A6IDA7XG4gIGxlZnQ6IDA7XG4gIGJvdHRvbTogMDtcbiAgYmFja2dyb3VuZC1jb2xvcjogJHsoeyB0aGVtZSwgc2VudGltZW50IH0pID0+XG4gICAgdGhlbWUuY29sb3JzW3NlbnRpbWVudCBhcyBDb2xvcl0uYmFja2dyb3VuZFN0cm9uZyA/PyAnaW5oZXJpdCd9O1xuICB0cmFuc2l0aW9uOiAwLjNzIHdpZHRoO1xuICB3aWR0aDogJHsoeyB2YWx1ZSB9KSA9PiBNYXRoLm1heCgwLCBNYXRoLm1pbigxMDAsIHZhbHVlKSl9JTtcbmBcblxudHlwZSBQcm9ncmVzc0JhclByb3BzID0ge1xuICBzZW50aW1lbnQ/OiAodHlwZW9mIHByb2dyZXNzQmFyU2VudGltZW50cylbbnVtYmVyXVxuICB2YWx1ZT86IG51bWJlclxuICAvKiogUHV0IFByb2dyZXNzQmFyIGluIGEgbG9hZGluZyBzdGF0ZSAqL1xuICBwcm9ncmVzcz86IGJvb2xlYW5cbiAgY2xhc3NOYW1lPzogc3RyaW5nXG4gICdkYXRhLXRlc3RpZCc/OiBzdHJpbmdcbn1cblxuLyoqXG4gKiBQcm9ncmVzcyBiYXIgY29tcG9uZW50IHRvIGRpc3BsYXkgcHJvZ3Jlc3Mgb2YgYSB0YXNrLiBDYW4gYmUgdXNlZCB0byBkaXNwbGF5IHByb2dyZXNzIG9mIGEgZm9ybSBvciBhIGxvYWRpbmcgc3RhdGUuXG4gKi9cbmV4cG9ydCBjb25zdCBQcm9ncmVzc0JhciA9ICh7XG4gIHByb2dyZXNzID0gZmFsc2UsXG4gIHZhbHVlID0gMCxcbiAgc2VudGltZW50ID0gJ3ByaW1hcnknLFxuICBjbGFzc05hbWUsXG4gICdkYXRhLXRlc3RpZCc6IGRhdGFUZXN0SWQsXG59OiBQcm9ncmVzc0JhclByb3BzKSA9PiAoXG4gIDxTdHlsZWRQcm9ncmVzc0NvbnRhaW5lclxuICAgIHJvbGU9XCJwcm9ncmVzc2JhclwiXG4gICAgYXJpYS12YWx1ZW5vdz17dmFsdWV9XG4gICAgYXJpYS12YWx1ZW1pbj17MH1cbiAgICBhcmlhLXZhbHVlbWF4PXsxMDB9XG4gICAgY2xhc3NOYW1lPXtjbGFzc05hbWV9XG4gICAgZGF0YS10ZXN0aWQ9e2RhdGFUZXN0SWR9XG4gID5cbiAgICB7cHJvZ3Jlc3MgPyAoXG4gICAgICA8U3R5bGVkUHJvZ3Jlc3MgLz5cbiAgICApIDogKFxuICAgICAgPFN0eWxlZEZpbGxlZCBzZW50aW1lbnQ9e3NlbnRpbWVudH0gdmFsdWU9e3ZhbHVlfSAvPlxuICAgICl9XG4gIDwvU3R5bGVkUHJvZ3Jlc3NDb250YWluZXI+XG4pXG4iXX0= */"));
+const StyledProgress = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1b95x8r1"
+} : {
+  target: "e1b95x8r1",
+  label: "StyledProgress"
+})("position:absolute;top:0;left:0;bottom:0;width:25%;opacity:0.8;background:linear-gradient(\n    90deg,\n    rgba(255, 255, 255, 0),\n    rgba(255, 255, 255, 0.3),\n    rgba(255, 255, 255, 0.4),\n    rgba(255, 255, 255, 0.3),\n    rgba(255, 255, 255, 0)\n  );animation:", shineAnimation, " 1s linear infinite;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const StyledFilled = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["sentiment", "value"].includes(prop),
+  target: "e1b95x8r0"
+} : {
+  shouldForwardProp: (prop) => !["sentiment", "value"].includes(prop),
+  target: "e1b95x8r0",
+  label: "StyledFilled"
+})("border-radius:", ({
+  theme
+}) => theme.radii.default, ";position:absolute;top:0;left:0;bottom:0;background-color:", ({
+  theme,
+  sentiment
+}) => theme.colors[sentiment].backgroundStrong ?? "inherit", ";transition:0.3s width;width:", ({
+  value
+}) => Math.max(0, Math.min(100, value)), "%;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const ProgressBar = ({
+  progress = false,
+  value = 0,
+  sentiment = "primary",
+  className,
+  "data-testid": dataTestId
+}) => /* @__PURE__ */ jsx(StyledProgressContainer, { role: "progressbar", "aria-valuenow": value, "aria-valuemin": 0, "aria-valuemax": 100, className, "data-testid": dataTestId, children: progress ? /* @__PURE__ */ jsx(StyledProgress, {}) : /* @__PURE__ */ jsx(StyledFilled, { sentiment, value }) });
+export {
+  ProgressBar
+};