@zextras/carbonio-design-system 12.1.5 → 12.1.7

package/dist/zapp-ui.bundle.cjs

@@ -7681,6 +7681,20 @@ function getKeyboardPreset(type, callback = () => undefined, ref = undefined, ke
       return [];
   }
 }
+function createKeyboardListener({
+  keys,
+  callback,
+  haveToPreventDefault = true
+}) {
+  return e => {
+    if (keys.length === 0 || keys.some(key => lodash.isMatch(e, key))) {
+      if (haveToPreventDefault) {
+        e.preventDefault();
+      }
+      callback(e);
+    }
+  };
+}
 
 /**
  * Attach listeners for the given presets to the given ref.
@@ -7690,18 +7704,7 @@ function getKeyboardPreset(type, callback = () => undefined, ref = undefined, ke
  * To avoid having listeners registered on the keyboard events, provide an empty presets array.
  */
 function useKeyboard(ref, presets, registerListener = true) {
-  const keyboardListeners = React.useMemo(() => presets.map(({
-    keys,
-    callback,
-    haveToPreventDefault = true
-  }) => e => {
-    if (keys.length === 0 || keys.some(key => lodash.isMatch(e, key))) {
-      if (haveToPreventDefault) {
-        e.preventDefault();
-      }
-      callback(e);
-    }
-  }), [presets]);
+  const keyboardListeners = React.useMemo(() => presets.map(createKeyboardListener), [presets]);
   React.useEffect(() => {
     const refSave = ref instanceof HTMLElement ? ref : ref?.current;
     if (refSave && registerListener) {
@@ -8616,7 +8619,7 @@ const ContainerEl$2 = /*#__PURE__*/createStyled(Container, process.env.NODE_ENV
   theme,
   $disabled,
   $selectedBackgroundColor
-}) => !$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5'), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AA0CE","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => () => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */"));
+}) => !$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5'), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AA0CE","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => (): void => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */"));
 function ListItemContent({
   icon,
   label,
@@ -8859,13 +8862,13 @@ const PopperDropdownWrapper = /*#__PURE__*/createStyled("div", process.env.NODE_
   $display
 }) => $display, ";width:", ({
   $display
-}) => $display === 'block' ? '100%' : 'auto', ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AAqVE","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => () => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */"));
+}) => $display === 'block' ? '100%' : 'auto', ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AAsVE","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => (): void => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */"));
 var _ref$9 = process.env.NODE_ENV === "production" ? {
   name: "4ecpbi",
   styles: "display:block;visibility:visible;pointer-events:auto"
 } : {
   name: "ck7rto-PopperList",
-  styles: "display:block;visibility:visible;pointer-events:auto;label:PopperList;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AAmYK","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => () => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */",
+  styles: "display:block;visibility:visible;pointer-events:auto;label:PopperList;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AAoYK","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => (): void => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$q
 };
 const PopperList = /*#__PURE__*/createStyled("div", process.env.NODE_ENV === "production" ? {
@@ -8889,7 +8892,7 @@ const PopperList = /*#__PURE__*/createStyled("div", process.env.NODE_ENV === "pr
   theme
 }) => theme.palette.gray3.regular, ";border-radius:0.25rem;}&,>[tabindex='-1']:focus{outline:none;}", ({
   $open
-}) => $open && _ref$9, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AAgWE","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => () => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */"));
+}) => $open && _ref$9, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Dropdown.tsx"],"names":[],"mappings":"AAiWE","file":"Dropdown.tsx","sourcesContent":["/*\n * SPDX-FileCopyrightText: 2021 Zextras <https://www.zextras.com>\n *\n * SPDX-License-Identifier: AGPL-3.0-only\n */\n/* eslint-disable jsx-a11y/no-noninteractive-tabindex */\n\nimport type { HTMLAttributes } from 'react';\nimport React, { useState, useRef, useEffect, useLayoutEffect, useCallback, useMemo } from 'react';\n\nimport { css, useTheme } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport type { Placement, VirtualElement } from '@floating-ui/dom';\nimport { flip, limitShift, shift } from '@floating-ui/dom';\n\nimport { useCombinedRefs } from '../../../hooks/useCombinedRefs';\nimport type { KeyboardPresetObj } from '../../../hooks/useKeyboard';\nimport {\n\tuseKeyboard,\n\tgetKeyboardPreset,\n\tfocusOnNextNode,\n\tfocusOnPreviousNode,\n\tfocusOnFirstNode,\n\tfocusOnLastNode,\n\tclickNodeWithFocus\n} from '../../../hooks/useKeyboard';\nimport type { Theme } from '../../../theme/theme';\nimport { pseudoClasses } from '../../../theme/theme-utils';\nimport type { AnyColor } from '../../../types/utils';\nimport { setupFloating } from '../../../utils/floating-ui';\nimport { Icon } from '../../basic/icon/Icon';\nimport { Text } from '../../basic/text/Text';\nimport { FOCUSABLE_SELECTOR, TIMERS } from '../../constants';\nimport { Container } from '../../layout/container/Container';\nimport { Divider } from '../../layout/divider/Divider';\nimport { Padding } from '../../layout/padding/Padding';\nimport { Portal } from '../../utilities/portal/Portal';\nimport { Tooltip } from '../tooltip/Tooltip';\n\nconst ContainerEl = styled(Container)<{\n\t$selectedBackgroundColor?: AnyColor;\n\t$disabled: boolean;\n}>`\n\tuser-select: none;\n\toutline: none;\n\t${({ theme, $disabled, $selectedBackgroundColor }): ReturnType<typeof css> | false =>\n\t\t!$disabled && pseudoClasses(theme, $selectedBackgroundColor ?? 'gray5')};\n`;\n\ninterface ListItemContentProps {\n\ticon?: string;\n\tlabel: string;\n\tselected?: boolean;\n\tdisabled?: boolean;\n\titemIconSize: React.ComponentPropsWithRef<typeof Icon>['size'];\n\titemTextSize: React.ComponentProps<typeof Text>['size'];\n\titemPaddingBetween: keyof Theme['sizes']['padding'];\n\ttooltipLabel?: string;\n}\n\nfunction ListItemContent({\n\ticon,\n\tlabel,\n\tselected,\n\tdisabled,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\ttooltipLabel\n}: Readonly<ListItemContentProps>): React.JSX.Element {\n\treturn (\n\t\t<Tooltip disabled={!disabled || !tooltipLabel} label={tooltipLabel} placement=\"bottom-end\">\n\t\t\t<Container orientation=\"horizontal\" mainAlignment=\"flex-start\">\n\t\t\t\t{icon && (\n\t\t\t\t\t<Padding right={itemPaddingBetween}>\n\t\t\t\t\t\t<Icon\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tsize={itemIconSize}\n\t\t\t\t\t\t\tcolor={disabled ? 'secondary' : 'text'}\n\t\t\t\t\t\t\tstyle={{ pointerEvents: 'none' }}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</Padding>\n\t\t\t\t)}\n\t\t\t\t<Text\n\t\t\t\t\tsize={itemTextSize}\n\t\t\t\t\tweight={selected ? 'bold' : 'regular'}\n\t\t\t\t\tcolor={disabled ? 'secondary.regular' : 'text'}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t>\n\t\t\t\t\t{label}\n\t\t\t\t</Text>\n\t\t\t</Container>\n\t\t</Tooltip>\n\t);\n}\n\ninterface PopperListItemProps extends ListItemContentProps, HTMLAttributes<HTMLDivElement> {\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tcustomComponent?: React.ReactNode;\n\tselectedBackgroundColor?: AnyColor;\n\tkeepOpen?: boolean;\n}\n\nfunction PopperListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\tkeepOpen,\n\titemPaddingBetween,\n\ttooltipLabel,\n\t...rest\n}: Readonly<PopperListItemProps>): React.JSX.Element {\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={(!disabled && onClick) || undefined}\n\t\t\ttabIndex={disabled ? -1 : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tbackground={selected && selectedBackgroundColor ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{customComponent || (\n\t\t\t\t<ListItemContent\n\t\t\t\t\ticon={icon}\n\t\t\t\t\tlabel={label}\n\t\t\t\t\tselected={selected}\n\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</ContainerEl>\n\t);\n}\n\ninterface NestListItemProps\n\textends PopperListItemProps,\n\t\tPick<DropdownProps, 'onOpen' | 'onClose' | 'dropdownListRef' | 'items'> {}\n\nfunction NestListItem({\n\ticon,\n\tlabel,\n\tonClick,\n\tselected,\n\tcustomComponent,\n\tdisabled = false,\n\titems,\n\tselectedBackgroundColor,\n\titemIconSize,\n\titemTextSize,\n\titemPaddingBetween,\n\tkeepOpen,\n\tdropdownListRef = null,\n\ttooltipLabel,\n\tonOpen,\n\tonClose,\n\t...rest\n}: Readonly<NestListItemProps>): React.JSX.Element {\n\tconst [open, setOpen] = useState(false);\n\tconst itemRef = useRef<HTMLDivElement | null>(null);\n\tconst [innerDropdownListElement, setInnerDropdownListElement] = useState<HTMLDivElement | null>(\n\t\tnull\n\t);\n\tconst setDropdownListRef = useCallback<React.RefCallback<HTMLDivElement>>(\n\t\t(node) => {\n\t\t\tsetInnerDropdownListElement(node);\n\t\t\tif (dropdownListRef) {\n\t\t\t\tif (typeof dropdownListRef === 'function') {\n\t\t\t\t\tdropdownListRef(node);\n\t\t\t\t} else {\n\t\t\t\t\t// eslint-disable-next-line no-param-reassign\n\t\t\t\t\tdropdownListRef.current = node;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[dropdownListRef]\n\t);\n\tconst closeNestedDropdownTimeoutRef = useRef<NodeJS.Timeout>();\n\n\tuseEffect(\n\t\t() => (): void => {\n\t\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t}\n\t\t},\n\t\t[]\n\t);\n\n\tconst openNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tsetOpen(true);\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closeNestedDropdown = useCallback(() => {\n\t\tif (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t}\n\t\tconst focusIsOnChild = itemRef.current?.contains(document.activeElement);\n\t\tsetOpen(false);\n\t\tonClose?.();\n\t\tif (focusIsOnChild) {\n\t\t\titemRef.current?.focus({ preventScroll: true });\n\t\t}\n\t}, [onClose]);\n\n\tconst itemKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: openNestedDropdown,\n\t\t\t\tkeys: [{ key: 'ArrowRight', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[openNestedDropdown]\n\t);\n\n\tuseKeyboard(itemRef, itemKeyEvents);\n\n\tconst dropdownKeyEvents = useMemo(\n\t\t(): KeyboardPresetObj[] => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t},\n\t\t\t\tkeys: [\n\t\t\t\t\t{ key: 'Escape', ctrlKey: false },\n\t\t\t\t\t{ key: 'ArrowLeft', ctrlKey: false }\n\t\t\t\t]\n\t\t\t}\n\t\t],\n\t\t[closeNestedDropdown]\n\t);\n\n\tuseKeyboard(innerDropdownListElement, dropdownKeyEvents, open);\n\n\tconst closeOnMouseLeave = useCallback(\n\t\t(event: Event) => {\n\t\t\tif (event.target instanceof Node) {\n\t\t\t\tconst eventIsOnTrigger = itemRef.current?.contains(event.target);\n\t\t\t\tconst eventIsOnDropdown = innerDropdownListElement?.contains(event.target);\n\t\t\t\tif (!eventIsOnDropdown && !eventIsOnTrigger) {\n\t\t\t\t\tif (closeNestedDropdownTimeoutRef.current === undefined) {\n\t\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = setTimeout(() => {\n\t\t\t\t\t\t\tcloseNestedDropdown();\n\t\t\t\t\t\t}, TIMERS.DROPDOWN.CLOSE_NESTED);\n\t\t\t\t\t}\n\t\t\t\t} else if (closeNestedDropdownTimeoutRef.current !== undefined) {\n\t\t\t\t\tclearTimeout(closeNestedDropdownTimeoutRef.current);\n\t\t\t\t\tcloseNestedDropdownTimeoutRef.current = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[closeNestedDropdown, innerDropdownListElement]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindow.addEventListener('mouseover', closeOnMouseLeave);\n\t\t}\n\t\treturn (): void => {\n\t\t\twindow.removeEventListener('mouseover', closeOnMouseLeave);\n\t\t};\n\t}, [closeOnMouseLeave, open]);\n\n\treturn (\n\t\t<ContainerEl\n\t\t\tdata-keep-open={keepOpen}\n\t\t\tref={itemRef}\n\t\t\tclassName={selected ? 'zapp-selected' : ''}\n\t\t\torientation=\"horizontal\"\n\t\t\tmainAlignment=\"flex-start\"\n\t\t\tstyle={{ cursor: onClick && !disabled ? 'pointer' : 'default' }}\n\t\t\tonClick={disabled ? undefined : onClick}\n\t\t\ttabIndex={disabled ? undefined : 0}\n\t\t\t$disabled={disabled}\n\t\t\t$selectedBackgroundColor={selected ? selectedBackgroundColor : undefined}\n\t\t\tdata-testid={'dropdown-item'}\n\t\t\tonMouseEnter={openNestedDropdown}\n\t\t\t{...rest}\n\t\t>\n\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t<Dropdown\n\t\t\t\tdisplay=\"block\"\n\t\t\t\titems={items}\n\t\t\t\tforceOpen={open}\n\t\t\t\tplacement=\"right-start\"\n\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\tdropdownListRef={setDropdownListRef}\n\t\t\t\tdisablePortal\n\t\t\t>\n\t\t\t\t<Container\n\t\t\t\t\torientation=\"horizontal\"\n\t\t\t\t\tmainAlignment=\"space-between\"\n\t\t\t\t\tpadding={{ vertical: 'small', horizontal: 'large' }}\n\t\t\t\t>\n\t\t\t\t\t{customComponent || (\n\t\t\t\t\t\t<ListItemContent\n\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\tlabel={label}\n\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\tdisabled={disabled}\n\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\ttooltipLabel={tooltipLabel}\n\t\t\t\t\t\t/>\n\t\t\t\t\t)}\n\t\t\t\t\t<Icon size={itemIconSize} icon=\"ChevronRight\" />\n\t\t\t\t</Container>\n\t\t\t\t{/* eslint-disable-next-line @typescript-eslint/no-use-before-define */}\n\t\t\t</Dropdown>\n\t\t</ContainerEl>\n\t);\n}\n\nconst PopperDropdownWrapper = styled.div<{\n\t$display: 'inline-block' | 'block';\n}>`\n\tposition: relative;\n\tdisplay: ${({ $display }): 'inline-block' | 'block' => $display};\n\twidth: ${({ $display }): string => ($display === 'block' ? '100%' : 'auto')};\n`;\nconst PopperList = styled.div<{\n\t$width: string;\n\t$maxWidth: string;\n\t$maxHeight: string;\n\t$triggerRef: React.RefObject<HTMLElement>;\n\t$open: boolean;\n}>`\n\tposition: fixed;\n\tdisplay: none;\n\tvisibility: hidden;\n\tpointer-events: none;\n\tbackground-color: ${({ theme }): string => theme.palette.gray5.regular};\n\tbox-shadow: ${({ theme }): string => theme.shadows.regular};\n\tz-index: 999;\n\n\tmax-width: ${({ $width, $maxWidth }): string => ($width === '100%' ? '100%' : $maxWidth)};\n\tmax-height: ${({ $maxHeight }): string => $maxHeight};\n\twidth: ${({ $width, $triggerRef }): string =>\n\t\t$width === '100%' && $triggerRef.current ? `${$triggerRef.current.clientWidth}px` : $width};\n\toverflow-y: auto;\n\n\t&::-webkit-scrollbar {\n\t\twidth: 0.5rem;\n\t}\n\n\t&::-webkit-scrollbar-track {\n\t\tbackground-color: transparent;\n\t}\n\n\t&::-webkit-scrollbar-thumb {\n\t\tbackground-color: ${({ theme }): string => theme.palette.gray3.regular};\n\t\tborder-radius: 0.25rem;\n\t}\n\n\t&,\n\t> [tabindex='-1']:focus {\n\t\toutline: none;\n\t}\n\n\t${({ $open }): ReturnType<typeof css> | false =>\n\t\t$open &&\n\t\tcss`\n\t\t\tdisplay: block;\n\t\t\tvisibility: visible;\n\t\t\tpointer-events: auto;\n\t\t`};\n`;\n\ninterface DropdownItem {\n\ttype?: 'divider';\n\tid: string;\n\tlabel?: string;\n\ticon?: string;\n\tonClick?: (e: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;\n\tselected?: boolean;\n\tcustomComponent?: React.ReactNode;\n\tdisabled?: boolean;\n\titems?: Array<DropdownItem>;\n\tkeepOpen?: boolean;\n\ttooltipLabel?: string;\n}\n\ninterface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {\n\t/** Whether to disable the Dropdown or not */\n\tdisabled?: boolean;\n\t/** Array of items to display */\n\titems: Array<DropdownItem>;\n\t/** Css display property */\n\tdisplay?: 'block' | 'inline-block';\n\t/** Dropdown width type */\n\twidth?: string;\n\t/** Css max-width property */\n\tmaxWidth?: string;\n\t/** Css max-height property */\n\tmaxHeight?: string;\n\t/** whether to manage the keyboard events for dropdown trigger */\n\thandleTriggerEvents?: boolean;\n\t/** whether to disable the re-focus of trigger */\n\tdisableRestoreFocus?: boolean;\n\t/** whether to focus the first item of the Dropdown on open */\n\tdisableAutoFocus?: boolean;\n\t/** whether user can select multiple items of dropdown aka do not close popover on item click */\n\tmultiple?: boolean;\n\t/** Open dropdown on right click at cursor position */\n\tcontextMenu?: boolean;\n\t/** Callback for opened Dropdown */\n\tonOpen?: () => void;\n\t/** Callback for closed Dropdown */\n\tonClose?: () => void;\n\t/** Only one component can be passed as children */\n\tchildren: React.ReactElement;\n\t/** trigger ref that can be used instead of lost children ref caused by cloneElement */\n\ttriggerRef?: React.Ref<HTMLElement> | null;\n\t/** Placement of the dropdown */\n\tplacement?: Placement;\n\t/** Flag to disable the Portal implementation */\n\tdisablePortal?: boolean;\n\t/** Whether the Component is visible or not */\n\tforceOpen?: boolean;\n\t/** Whether to preventDefault on Dropdown click */\n\tpreventDefault?: boolean;\n\t/** Customize selected background color */\n\tselectedBackgroundColor?: AnyColor;\n\t/** Item Icon size */\n\titemIconSize?: React.ComponentPropsWithRef<typeof Icon>['size'];\n\t/** Item Text size */\n\titemTextSize?: React.ComponentPropsWithRef<typeof Text>['size'];\n\t/** Item Padding Between */\n\titemPaddingBetween?: keyof Theme['sizes']['padding'];\n\t/** Ref assign to the dropdown list popper container */\n\tdropdownListRef?: React.ForwardedRef<HTMLDivElement> | null;\n}\n\nconst Dropdown = React.forwardRef<HTMLDivElement, DropdownProps>(function DropdownFn(\n\t{\n\t\tforceOpen = false,\n\t\tdisabled = false,\n\t\titems,\n\t\tplacement = 'bottom-start',\n\t\tdisplay = 'inline-block',\n\t\twidth = 'auto',\n\t\tmaxWidth = '18.75rem',\n\t\tmaxHeight = '50vh',\n\t\thandleTriggerEvents = false,\n\t\tdisableRestoreFocus = false,\n\t\tdisableAutoFocus = false,\n\t\tmultiple = false,\n\t\tcontextMenu = false,\n\t\tonOpen,\n\t\tonClose,\n\t\tchildren,\n\t\ttriggerRef = null,\n\t\tdisablePortal = false,\n\t\tpreventDefault = true,\n\t\tselectedBackgroundColor,\n\t\titemIconSize = 'medium',\n\t\titemTextSize = 'medium',\n\t\titemPaddingBetween = 'small',\n\t\tdropdownListRef = null,\n\t\t...rest\n\t},\n\tref\n) {\n\tconst { windowObj } = useTheme();\n\tconst [open, setOpen] = useState<boolean>(forceOpen);\n\tconst openRef = useRef<boolean>(open);\n\tconst dropdownRef = useCombinedRefs<HTMLDivElement>(dropdownListRef);\n\tconst innerTriggerRef = useCombinedRefs(triggerRef);\n\tconst popperItemsRef = useRef<HTMLDivElement | null>(null);\n\tconst startSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst endSentinelRef = useRef<HTMLDivElement | null>(null);\n\tconst [position, setPosition] = useState<VirtualElement | null>(null);\n\tconst nestedDropdownsRef = useRef<React.RefObject<HTMLDivElement>[]>([]);\n\n\tuseEffect(() => {\n\t\tsetOpen(forceOpen);\n\t\topenRef.current = forceOpen;\n\t}, [forceOpen]);\n\n\tconst openPopper = useCallback(() => {\n\t\tsetOpen(true);\n\t\topenRef.current = true;\n\t\tonOpen?.();\n\t}, [onOpen]);\n\n\tconst closePopper = useCallback(\n\t\t(e?: React.SyntheticEvent | KeyboardEvent) => {\n\t\t\te?.preventDefault();\n\t\t\tsetOpen(forceOpen);\n\t\t\topenRef.current = forceOpen;\n\t\t\tif (!disableRestoreFocus) {\n\t\t\t\tconst triggerElement = innerTriggerRef.current;\n\t\t\t\tif (triggerElement) {\n\t\t\t\t\tif (triggerElement.matches(FOCUSABLE_SELECTOR)) {\n\t\t\t\t\t\ttriggerElement.focus();\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttriggerElement.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)?.focus();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tonClose?.();\n\t\t},\n\t\t[disableRestoreFocus, forceOpen, innerTriggerRef, onClose]\n\t);\n\n\tconst toggleOpen = useCallback<(e: React.SyntheticEvent | KeyboardEvent) => void>(\n\t\t(e) => {\n\t\t\tif (openRef.current) {\n\t\t\t\te.preventDefault();\n\t\t\t\tclosePopper();\n\t\t\t} else if (!disabled) {\n\t\t\t\te.preventDefault();\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, disabled, openPopper]\n\t);\n\n\tconst triggerComponentLeftClickHandler = useCallback<React.ReactEventHandler>(\n\t\t(e) => {\n\t\t\tchildren.props.onClick?.(e);\n\t\t\ttoggleOpen(e);\n\t\t},\n\t\t[children.props, toggleOpen]\n\t);\n\n\tconst triggerComponentRightClickHandler = useCallback<React.MouseEventHandler<HTMLElement>>(\n\t\t(e) => {\n\t\t\te.preventDefault();\n\t\t\tconst virtualElement: VirtualElement = {\n\t\t\t\tgetBoundingClientRect: () => ({\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: e.clientY,\n\t\t\t\t\tright: e.clientX,\n\t\t\t\t\tbottom: e.clientY,\n\t\t\t\t\tleft: e.clientX,\n\t\t\t\t\tx: e.clientX,\n\t\t\t\t\ty: e.clientY\n\t\t\t\t})\n\t\t\t};\n\t\t\tsetPosition(virtualElement);\n\t\t\tif (!disabled && !openRef.current) {\n\t\t\t\topenPopper();\n\t\t\t}\n\t\t},\n\t\t[disabled, openPopper]\n\t);\n\n\tconst handleOutsidePopperInteraction = useCallback(\n\t\t(e: Event) => {\n\t\t\tconst isInteractingWithDropdown =\n\t\t\t\tdropdownRef.current &&\n\t\t\t\t(e.target === dropdownRef.current || dropdownRef.current.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithTrigger =\n\t\t\t\t!contextMenu &&\n\t\t\t\tinnerTriggerRef.current &&\n\t\t\t\t(e.target === innerTriggerRef.current ||\n\t\t\t\t\tinnerTriggerRef.current?.contains(e.target as Node | null));\n\t\t\tconst isInteractingWithNestedDropdown = nestedDropdownsRef.current?.some((nestedItemRef) =>\n\t\t\t\tnestedItemRef.current?.contains(e.target as Node | null)\n\t\t\t);\n\t\t\tif (\n\t\t\t\t!isInteractingWithDropdown &&\n\t\t\t\t!isInteractingWithTrigger &&\n\t\t\t\t!isInteractingWithNestedDropdown &&\n\t\t\t\t// check if the attribute is in the event path\n\t\t\t\t!e\n\t\t\t\t\t.composedPath?.()\n\t\t\t\t\t?.some((el) => el instanceof Element && el.hasAttribute?.('data-keep-open'))\n\t\t\t) {\n\t\t\t\tclosePopper();\n\t\t\t}\n\t\t},\n\t\t[closePopper, contextMenu, dropdownRef, innerTriggerRef]\n\t);\n\n\tconst onStartSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:last-child');\n\t\tlastChild?.focus();\n\t}, []);\n\tconst onEndSentinelFocus = useCallback(() => {\n\t\tconst lastChild = popperItemsRef.current?.querySelector<HTMLElement>('[tabindex]:first-child');\n\t\tlastChild?.focus();\n\t}, []);\n\n\tconst triggerEvents = useMemo(\n\t\t() => (handleTriggerEvents ? getKeyboardPreset('button', toggleOpen) : []),\n\t\t[toggleOpen, handleTriggerEvents]\n\t);\n\tuseKeyboard(innerTriggerRef, triggerEvents);\n\n\tconst listEvents = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnPreviousNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnNextNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnFirstNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowUp', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tfocusOnLastNode(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'ArrowDown', ctrlKey: true }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: (event): void => {\n\t\t\t\t\tif (event.defaultPrevented) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclickNodeWithFocus(popperItemsRef);\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t},\n\t\t\t\tkeys: [{ key: 'Enter', ctrlKey: false }],\n\t\t\t\thaveToPreventDefault: false\n\t\t\t}\n\t\t],\n\t\t[popperItemsRef]\n\t);\n\n\tuseKeyboard(popperItemsRef, listEvents, open);\n\n\tconst escapeEvent = useMemo<KeyboardPresetObj[]>(\n\t\t() => [\n\t\t\t{\n\t\t\t\ttype: 'keydown',\n\t\t\t\tcallback: closePopper,\n\t\t\t\tkeys: [{ key: 'Escape', ctrlKey: false }]\n\t\t\t}\n\t\t],\n\t\t[closePopper]\n\t);\n\n\tuseKeyboard(dropdownRef, escapeEvent, open);\n\n\tuseLayoutEffect(() => {\n\t\tlet cleanup: ReturnType<typeof setupFloating>;\n\t\tif (open) {\n\t\t\tconst popperReference = contextMenu ? position : innerTriggerRef.current;\n\t\t\tif (popperReference && dropdownRef.current) {\n\t\t\t\tcleanup = setupFloating(popperReference, dropdownRef.current, {\n\t\t\t\t\tplacement,\n\t\t\t\t\tmiddleware: [flip(), shift({ limiter: limitShift() })],\n\t\t\t\t\tstrategy: 'fixed'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn (): void => {\n\t\t\tcleanup?.();\n\t\t};\n\t}, [open, placement, contextMenu, position, dropdownRef, innerTriggerRef]);\n\n\tconst setPopperItemsRefAndFocus = useCallback<React.RefCallback<HTMLDivElement | null>>(\n\t\t(node) => {\n\t\t\tpopperItemsRef.current = node;\n\t\t\tif (node && !disableAutoFocus) {\n\t\t\t\tconst itemToFocus = node.querySelector<HTMLElement>('.zapp-selected') ?? node.firstChild;\n\t\t\t\tif (itemToFocus instanceof HTMLElement) {\n\t\t\t\t\titemToFocus.focus();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[disableAutoFocus]\n\t);\n\n\tuseEffect(() => {\n\t\tif (open) {\n\t\t\twindowObj.document.addEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.addEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\tcontextMenu &&\n\t\t\t\twindowObj.document.addEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t}\n\n\t\treturn (): void => {\n\t\t\twindowObj.document.removeEventListener('click', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('scroll', handleOutsidePopperInteraction, true);\n\t\t\twindowObj.document.removeEventListener('contextmenu', handleOutsidePopperInteraction, true);\n\t\t};\n\t}, [open, closePopper, handleOutsidePopperInteraction, contextMenu, windowObj.document]);\n\n\tuseEffect(() => {\n\t\tconst startSentinelRefElement = startSentinelRef.current;\n\t\tconst endSentinelRefElement = endSentinelRef.current;\n\t\tif (open && !disableAutoFocus) {\n\t\t\tstartSentinelRefElement?.addEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.addEventListener('focus', onEndSentinelFocus);\n\t\t}\n\t\treturn (): void => {\n\t\t\tstartSentinelRefElement?.removeEventListener('focus', onStartSentinelFocus);\n\t\t\tendSentinelRefElement?.removeEventListener('focus', onEndSentinelFocus);\n\t\t};\n\t}, [\n\t\topen,\n\t\tstartSentinelRef,\n\t\tendSentinelRef,\n\t\tonStartSentinelFocus,\n\t\tonEndSentinelFocus,\n\t\tdisableAutoFocus\n\t]);\n\n\tconst listItemClickHandler = useCallback<\n\t\t(\n\t\t\tonClick?: PopperListItemProps['onClick'],\n\t\t\tkeepOpen?: boolean\n\t\t) => (event: React.SyntheticEvent<HTMLElement> | KeyboardEvent) => void\n\t>(\n\t\t(onClick, keepOpen) =>\n\t\t\t(event): void => {\n\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\tonClick?.(event);\n\t\t\t\t}\n\t\t\t\tif (!multiple && !keepOpen) {\n\t\t\t\t\tclosePopper();\n\t\t\t\t} else {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\t\t\t},\n\t\t[closePopper, multiple]\n\t);\n\n\tconst popperListItems = useMemo(() => {\n\t\tnestedDropdownsRef.current = [];\n\t\tif (items) {\n\t\t\treturn items.map(\n\t\t\t\t(\n\t\t\t\t\t{\n\t\t\t\t\t\tid,\n\t\t\t\t\t\ticon,\n\t\t\t\t\t\tlabel,\n\t\t\t\t\t\tonClick,\n\t\t\t\t\t\tselected,\n\t\t\t\t\t\tcustomComponent,\n\t\t\t\t\t\titems: subItems,\n\t\t\t\t\t\tdisabled: itemDisabled,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tkeepOpen,\n\t\t\t\t\t\t...itemProps\n\t\t\t\t\t},\n\t\t\t\t\tindex\n\t\t\t\t) => {\n\t\t\t\t\tconst nestedRef = React.createRef<HTMLDivElement>();\n\t\t\t\t\tnestedDropdownsRef.current.push(nestedRef);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t(type === 'divider' && <Divider key={id ?? `divider-${index}`} />) ||\n\t\t\t\t\t\t(subItems && (\n\t\t\t\t\t\t\t<NestListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\titems={subItems}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\tdropdownListRef={nestedRef}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)) || (\n\t\t\t\t\t\t\t<PopperListItem\n\t\t\t\t\t\t\t\ticon={icon}\n\t\t\t\t\t\t\t\tlabel={label ?? ''}\n\t\t\t\t\t\t\t\tonClick={listItemClickHandler(onClick, keepOpen)}\n\t\t\t\t\t\t\t\tkeepOpen={keepOpen}\n\t\t\t\t\t\t\t\tselected={selected}\n\t\t\t\t\t\t\t\tkey={id}\n\t\t\t\t\t\t\t\tcustomComponent={customComponent}\n\t\t\t\t\t\t\t\tdisabled={itemDisabled}\n\t\t\t\t\t\t\t\tselectedBackgroundColor={selectedBackgroundColor}\n\t\t\t\t\t\t\t\titemIconSize={itemIconSize}\n\t\t\t\t\t\t\t\titemTextSize={itemTextSize}\n\t\t\t\t\t\t\t\titemPaddingBetween={itemPaddingBetween}\n\t\t\t\t\t\t\t\t{...itemProps}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\treturn null;\n\t}, [\n\t\titems,\n\t\tlistItemClickHandler,\n\t\tselectedBackgroundColor,\n\t\titemIconSize,\n\t\titemTextSize,\n\t\titemPaddingBetween\n\t]);\n\n\tconst popperListPreventDefaultHandler = useCallback<React.MouseEventHandler>(\n\t\t(event) => {\n\t\t\tpreventDefault && event.preventDefault();\n\t\t},\n\t\t[preventDefault]\n\t);\n\n\tconst triggerComponent = useMemo(() => {\n\t\tconst props = contextMenu\n\t\t\t? { onContextMenu: triggerComponentRightClickHandler }\n\t\t\t: { onClick: triggerComponentLeftClickHandler };\n\t\treturn React.cloneElement(children, { ref: innerTriggerRef, ...props });\n\t}, [\n\t\tchildren,\n\t\tinnerTriggerRef,\n\t\tcontextMenu,\n\t\ttriggerComponentLeftClickHandler,\n\t\ttriggerComponentRightClickHandler\n\t]);\n\n\tconst popperListProps = useMemo(\n\t\t() =>\n\t\t\tcontextMenu\n\t\t\t\t? { onContextMenu: popperListPreventDefaultHandler }\n\t\t\t\t: { onClick: popperListPreventDefaultHandler },\n\t\t[contextMenu, popperListPreventDefaultHandler]\n\t);\n\n\treturn (\n\t\t<PopperDropdownWrapper ref={ref} $display={display} {...rest}>\n\t\t\t{triggerComponent}\n\t\t\t<Portal show={open} disablePortal={disablePortal}>\n\t\t\t\t<PopperList\n\t\t\t\t\tref={dropdownRef}\n\t\t\t\t\t$open={open}\n\t\t\t\t\t$width={width}\n\t\t\t\t\t$maxWidth={maxWidth}\n\t\t\t\t\t$maxHeight={maxHeight}\n\t\t\t\t\t$triggerRef={innerTriggerRef}\n\t\t\t\t\tdata-testid=\"dropdown-popper-list\"\n\t\t\t\t\t{...popperListProps}\n\t\t\t\t>\n\t\t\t\t\t<div tabIndex={0} ref={startSentinelRef} />\n\t\t\t\t\t<div ref={setPopperItemsRefAndFocus}>{popperListItems}</div>\n\t\t\t\t\t<div tabIndex={0} ref={endSentinelRef} />\n\t\t\t\t</PopperList>\n\t\t\t</Portal>\n\t\t</PopperDropdownWrapper>\n\t);\n});\n\nexport { Dropdown, type DropdownProps, type DropdownItem };\n"]} */"));
 const Dropdown = /*#__PURE__*/React__namespace.default.forwardRef(function DropdownFn({
   forceOpen = false,
   disabled = false,