@amboss/design-system 2.3.9 → 2.3.11

package/build/esm/components/DropdownMenu/Menu.js

@@ -1 +1 @@
-import React,{useEffect,useRef,useState,useCallback}from"react";import styled from"@emotion/styled";import{createPortal}from"react-dom";import{useDocument}from"../../shared/useDocument";import{useKeyboard}from"../../shared/useKeyboard";import{getMenuStyle}from"./utils";import{Divider}from"../Divider/Divider";import{MenuItem}from"./MenuItem";import zIndices from"../../web-tokens/_zindex.json";import{useWindow}from"../../shared/useWindow";let isSeperator=item=>"separator"===item,StyledMenu=styled("div",{target:"e3i12uf0",label:"StyledMenu"})(({theme})=>({position:"absolute",display:"inline-block",width:"fit-content",minWidth:theme.variables.size.dimension.dropdownMenu.width,zIndex:zIndices.tooltip.value,borderRadius:theme.variables.size.borderRadius.s,backgroundColor:theme.values.color.background.primary.default,paddingTop:theme.variables.size.spacing.xs,paddingBottom:theme.variables.size.spacing.xs,":after":{content:'" "',position:"absolute",top:0,left:0,width:"100%",height:"100%",pointerEvents:"none",borderRadius:"inherit",boxShadow:theme.values.elevation[3]}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRHJvcGRvd25NZW51L01lbnUudHN4Iiwic291cmNlcyI6WyJzcmMvY29tcG9uZW50cy9Ecm9wZG93bk1lbnUvTWVudS50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSZWZPYmplY3QgfSBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCBSZWFjdCwgeyB1c2VFZmZlY3QsIHVzZVJlZiwgdXNlU3RhdGUsIHVzZUNhbGxiYWNrIH0gZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IGNyZWF0ZVBvcnRhbCB9IGZyb20gXCJyZWFjdC1kb21cIjtcbmltcG9ydCB7IHVzZURvY3VtZW50IH0gZnJvbSBcIi4uLy4uL3NoYXJlZC91c2VEb2N1bWVudFwiO1xuaW1wb3J0IHsgdXNlS2V5Ym9hcmQgfSBmcm9tIFwiLi4vLi4vc2hhcmVkL3VzZUtleWJvYXJkXCI7XG5pbXBvcnQgdHlwZSB7IE1lbnVTdHlsZSB9IGZyb20gXCIuL3V0aWxzXCI7XG5pbXBvcnQgeyBnZXRNZW51U3R5bGUgfSBmcm9tIFwiLi91dGlsc1wiO1xuaW1wb3J0IHR5cGUgeyBEcm9wZG93bkl0ZW0sIERyb3Bkb3duTWVudVByb3BzIH0gZnJvbSBcIi4vRHJvcGRvd25NZW51XCI7XG5pbXBvcnQgeyBEaXZpZGVyIH0gZnJvbSBcIi4uL0RpdmlkZXIvRGl2aWRlclwiO1xuaW1wb3J0IHR5cGUgeyBNZW51SXRlbVByb3BzIH0gZnJvbSBcIi4vTWVudUl0ZW1cIjtcbmltcG9ydCB7IE1lbnVJdGVtIH0gZnJvbSBcIi4vTWVudUl0ZW1cIjtcbmltcG9ydCB6SW5kaWNlcyBmcm9tIFwiLi4vLi4vd2ViLXRva2Vucy9femluZGV4Lmpzb25cIjtcbmltcG9ydCB7IHVzZVdpbmRvdyB9IGZyb20gXCIuLi8uLi9zaGFyZWQvdXNlV2luZG93XCI7XG5cbnR5cGUgTWVudVByb3BzID0ge1xuICBpc09wZW46IGJvb2xlYW47XG4gIGl0ZW1zOiBEcm9wZG93bkl0ZW1bXTtcbiAgdHJpZ2dlclJlZjogUmVmT2JqZWN0PEhUTUxCdXR0b25FbGVtZW50PjtcbiAgZm9jdXNJbmRleDogbnVtYmVyO1xuICBvbkZvY3VzSW5kZXhDaGFuZ2U6IChmb2N1c0luZGV4OiBudW1iZXIpID0+IHZvaWQ7XG4gIG9uQ2xvc2VNZW51OiAoZTogYW55KSA9PiB2b2lkO1xufSAmIFBpY2s8RHJvcGRvd25NZW51UHJvcHMsIFwibWVudUl0ZW1UZXh0VmFyaWFudFwiIHwgXCJwb3J0YWxDb250YWluZXJcIj4gJlxuICBQaWNrPE1lbnVJdGVtUHJvcHMsIFwib25CbHVyXCI+O1xuXG5jb25zdCBpc1NlcGVyYXRvciA9IChpdGVtOiBEcm9wZG93bkl0ZW0pID0+IGl0ZW0gPT09IFwic2VwYXJhdG9yXCI7XG5cbmNvbnN0IFN0eWxlZE1lbnUgPSBzdHlsZWQuZGl2KCh7IHRoZW1lIH0pID0+ICh7XG4gIHBvc2l0aW9uOiBcImFic29sdXRlXCIsXG4gIGRpc3BsYXk6IFwiaW5saW5lLWJsb2NrXCIsXG4gIHdpZHRoOiBcImZpdC1jb250ZW50XCIsXG4gIG1pbldpZHRoOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5kaW1lbnNpb24uZHJvcGRvd25NZW51LndpZHRoLFxuICB6SW5kZXg6IHpJbmRpY2VzLnRvb2x0aXAudmFsdWUsXG4gIGJvcmRlclJhZGl1czogdGhlbWUudmFyaWFibGVzLnNpemUuYm9yZGVyUmFkaXVzLnMsXG4gIGJhY2tncm91bmRDb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLmJhY2tncm91bmQucHJpbWFyeS5kZWZhdWx0LFxuICBwYWRkaW5nVG9wOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzLFxuICBwYWRkaW5nQm90dG9tOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzLFxuXG4gIFwiOmFmdGVyXCI6IHtcbiAgICBjb250ZW50OiAnXCIgXCInLFxuICAgIHBvc2l0aW9uOiBcImFic29sdXRlXCIsXG4gICAgdG9wOiAwLFxuICAgIGxlZnQ6IDAsXG4gICAgd2lkdGg6IFwiMTAwJVwiLFxuICAgIGhlaWdodDogXCIxMDAlXCIsXG4gICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG4gICAgYm9yZGVyUmFkaXVzOiBcImluaGVyaXRcIixcbiAgICBib3hTaGFkb3c6IHRoZW1lLnZhbHVlcy5lbGV2YXRpb25bM10sXG4gIH0sXG59KSk7XG5cbmNvbnN0IFN0eWxlZFVsID0gc3R5bGVkLnVsKCgpID0+ICh7XG4gIG1hcmdpbjogMCxcbiAgcGFkZGluZzogMCxcbiAgb3ZlcmZsb3c6IFwiaGlkZGVuXCIsXG59KSk7XG5cbmNvbnN0IFN0eWxlZExpID0gc3R5bGVkLmxpKCgpID0+ICh7XG4gIG1hcmdpbjogMCxcbiAgcGFkZGluZzogMCxcbiAgd2lkdGg6IFwiMTAwJVwiLFxuICBsaXN0U3R5bGVUeXBlOiBcIm5vbmVcIixcbiAgd2hpdGVTcGFjZTogXCJub3dyYXBcIixcbn0pKTtcblxuY29uc3QgU3R5bGVkTGlTZXBhcmF0b3IgPSBzdHlsZWQoU3R5bGVkTGkpKCh7IHRoZW1lIH0pID0+ICh7XG4gIG1hcmdpblRvcDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54cyxcbiAgbWFyZ2luQm90dG9tOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzLFxufSkpO1xuXG5leHBvcnQgZnVuY3Rpb24gTWVudSh7XG4gIGlzT3BlbixcbiAgaXRlbXMsXG4gIHBvcnRhbENvbnRhaW5lcixcbiAgdHJpZ2dlclJlZixcbiAgbWVudUl0ZW1UZXh0VmFyaWFudCxcbiAgZm9jdXNJbmRleCxcbiAgb25Gb2N1c0luZGV4Q2hhbmdlLFxuICBvbkNsb3NlTWVudSxcbn06IE1lbnVQcm9wcyk6IFJlYWN0LlJlYWN0RWxlbWVudCB7XG4gIGNvbnN0IGRvY3VtZW50ID0gdXNlRG9jdW1lbnQoKTtcbiAgY29uc3Qgd2luZG93ID0gdXNlV2luZG93KCk7XG4gIGNvbnN0IG1lbnVSZWYgPSB1c2VSZWYobnVsbCk7XG4gIGNvbnN0IFttZW51U3R5bGUsIHNldE1lbnVTdHlsZV0gPSB1c2VTdGF0ZTxNZW51U3R5bGU+KHtcbiAgICB0b3A6IDAsXG4gICAgbGVmdDogMCxcbiAgfSk7XG5cbiAgLy8gLS0tLSBDbG9zZSBtZW51IHdoZW4gdGhlIG1lbnUgaXMgbm90IG9uIGZvY3VzXG4gIGNvbnN0IGhhbmRsZUJsdXJFdmVudCA9IHVzZUNhbGxiYWNrKFxuICAgIChlOiBSZWFjdC5Gb2N1c0V2ZW50KSA9PiB7XG4gICAgICBpZiAoIWUucmVsYXRlZFRhcmdldCB8fCAhbWVudVJlZi5jdXJyZW50LmNvbnRhaW5zKGUucmVsYXRlZFRhcmdldCkpIHtcbiAgICAgICAgb25DbG9zZU1lbnUoZSk7XG4gICAgICB9XG4gICAgfSxcbiAgICBbb25DbG9zZU1lbnVdXG4gICk7XG5cbiAgY29uc3QgY2FsY3VsYXRlU3R5bGUgPSB1c2VDYWxsYmFjaygoKSA9PiB7XG4gICAgaWYgKHRyaWdnZXJSZWYuY3VycmVudCAmJiBtZW51UmVmLmN1cnJlbnQpIHtcbiAgICAgIHNldE1lbnVTdHlsZShnZXRNZW51U3R5bGUodHJpZ2dlclJlZiwgbWVudVJlZiwgZG9jdW1lbnQsIHdpbmRvdykpO1xuICAgIH1cbiAgfSwgW3RyaWdnZXJSZWYsIG1lbnVSZWYsIGRvY3VtZW50LCB3aW5kb3ddKTtcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIGlmIChpc09wZW4pIHtcbiAgICAgIGNhbGN1bGF0ZVN0eWxlKCk7XG4gICAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcihcInJlc2l6ZVwiLCBjYWxjdWxhdGVTdHlsZSk7XG4gICAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcihcInNjcm9sbFwiLCBjYWxjdWxhdGVTdHlsZSwgdHJ1ZSk7IC8vIHVzZSBjYXB0dXJlIGhlcmUgdG8gZGV0ZWN0IHNjcm9sbCBvbiBhbnkgcGFyZW50XG4gICAgfVxuICAgIHJldHVybiAoKSA9PiB7XG4gICAgICB3aW5kb3cucmVtb3ZlRXZlbnRMaXN0ZW5lcihcInJlc2l6ZVwiLCBjYWxjdWxhdGVTdHlsZSk7XG4gICAgICB3aW5kb3cucmVtb3ZlRXZlbnRMaXN0ZW5lcihcInNjcm9sbFwiLCBjYWxjdWxhdGVTdHlsZSk7XG4gICAgfTtcbiAgfSwgW2lzT3BlbiwgY2FsY3VsYXRlU3R5bGUsIHdpbmRvd10pO1xuXG4gIHVzZUtleWJvYXJkKFxuICAgIHtcbiAgICAgIEVzY2FwZTogb25DbG9zZU1lbnUsXG4gICAgICBBcnJvd1VwOiAoKSA9PiB7XG4gICAgICAgIG9uRm9jdXNJbmRleENoYW5nZShmb2N1c0luZGV4IC0gMSk7XG4gICAgICB9LFxuICAgICAgQXJyb3dEb3duOiAoKSA9PiB7XG4gICAgICAgIG9uRm9jdXNJbmRleENoYW5nZShmb2N1c0luZGV4ICsgMSk7XG4gICAgICB9LFxuICAgIH0sXG4gICAgbWVudVJlZixcbiAgICBpc09wZW5cbiAgKTtcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIGlmIChtZW51UmVmICYmIG1lbnVSZWYuY3VycmVudCkge1xuICAgICAgY29uc3QgYnV0dG9ucyA9IG1lbnVSZWYuY3VycmVudC5xdWVyeVNlbGVjdG9yQWxsKFwiYnV0dG9uXCIpO1xuXG4gICAgICBidXR0b25zW01hdGguYWJzKGZvY3VzSW5kZXgpICUgYnV0dG9ucy5sZW5ndGhdLmZvY3VzKCk7XG4gICAgfVxuICB9LCBbbWVudVJlZiwgZm9jdXNJbmRleF0pO1xuXG4gIGNvbnN0IG1lbnVFbG0gPSAoXG4gICAgPFN0eWxlZE1lbnUgcmVmPXttZW51UmVmfSBzdHlsZT17bWVudVN0eWxlfT5cbiAgICAgIDxTdHlsZWRVbCByb2xlPVwibWVudVwiPlxuICAgICAgICB7aXRlbXMubWFwKChpdGVtLCBpbmRleCkgPT4ge1xuICAgICAgICAgIGlmIChpc1NlcGVyYXRvcihpdGVtKSlcbiAgICAgICAgICAgIHJldHVybiAoXG4gICAgICAgICAgICAgIDxTdHlsZWRMaVNlcGFyYXRvclxuICAgICAgICAgICAgICAgIHJvbGU9XCJzZXBhcmF0b3JcIlxuICAgICAgICAgICAgICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSByZWFjdC9uby1hcnJheS1pbmRleC1rZXlcbiAgICAgICAgICAgICAgICBrZXk9e2BtZW51aXRlbS1zZXBhcmF0b3ItJHtpbmRleH1gfVxuICAgICAgICAgICAgICA+XG4gICAgICAgICAgICAgICAgPERpdmlkZXIgLz5cbiAgICAgICAgICAgICAgPC9TdHlsZWRMaVNlcGFyYXRvcj5cbiAgICAgICAgICAgICk7XG5cbiAgICAgICAgICBjb25zdCB7IGxhYmVsLCBkZXN0cnVjdGl2ZSwgZGlzYWJsZWQsIGVtcGhhc2l6ZWQsIGljb24sIG9uU2VsZWN0IH0gPVxuICAgICAgICAgICAgaXRlbSBhcyBNZW51SXRlbVByb3BzO1xuXG4gICAgICAgICAgcmV0dXJuIChcbiAgICAgICAgICAgIDxTdHlsZWRMaSByb2xlPVwibWVudWl0ZW1cIiBrZXk9e2BtZW51aXRlbS0ke2xhYmVsfWB9PlxuICAgICAgICAgICAgICA8TWVudUl0ZW1cbiAgICAgICAgICAgICAgICBvblNlbGVjdD17b25TZWxlY3R9XG4gICAgICAgICAgICAgICAgb25CbHVyPXtoYW5kbGVCbHVyRXZlbnR9XG4gICAgICAgICAgICAgICAgaWNvbj17aWNvbn1cbiAgICAgICAgICAgICAgICBsYWJlbD17bGFiZWx9XG4gICAgICAgICAgICAgICAgZGlzYWJsZWQ9e2Rpc2FibGVkfVxuICAgICAgICAgICAgICAgIGRlc3RydWN0aXZlPXtkZXN0cnVjdGl2ZX1cbiAgICAgICAgICAgICAgICBlbXBoYXNpemVkPXtlbXBoYXNpemVkfVxuICAgICAgICAgICAgICAgIHRleHRWYXJpYW50PXttZW51SXRlbVRleHRWYXJpYW50fVxuICAgICAgICAgICAgICAvPlxuICAgICAgICAgICAgPC9TdHlsZWRMaT5cbiAgICAgICAgICApO1xuICAgICAgICB9KX1cbiAgICAgIDwvU3R5bGVkVWw+XG4gICAgPC9TdHlsZWRNZW51PlxuICApO1xuXG4gIGlmICghaXNPcGVuKSB7XG4gICAgcmV0dXJuIG51bGw7XG4gIH1cblxuICByZXR1cm4gY3JlYXRlUG9ydGFsKG1lbnVFbG0sIHBvcnRhbENvbnRhaW5lciB8fCBkb2N1bWVudC5ib2R5KTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQm1CIn0= */"),StyledUl=styled("ul",{target:"e3i12uf1",label:"StyledUl"})(()=>({margin:0,padding:0,overflow:"hidden"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledLi=styled("li",{target:"e3i12uf2",label:"StyledLi"})(()=>({margin:0,padding:0,width:"100%",listStyleType:"none",whiteSpace:"nowrap"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledLiSeparator=styled(StyledLi,{target:"e3i12uf3",label:"StyledLiSeparator"})(({theme})=>({marginTop:theme.variables.size.spacing.xs,marginBottom:theme.variables.size.spacing.xs}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function Menu({isOpen,items,portalContainer,triggerRef,menuItemTextVariant,focusIndex,onFocusIndexChange,onCloseMenu}){let document=useDocument(),window=useWindow(),menuRef=useRef(null),[menuStyle,setMenuStyle]=useState({top:0,left:0}),handleBlurEvent=useCallback(e=>{e.relatedTarget&&menuRef.current.contains(e.relatedTarget)||onCloseMenu(e)},[onCloseMenu]),calculateStyle=useCallback(()=>{triggerRef.current&&menuRef.current&&setMenuStyle(getMenuStyle(triggerRef,menuRef,document,window))},[triggerRef,menuRef,document,window]);useEffect(()=>(isOpen&&(calculateStyle(),window.addEventListener("resize",calculateStyle),window.addEventListener("scroll",calculateStyle,!0)),()=>{window.removeEventListener("resize",calculateStyle),window.removeEventListener("scroll",calculateStyle)}),[isOpen,calculateStyle,window]),useKeyboard({Escape:onCloseMenu,ArrowUp:()=>{onFocusIndexChange(focusIndex-1)},ArrowDown:()=>{onFocusIndexChange(focusIndex+1)}},menuRef,isOpen),useEffect(()=>{if(menuRef&&menuRef.current){let buttons=menuRef.current.querySelectorAll("button");buttons[Math.abs(focusIndex)%buttons.length].focus()}},[menuRef,focusIndex]);let menuElm=React.createElement(StyledMenu,{ref:menuRef,style:menuStyle},React.createElement(StyledUl,{role:"menu"},items.map((item,index)=>{if(isSeperator(item))return React.createElement(StyledLiSeparator,{role:"separator",key:`menuitem-separator-${index}`},React.createElement(Divider,null));let{label,destructive,disabled,emphasized,icon,onSelect}=item;return React.createElement(StyledLi,{role:"menuitem",key:`menuitem-${label}`},React.createElement(MenuItem,{onSelect:onSelect,onBlur:handleBlurEvent,icon:icon,label:label,disabled:disabled,destructive:destructive,emphasized:emphasized,textVariant:menuItemTextVariant}))})));return isOpen?createPortal(menuElm,portalContainer||document.body):null}
+import React,{useEffect,useRef,useState,useCallback}from"react";import styled from"@emotion/styled";import{useKeyboard}from"../../shared/useKeyboard";import{Divider}from"../Divider/Divider";import{MenuItem}from"./MenuItem";import zIndices from"../../web-tokens/_zindex.json";import{usePopupMenu}from"../../shared/popupMenu/usePopupMenu";import{Portal}from"../Portal/Portal";let isSeperator=item=>"separator"===item,StyledMenu=styled("div",{target:"e1jwkd2s0",label:"StyledMenu"})(({theme})=>({position:"absolute",display:"inline-block",width:"fit-content",minWidth:theme.variables.size.dimension.dropdownMenu.width,zIndex:zIndices.tooltip.value,borderRadius:theme.variables.size.borderRadius.s,backgroundColor:theme.values.color.background.primary.default,paddingTop:theme.variables.size.spacing.xs,paddingBottom:theme.variables.size.spacing.xs,":after":{content:'" "',position:"absolute",top:0,left:0,width:"100%",height:"100%",pointerEvents:"none",borderRadius:"inherit",boxShadow:theme.values.elevation[3]}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledUl=styled("ul",{target:"e1jwkd2s1",label:"StyledUl"})(()=>({margin:0,padding:0,overflow:"hidden"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledLi=styled("li",{target:"e1jwkd2s2",label:"StyledLi"})(()=>({margin:0,padding:0,width:"100%",listStyleType:"none",whiteSpace:"nowrap"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledLiSeparator=styled(StyledLi,{target:"e1jwkd2s3",label:"StyledLiSeparator"})(({theme})=>({marginTop:theme.variables.size.spacing.xs,marginBottom:theme.variables.size.spacing.xs}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function Menu({isOpen,items,portalContainer,triggerRef,menuItemTextVariant,onCloseMenu}){let menuRef=useRef(null),[focusIndex,setFocusIndex]=useState(0),{menuStyle}=usePopupMenu({triggerRef,menuRef,isOpen}),handleBlurEvent=useCallback(e=>{menuRef.current.contains(e.relatedTarget)||triggerRef.current.contains(e.relatedTarget)||onCloseMenu(e)},[onCloseMenu,triggerRef]);useKeyboard({Escape:onCloseMenu,ArrowUp:()=>{setFocusIndex(index=>index-1)},ArrowDown:()=>{setFocusIndex(index=>index+1)}},menuRef,isOpen),useEffect(()=>{if(menuRef&&menuRef.current){let buttons=menuRef.current.querySelectorAll("button");buttons[Math.abs(focusIndex)%buttons.length].focus({preventScroll:!0})}isOpen||setFocusIndex(0)},[menuRef,focusIndex,isOpen]);let menuElm=React.createElement(StyledMenu,{ref:menuRef,style:menuStyle},React.createElement(StyledUl,{role:"menu"},items.map((item,index)=>{if(isSeperator(item))return React.createElement(StyledLiSeparator,{role:"separator",key:`menuitem-separator-${index}`},React.createElement(Divider,null));let{label,destructive,disabled,emphasized,icon,onSelect}=item;return React.createElement(StyledLi,{role:"menuitem",key:`menuitem-${label}`},React.createElement(MenuItem,{onSelect:onSelect,onBlur:handleBlurEvent,icon:icon,label:label,disabled:disabled,destructive:destructive,emphasized:emphasized,textVariant:menuItemTextVariant}))})));return isOpen?React.createElement(Portal,{portalContainer:portalContainer},menuElm):null}

package/build/esm/components/DropdownMenu/MenuItem.js

@@ -1 +1 @@
-import React from"react";import styled from"@emotion/styled";import{Icon}from"../Icon/Icon";import{Inline}from"../Inline/Inline";let StyledMenuItem=styled("button",{target:"e1nmkwv0",label:"StyledMenuItem"})(({theme,size,textVariant,destructive})=>({"&[type='button']":{appearance:"none",MozAppearance:"none",WebkitAppearance:"none"},display:"inline-block",width:"100%",border:0,color:destructive?theme.values.color.text.error.default:theme.values.color.text.secondary.default,backgroundColor:theme.values.color.background.primary.default,textTransform:textVariant||"uppercase",textDecoration:"none",fontFamily:theme.variables.fontFamily.lato,fontSize:theme.variables.size.font.xs,lineHeight:theme.variables.size.lineHeight.m,letterSpacing:theme.variables.size.letterSpacing.s,fontWeight:theme.variables.weight.bold,cursor:"pointer","&:hover":{backgroundColor:destructive?theme.values.color.destructiveTertiaryButton.background.hover:theme.values.color.background.secondary.hover},"&:active":{color:destructive?theme.values.color.text.error.default:theme.values.color.text.primary.default},"&:disabled":{backgroundColor:theme.values.color.background.transparent.default,color:destructive?theme.values.color.text.error.disabled:theme.values.color.text.tertiary.disabled},..."s"===size&&{padding:theme.variables.size.spacing.xs},..."m"===size&&{padding:theme.variables.size.spacing.s},..."l"===size&&{padding:theme.variables.size.spacing.m},"&[disabled], &:disabled":{pointerEvents:"none"}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function MenuItem({label,size="m",disabled=!1,onSelect,icon,destructive,emphasized=!1,textVariant="uppercase",onBlur}){return React.createElement(StyledMenuItem,{size:size,destructive:destructive,disabled:disabled,onClick:onSelect,textVariant:textVariant,onBlur:onBlur},React.createElement(Inline,{vAlignItems:"center",alignItems:"left",space:"xxs",noWrap:!0},icon&&React.createElement(Icon,{size:"s",name:icon,"data-testid":`menuItem-${icon}`,"data-e2e-test-id":`menuItem-${icon}`}),label,emphasized&&React.createElement(Icon,{size:"s",color:"error",name:"filled-dot","data-testid":"menuItem-emphasized","data-e2e-test-id":"menuItem-emphasized"})))}
+import React from"react";import styled from"@emotion/styled";import{Icon}from"../Icon/Icon";import{Inline}from"../Inline/Inline";let StyledMenuItem=styled("button",{target:"e99xw560",label:"StyledMenuItem"})(({theme,size,textVariant,destructive,disabled})=>({"&[type='button']":{appearance:"none",MozAppearance:"none",WebkitAppearance:"none"},display:"inline-block",width:"100%",border:0,color:destructive?theme.values.color.text.error.default:theme.values.color.text.secondary.default,backgroundColor:theme.values.color.background.primary.default,textTransform:textVariant||"uppercase",textDecoration:"none",fontFamily:theme.variables.fontFamily.lato,fontSize:theme.variables.size.font.xs,lineHeight:theme.variables.size.lineHeight.m,letterSpacing:theme.variables.size.letterSpacing.s,fontWeight:theme.variables.weight.bold,cursor:"pointer",...!disabled&&{"&:hover":{backgroundColor:destructive?theme.values.color.destructiveTertiaryButton.background.hover:theme.values.color.background.secondary.hover},"&:active":{color:destructive?theme.values.color.text.error.default:theme.values.color.text.primary.default}},...disabled&&{opacity:theme.variables.opacity.disabled,cursor:"not-allowed"},..."s"===size&&{padding:theme.variables.size.spacing.xs},..."m"===size&&{padding:theme.variables.size.spacing.s},..."l"===size&&{padding:theme.variables.size.spacing.m}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function MenuItem({label,size="m",disabled=!1,onSelect,icon,destructive,emphasized=!1,textVariant="uppercase",onBlur}){return React.createElement(StyledMenuItem,{size:size,destructive:destructive,disabled:disabled,onClick:onSelect,textVariant:textVariant,onBlur:onBlur},React.createElement(Inline,{vAlignItems:"center",alignItems:"left",space:"xxs",noWrap:!0},icon&&React.createElement(Icon,{size:"s",name:icon,"data-testid":`menuItem-${icon}`,"data-e2e-test-id":`menuItem-${icon}`}),label,emphasized&&React.createElement(Icon,{size:"s",color:"error",name:"filled-dot","data-testid":"menuItem-emphasized","data-e2e-test-id":"menuItem-emphasized"})))}

package/build/esm/components/EntityList/BaseEntityList.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { EntityListProps } from "./types";
+export declare function BaseEntityList({ data, size, onClick, isSelectable, selectedIds, onSelectionChange, renderRightContent, getLeftIconProps, hideBorder, "data-e2e-test-id": dataE2eTestId, }: EntityListProps): React.ReactElement;

package/build/esm/components/EntityList/BaseEntityList.js

@@ -0,0 +1 @@
+import React,{useMemo,useCallback}from"react";import{EntityListItem}from"./EntityListItem";import{Icon}from"../Icon/Icon";import{Box}from"../Box/Box";import{CheckboxRaw}from"../Form/Checkbox/Checkbox";import{StyledList,StyledMinHeightCell}from"./styled-components";let LeftCell=({isSelectable,selectedIdsSet,getLeftIconProps,...itemProps})=>{if(isSelectable)return React.createElement(Box,{vSpace:"zero",space:"xxs"},React.createElement(CheckboxRaw,{name:"list-checkbox",size:"s",onChange:()=>{},checked:selectedIdsSet.has(itemProps.id)}));let{textSize,...restNodeData}=itemProps,{name,color}=getLeftIconProps(restNodeData);return React.createElement(Icon,{name:name,color:color,size:textSize})};export function BaseEntityList({data,size="m",onClick,isSelectable,selectedIds,onSelectionChange,renderRightContent,getLeftIconProps,hideBorder,"data-e2e-test-id":dataE2eTestId}){let selectedIdsSet=useMemo(()=>new Set(selectedIds),[selectedIds]),handleOnClick=useCallback(item=>{let{id}=item;isSelectable&&(selectedIdsSet.has(id)?selectedIdsSet.delete(id):selectedIdsSet.add(id),onSelectionChange?.(Array.from(selectedIdsSet))),onClick?.(item)},[selectedIdsSet,onSelectionChange,onClick,isSelectable]);return React.createElement(StyledList,{size:size,"data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityList",role:"list"},data.map((item,i)=>React.createElement(EntityListItem,{key:item.id,"aria-label":item["aria-label"]||item.label,size:size,hideBorder:hideBorder||i===data.length-1,isActive:item.isActive,isDisabled:item.isDisabled,onClick:()=>handleOnClick(item),isClickable:!!(onClick||selectedIds),description:item.description,renderLabel:()=>item.label,renderLeft:getLeftIconProps||isSelectable?({textSize})=>React.createElement(LeftCell,{...item,isSelectable:isSelectable,selectedIdsSet:selectedIdsSet,getLeftIconProps:getLeftIconProps,textSize:textSize}):null,renderRight:({actionSize,textSize})=>renderRightContent?React.createElement(StyledMinHeightCell,{textSize:textSize},renderRightContent({textSize,actionSize,...item})):null})))}

package/build/esm/components/EntityList/EntityList.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { EntityListProps } from "./types";
+export declare const EntityList: (props: EntityListProps) => React.ReactElement;

package/build/esm/components/EntityList/EntityList.js

@@ -0,0 +1 @@
+import React from"react";import{BaseEntityList}from"./BaseEntityList";import{Container}from"../Container/Container";export const EntityList=props=>React.createElement(Container,{overflow:"hidden"},React.createElement(BaseEntityList,props));

package/build/esm/components/EntityList/EntityListItem.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { EntityListItemProps } from "./types";
+export declare function EntityListItem({ description, size, role, renderLeft, renderRight, isExpanded, isDisabled, isActive, children, onClick, onExpandClick, isClickable, lSpaceStep, renderLabel, hideBorder, isDisabledExpand, "aria-label": ariaLabel, }: EntityListItemProps): React.ReactElement;

package/build/esm/components/EntityList/EntityListItem.js

@@ -0,0 +1 @@
+import React,{useCallback}from"react";import{EntityListItemText}from"./EntityListItemText";import{EntityListItemExpandButton}from"./EntityListItemExpandButton";import{Inline}from"../Inline/Inline";import{StyledEntityListItem,StyledEntityListItemWrapper,StyledEntityListItemLabel,StyledEntityListDisabler}from"./styled-components";let useEntityListItemLabel=({size,isExpanded,lSpaceStep})=>{let hasExpandableIcon=void 0!==isExpanded,isTreeNode=void 0!==lSpaceStep;return{isDeepestTreeNode:!hasExpandableIcon&&isTreeNode,isTreeNode,textSize:"xs"===size?"s":"m",actionSize:"l"===size?"m":"s",hasExpandableIcon}},StopPropogationWrapper=({children})=>{let handleClick=useCallback(e=>{e.stopPropagation()},[]);return React.createElement("div",{role:"presentation",onClick:handleClick},children)};export function EntityListItem({description,size="m",role,renderLeft,renderRight,isExpanded,isDisabled,isActive,children,onClick,onExpandClick,isClickable,lSpaceStep,renderLabel,hideBorder,isDisabledExpand,"aria-label":ariaLabel}){let{textSize,actionSize,hasExpandableIcon,isTreeNode,isDeepestTreeNode}=useEntityListItemLabel({size,isExpanded,lSpaceStep});return React.createElement(StyledEntityListItem,{role:role,"aria-expanded":isExpanded,"aria-label":ariaLabel,isDisabled:isDisabled},React.createElement(StyledEntityListItemLabel,{size:size,onClick:onClick,isClickable:isClickable,isActive:isActive,isDeepestTreeNode:isDeepestTreeNode,lSpaceStep:lSpaceStep},hasExpandableIcon&&React.createElement(EntityListItemExpandButton,{disabled:isDisabledExpand,isExpanded:isExpanded,onClick:onExpandClick}),React.createElement(StyledEntityListItemWrapper,{size:size,hasLSpace:!isTreeNode,hideBorder:hideBorder||"xs"===size},React.createElement(StyledEntityListDisabler,null,React.createElement(Inline,{noWrap:!0,alignItems:"spaceBetween",space:["xs","m"]},React.createElement(Inline,{noWrap:!0,alignItems:"spaceBetween",space:["xs","m"]},renderLeft&&renderLeft({textSize}),React.createElement(EntityListItemText,{size:textSize,description:description},renderLabel({textSize}))),renderRight&&React.createElement(StopPropogationWrapper,null,renderRight({textSize,actionSize})))))),isExpanded&&children)}

package/build/esm/components/EntityList/EntityListItemExpandButton.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { EntityListItemProps } from "./types";
+export declare function EntityListItemExpandButton({ onClick, isExpanded, disabled, }: Partial<EntityListItemProps> & {
+    disabled?: boolean;
+}): React.ReactElement;

package/build/esm/components/EntityList/EntityListItemExpandButton.js

@@ -0,0 +1 @@
+import React from"react";import{PictogramButton}from"../PictogramButton/PictogramButton";import{Box}from"../Box/Box";export function EntityListItemExpandButton({onClick,isExpanded,disabled}){return React.createElement(Box,{vSpace:"zero",lSpace:["xs","m"],rSpace:["xs","m"]},React.createElement(PictogramButton,{disabled:disabled,onClick:onClick,icon:isExpanded?"chevron-down":"chevron-right"}))}

package/build/esm/components/EntityList/EntityListItemText.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { EntityListItemLabelProps } from "./types";
+export declare function EntityListItemText({ children, size, description, }: EntityListItemLabelProps): React.ReactElement;

package/build/esm/components/EntityList/EntityListItemText.js

@@ -0,0 +1 @@
+import React from"react";import{Text}from"../Typography/Text/Text";import{Stack}from"../Stack/Stack";export function EntityListItemText({children,size,description}){return React.createElement(Stack,{space:"xxxs"},React.createElement(Text,{size:size},children),description&&React.createElement(Text,{color:"tertiary",size:"s"},description))}

package/build/esm/components/EntityList/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./BaseEntityList";
+export * from "./EntityList";
+export * from "./types";

package/build/esm/components/EntityList/index.js

@@ -0,0 +1 @@
+export*from"./BaseEntityList";export*from"./EntityList";export*from"./types";

package/build/esm/components/EntityList/styled-components.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import type { EntityListItemProps, TextSizeProps, EntityListItemWrapperProps, UseEntityListItemLabelReturn } from "./types";
+import type { ListSize } from "../../types";
+export declare const StyledList: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any>;
+} & {
+    size: ListSize;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {}>;
+export declare const StyledEntityListItemWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any>;
+} & EntityListItemWrapperProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const StyledEntityListDisabler: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any>;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const StyledEntityListItemLabel: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any>;
+} & Partial<EntityListItemProps> & Partial<UseEntityListItemLabelReturn>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const StyledEntityListItem: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any>;
+} & Partial<EntityListItemProps>, import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {}>;
+export declare const StyledMinHeightCell: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any>;
+} & TextSizeProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/build/esm/components/EntityList/styled-components.js

@@ -0,0 +1 @@
+import styled from"@emotion/styled";import{mq,mqValue}from"../../shared/mediaQueries";export const StyledList=styled("ul",{target:"e1eych280",label:"StyledList"})(({theme,size})=>({..."xs"===size&&{paddingTop:theme.variables.size.spacing.xs,paddingBottom:theme.variables.size.spacing.xs}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const StyledEntityListItemWrapper=styled("div",{target:"e1eych281",label:"StyledEntityListItemWrapper"})(({theme,size,hideBorder})=>({borderBottom:`1px solid ${theme.values.color.border.secondary.default}`,...hideBorder&&{borderBottom:"none"},width:"100%",...mq({paddingBottom:[size,{xs:theme.variables.size.spacing.xxs,s:theme.variables.size.spacing.s,m:theme.variables.size.spacing.m,l:theme.variables.size.spacing.l}]}),"& button, & a":{margin:`-${theme.variables.size.spacing.xs} 0`}}),({theme,hasLSpace})=>({...mqValue({paddingRight:[theme.variables.size.spacing.m,theme.variables.size.spacing.l],...hasLSpace&&{paddingLeft:[theme.variables.size.spacing.m,theme.variables.size.spacing.l]}})}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const StyledEntityListDisabler=styled("div",{target:"e1eych282",label:"StyledEntityListDisabler"})("/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const StyledEntityListItemLabel=styled("div",{target:"e1eych283",label:"StyledEntityListItemLabel"})(({theme,isClickable,lSpaceStep,isDeepestTreeNode,isActive})=>{let getSize=(baseOffset,deepestNodeOffset)=>`calc(${baseOffset} * ${lSpaceStep} + ${isDeepestTreeNode?deepestNodeOffset:"0px"} + ${theme.variables.size.spacing.xxs})`,mobileSize=getSize(theme.variables.size.spacing.m,"42px"),desktopSize=getSize(theme.variables.size.spacing.xl,"56px");return{display:"flex",flexGrow:1,width:"100%",...void 0!==lSpaceStep&&{...mqValue({paddingLeft:[mobileSize,desktopSize]})},transition:"background-color 0.1s ease-out",...isClickable&&{cursor:"pointer","&:hover":{backgroundColor:theme.values.color.background.transparent.hover}},...isActive&&{backgroundColor:theme.values.color.background.transparent.active}}},({theme,size})=>({...mq({paddingTop:[size,{xs:theme.variables.size.spacing.xxs,s:theme.variables.size.spacing.s,m:theme.variables.size.spacing.m,l:theme.variables.size.spacing.l}]})}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyIsInNvdXJjZXMiOlsic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB0eXBlIHtcbiAgRW50aXR5TGlzdEl0ZW1Qcm9wcyxcbiAgVGV4dFNpemVQcm9wcyxcbiAgRW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHMsXG4gIFVzZUVudGl0eUxpc3RJdGVtTGFiZWxSZXR1cm4sXG59IGZyb20gXCIuL3R5cGVzXCI7XG5pbXBvcnQgdHlwZSB7IExpc3RTaXplIH0gZnJvbSBcIi4uLy4uL3R5cGVzXCI7XG5pbXBvcnQgeyBtcSwgbXFWYWx1ZSB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWVkaWFRdWVyaWVzXCI7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMaXN0ID0gc3R5bGVkLnVsPHsgc2l6ZTogTGlzdFNpemUgfT4oKHsgdGhlbWUsIHNpemUgfSkgPT4gKHtcbiAgLi4uKHNpemUgPT09IFwieHNcIiAmJiB7XG4gICAgcGFkZGluZ1RvcDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54cyxcbiAgICBwYWRkaW5nQm90dG9tOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzLFxuICB9KSxcbn0pKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEVudGl0eUxpc3RJdGVtV3JhcHBlciA9XG4gIHN0eWxlZC5kaXY8RW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHM+KFxuICAgICh7IHRoZW1lLCBzaXplLCBoaWRlQm9yZGVyIH0pID0+ICh7XG4gICAgICBib3JkZXJCb3R0b206IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG4gICAgICAuLi4oaGlkZUJvcmRlciAmJiB7XG4gICAgICAgIGJvcmRlckJvdHRvbTogXCJub25lXCIsXG4gICAgICB9KSxcbiAgICAgIHdpZHRoOiBcIjEwMCVcIixcblxuICAgICAgLi4ubXEoe1xuICAgICAgICBwYWRkaW5nQm90dG9tOiBbXG4gICAgICAgICAgc2l6ZSxcbiAgICAgICAgICB7XG4gICAgICAgICAgICB4czogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54eHMsXG4gICAgICAgICAgICBzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnMsXG4gICAgICAgICAgICBtOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLm0sXG4gICAgICAgICAgICBsOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLmwsXG4gICAgICAgICAgfSBhcyBhbnksXG4gICAgICAgIF0sXG4gICAgICB9KSxcblxuICAgICAgXCImIGJ1dHRvbiwgJiBhXCI6IHtcbiAgICAgICAgLy8gYnV0dG9uIGFuZCBsaW5rcyBoYXZlIGEgZ3JlYXRlZCBoZWlnaHQgdGhhbiBsaXN0IGl0ZW1cbiAgICAgICAgLy8gZnJvbSBkZXNpZ24gc3BlY3MgaXQgc2hvdWxkIG5vdCBleHBhbmQgdGhlIGxpc3QgaXRlbVxuICAgICAgICBtYXJnaW46IGAtJHt0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhzfSAwYCxcbiAgICAgIH0sXG4gICAgfSksXG4gICAgKHsgdGhlbWUsIGhhc0xTcGFjZSB9KSA9PiAoe1xuICAgICAgLi4ubXFWYWx1ZSh7XG4gICAgICAgIHBhZGRpbmdSaWdodDogW1xuICAgICAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgICAgICB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLmwsXG4gICAgICAgIF0sXG4gICAgICAgIC4uLihoYXNMU3BhY2UgJiYge1xuICAgICAgICAgIHBhZGRpbmdMZWZ0OiBbXG4gICAgICAgICAgICB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLm0sXG4gICAgICAgICAgICB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLmwsXG4gICAgICAgICAgXSxcbiAgICAgICAgfSksXG4gICAgICB9KSxcbiAgICB9KVxuICApO1xuXG4vLyB3ZSBuZWVkIGl0IGJlY2F1c2UgaW4gU3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyXG4vLyB3ZSBoYXZlIGJvcmRlci1ib3R0b20gd2hpY2ggc2hvdWxkIG5vdCBsb29rIGRpc2FibGVkIHdoZW4gaXQncyBkaXNhYmxlZFxuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5TGlzdERpc2FibGVyID0gc3R5bGVkLmRpdmBgO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5TGlzdEl0ZW1MYWJlbCA9IHN0eWxlZC5kaXY8XG4gIFBhcnRpYWw8RW50aXR5TGlzdEl0ZW1Qcm9wcz4gJiBQYXJ0aWFsPFVzZUVudGl0eUxpc3RJdGVtTGFiZWxSZXR1cm4+XG4+KFxuICAoeyB0aGVtZSwgaXNDbGlja2FibGUsIGxTcGFjZVN0ZXAsIGlzRGVlcGVzdFRyZWVOb2RlLCBpc0FjdGl2ZSB9KSA9PiB7XG4gICAgY29uc3QgZ2V0U2l6ZSA9IChiYXNlT2Zmc2V0OiBzdHJpbmcsIGRlZXBlc3ROb2RlT2Zmc2V0OiBzdHJpbmcpID0+XG4gICAgICBgY2FsYygke2Jhc2VPZmZzZXR9ICogJHtsU3BhY2VTdGVwfSArICR7XG4gICAgICAgIGlzRGVlcGVzdFRyZWVOb2RlID8gZGVlcGVzdE5vZGVPZmZzZXQgOiBcIjBweFwiXG4gICAgICB9ICsgJHt0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4c30pYDtcblxuICAgIGNvbnN0IG1vYmlsZVNpemUgPSBnZXRTaXplKHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSwgXCI0MnB4XCIpO1xuICAgIGNvbnN0IGRlc2t0b3BTaXplID0gZ2V0U2l6ZSh0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhsLCBcIjU2cHhcIik7XG5cbiAgICByZXR1cm4ge1xuICAgICAgZGlzcGxheTogXCJmbGV4XCIsXG4gICAgICBmbGV4R3JvdzogMSxcbiAgICAgIHdpZHRoOiBcIjEwMCVcIixcblxuICAgICAgLi4uKGxTcGFjZVN0ZXAgIT09IHVuZGVmaW5lZCAmJiB7XG4gICAgICAgIC4uLm1xVmFsdWUoe1xuICAgICAgICAgIHBhZGRpbmdMZWZ0OiBbbW9iaWxlU2l6ZSwgZGVza3RvcFNpemVdLFxuICAgICAgICB9KSxcbiAgICAgIH0pLFxuXG4gICAgICB0cmFuc2l0aW9uOiBcImJhY2tncm91bmQtY29sb3IgMC4xcyBlYXNlLW91dFwiLFxuXG4gICAgICAuLi4oaXNDbGlja2FibGUgJiYge1xuICAgICAgICBjdXJzb3I6IFwicG9pbnRlclwiLFxuICAgICAgICBcIiY6aG92ZXJcIjoge1xuICAgICAgICAgIGJhY2tncm91bmRDb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLmJhY2tncm91bmQudHJhbnNwYXJlbnQuaG92ZXIsXG4gICAgICAgIH0sXG4gICAgICB9KSxcblxuICAgICAgLi4uKGlzQWN0aXZlICYmIHtcbiAgICAgICAgYmFja2dyb3VuZENvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IuYmFja2dyb3VuZC50cmFuc3BhcmVudC5hY3RpdmUsXG4gICAgICB9KSxcbiAgICB9O1xuICB9LFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLm1xKHtcbiAgICAgIHBhZGRpbmdUb3A6IFtcbiAgICAgICAgc2l6ZSxcbiAgICAgICAge1xuICAgICAgICAgIHhzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4cyxcbiAgICAgICAgICBzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnMsXG4gICAgICAgICAgbTogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5tLFxuICAgICAgICAgIGw6IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubCxcbiAgICAgICAgfSBhcyBhbnksXG4gICAgICBdLFxuICAgIH0pLFxuICB9KVxuKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEVudGl0eUxpc3RJdGVtID0gc3R5bGVkLmxpPFBhcnRpYWw8RW50aXR5TGlzdEl0ZW1Qcm9wcz4+KFxuICAoeyBpc0Rpc2FibGVkLCB0aGVtZSB9KSA9PiAoe1xuICAgIC4uLihpc0Rpc2FibGVkICYmIHtcbiAgICAgIGN1cnNvcjogXCJub3QtYWxsb3dlZFwiLFxuXG4gICAgICBbYCR7U3R5bGVkRW50aXR5TGlzdERpc2FibGVyfWBdOiB7XG4gICAgICAgIG9wYWNpdHk6IHRoZW1lLnZhcmlhYmxlcy5vcGFjaXR5LmRpc2FibGVkLFxuICAgICAgfSxcblxuICAgICAgW2Ake1N0eWxlZEVudGl0eUxpc3RJdGVtTGFiZWx9YF06IHtcbiAgICAgICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG4gICAgICB9LFxuICAgIH0pLFxuICAgIGxpc3RTdHlsZVR5cGU6IFwibm9uZVwiLFxuICB9KVxuKTtcblxuLy8gVGhpcyBtaW5IZWlnaHQgaXMgbmVlZGVkIGZvciBhbGlnbiBzbWFsbCBpY29ucyBpbiB0aGUgbWlkZGxlIG9mIDEgcm93IHRleHQsXG4vLyBidXQgaXQgc2hvdWxkIHN0YXkgYXQgdGhlIHRvcCBpZiB0aGVyZSBpcyBtdWx0aWxpbmUgdGV4dFxuZXhwb3J0IGNvbnN0IFN0eWxlZE1pbkhlaWdodENlbGwgPSBzdHlsZWQuZGl2PFRleHRTaXplUHJvcHM+KFxuICAoeyB0aGVtZSwgdGV4dFNpemUgfSkgPT4gKHtcbiAgICBtaW5IZWlnaHQ6XG4gICAgICB0ZXh0U2l6ZSA9PT0gXCJzXCJcbiAgICAgICAgPyBgY2FsYygke3RoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubX0gKyAke3RoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHhzfSlgXG4gICAgICAgIDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgIGRpc3BsYXk6IFwiZmxleFwiLFxuICAgIGFsaWduSXRlbXM6IFwiY2VudGVyXCIsXG4gIH0pXG4pO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWlFeUMifQ== */");export const StyledEntityListItem=styled("li",{target:"e1eych284",label:"StyledEntityListItem"})(({isDisabled,theme})=>({...isDisabled&&{cursor:"not-allowed",[`${StyledEntityListDisabler}`]:{opacity:theme.variables.opacity.disabled},[`${StyledEntityListItemLabel}`]:{pointerEvents:"none"}},listStyleType:"none"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const StyledMinHeightCell=styled("div",{target:"e1eych285",label:"StyledMinHeightCell"})(({theme,textSize})=>({minHeight:"s"===textSize?`calc(${theme.variables.size.spacing.m} + ${theme.variables.size.spacing.xxs})`:theme.variables.size.spacing.l,display:"flex",alignItems:"center"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");

package/build/esm/components/EntityList/types.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="react" />
+import type { TextSize, ListSize } from "../../types";
+import type { IconProps } from "../Icon/Icon";
+export type ListNode = {
+    id: string;
+    label: string;
+    isActive?: boolean;
+    description?: string;
+    "aria-label"?: string;
+    [key: string]: any;
+};
+export type ActionSizeProps = {
+    actionSize: "s" | "m";
+};
+export type TextSizeProps = {
+    textSize: "s" | "m";
+};
+type RenderProps = (props: TextSizeProps) => React.ReactNode;
+export type ListNodeProps = ListNode & TextSizeProps;
+export type EntityListProps = {
+    data: ListNode[];
+    size?: ListSize;
+    selectedIds?: string[];
+    isSelectable?: boolean;
+    onSelectionChange?: (ids: string[]) => void;
+    onClick?: (props: ListNodeProps) => void;
+    getLeftIconProps?: (props: ListNode) => Pick<IconProps, "name" | "color">;
+    renderRightContent?: (props: ListNodeProps & ActionSizeProps) => React.ReactNode;
+    hideBorder?: boolean;
+    "data-e2e-test-id"?: string;
+};
+export type EntityListItemWrapperProps = {
+    size: ListSize;
+    hasLSpace: boolean;
+    hideBorder: boolean;
+};
+export type EntityListItemProps = {
+    children?: React.ReactNode;
+    role?: string;
+    isClickable?: boolean;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    size?: ListSize;
+    lSpaceStep?: 0 | 1 | 2 | 3 | 4 | 5;
+    description?: string;
+    renderLabel: RenderProps;
+    renderLeft?: RenderProps;
+    renderRight?: (props: TextSizeProps & ActionSizeProps) => React.ReactNode;
+    isExpanded?: boolean;
+    isDisabledExpand?: boolean;
+    hideBorder?: boolean;
+    onExpandClick?: (e: React.MouseEvent) => void;
+    onClick?: (e: React.MouseEvent) => void;
+    "aria-label": string;
+};
+export type EntityListItemLabelProps = {
+    children: React.ReactNode;
+    size: TextSize;
+    description?: string;
+};
+export type EntityListItemExpandButtonProps = {
+    disabled?: boolean;
+} & Partial<EntityListItemProps>;
+export type UseEntityListItemLabelProps = {
+    size: EntityListItemProps["size"];
+    isExpanded?: boolean;
+    isTreeNode?: boolean;
+    lSpaceStep?: number;
+};
+export type UseEntityListItemLabelReturn = {
+    actionSize: ActionSizeProps["actionSize"];
+    textSize: TextSizeProps["textSize"];
+    hasExpandableIcon: boolean;
+    isTreeNode: boolean;
+    isDeepestTreeNode: boolean;
+};
+export {};

package/build/esm/components/EntityTree/BaseEntityTree.d.ts

@@ -1,18 +1,11 @@
 import React from "react";
-import type { ListItemProps } from "../List/types";
-import type { NodeID, CheckboxState } from "./types";
-export type TreeNode = {
-    id: NodeID;
-    label: string;
-    description?: string;
-    children: TreeNode[];
-    isFiltered?: boolean;
-};
+import type { EntityListItemProps } from "../EntityList/types";
+import type { NodeID, TreeNode, CheckboxState } from "./types";
 export type TreeNodeWithUIState = TreeNode & {
     isExpanded: boolean;
     checkedState: CheckboxState;
 };
-type PartialListItemProps = Pick<ListItemProps, "hideBorder" | "size" | "renderRight">;
+type PartialEntityListItemProps = Pick<EntityListItemProps, "hideBorder" | "size" | "renderRight">;
 export type EntityTreeProps = {
     data: TreeNode[];
     selectedIds?: NodeID[];
@@ -23,6 +16,6 @@ export type EntityTreeProps = {
     onTreeChange?: (data: TreeNodeWithUIState[]) => void;
     showItemsCount?: boolean;
     "data-e2e-test-id"?: string;
-} & PartialListItemProps;
+} & PartialEntityListItemProps;
 export declare const BaseEntityTree: ({ data, selectedIds, onSelectionChange, expandedIds, onToggle, filterFn, onTreeChange, hideBorder, size, showItemsCount, renderRight, "data-e2e-test-id": dataE2eTestId, }: EntityTreeProps) => React.ReactElement;
 export {};

package/build/esm/components/EntityTree/BaseEntityTree.js

@@ -1 +1 @@
-import React,{useEffect}from"react";import{StyledList}from"../List/styled-components";import{ListItem}from"../List/ListItem";import{Text}from"../Typography/Text/Text";import{CheckboxRaw}from"../Form/Checkbox/Checkbox";import{getNodeChildrenMap,getTreeCheckboxState,getLeafNodeIds,filterTree,mapTree}from"./tree";let getLastNodeOfList=({node,data,level,isParentsLastOfLvl})=>{let currentLastNodeOfLvl=node.id===data[data.length-1].id;return 0===level?currentLastNodeOfLvl:isParentsLastOfLvl&&currentLastNodeOfLvl},makeRenderTreeBranches=({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange,handleToggle,expandAll,hideBorder,size,showItemsCount,renderRight})=>({data,level,renderFn,isParentsLastOfLvl})=>data.map(node=>{let readOnly=null===nodeCheckboxState,hasChildren=node.children.length>0,expandedState=!!expandAll||!!nodeExpandedState[node.id],leafItems=getLeafNodeIds(nodeChildrenMap,node.id),totalItemsCount=leafItems.length,selectedItemsCount=nodeCheckboxState?leafItems.filter(leafId=>"checked"===nodeCheckboxState[leafId]).length:null,countLabel=nodeCheckboxState?`(${selectedItemsCount}/${totalItemsCount})`:`(${totalItemsCount})`,isLastNodeOfList=getLastNodeOfList({node,data,level,isParentsLastOfLvl}),lastLeaf=!hasChildren&&!node.isFiltered,isExpanded=lastLeaf?void 0:expandedState;return React.createElement(ListItem,{key:node.id,role:"treeitem",hideBorder:hideBorder||isLastNodeOfList&&(!isExpanded||node.isFiltered),size:size,lSpaceStep:level,"aria-label":node.label,description:node.description,renderLabel:({size:textSize})=>React.createElement(React.Fragment,null,node.label,showItemsCount&&!lastLeaf&&React.createElement(Text,{as:"span",size:textSize,color:"tertiary"}," ",countLabel)),isExpanded:isExpanded,isDisabledExpand:expandAll,onExpandClick:e=>{e.stopPropagation(),handleToggle(node.id)},onClick:readOnly?()=>handleToggle(node.id):()=>handleSelectionChange(node.id),renderLeft:readOnly?void 0:()=>React.createElement(CheckboxRaw,{size:"s",name:node.label,checked:"checked"===nodeCheckboxState[node.id],indeterminate:"indeterminate"===nodeCheckboxState[node.id],onChange:()=>handleSelectionChange(node.id)}),renderRight:renderRight},hasChildren&&React.createElement("ul",null,renderFn({data:node.children,level:level+1,renderFn,isParentsLastOfLvl:isLastNodeOfList})))});export const BaseEntityTree=({data,selectedIds,onSelectionChange,expandedIds=[],onToggle,filterFn,onTreeChange,hideBorder=!1,size="m",showItemsCount=!0,renderRight,"data-e2e-test-id":dataE2eTestId})=>{let nodeChildrenMap=Object.assign({},...data.map(tree=>getNodeChildrenMap(tree))),nodeCheckboxState=selectedIds?Object.assign({},...data.map(tree=>getTreeCheckboxState(nodeChildrenMap,tree.id,selectedIds))):null,nodeExpandedState=expandedIds.reduce((acc,id)=>(acc[id]=!0,acc),{}),dataShown=filterFn?data.map(tree=>filterTree(tree,filterFn)).filter(Boolean):data;useEffect(()=>{onTreeChange&&onTreeChange(dataShown.map(tree=>mapTree(tree,node=>({...node,checkedState:!!nodeCheckboxState&&nodeCheckboxState[node.id],isExpanded:!!nodeExpandedState[node.id]}))))},[dataShown,nodeCheckboxState,nodeExpandedState,onTreeChange]);let renderTreeBranches=makeRenderTreeBranches({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange:targetId=>{if(onSelectionChange){let updatedSelectedIds=[];if(0===nodeChildrenMap[targetId].length)updatedSelectedIds=selectedIds.includes(targetId)?selectedIds.filter(id=>id!==targetId):selectedIds.concat([targetId]);else{let affectedLeafNodeIds=getLeafNodeIds(nodeChildrenMap,targetId);updatedSelectedIds="checked"===nodeCheckboxState[targetId]?selectedIds.filter(id=>!affectedLeafNodeIds.includes(id)):selectedIds.concat(affectedLeafNodeIds)}onSelectionChange(updatedSelectedIds)}},handleToggle:targetId=>{onToggle&&onToggle(expandedIds.includes(targetId)?expandedIds.filter(id=>id!==targetId):expandedIds.concat([targetId]))},expandAll:!!filterFn,hideBorder,size,showItemsCount,renderRight});return React.createElement(StyledList,{role:"tree","data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityTree"},renderTreeBranches({data:dataShown,level:0,renderFn:renderTreeBranches}))};
+import React,{useEffect}from"react";import{StyledList}from"../EntityList/styled-components";import{EntityListItem}from"../EntityList/EntityListItem";import{Text}from"../Typography/Text/Text";import{CheckboxRaw}from"../Form/Checkbox/Checkbox";import{getNodeChildrenMap,getTreeCheckboxState,getLeafNodeIds,filterTree,mapTree}from"./tree";let getLastNodeOfList=({node,data,level,isParentsLastOfLvl})=>{let currentLastNodeOfLvl=node.id===data[data.length-1].id;return 0===level?currentLastNodeOfLvl:isParentsLastOfLvl&&currentLastNodeOfLvl},makeRenderTreeBranches=({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange,handleToggle,expandAll,hideBorder,size,showItemsCount,renderRight})=>({data,level,renderFn,isParentsLastOfLvl})=>data.map(node=>{let readOnly=null===nodeCheckboxState,hasChildren=node.children.length>0,expandedState=!!expandAll||!!nodeExpandedState[node.id],leafItems=getLeafNodeIds(nodeChildrenMap,node.id),totalItemsCount=leafItems.length,selectedItemsCount=nodeCheckboxState?leafItems.filter(leafId=>"checked"===nodeCheckboxState[leafId]).length:null,countLabel=nodeCheckboxState?`(${selectedItemsCount}/${totalItemsCount})`:`(${totalItemsCount})`,isLastNodeOfList=getLastNodeOfList({node,data,level,isParentsLastOfLvl}),lastLeaf=!hasChildren&&!node.isFiltered,isExpanded=lastLeaf?void 0:expandedState;return React.createElement(EntityListItem,{key:node.id,role:"treeitem",hideBorder:hideBorder||isLastNodeOfList&&(!isExpanded||node.isFiltered),size:size,isClickable:!0,lSpaceStep:level,"aria-label":node.label,description:node.description,renderLabel:({textSize})=>React.createElement(React.Fragment,null,node.label,showItemsCount&&!lastLeaf&&React.createElement(Text,{as:"span",size:textSize,color:"tertiary"}," ",countLabel)),isExpanded:isExpanded,isDisabledExpand:expandAll,onExpandClick:e=>{e.stopPropagation(),handleToggle(node.id)},onClick:readOnly?()=>handleToggle(node.id):()=>handleSelectionChange(node.id),renderLeft:readOnly?void 0:()=>React.createElement(CheckboxRaw,{size:"s",name:node.label,checked:"checked"===nodeCheckboxState[node.id],indeterminate:"indeterminate"===nodeCheckboxState[node.id],onChange:()=>handleSelectionChange(node.id)}),renderRight:renderRight},hasChildren&&React.createElement("ul",null,renderFn({data:node.children,level:level+1,renderFn,isParentsLastOfLvl:isLastNodeOfList})))});export const BaseEntityTree=({data,selectedIds,onSelectionChange,expandedIds=[],onToggle,filterFn,onTreeChange,hideBorder=!1,size="m",showItemsCount=!0,renderRight,"data-e2e-test-id":dataE2eTestId})=>{let nodeChildrenMap=Object.assign({},...data.map(tree=>getNodeChildrenMap(tree))),nodeCheckboxState=selectedIds?Object.assign({},...data.map(tree=>getTreeCheckboxState(nodeChildrenMap,tree.id,selectedIds))):null,nodeExpandedState=expandedIds.reduce((acc,id)=>(acc[id]=!0,acc),{}),dataShown=filterFn?data.map(tree=>filterTree(tree,filterFn)).filter(Boolean):data;useEffect(()=>{onTreeChange&&onTreeChange(dataShown.map(tree=>mapTree(tree,node=>({...node,checkedState:!!nodeCheckboxState&&nodeCheckboxState[node.id],isExpanded:!!nodeExpandedState[node.id]}))))},[dataShown,nodeCheckboxState,nodeExpandedState,onTreeChange]);let renderTreeBranches=makeRenderTreeBranches({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange:targetId=>{if(onSelectionChange){let updatedSelectedIds=[];if(0===nodeChildrenMap[targetId].length)updatedSelectedIds=selectedIds.includes(targetId)?selectedIds.filter(id=>id!==targetId):selectedIds.concat([targetId]);else{let affectedLeafNodeIds=getLeafNodeIds(nodeChildrenMap,targetId);updatedSelectedIds="checked"===nodeCheckboxState[targetId]?selectedIds.filter(id=>!affectedLeafNodeIds.includes(id)):selectedIds.concat(affectedLeafNodeIds)}onSelectionChange(updatedSelectedIds)}},handleToggle:targetId=>{onToggle&&onToggle(expandedIds.includes(targetId)?expandedIds.filter(id=>id!==targetId):expandedIds.concat([targetId]))},expandAll:!!filterFn,hideBorder,size,showItemsCount,renderRight});return React.createElement(StyledList,{role:"tree","data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityTree",size:size},renderTreeBranches({data:dataShown,level:0,renderFn:renderTreeBranches}))};

package/build/esm/components/EntityTree/EntityTree.js

@@ -1 +1 @@
-import React from"react";import{Container}from"../Container/Container";import{Box}from"../Box/Box";import{BaseEntityTree}from"./BaseEntityTree";export const EntityTree=props=>{let{size}=props;return React.createElement(Container,{overflow:"hidden"},React.createElement(Box,{space:"zero",vSpace:"xs"===size?"xs":"zero"},React.createElement(BaseEntityTree,props)))};
+import React from"react";import{BaseEntityTree}from"./BaseEntityTree";import{Container}from"../Container/Container";export const EntityTree=props=>React.createElement(Container,{overflow:"hidden"},React.createElement(BaseEntityTree,props));

package/build/esm/components/EntityTree/tree.d.ts

@@ -1,5 +1,4 @@
-import type { NodeID, NodeChildrenMap, NodeCheckboxState } from "./types";
-import type { TreeNode } from "./BaseEntityTree";
+import type { NodeID, TreeNode, NodeChildrenMap, NodeCheckboxState } from "./types";
 export declare function getNodeChildrenMap(tree: Partial<TreeNode>): NodeChildrenMap;
 export declare function getTreeCheckboxState(nodeChildrenMap: NodeChildrenMap, rootID: NodeID, selectedLeafNodeIds: NodeID[]): NodeCheckboxState;
 export declare function getLeafNodeIds(nodeChildrenMap: NodeChildrenMap, rootID: NodeID): NodeID[];

package/build/esm/components/EntityTree/tree.js

@@ -1 +1 @@
-function foldTree(f,nodeChildrenMap,rootID){let go=nodeID=>f(nodeID,nodeChildrenMap[nodeID].map(go));return go(rootID)}export function getNodeChildrenMap(tree){let nodeChildrenMap={};return!function traverse(node){let{children}=node;nodeChildrenMap[node.id]=children.map(child=>(traverse(child),child.id))}(tree),nodeChildrenMap}export function getTreeCheckboxState(nodeChildrenMap,rootID,selectedLeafNodeIds){return foldTree((currId,childrenResults)=>{if(0===nodeChildrenMap[currId].length)return{[currId]:selectedLeafNodeIds.includes(currId)?"checked":"unchecked"};let mergedChildrenResult=childrenResults.reduce((acc,result)=>Object.assign(acc,result)),childrenStates=new Set(nodeChildrenMap[currId].map(childId=>mergedChildrenResult[childId]));return{[currId]:1===childrenStates.size?childrenStates.values().next().value:"indeterminate",...mergedChildrenResult}},nodeChildrenMap,rootID)}export function getLeafNodeIds(nodeChildrenMap,rootID){return foldTree((currId,childrenResults)=>0===nodeChildrenMap[currId].length?[currId]:childrenResults.flat(),nodeChildrenMap,rootID)}export function filterTree(tree,filterFn){let filteredChildren=tree.children.map(child=>filterTree(child,filterFn)).filter(child=>child);return 0!==filteredChildren.length||filterFn(tree)?{...tree,isFiltered:tree.children.length!==filteredChildren.length,children:filteredChildren}:null}export function mapTree(tree,mapFn){return{...mapFn(tree),children:tree.children.map(child=>mapTree(child,mapFn))}}
+import{CheckboxState}from"./types";function foldTree(f,nodeChildrenMap,rootID){let go=nodeID=>f(nodeID,nodeChildrenMap[nodeID].map(go));return go(rootID)}export function getNodeChildrenMap(tree){let nodeChildrenMap={};return!function traverse(node){let{children}=node;nodeChildrenMap[node.id]=children.map(child=>(traverse(child),child.id))}(tree),nodeChildrenMap}export function getTreeCheckboxState(nodeChildrenMap,rootID,selectedLeafNodeIds){return foldTree((currId,childrenResults)=>{if(0===nodeChildrenMap[currId].length)return{[currId]:selectedLeafNodeIds.includes(currId)?CheckboxState.Checked:CheckboxState.Unchecked};let mergedChildrenResult=childrenResults.reduce((acc,result)=>Object.assign(acc,result)),childrenStates=new Set(nodeChildrenMap[currId].map(childId=>mergedChildrenResult[childId]));return{[currId]:1===childrenStates.size?childrenStates.values().next().value:CheckboxState.Indeterminate,...mergedChildrenResult}},nodeChildrenMap,rootID)}export function getLeafNodeIds(nodeChildrenMap,rootID){return foldTree((currId,childrenResults)=>0===nodeChildrenMap[currId].length?[currId]:childrenResults.flat(),nodeChildrenMap,rootID)}export function filterTree(tree,filterFn){let filteredChildren=tree.children.map(child=>filterTree(child,filterFn)).filter(child=>child);return 0!==filteredChildren.length||filterFn(tree)?{...tree,isFiltered:tree.children.length!==filteredChildren.length,children:filteredChildren}:null}export function mapTree(tree,mapFn){return{...mapFn(tree),children:tree.children.map(child=>mapTree(child,mapFn))}}

package/build/esm/components/EntityTree/treeListData.mock.d.ts

@@ -0,0 +1,2 @@
+import type { TreeNode } from "./types";
+export declare const treeListData: TreeNode[];

package/build/esm/components/EntityTree/treeListData.mock.js

@@ -0,0 +1 @@
+export const treeListData=[{id:"a",label:"a",children:[{id:"a.1",label:"a.1",children:[{id:"a.1.1",label:"a.1.1",children:[]},{id:"a.1.2",label:"a.1.2",children:[]}]}]},{id:"b",label:"b",children:[{id:"b.1",label:"b.1",children:[{id:"b.1.1",label:"b.1.1",children:[]}]}]}];

package/build/esm/components/EntityTree/types.d.ts

@@ -1,5 +1,16 @@
 export type NodeID = string;
+export type TreeNode = {
+    id: NodeID;
+    label: string;
+    description?: string;
+    children: TreeNode[];
+    isFiltered?: boolean;
+};
 export type NodeChildrenMap = Record<NodeID, NodeID[]>;
-export type CheckboxState = "checked" | "unchecked" | "indeterminate";
+export declare enum CheckboxState {
+    Unchecked = "unchecked",
+    Checked = "checked",
+    Indeterminate = "indeterminate"
+}
 export type NodeCheckboxState = Record<NodeID, CheckboxState>;
 export type NodeExpandedState = Record<NodeID, boolean>;

package/build/esm/components/EntityTree/types.js

@@ -1 +1 @@
-export{};
+var CheckboxState;var CheckboxState1;export{CheckboxState1 as CheckboxState};(CheckboxState=CheckboxState1||(CheckboxState1={})).Unchecked="unchecked",CheckboxState.Checked="checked",CheckboxState.Indeterminate="indeterminate";