@amboss/design-system 3.35.1 → 3.35.4

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var target=exports,all={get StyledEntityItemLi(){return StyledEntityItemLi},get StyledEntityListItemButton(){return StyledEntityListItemButton},get StyledEntityListItemWrapper(){return StyledEntityListItemWrapper},get StyledList(){return StyledList},get StyledShowMore(){return StyledShowMore},get StyledWrapperOffset(){return StyledWrapperOffset},get getOffsetMqStyle(){return getOffsetMqStyle}};for(var name in all)Object.defineProperty(target,name,{enumerable:!0,get:Object.getOwnPropertyDescriptor(all,name).get});const _styled=/*#__PURE__*/require("@swc/helpers/_/_interop_require_default")._(require("@emotion/styled")),_mediaQueries=require("../../shared/mediaQueries"),_mixins=require("../../shared/mixins"),getOffsetMqStyle=(cssProp,{theme,size})=>(0,_mediaQueries.mq)({[cssProp]:[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}]}),StyledList=(0,_styled.default)("ul",{target:"e3zp63p0",label:"StyledList"})(({theme,size})=>({..."xs"===size&&{padding:`${theme.variables.size.spacing.xs} 0`}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityItemLi=(0,_styled.default)("li",{target:"e3zp63p1",label:"StyledEntityItemLi"})({listStyleType:"none"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyIsInNvdXJjZXMiOlsic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvZXhwbGljaXQtbW9kdWxlLWJvdW5kYXJ5LXR5cGVzICovXG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IHR5cGUgVGhlbWUgfSBmcm9tIFwiQGVtb3Rpb24vcmVhY3RcIjtcbmltcG9ydCB0eXBlIHsgRW50aXR5TGlzdEl0ZW1Qcm9wcywgRW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHMgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHR5cGUgeyBMaXN0U2l6ZSB9IGZyb20gXCIuLi8uLi90eXBlc1wiO1xuaW1wb3J0IHsgbXEsIHVzZVJlc3BvbnNpdmVWYWx1ZSB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWVkaWFRdWVyaWVzXCI7XG5pbXBvcnQgeyBnZXRGb2N1c1N0eWxlcyB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWl4aW5zXCI7XG5cbmV4cG9ydCBjb25zdCBnZXRPZmZzZXRNcVN0eWxlID0gKFxuICBjc3NQcm9wOiBzdHJpbmcsXG4gIHtcbiAgICB0aGVtZSxcbiAgICBzaXplLFxuICB9OiB7XG4gICAgdGhlbWU6IFRoZW1lO1xuICB9ICYgUGFydGlhbDxFbnRpdHlMaXN0SXRlbVdyYXBwZXJQcm9wcz5cbikgPT5cbiAgbXEoe1xuICAgIFtjc3NQcm9wXTogW1xuICAgICAgc2l6ZSxcbiAgICAgIHtcbiAgICAgICAgeHM6IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHhzLFxuICAgICAgICBzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnMsXG4gICAgICAgIG06IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgICAgbDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgICAgfSBhcyBhbnksXG4gICAgXSxcbiAgfSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMaXN0ID0gc3R5bGVkLnVsPHsgc2l6ZTogTGlzdFNpemUgfT4oKHsgdGhlbWUsIHNpemUgfSkgPT4gKHtcbiAgLi4uKHNpemUgPT09IFwieHNcIiAmJiB7XG4gICAgcGFkZGluZzogYCR7dGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54c30gMGAsXG4gIH0pLFxufSkpO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5SXRlbUxpID0gc3R5bGVkLmxpKHtcbiAgbGlzdFN0eWxlVHlwZTogXCJub25lXCIsXG59KTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZFNob3dNb3JlID0gc3R5bGVkLmRpdigoeyB0aGVtZSB9KSA9PiAoe1xuICBtYXJnaW5Ub3A6IC0xLFxuICBib3JkZXJUb3A6IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG59KSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRXcmFwcGVyT2Zmc2V0ID0gc3R5bGVkLmRpdjx7IHNpemU6IExpc3RTaXplIH0+KFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLmdldE9mZnNldE1xU3R5bGUoXCJwYWRkaW5nQm90dG9tXCIsIHsgdGhlbWUsIHNpemUgfSksXG4gIH0pLFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLmdldE9mZnNldE1xU3R5bGUoXCJwYWRkaW5nVG9wXCIsIHsgdGhlbWUsIHNpemUgfSksXG4gIH0pXG4pO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyID0gc3R5bGVkKFxuICBTdHlsZWRXcmFwcGVyT2Zmc2V0XG4pPEVudGl0eUxpc3RJdGVtV3JhcHBlclByb3BzPigoeyB0aGVtZSwgaGlkZUJvcmRlciB9KSA9PiAoe1xuICB3aWR0aDogXCIxMDAlXCIsXG5cbiAgLi4uKCFoaWRlQm9yZGVyICYmIHtcbiAgICBib3JkZXJCb3R0b206IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG4gIH0pLFxuXG4gIC4uLnVzZVJlc3BvbnNpdmVWYWx1ZSh7XG4gICAgcGFkZGluZ0xlZnQ6IFtcbiAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubCxcbiAgICBdLFxuICAgIHBhZGRpbmdSaWdodDogW1xuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5tLFxuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgIF0sXG4gIH0pLFxuXG4gIC8vIGJ1dHRvbiBhbmQgbGlua3MgaGF2ZSBhIGdyZWF0ZWQgaGVpZ2h0IHRoYW4gbGlzdCBpdGVtXG4gIC8vIGZyb20gZGVzaWduIHNwZWNzIGl0IHNob3VsZCBub3QgZXhwYW5kIHRoZSBsaXN0IGl0ZW1cbiAgXCImIGJ1dHRvbiwgJiBhXCI6IHtcbiAgICBtYXJnaW46IGAtJHt0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4c30gMGAsXG4gIH0sXG59KSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRFbnRpdHlMaXN0SXRlbUJ1dHRvbiA9IHN0eWxlZC5kaXY8XG4gIFBhcnRpYWw8RW50aXR5TGlzdEl0ZW1Qcm9wcz5cbj4oKHsgdGhlbWUsIGlzQ2xpY2thYmxlLCBpc0FjdGl2ZSwgaXNEaXNhYmxlZCB9KSA9PiAoe1xuICBkaXNwbGF5OiBcImZsZXhcIixcbiAgZmxleDogXCIxIDEgMTAwJVwiLFxuICBmbGV4V3JhcDogXCJub3dyYXBcIixcbiAgdHJhbnNpdGlvbjogXCJiYWNrZ3JvdW5kLWNvbG9yIDAuMXMgZWFzZS1vdXRcIixcblxuICAuLi4oaXNDbGlja2FibGUgJiYge1xuICAgIGN1cnNvcjogXCJwb2ludGVyXCIsXG4gIH0pLFxuXG4gIFwiJjpob3ZlclwiOiB7XG4gICAgYmFja2dyb3VuZENvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IuYmFja2dyb3VuZC50cmFuc3BhcmVudC5ob3ZlcixcbiAgfSxcblxuICAuLi4oaXNBY3RpdmUgJiYge1xuICAgIGJhY2tncm91bmRDb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLmJhY2tncm91bmQudHJhbnNwYXJlbnQuYWN0aXZlLFxuICB9KSxcblxuICAuLi5nZXRGb2N1c1N0eWxlcyh7IG9mZnNldDogLTIgfSksXG4gIFwiJjpmb2N1cy12aXNpYmxlXCI6IHtcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IHRoZW1lLnZhbHVlcy5jb2xvci5iYWNrZ3JvdW5kLnRyYW5zcGFyZW50LmFjdGl2ZSxcbiAgfSxcblxuICAuLi4oaXNEaXNhYmxlZCAmJiB7XG4gICAgY3Vyc29yOiBcIm5vdC1hbGxvd2VkXCIsXG4gICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG5cbiAgICBbYCR7U3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyfSA+ICpgXToge1xuICAgICAgb3BhY2l0eTogdGhlbWUudmFyaWFibGVzLm9wYWNpdHkuZGlzYWJsZWQsXG4gICAgfSxcbiAgfSksXG59KSk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUNrQyJ9 */"),StyledShowMore=(0,_styled.default)("div",{target:"e3zp63p2",label:"StyledShowMore"})(({theme})=>({marginTop:-1,borderTop:`1px solid ${theme.values.color.border.secondary.default}`}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledWrapperOffset=(0,_styled.default)("div",{target:"e3zp63p3",label:"StyledWrapperOffset"})(({theme,size})=>({...getOffsetMqStyle("paddingBottom",{theme,size})}),({theme,size})=>({...getOffsetMqStyle("paddingTop",{theme,size})}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityListItemWrapper=(0,_styled.default)(StyledWrapperOffset,{target:"e3zp63p4",label:"StyledEntityListItemWrapper"})(({theme,hideBorder})=>({width:"100%",...!hideBorder&&{borderBottom:`1px solid ${theme.values.color.border.secondary.default}`},...(0,_mediaQueries.useResponsiveValue)({paddingLeft:[theme.variables.size.spacing.m,theme.variables.size.spacing.l],paddingRight:[theme.variables.size.spacing.m,theme.variables.size.spacing.l]}),"& button, & a":{margin:`-${theme.variables.size.spacing.xxs} 0`}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityListItemButton=(0,_styled.default)("div",{target:"e3zp63p5",label:"StyledEntityListItemButton"})(({theme,isClickable,isActive,isDisabled})=>({display:"flex",flex:"1 1 100%",flexWrap:"nowrap",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},...(0,_mixins.getFocusStyles)({offset:-2}),"&:focus-visible":{backgroundColor:theme.values.color.background.transparent.active},...isDisabled&&{cursor:"not-allowed",pointerEvents:"none",[`${StyledEntityListItemWrapper} > *`]:{opacity:theme.variables.opacity.disabled}}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyIsInNvdXJjZXMiOlsic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvZXhwbGljaXQtbW9kdWxlLWJvdW5kYXJ5LXR5cGVzICovXG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IHR5cGUgVGhlbWUgfSBmcm9tIFwiQGVtb3Rpb24vcmVhY3RcIjtcbmltcG9ydCB0eXBlIHsgRW50aXR5TGlzdEl0ZW1Qcm9wcywgRW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHMgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHR5cGUgeyBMaXN0U2l6ZSB9IGZyb20gXCIuLi8uLi90eXBlc1wiO1xuaW1wb3J0IHsgbXEsIHVzZVJlc3BvbnNpdmVWYWx1ZSB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWVkaWFRdWVyaWVzXCI7XG5pbXBvcnQgeyBnZXRGb2N1c1N0eWxlcyB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWl4aW5zXCI7XG5cbmV4cG9ydCBjb25zdCBnZXRPZmZzZXRNcVN0eWxlID0gKFxuICBjc3NQcm9wOiBzdHJpbmcsXG4gIHtcbiAgICB0aGVtZSxcbiAgICBzaXplLFxuICB9OiB7XG4gICAgdGhlbWU6IFRoZW1lO1xuICB9ICYgUGFydGlhbDxFbnRpdHlMaXN0SXRlbVdyYXBwZXJQcm9wcz5cbikgPT5cbiAgbXEoe1xuICAgIFtjc3NQcm9wXTogW1xuICAgICAgc2l6ZSxcbiAgICAgIHtcbiAgICAgICAgeHM6IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHhzLFxuICAgICAgICBzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnMsXG4gICAgICAgIG06IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgICAgbDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgICAgfSBhcyBhbnksXG4gICAgXSxcbiAgfSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMaXN0ID0gc3R5bGVkLnVsPHsgc2l6ZTogTGlzdFNpemUgfT4oKHsgdGhlbWUsIHNpemUgfSkgPT4gKHtcbiAgLi4uKHNpemUgPT09IFwieHNcIiAmJiB7XG4gICAgcGFkZGluZzogYCR7dGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy54c30gMGAsXG4gIH0pLFxufSkpO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5SXRlbUxpID0gc3R5bGVkLmxpKHtcbiAgbGlzdFN0eWxlVHlwZTogXCJub25lXCIsXG59KTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZFNob3dNb3JlID0gc3R5bGVkLmRpdigoeyB0aGVtZSB9KSA9PiAoe1xuICBtYXJnaW5Ub3A6IC0xLFxuICBib3JkZXJUb3A6IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG59KSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRXcmFwcGVyT2Zmc2V0ID0gc3R5bGVkLmRpdjx7IHNpemU6IExpc3RTaXplIH0+KFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLmdldE9mZnNldE1xU3R5bGUoXCJwYWRkaW5nQm90dG9tXCIsIHsgdGhlbWUsIHNpemUgfSksXG4gIH0pLFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLmdldE9mZnNldE1xU3R5bGUoXCJwYWRkaW5nVG9wXCIsIHsgdGhlbWUsIHNpemUgfSksXG4gIH0pXG4pO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyID0gc3R5bGVkKFxuICBTdHlsZWRXcmFwcGVyT2Zmc2V0XG4pPEVudGl0eUxpc3RJdGVtV3JhcHBlclByb3BzPigoeyB0aGVtZSwgaGlkZUJvcmRlciB9KSA9PiAoe1xuICB3aWR0aDogXCIxMDAlXCIsXG5cbiAgLi4uKCFoaWRlQm9yZGVyICYmIHtcbiAgICBib3JkZXJCb3R0b206IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG4gIH0pLFxuXG4gIC4uLnVzZVJlc3BvbnNpdmVWYWx1ZSh7XG4gICAgcGFkZGluZ0xlZnQ6IFtcbiAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubCxcbiAgICBdLFxuICAgIHBhZGRpbmdSaWdodDogW1xuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5tLFxuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgIF0sXG4gIH0pLFxuXG4gIC8vIGJ1dHRvbiBhbmQgbGlua3MgaGF2ZSBhIGdyZWF0ZWQgaGVpZ2h0IHRoYW4gbGlzdCBpdGVtXG4gIC8vIGZyb20gZGVzaWduIHNwZWNzIGl0IHNob3VsZCBub3QgZXhwYW5kIHRoZSBsaXN0IGl0ZW1cbiAgXCImIGJ1dHRvbiwgJiBhXCI6IHtcbiAgICBtYXJnaW46IGAtJHt0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4c30gMGAsXG4gIH0sXG59KSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRFbnRpdHlMaXN0SXRlbUJ1dHRvbiA9IHN0eWxlZC5kaXY8XG4gIFBhcnRpYWw8RW50aXR5TGlzdEl0ZW1Qcm9wcz5cbj4oKHsgdGhlbWUsIGlzQ2xpY2thYmxlLCBpc0FjdGl2ZSwgaXNEaXNhYmxlZCB9KSA9PiAoe1xuICBkaXNwbGF5OiBcImZsZXhcIixcbiAgZmxleDogXCIxIDEgMTAwJVwiLFxuICBmbGV4V3JhcDogXCJub3dyYXBcIixcbiAgdHJhbnNpdGlvbjogXCJiYWNrZ3JvdW5kLWNvbG9yIDAuMXMgZWFzZS1vdXRcIixcblxuICAuLi4oaXNDbGlja2FibGUgJiYge1xuICAgIGN1cnNvcjogXCJwb2ludGVyXCIsXG4gIH0pLFxuXG4gIFwiJjpob3ZlclwiOiB7XG4gICAgYmFja2dyb3VuZENvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IuYmFja2dyb3VuZC50cmFuc3BhcmVudC5ob3ZlcixcbiAgfSxcblxuICAuLi4oaXNBY3RpdmUgJiYge1xuICAgIGJhY2tncm91bmRDb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLmJhY2tncm91bmQudHJhbnNwYXJlbnQuYWN0aXZlLFxuICB9KSxcblxuICAuLi5nZXRGb2N1c1N0eWxlcyh7IG9mZnNldDogLTIgfSksXG4gIFwiJjpmb2N1cy12aXNpYmxlXCI6IHtcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IHRoZW1lLnZhbHVlcy5jb2xvci5iYWNrZ3JvdW5kLnRyYW5zcGFyZW50LmFjdGl2ZSxcbiAgfSxcblxuICAuLi4oaXNEaXNhYmxlZCAmJiB7XG4gICAgY3Vyc29yOiBcIm5vdC1hbGxvd2VkXCIsXG4gICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG5cbiAgICBbYCR7U3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyfSA+ICpgXToge1xuICAgICAgb3BhY2l0eTogdGhlbWUudmFyaWFibGVzLm9wYWNpdHkuZGlzYWJsZWQsXG4gICAgfSxcbiAgfSksXG59KSk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBZ0YwQyJ9 */");
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var target=exports,all={get StyledEntityItem(){return StyledEntityItem},get StyledEntityListItemButton(){return StyledEntityListItemButton},get StyledEntityListItemWrapper(){return StyledEntityListItemWrapper},get StyledList(){return StyledList},get StyledShowMore(){return StyledShowMore},get StyledWrapperOffset(){return StyledWrapperOffset},get getOffsetMqStyle(){return getOffsetMqStyle}};for(var name in all)Object.defineProperty(target,name,{enumerable:!0,get:Object.getOwnPropertyDescriptor(all,name).get});const _styled=/*#__PURE__*/require("@swc/helpers/_/_interop_require_default")._(require("@emotion/styled")),_mediaQueries=require("../../shared/mediaQueries"),_mixins=require("../../shared/mixins"),getOffsetMqStyle=(cssProp,{theme,size})=>(0,_mediaQueries.mq)({[cssProp]:[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}]}),StyledList=(0,_styled.default)("div",{target:"epeu2lv0",label:"StyledList"})(({theme,size})=>({..."xs"===size&&{padding:`${theme.variables.size.spacing.xs} 0`}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityItem=(0,_styled.default)("div",{target:"epeu2lv1",label:"StyledEntityItem"})({},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledShowMore=(0,_styled.default)("div",{target:"epeu2lv2",label:"StyledShowMore"})(({theme})=>({marginTop:-1,borderTop:`1px solid ${theme.values.color.border.secondary.default}`}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledWrapperOffset=(0,_styled.default)("div",{target:"epeu2lv3",label:"StyledWrapperOffset"})(({theme,size})=>({...getOffsetMqStyle("paddingBottom",{theme,size})}),({theme,size})=>({...getOffsetMqStyle("paddingTop",{theme,size})}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityListItemWrapper=(0,_styled.default)(StyledWrapperOffset,{target:"epeu2lv4",label:"StyledEntityListItemWrapper"})(({theme,hideBorder})=>({width:"100%",...!hideBorder&&{borderBottom:`1px solid ${theme.values.color.border.secondary.default}`},...(0,_mediaQueries.useResponsiveValue)({paddingLeft:[theme.variables.size.spacing.m,theme.variables.size.spacing.l],paddingRight:[theme.variables.size.spacing.m,theme.variables.size.spacing.l]}),"& button, & a":{margin:`-${theme.variables.size.spacing.xxs} 0`}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyIsInNvdXJjZXMiOlsic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvZXhwbGljaXQtbW9kdWxlLWJvdW5kYXJ5LXR5cGVzICovXG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IHR5cGUgVGhlbWUgfSBmcm9tIFwiQGVtb3Rpb24vcmVhY3RcIjtcbmltcG9ydCB0eXBlIHsgRW50aXR5TGlzdEl0ZW1Qcm9wcywgRW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHMgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHR5cGUgeyBMaXN0U2l6ZSB9IGZyb20gXCIuLi8uLi90eXBlc1wiO1xuaW1wb3J0IHsgbXEsIHVzZVJlc3BvbnNpdmVWYWx1ZSB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWVkaWFRdWVyaWVzXCI7XG5pbXBvcnQgeyBnZXRGb2N1c1N0eWxlcyB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWl4aW5zXCI7XG5cbmV4cG9ydCBjb25zdCBnZXRPZmZzZXRNcVN0eWxlID0gKFxuICBjc3NQcm9wOiBzdHJpbmcsXG4gIHtcbiAgICB0aGVtZSxcbiAgICBzaXplLFxuICB9OiB7XG4gICAgdGhlbWU6IFRoZW1lO1xuICB9ICYgUGFydGlhbDxFbnRpdHlMaXN0SXRlbVdyYXBwZXJQcm9wcz5cbikgPT5cbiAgbXEoe1xuICAgIFtjc3NQcm9wXTogW1xuICAgICAgc2l6ZSxcbiAgICAgIHtcbiAgICAgICAgeHM6IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHhzLFxuICAgICAgICBzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnMsXG4gICAgICAgIG06IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgICAgbDogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgICAgfSBhcyBhbnksXG4gICAgXSxcbiAgfSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMaXN0ID0gc3R5bGVkLmRpdjx7IHNpemU6IExpc3RTaXplIH0+KCh7IHRoZW1lLCBzaXplIH0pID0+ICh7XG4gIC4uLihzaXplID09PSBcInhzXCIgJiYge1xuICAgIHBhZGRpbmc6IGAke3RoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHN9IDBgLFxuICB9KSxcbn0pKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEVudGl0eUl0ZW0gPSBzdHlsZWQuZGl2KHt9KTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZFNob3dNb3JlID0gc3R5bGVkLmRpdigoeyB0aGVtZSB9KSA9PiAoe1xuICBtYXJnaW5Ub3A6IC0xLFxuICBib3JkZXJUb3A6IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG59KSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRXcmFwcGVyT2Zmc2V0ID0gc3R5bGVkLmRpdjx7IHNpemU6IExpc3RTaXplIH0+KFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLmdldE9mZnNldE1xU3R5bGUoXCJwYWRkaW5nQm90dG9tXCIsIHsgdGhlbWUsIHNpemUgfSksXG4gIH0pLFxuICAoeyB0aGVtZSwgc2l6ZSB9KSA9PiAoe1xuICAgIC4uLmdldE9mZnNldE1xU3R5bGUoXCJwYWRkaW5nVG9wXCIsIHsgdGhlbWUsIHNpemUgfSksXG4gIH0pXG4pO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyID0gc3R5bGVkKFxuICBTdHlsZWRXcmFwcGVyT2Zmc2V0XG4pPEVudGl0eUxpc3RJdGVtV3JhcHBlclByb3BzPigoeyB0aGVtZSwgaGlkZUJvcmRlciB9KSA9PiAoe1xuICB3aWR0aDogXCIxMDAlXCIsXG5cbiAgLi4uKCFoaWRlQm9yZGVyICYmIHtcbiAgICBib3JkZXJCb3R0b206IGAxcHggc29saWQgJHt0aGVtZS52YWx1ZXMuY29sb3IuYm9yZGVyLnNlY29uZGFyeS5kZWZhdWx0fWAsXG4gIH0pLFxuXG4gIC4uLnVzZVJlc3BvbnNpdmVWYWx1ZSh7XG4gICAgcGFkZGluZ0xlZnQ6IFtcbiAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubSxcbiAgICAgIHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubCxcbiAgICBdLFxuICAgIHBhZGRpbmdSaWdodDogW1xuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5tLFxuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgIF0sXG4gIH0pLFxuXG4gIC8vIGJ1dHRvbiBhbmQgbGlua3MgaGF2ZSBhIGdyZWF0ZWQgaGVpZ2h0IHRoYW4gbGlzdCBpdGVtXG4gIC8vIGZyb20gZGVzaWduIHNwZWNzIGl0IHNob3VsZCBub3QgZXhwYW5kIHRoZSBsaXN0IGl0ZW1cbiAgXCImIGJ1dHRvbiwgJiBhXCI6IHtcbiAgICBtYXJnaW46IGAtJHt0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4c30gMGAsXG4gIH0sXG59KSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRFbnRpdHlMaXN0SXRlbUJ1dHRvbiA9IHN0eWxlZC5kaXY8XG4gIFBhcnRpYWw8RW50aXR5TGlzdEl0ZW1Qcm9wcz5cbj4oKHsgdGhlbWUsIGlzQ2xpY2thYmxlLCBpc0FjdGl2ZSwgaXNEaXNhYmxlZCB9KSA9PiAoe1xuICBkaXNwbGF5OiBcImZsZXhcIixcbiAgZmxleDogXCIxIDEgMTAwJVwiLFxuICBmbGV4V3JhcDogXCJub3dyYXBcIixcbiAgdHJhbnNpdGlvbjogXCJiYWNrZ3JvdW5kLWNvbG9yIDAuMXMgZWFzZS1vdXRcIixcblxuICAuLi4oaXNDbGlja2FibGUgJiYge1xuICAgIGN1cnNvcjogXCJwb2ludGVyXCIsXG4gIH0pLFxuXG4gIFwiJjpob3ZlclwiOiB7XG4gICAgYmFja2dyb3VuZENvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IuYmFja2dyb3VuZC50cmFuc3BhcmVudC5ob3ZlcixcbiAgfSxcblxuICAuLi4oaXNBY3RpdmUgJiYge1xuICAgIGJhY2tncm91bmRDb2xvcjogdGhlbWUudmFsdWVzLmNvbG9yLmJhY2tncm91bmQudHJhbnNwYXJlbnQuYWN0aXZlLFxuICB9KSxcblxuICAuLi5nZXRGb2N1c1N0eWxlcyh7IG9mZnNldDogLTIgfSksXG4gIFwiJjpmb2N1cy12aXNpYmxlXCI6IHtcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IHRoZW1lLnZhbHVlcy5jb2xvci5iYWNrZ3JvdW5kLnRyYW5zcGFyZW50LmFjdGl2ZSxcbiAgfSxcblxuICAuLi4oaXNEaXNhYmxlZCAmJiB7XG4gICAgY3Vyc29yOiBcIm5vdC1hbGxvd2VkXCIsXG4gICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG5cbiAgICBbYCR7U3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyfSA+ICpgXToge1xuICAgICAgb3BhY2l0eTogdGhlbWUudmFyaWFibGVzLm9wYWNpdHkuZGlzYWJsZWQsXG4gICAgfSxcbiAgfSksXG59KSk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUQyQyJ9 */"),StyledEntityListItemButton=(0,_styled.default)("div",{target:"epeu2lv5",label:"StyledEntityListItemButton"})(({theme,isClickable,isActive,isDisabled})=>({display:"flex",flex:"1 1 100%",flexWrap:"nowrap",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},...(0,_mixins.getFocusStyles)({offset:-2}),"&:focus-visible":{backgroundColor:theme.values.color.background.transparent.active},...isDisabled&&{cursor:"not-allowed",pointerEvents:"none",[`${StyledEntityListItemWrapper} > *`]:{opacity:theme.variables.opacity.disabled}}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");

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

@@ -79,6 +79,7 @@ export type BaseEntityListProps = {
     /** Props forwarded to internal sub-components */
     slotProps?: EntityListSlotProps;
     "data-e2e-test-id"?: string;
+    "aria-label"?: string;
 };
 export type EntityListProps = BaseEntityListProps & ({
     /** Enable virtualization for large lists. When true, only visible items are rendered. */
@@ -119,6 +120,7 @@ export type EntityListItemProps = {
     ariaLabelExpand?: string;
     /** @deprecated Use slotProps.toggle['aria-label-collapse'] instead */
     ariaLabelCollapse?: string;
+    isSelected?: boolean;
     "aria-label": string;
     "aria-level"?: number;
     "data-list-item"?: number;

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"BaseEntityTree",{enumerable:!0,get:function(){return BaseEntityTree}});const _react=/*#__PURE__*/require("@swc/helpers/_/_interop_require_wildcard")._(require("react")),_Button=require("../Button/Button"),_Box=require("../Box/Box"),_styledcomponents=require("../EntityList/styled-components"),_EntityTreeItem=require("./EntityTreeItem"),_useKeyboard=require("../../shared/useKeyboard"),_useFocusByIndex=require("../EntityList/useFocusByIndex"),_Text=require("../Typography/Text/Text"),_tree=require("./tree"),flattenTree=(data,expandedIds,expadedAll)=>{let flattened=[];return data.forEach(node=>{flattened.push(node),(node.children.length>0&&expandedIds[node.id]||expadedAll)&&flattened.push(...flattenTree(node.children,expandedIds,expadedAll))}),flattened},getLastNodeOfList=({node,data,level,isParentsLastOfLvl})=>{let currentLastNodeOfLvl=node.id===data[data.length-1].id;return 0===level?currentLastNodeOfLvl:isParentsLastOfLvl&&currentLastNodeOfLvl},useTreeTruncation=({chunkSize,data,expandAll,nodeExpandedState})=>{let[maxNodesCount,setMaxNodesCount]=(0,_react.useState)(chunkSize),{result,hasMoreNodes}=(0,_react.useMemo)(()=>(0,_tree.trimDataByMaxSize)(data,nodeExpandedState,expandAll,maxNodesCount),[data,nodeExpandedState,expandAll,maxNodesCount]);return{handleIncreaseMaxNodeCount:(0,_react.useCallback)(()=>{setMaxNodesCount(prev=>prev+chunkSize)},[chunkSize]),result,hasMoreNodes}},Node=({isFirstNode,nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange,handleToggle,expandAll,onNodeClick,hideBorder,size,showItemsCount,renderRightContent,activeId,focusedNodeId,node,level,renderFn,isLastNodeOfList,ariaLabelExpand,ariaLabelCollapse,visibleNodeIndexMap})=>{let readOnly=null===nodeCheckboxState,hasChildren=node.children.length>0,expandedState=!!expandAll||!!nodeExpandedState[node.id],leafItems=(0,_tree.getLeafNodeIds)(nodeChildrenMap,node.id),totalItemsCount=leafItems.length,selectedItemsCount=nodeCheckboxState?leafItems.filter(leafId=>"checked"===nodeCheckboxState[leafId]).length:null,countLabel=nodeCheckboxState?`(${selectedItemsCount}/${totalItemsCount})`:`(${totalItemsCount})`,lastLeaf=!hasChildren&&!node.isFiltered,isExpanded=lastLeaf?void 0:expandedState,{children,...nodeDataWithoutChildren}=node,isFocused=focusedNodeId===node.id;return _react.default.createElement(_EntityTreeItem.EntityTreeItem,{key:node.id,"data-list-item":visibleNodeIndexMap[node.id],hideBorder:hideBorder||isLastNodeOfList&&(!isExpanded||node.isFiltered),tabIndex:isFocused||null===focusedNodeId&&isFirstNode?0:-1,size:size,lSpaceStep:level,onSpaceEnterPress:()=>{if(readOnly){handleToggle(node.id),onNodeClick?.(nodeDataWithoutChildren);return}handleSelectionChange(node.id)},description:node.description,renderLabel:({textSize})=>_react.default.createElement(_react.default.Fragment,null,node.label,showItemsCount&&!lastLeaf&&_react.default.createElement(_Text.Text,{as:"span",size:textSize,color:"tertiary"}," ",countLabel)),isActive:activeId===node.id,isExpanded:isExpanded,isDisabledExpand:expandAll,checkboxProps:!readOnly&&{size:"s",name:node.label,checked:nodeCheckboxState?.[node.id]==="checked",indeterminate:nodeCheckboxState?.[node.id]==="indeterminate",onChange:()=>handleSelectionChange(node.id)},onExpandClick:e=>{e.stopPropagation(),handleToggle(node.id)},isClickable:readOnly,onClick:()=>{handleToggle(node.id),onNodeClick?.(nodeDataWithoutChildren)},renderRight:renderRightContent?sizeProps=>renderRightContent({...sizeProps,...node}):void 0,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse,"aria-label":node.label,"aria-level":level+1},hasChildren&&_react.default.createElement("ul",{role:"group"},renderFn({data:children,level:level+1,renderFn,isParentsLastOfLvl:isLastNodeOfList})))},makeRenderTreeBranches=renderTreeArgs=>({data,level,renderFn,isParentsLastOfLvl})=>data.map((node,i)=>{let isFirstNode=0===level&&0===i,isLastNodeOfList=getLastNodeOfList({node,data,level,isParentsLastOfLvl});return _react.default.createElement(Node,{key:node.id,level:level,node:node,isFirstNode:isFirstNode,renderFn:renderFn,isLastNodeOfList:isLastNodeOfList,...renderTreeArgs})}),BaseEntityTree=({ariaAttributes:deprecatedAriaAttributes,slotProps,data,selectedIds,onSelectionChange,onSelectionToggle,onNodeClick,expandedIds=[],onToggle,activeId,chunkSize=10,filterFn,onTreeChange,hideBorder=!1,size="m",showItemsCount=!0,showMoreButtonLabel,renderRightContent,"data-e2e-test-id":dataE2eTestId,...ariaAttributes})=>{let nodeChildrenMap=Object.assign({},...data.map(tree=>(0,_tree.getNodeChildrenMap)(tree))),nodeCheckboxState=selectedIds?Object.assign({},...data.map(tree=>(0,_tree.getTreeCheckboxState)(nodeChildrenMap,tree.id,selectedIds))):null,nodeExpandedState=expandedIds.reduce((acc,id)=>(acc[id]=!0,acc),{}),visibleActiveNodeId=(0,_tree.getVisibleActiveNodeId)(nodeChildrenMap,nodeExpandedState,activeId),handleExpand=(0,_react.useCallback)(targetId=>{onToggle&&!expandedIds.includes(targetId)&&onToggle(expandedIds.concat([targetId]))},[expandedIds,onToggle]),handleCollapse=(0,_react.useCallback)(targetId=>{onToggle&&expandedIds.includes(targetId)&&onToggle(expandedIds.filter(id=>id!==targetId))},[expandedIds,onToggle]),handleToggle=(0,_react.useCallback)(targetId=>{expandedIds.includes(targetId)?handleCollapse(targetId):handleExpand(targetId)},[expandedIds,handleCollapse,handleExpand]),dataShown=filterFn?data.map(tree=>(0,_tree.filterTree)(tree,filterFn)).filter(Boolean):data;(0,_react.useEffect)(()=>{onTreeChange&&onTreeChange(dataShown.map(tree=>(0,_tree.mapTree)(tree,node=>({...node,checkedState:!!nodeCheckboxState&&nodeCheckboxState[node.id],isExpanded:!!nodeExpandedState[node.id]}))))},[dataShown,nodeCheckboxState,nodeExpandedState,onTreeChange]);let expandAll=!!filterFn,{hasMoreNodes,handleIncreaseMaxNodeCount,result}=useTreeTruncation({chunkSize,data:dataShown,nodeExpandedState,expandAll}),listRef=_react.default.useRef(null),visibleNodes=(0,_react.useMemo)(()=>flattenTree(result,nodeExpandedState,expandAll),[result,nodeExpandedState,expandAll]),visibleNodeIndexMap=(0,_react.useMemo)(()=>visibleNodes.reduce((acc,node,index)=>(acc[node.id]=index,acc),{}),[visibleNodes]),focusableNodes=(0,_react.useMemo)(()=>visibleNodes.map(node=>({id:node.id,isDisabled:!!node.isDisabled})),[visibleNodes]),{moveFocus,focusedIndex}=(0,_useFocusByIndex.useFocusByIndex)({containerRef:listRef,nodeSelector:"data-list-item",data:focusableNodes}),focusedNodeId=focusedIndex>=0?visibleNodes[focusedIndex]?.id??null:null;(0,_useKeyboard.useKeyboard)({ArrowDown:()=>{moveFocus(1)},ArrowUp:()=>{moveFocus(-1)},ArrowRight:()=>{!expandAll&&focusedNodeId&&nodeChildrenMap[focusedNodeId]?.length&&!nodeExpandedState[focusedNodeId]&&handleExpand(focusedNodeId)},ArrowLeft:()=>{!expandAll&&focusedNodeId&&nodeChildrenMap[focusedNodeId]?.length&&nodeExpandedState[focusedNodeId]&&handleCollapse(focusedNodeId)}},listRef,!!visibleNodes.length);let renderTreeBranches=makeRenderTreeBranches({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange:targetId=>{if(onSelectionChange){let isSelected,updatedSelectedIds=[];if(0===nodeChildrenMap[targetId].length)isSelected=!selectedIds.includes(targetId),updatedSelectedIds=selectedIds.includes(targetId)?selectedIds.filter(id=>id!==targetId):selectedIds.concat([targetId]);else{let affectedLeafNodeIds=(0,_tree.getLeafNodeIds)(nodeChildrenMap,targetId),hasUncheckedChildren=affectedLeafNodeIds.some(leafId=>!selectedIds.includes(leafId));updatedSelectedIds=hasUncheckedChildren?selectedIds.concat(affectedLeafNodeIds.filter(id=>!selectedIds.includes(id))):selectedIds.filter(id=>!affectedLeafNodeIds.includes(id)),isSelected=hasUncheckedChildren}onSelectionToggle?.(targetId,isSelected),onSelectionChange(updatedSelectedIds)}},handleToggle,onNodeClick:node=>{onNodeClick?.(node)},expandAll,hideBorder,size,showItemsCount,renderRightContent,activeId:visibleActiveNodeId,focusedNodeId,visibleNodeIndexMap,ariaLabelExpand:slotProps?.toggle?.["aria-label-expand"]??deprecatedAriaAttributes?.ariaLabelExpand,ariaLabelCollapse:slotProps?.toggle?.["aria-label-collapse"]??deprecatedAriaAttributes?.ariaLabelCollapse});return _react.default.createElement("div",null,_react.default.createElement(_styledcomponents.StyledList,{ref:listRef,"data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityTree",size:size,...ariaAttributes,role:"tree","aria-multiselectable":!!nodeCheckboxState||void 0},renderTreeBranches({data:result,level:0,renderFn:renderTreeBranches})),hasMoreNodes&&_react.default.createElement(_styledcomponents.StyledShowMore,null,_react.default.createElement(_Box.Box,{alignText:"center",space:"xs"},_react.default.createElement(_Button.Button,{fullWidth:!0,size:"s",variant:"tertiary",onClick:handleIncreaseMaxNodeCount},showMoreButtonLabel))))};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"BaseEntityTree",{enumerable:!0,get:function(){return BaseEntityTree}});const _react=/*#__PURE__*/require("@swc/helpers/_/_interop_require_wildcard")._(require("react")),_Button=require("../Button/Button"),_Box=require("../Box/Box"),_styledcomponents=require("../EntityList/styled-components"),_EntityTreeItem=require("./EntityTreeItem"),_useKeyboard=require("../../shared/useKeyboard"),_useFocusByIndex=require("../EntityList/useFocusByIndex"),_Text=require("../Typography/Text/Text"),_tree=require("./tree"),flattenTree=(data,expandedIds,expadedAll)=>{let flattened=[];return data.forEach(node=>{flattened.push(node),(node.children.length>0&&expandedIds[node.id]||expadedAll)&&flattened.push(...flattenTree(node.children,expandedIds,expadedAll))}),flattened},getLastNodeOfList=({node,data,level,isParentsLastOfLvl})=>{let currentLastNodeOfLvl=node.id===data[data.length-1].id;return 0===level?currentLastNodeOfLvl:isParentsLastOfLvl&&currentLastNodeOfLvl},useTreeTruncation=({chunkSize,data,expandAll,nodeExpandedState})=>{let[maxNodesCount,setMaxNodesCount]=(0,_react.useState)(chunkSize),{result,hasMoreNodes}=(0,_react.useMemo)(()=>(0,_tree.trimDataByMaxSize)(data,nodeExpandedState,expandAll,maxNodesCount),[data,nodeExpandedState,expandAll,maxNodesCount]);return{handleIncreaseMaxNodeCount:(0,_react.useCallback)(()=>{setMaxNodesCount(prev=>prev+chunkSize)},[chunkSize]),result,hasMoreNodes}},Node=({isFirstNode,nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange,handleToggle,expandAll,onNodeClick,hideBorder,size,showItemsCount,renderRightContent,activeId,focusedNodeId,node,level,renderFn,isLastNodeOfList,ariaLabelExpand,ariaLabelCollapse,visibleNodeIndexMap})=>{let readOnly=null===nodeCheckboxState,hasChildren=node.children.length>0,expandedState=!!expandAll||!!nodeExpandedState[node.id],leafItems=(0,_tree.getLeafNodeIds)(nodeChildrenMap,node.id),totalItemsCount=leafItems.length,selectedItemsCount=nodeCheckboxState?leafItems.filter(leafId=>"checked"===nodeCheckboxState[leafId]).length:null,countLabel=nodeCheckboxState?`(${selectedItemsCount}/${totalItemsCount})`:`(${totalItemsCount})`,lastLeaf=!hasChildren&&!node.isFiltered,isExpanded=lastLeaf?void 0:expandedState,{children,...nodeDataWithoutChildren}=node,isFocused=focusedNodeId===node.id;return _react.default.createElement(_EntityTreeItem.EntityTreeItem,{key:node.id,"data-list-item":visibleNodeIndexMap[node.id],hideBorder:hideBorder||isLastNodeOfList&&(!isExpanded||node.isFiltered),tabIndex:isFocused||null===focusedNodeId&&isFirstNode?0:-1,size:size,lSpaceStep:level,onSpaceEnterPress:()=>{if(readOnly){handleToggle(node.id),onNodeClick?.(nodeDataWithoutChildren);return}handleSelectionChange(node.id)},description:node.description,renderLabel:({textSize})=>_react.default.createElement(_react.default.Fragment,null,node.label,showItemsCount&&!lastLeaf&&_react.default.createElement(_Text.Text,{as:"span",size:textSize,color:"tertiary"}," ",countLabel)),isActive:activeId===node.id,isExpanded:isExpanded,isDisabledExpand:expandAll,checkboxProps:!readOnly&&{size:"s",name:node.label,checked:nodeCheckboxState?.[node.id]==="checked",indeterminate:nodeCheckboxState?.[node.id]==="indeterminate",onChange:()=>handleSelectionChange(node.id)},onExpandClick:e=>{e.stopPropagation(),handleToggle(node.id)},isClickable:readOnly,onClick:()=>{handleToggle(node.id),onNodeClick?.(nodeDataWithoutChildren)},renderRight:renderRightContent?sizeProps=>renderRightContent({...sizeProps,...node}):void 0,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse,"aria-label":node.label,"aria-level":level+1},hasChildren&&_react.default.createElement("div",{role:"group"},renderFn({data:children,level:level+1,renderFn,isParentsLastOfLvl:isLastNodeOfList})))},makeRenderTreeBranches=renderTreeArgs=>({data,level,renderFn,isParentsLastOfLvl})=>data.map((node,i)=>{let isFirstNode=0===level&&0===i,isLastNodeOfList=getLastNodeOfList({node,data,level,isParentsLastOfLvl});return _react.default.createElement(Node,{key:node.id,level:level,node:node,isFirstNode:isFirstNode,renderFn:renderFn,isLastNodeOfList:isLastNodeOfList,...renderTreeArgs})}),BaseEntityTree=({ariaAttributes:deprecatedAriaAttributes,slotProps,data,selectedIds,onSelectionChange,onSelectionToggle,onNodeClick,expandedIds=[],onToggle,activeId,chunkSize=10,filterFn,onTreeChange,hideBorder=!1,size="m",showItemsCount=!0,showMoreButtonLabel,renderRightContent,"data-e2e-test-id":dataE2eTestId,...ariaAttributes})=>{let nodeChildrenMap=Object.assign({},...data.map(tree=>(0,_tree.getNodeChildrenMap)(tree))),nodeCheckboxState=selectedIds?Object.assign({},...data.map(tree=>(0,_tree.getTreeCheckboxState)(nodeChildrenMap,tree.id,selectedIds))):null,nodeExpandedState=expandedIds.reduce((acc,id)=>(acc[id]=!0,acc),{}),visibleActiveNodeId=(0,_tree.getVisibleActiveNodeId)(nodeChildrenMap,nodeExpandedState,activeId),handleExpand=(0,_react.useCallback)(targetId=>{onToggle&&!expandedIds.includes(targetId)&&onToggle(expandedIds.concat([targetId]))},[expandedIds,onToggle]),handleCollapse=(0,_react.useCallback)(targetId=>{onToggle&&expandedIds.includes(targetId)&&onToggle(expandedIds.filter(id=>id!==targetId))},[expandedIds,onToggle]),handleToggle=(0,_react.useCallback)(targetId=>{expandedIds.includes(targetId)?handleCollapse(targetId):handleExpand(targetId)},[expandedIds,handleCollapse,handleExpand]),dataShown=filterFn?data.map(tree=>(0,_tree.filterTree)(tree,filterFn)).filter(Boolean):data;(0,_react.useEffect)(()=>{onTreeChange&&onTreeChange(dataShown.map(tree=>(0,_tree.mapTree)(tree,node=>({...node,checkedState:!!nodeCheckboxState&&nodeCheckboxState[node.id],isExpanded:!!nodeExpandedState[node.id]}))))},[dataShown,nodeCheckboxState,nodeExpandedState,onTreeChange]);let expandAll=!!filterFn,{hasMoreNodes,handleIncreaseMaxNodeCount,result}=useTreeTruncation({chunkSize,data:dataShown,nodeExpandedState,expandAll}),listRef=_react.default.useRef(null),visibleNodes=(0,_react.useMemo)(()=>flattenTree(result,nodeExpandedState,expandAll),[result,nodeExpandedState,expandAll]),visibleNodeIndexMap=(0,_react.useMemo)(()=>visibleNodes.reduce((acc,node,index)=>(acc[node.id]=index,acc),{}),[visibleNodes]),focusableNodes=(0,_react.useMemo)(()=>visibleNodes.map(node=>({id:node.id,isDisabled:!!node.isDisabled})),[visibleNodes]),{moveFocus,focusedIndex}=(0,_useFocusByIndex.useFocusByIndex)({containerRef:listRef,nodeSelector:"data-list-item",data:focusableNodes}),focusedNodeId=focusedIndex>=0?visibleNodes[focusedIndex]?.id??null:null;(0,_useKeyboard.useKeyboard)({ArrowDown:()=>{moveFocus(1)},ArrowUp:()=>{moveFocus(-1)},ArrowRight:()=>{!expandAll&&focusedNodeId&&nodeChildrenMap[focusedNodeId]?.length&&!nodeExpandedState[focusedNodeId]&&handleExpand(focusedNodeId)},ArrowLeft:()=>{!expandAll&&focusedNodeId&&nodeChildrenMap[focusedNodeId]?.length&&nodeExpandedState[focusedNodeId]&&handleCollapse(focusedNodeId)}},listRef,!!visibleNodes.length);let renderTreeBranches=makeRenderTreeBranches({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange:targetId=>{if(onSelectionChange){let isSelected,updatedSelectedIds=[];if(0===nodeChildrenMap[targetId].length)isSelected=!selectedIds.includes(targetId),updatedSelectedIds=selectedIds.includes(targetId)?selectedIds.filter(id=>id!==targetId):selectedIds.concat([targetId]);else{let affectedLeafNodeIds=(0,_tree.getLeafNodeIds)(nodeChildrenMap,targetId),hasUncheckedChildren=affectedLeafNodeIds.some(leafId=>!selectedIds.includes(leafId));updatedSelectedIds=hasUncheckedChildren?selectedIds.concat(affectedLeafNodeIds.filter(id=>!selectedIds.includes(id))):selectedIds.filter(id=>!affectedLeafNodeIds.includes(id)),isSelected=hasUncheckedChildren}onSelectionToggle?.(targetId,isSelected),onSelectionChange(updatedSelectedIds)}},handleToggle,onNodeClick:node=>{onNodeClick?.(node)},expandAll,hideBorder,size,showItemsCount,renderRightContent,activeId:visibleActiveNodeId,focusedNodeId,visibleNodeIndexMap,ariaLabelExpand:slotProps?.toggle?.["aria-label-expand"]??deprecatedAriaAttributes?.ariaLabelExpand,ariaLabelCollapse:slotProps?.toggle?.["aria-label-collapse"]??deprecatedAriaAttributes?.ariaLabelCollapse});return _react.default.createElement("div",null,_react.default.createElement(_styledcomponents.StyledList,{ref:listRef,"data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityTree",size:size,...ariaAttributes,role:"tree","aria-multiselectable":!!nodeCheckboxState||void 0},renderTreeBranches({data:result,level:0,renderFn:renderTreeBranches})),hasMoreNodes&&_react.default.createElement(_styledcomponents.StyledShowMore,null,_react.default.createElement(_Box.Box,{alignText:"center",space:"xs"},_react.default.createElement(_Button.Button,{fullWidth:!0,size:"s",variant:"tertiary",onClick:handleIncreaseMaxNodeCount},showMoreButtonLabel))))};

package/build/cjs/components/EntityTree/EntityTreeItem.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"EntityTreeItem",{enumerable:!0,get:function(){return EntityTreeItem}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_react=/*#__PURE__*/require("@swc/helpers/_/_interop_require_wildcard")._(require("react")),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_mediaQueries=require("../../shared/mediaQueries"),_EntityTreeItemExpandButton=require("./EntityTreeItemExpandButton"),_useKeyboard=require("../../shared/useKeyboard"),_mixins=require("../../shared/mixins"),_EntityItemBody=require("../EntityList/EntityItemBody"),_styledcomponents=require("../EntityList/styled-components"),StyledEntityTreeItemWrapper=(0,_styled.default)(_styledcomponents.StyledEntityListItemWrapper,{target:"e29eivf0",label:"StyledEntityTreeItemWrapper"})({paddingLeft:"0 !important"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityTreeItemContainer=(0,_styled.default)(_styledcomponents.StyledEntityListItemButton,{target:"e29eivf1",label:"StyledEntityTreeItemContainer"})(({theme,hasExpandableIcon,lSpaceStep})=>{let getSize=(baseOffset,deepestNodeOffset)=>`calc(${baseOffset} * ${lSpaceStep} + ${hasExpandableIcon?"0px":deepestNodeOffset} + ${theme.variables.size.spacing.xxs})`;return{...(0,_mixins.getFocusStyles)({offset:-2}),...(0,_mediaQueries.useResponsiveValue)({paddingLeft:[getSize(theme.variables.size.spacing.m,"42px"),getSize(theme.variables.size.spacing.xl,"56px")]})}},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),EntityTreeItem=({checkboxProps,children,description,hideBorder,isActive,isClickable,isDisabled,isDisabledExpand,isExpanded,lSpaceStep,onClick,onExpandClick,onSpaceEnterPress,renderLabel,renderLeft,renderRight,size="m",tabIndex,ariaLabelExpand,ariaLabelCollapse,"aria-level":ariaLevel,"aria-label":ariaLabel,"data-list-item":dataListItem})=>{let hasExpandableIcon=void 0!==isExpanded,handleOnClick=(0,_react.useCallback)(e=>{onClick&&onClick(e)},[onClick]),buttonRef=(0,_react.useRef)(null);return(0,_useKeyboard.useKeyboard)({"Space Enter":onSpaceEnterPress},buttonRef,0===tabIndex&&(isClickable||!!checkboxProps),!0),_react.default.createElement(_styledcomponents.StyledEntityItemLi,{role:"treeitem","aria-expanded":hasExpandableIcon?isExpanded:void 0,"aria-checked":checkboxProps?.checked,"aria-label":ariaLabel,"aria-level":ariaLevel},_react.default.createElement(StyledEntityTreeItemContainer,{"data-list-item":dataListItem,size:size,ref:buttonRef,"data-id":"list-item",tabIndex:tabIndex,role:"presentation",isActive:isActive,hasExpandableIcon:hasExpandableIcon,lSpaceStep:lSpaceStep,isDisabled:isDisabled,onClick:handleOnClick,isClickable:isClickable},hasExpandableIcon&&_react.default.createElement(_EntityTreeItemExpandButton.EntityTreeItemExpandButton,{size:size,tabIndex:-1,isDisabled:isDisabledExpand||isDisabled,isExpanded:isExpanded,onClick:onExpandClick,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse}),_react.default.createElement(StyledEntityTreeItemWrapper,{size:size,hideBorder:hideBorder||"xs"===size},_react.default.createElement(_EntityItemBody.EntityItemBody,{size:size,tabIndex:tabIndex,description:description,renderLabel:renderLabel,renderLeft:renderLeft,renderRight:renderRight,checkboxProps:checkboxProps}))),isExpanded&&children)};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"EntityTreeItem",{enumerable:!0,get:function(){return EntityTreeItem}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_react=/*#__PURE__*/require("@swc/helpers/_/_interop_require_wildcard")._(require("react")),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_mediaQueries=require("../../shared/mediaQueries"),_EntityTreeItemExpandButton=require("./EntityTreeItemExpandButton"),_useKeyboard=require("../../shared/useKeyboard"),_mixins=require("../../shared/mixins"),_EntityItemBody=require("../EntityList/EntityItemBody"),_styledcomponents=require("../EntityList/styled-components"),StyledEntityTreeItemWrapper=(0,_styled.default)(_styledcomponents.StyledEntityListItemWrapper,{target:"e1n4xnc20",label:"StyledEntityTreeItemWrapper"})({paddingLeft:"0 !important"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledEntityTreeItemContainer=(0,_styled.default)(_styledcomponents.StyledEntityListItemButton,{target:"e1n4xnc21",label:"StyledEntityTreeItemContainer"})(({theme,hasExpandableIcon,lSpaceStep})=>{let getSize=(baseOffset,deepestNodeOffset)=>`calc(${baseOffset} * ${lSpaceStep} + ${hasExpandableIcon?"0px":deepestNodeOffset} + ${theme.variables.size.spacing.xxs})`;return{...(0,_mixins.getFocusStyles)({offset:-2}),...(0,_mediaQueries.useResponsiveValue)({paddingLeft:[getSize(theme.variables.size.spacing.m,"42px"),getSize(theme.variables.size.spacing.xl,"56px")]})}},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRW50aXR5VHJlZS9FbnRpdHlUcmVlSXRlbS50c3giLCJzb3VyY2VzIjpbInNyYy9jb21wb25lbnRzL0VudGl0eVRyZWUvRW50aXR5VHJlZUl0ZW0udHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwgeyB1c2VDYWxsYmFjaywgdXNlUmVmIH0gZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IHVzZVJlc3BvbnNpdmVWYWx1ZSB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWVkaWFRdWVyaWVzXCI7XG5pbXBvcnQgeyBFbnRpdHlUcmVlSXRlbUV4cGFuZEJ1dHRvbiB9IGZyb20gXCIuL0VudGl0eVRyZWVJdGVtRXhwYW5kQnV0dG9uXCI7XG5pbXBvcnQgeyB1c2VLZXlib2FyZCB9IGZyb20gXCIuLi8uLi9zaGFyZWQvdXNlS2V5Ym9hcmRcIjtcbmltcG9ydCB7IGdldEZvY3VzU3R5bGVzIH0gZnJvbSBcIi4uLy4uL3NoYXJlZC9taXhpbnNcIjtcbmltcG9ydCB7IEVudGl0eUl0ZW1Cb2R5IH0gZnJvbSBcIi4uL0VudGl0eUxpc3QvRW50aXR5SXRlbUJvZHlcIjtcbmltcG9ydCB7XG4gIFN0eWxlZEVudGl0eUl0ZW0sXG4gIFN0eWxlZEVudGl0eUxpc3RJdGVtV3JhcHBlcixcbiAgU3R5bGVkRW50aXR5TGlzdEl0ZW1CdXR0b24sXG59IGZyb20gXCIuLi9FbnRpdHlMaXN0L3N0eWxlZC1jb21wb25lbnRzXCI7XG5pbXBvcnQgdHlwZSB7IEVudGl0eUxpc3RJdGVtUHJvcHMgfSBmcm9tIFwiLi4vRW50aXR5TGlzdC90eXBlc1wiO1xuXG5jb25zdCBTdHlsZWRFbnRpdHlUcmVlSXRlbVdyYXBwZXIgPSBzdHlsZWQoU3R5bGVkRW50aXR5TGlzdEl0ZW1XcmFwcGVyKSh7XG4gIHBhZGRpbmdMZWZ0OiBcIjAgIWltcG9ydGFudFwiLCAvLyBcImltcG9ydGFudFwiIGlzIG5lZWRlZCB0byBvdmVycmlkZSB0aGUgQG1lZGlhIHF1ZXJ5IG9mIE1RIGZ1bmN0aW9uXG59KTtcblxuY29uc3QgU3R5bGVkRW50aXR5VHJlZUl0ZW1Db250YWluZXIgPSBzdHlsZWQoU3R5bGVkRW50aXR5TGlzdEl0ZW1CdXR0b24pPHtcbiAgaGFzRXhwYW5kYWJsZUljb246IGJvb2xlYW47XG59PigoeyB0aGVtZSwgaGFzRXhwYW5kYWJsZUljb24sIGxTcGFjZVN0ZXAgfSkgPT4ge1xuICBjb25zdCBnZXRTaXplID0gKGJhc2VPZmZzZXQ6IHN0cmluZywgZGVlcGVzdE5vZGVPZmZzZXQ6IHN0cmluZykgPT5cbiAgICBgY2FsYygke2Jhc2VPZmZzZXR9ICogJHtsU3BhY2VTdGVwfSArICR7XG4gICAgICBoYXNFeHBhbmRhYmxlSWNvbiA/IFwiMHB4XCIgOiBkZWVwZXN0Tm9kZU9mZnNldFxuICAgIH0gKyAke3RoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHhzfSlgO1xuXG4gIHJldHVybiB7XG4gICAgLi4uZ2V0Rm9jdXNTdHlsZXMoeyBvZmZzZXQ6IC0yIH0pLFxuICAgIC4uLnVzZVJlc3BvbnNpdmVWYWx1ZSh7XG4gICAgICBwYWRkaW5nTGVmdDogW1xuICAgICAgICAvLyA0MnB4IGFuZCA1NnB4IGFyZSBFeHBhbmQgYnV0dG9uIHdpZHRoICsgcGFkZGluZ1xuICAgICAgICAvLyBpdCdzIG5lZWRlZCBmb3IgYSBkZWVwZXN0IG5vZGUgd2l0aG91dCBleHBhbmRCdXR0b25cbiAgICAgICAgZ2V0U2l6ZSh0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLm0sIFwiNDJweFwiKSxcbiAgICAgICAgZ2V0U2l6ZSh0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnhsLCBcIjU2cHhcIiksXG4gICAgICBdLFxuICAgIH0pLFxuICB9O1xufSk7XG5cbmV4cG9ydCBjb25zdCBFbnRpdHlUcmVlSXRlbSA9ICh7XG4gIGNoZWNrYm94UHJvcHMsXG4gIGNoaWxkcmVuLFxuICBkZXNjcmlwdGlvbixcbiAgaGlkZUJvcmRlcixcbiAgaXNBY3RpdmUsXG4gIGlzQ2xpY2thYmxlLFxuICBpc0Rpc2FibGVkLFxuICBpc0Rpc2FibGVkRXhwYW5kLFxuICBpc0V4cGFuZGVkLFxuICBsU3BhY2VTdGVwLFxuICBvbkNsaWNrLFxuICBvbkV4cGFuZENsaWNrLFxuICBvblNwYWNlRW50ZXJQcmVzcyxcbiAgcmVuZGVyTGFiZWwsXG4gIHJlbmRlckxlZnQsXG4gIHJlbmRlclJpZ2h0LFxuICBzaXplID0gXCJtXCIsXG4gIHRhYkluZGV4LFxuICBhcmlhTGFiZWxFeHBhbmQsXG4gIGFyaWFMYWJlbENvbGxhcHNlLFxuICBcImFyaWEtbGV2ZWxcIjogYXJpYUxldmVsLFxuICBcImFyaWEtbGFiZWxcIjogYXJpYUxhYmVsLFxuICBcImRhdGEtbGlzdC1pdGVtXCI6IGRhdGFMaXN0SXRlbSxcbn06IEVudGl0eUxpc3RJdGVtUHJvcHMpOiBSZWFjdC5SZWFjdEVsZW1lbnQgPT4ge1xuICBjb25zdCBoYXNFeHBhbmRhYmxlSWNvbiA9IGlzRXhwYW5kZWQgIT09IHVuZGVmaW5lZDtcblxuICBjb25zdCBoYW5kbGVPbkNsaWNrID0gdXNlQ2FsbGJhY2soXG4gICAgKGU6IFJlYWN0Lk1vdXNlRXZlbnQpID0+IHtcbiAgICAgIGlmIChvbkNsaWNrKSB7XG4gICAgICAgIG9uQ2xpY2soZSk7XG4gICAgICB9XG4gICAgfSxcbiAgICBbb25DbGlja11cbiAgKTtcblxuICBjb25zdCBidXR0b25SZWYgPSB1c2VSZWY8SFRNTERpdkVsZW1lbnQ+KG51bGwpO1xuXG4gIHVzZUtleWJvYXJkKFxuICAgIHtcbiAgICAgIFwiU3BhY2UgRW50ZXJcIjogb25TcGFjZUVudGVyUHJlc3MsXG4gICAgfSxcbiAgICBidXR0b25SZWYsXG4gICAgdGFiSW5kZXggPT09IDAgJiYgKGlzQ2xpY2thYmxlIHx8ICEhY2hlY2tib3hQcm9wcyksXG4gICAgdHJ1ZVxuICApO1xuXG4gIHJldHVybiAoXG4gICAgPFN0eWxlZEVudGl0eUl0ZW1cbiAgICAgIHJvbGU9XCJ0cmVlaXRlbVwiXG4gICAgICBhcmlhLWV4cGFuZGVkPXtoYXNFeHBhbmRhYmxlSWNvbiA/IGlzRXhwYW5kZWQgOiB1bmRlZmluZWR9XG4gICAgICBhcmlhLWNoZWNrZWQ9e2NoZWNrYm94UHJvcHM/LmNoZWNrZWR9XG4gICAgICBhcmlhLWxhYmVsPXthcmlhTGFiZWx9XG4gICAgICBhcmlhLWxldmVsPXthcmlhTGV2ZWx9XG4gICAgPlxuICAgICAgPFN0eWxlZEVudGl0eVRyZWVJdGVtQ29udGFpbmVyXG4gICAgICAgIGRhdGEtbGlzdC1pdGVtPXtkYXRhTGlzdEl0ZW19XG4gICAgICAgIHNpemU9e3NpemV9XG4gICAgICAgIHJlZj17YnV0dG9uUmVmfVxuICAgICAgICBkYXRhLWlkPVwibGlzdC1pdGVtXCJcbiAgICAgICAgdGFiSW5kZXg9e3RhYkluZGV4fVxuICAgICAgICByb2xlPVwicHJlc2VudGF0aW9uXCJcbiAgICAgICAgaXNBY3RpdmU9e2lzQWN0aXZlfVxuICAgICAgICBoYXNFeHBhbmRhYmxlSWNvbj17aGFzRXhwYW5kYWJsZUljb259XG4gICAgICAgIGxTcGFjZVN0ZXA9e2xTcGFjZVN0ZXB9XG4gICAgICAgIGlzRGlzYWJsZWQ9e2lzRGlzYWJsZWR9XG4gICAgICAgIG9uQ2xpY2s9e2hhbmRsZU9uQ2xpY2t9XG4gICAgICAgIGlzQ2xpY2thYmxlPXtpc0NsaWNrYWJsZX1cbiAgICAgID5cbiAgICAgICAge2hhc0V4cGFuZGFibGVJY29uICYmIChcbiAgICAgICAgICA8RW50aXR5VHJlZUl0ZW1FeHBhbmRCdXR0b25cbiAgICAgICAgICAgIHNpemU9e3NpemV9XG4gICAgICAgICAgICB0YWJJbmRleD17LTF9XG4gICAgICAgICAgICBpc0Rpc2FibGVkPXtpc0Rpc2FibGVkRXhwYW5kIHx8IGlzRGlzYWJsZWR9XG4gICAgICAgICAgICBpc0V4cGFuZGVkPXtpc0V4cGFuZGVkfVxuICAgICAgICAgICAgb25DbGljaz17b25FeHBhbmRDbGlja31cbiAgICAgICAgICAgIGFyaWFMYWJlbEV4cGFuZD17YXJpYUxhYmVsRXhwYW5kfVxuICAgICAgICAgICAgYXJpYUxhYmVsQ29sbGFwc2U9e2FyaWFMYWJlbENvbGxhcHNlfVxuICAgICAgICAgIC8+XG4gICAgICAgICl9XG4gICAgICAgIDxTdHlsZWRFbnRpdHlUcmVlSXRlbVdyYXBwZXJcbiAgICAgICAgICBzaXplPXtzaXplfVxuICAgICAgICAgIGhpZGVCb3JkZXI9e2hpZGVCb3JkZXIgfHwgc2l6ZSA9PT0gXCJ4c1wifVxuICAgICAgICA+XG4gICAgICAgICAgPEVudGl0eUl0ZW1Cb2R5XG4gICAgICAgICAgICBzaXplPXtzaXplfVxuICAgICAgICAgICAgdGFiSW5kZXg9e3RhYkluZGV4fVxuICAgICAgICAgICAgZGVzY3JpcHRpb249e2Rlc2NyaXB0aW9ufVxuICAgICAgICAgICAgcmVuZGVyTGFiZWw9e3JlbmRlckxhYmVsfVxuICAgICAgICAgICAgcmVuZGVyTGVmdD17cmVuZGVyTGVmdH1cbiAgICAgICAgICAgIHJlbmRlclJpZ2h0PXtyZW5kZXJSaWdodH1cbiAgICAgICAgICAgIGNoZWNrYm94UHJvcHM9e2NoZWNrYm94UHJvcHN9XG4gICAgICAgICAgLz5cbiAgICAgICAgPC9TdHlsZWRFbnRpdHlUcmVlSXRlbVdyYXBwZXI+XG4gICAgICA8L1N0eWxlZEVudGl0eVRyZWVJdGVtQ29udGFpbmVyPlxuICAgICAge2lzRXhwYW5kZWQgJiYgY2hpbGRyZW59XG4gICAgPC9TdHlsZWRFbnRpdHlJdGVtPlxuICApO1xufTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFrQnNDIn0= */"),EntityTreeItem=({checkboxProps,children,description,hideBorder,isActive,isClickable,isDisabled,isDisabledExpand,isExpanded,lSpaceStep,onClick,onExpandClick,onSpaceEnterPress,renderLabel,renderLeft,renderRight,size="m",tabIndex,ariaLabelExpand,ariaLabelCollapse,"aria-level":ariaLevel,"aria-label":ariaLabel,"data-list-item":dataListItem})=>{let hasExpandableIcon=void 0!==isExpanded,handleOnClick=(0,_react.useCallback)(e=>{onClick&&onClick(e)},[onClick]),buttonRef=(0,_react.useRef)(null);return(0,_useKeyboard.useKeyboard)({"Space Enter":onSpaceEnterPress},buttonRef,0===tabIndex&&(isClickable||!!checkboxProps),!0),_react.default.createElement(_styledcomponents.StyledEntityItem,{role:"treeitem","aria-expanded":hasExpandableIcon?isExpanded:void 0,"aria-checked":checkboxProps?.checked,"aria-label":ariaLabel,"aria-level":ariaLevel},_react.default.createElement(StyledEntityTreeItemContainer,{"data-list-item":dataListItem,size:size,ref:buttonRef,"data-id":"list-item",tabIndex:tabIndex,role:"presentation",isActive:isActive,hasExpandableIcon:hasExpandableIcon,lSpaceStep:lSpaceStep,isDisabled:isDisabled,onClick:handleOnClick,isClickable:isClickable},hasExpandableIcon&&_react.default.createElement(_EntityTreeItemExpandButton.EntityTreeItemExpandButton,{size:size,tabIndex:-1,isDisabled:isDisabledExpand||isDisabled,isExpanded:isExpanded,onClick:onExpandClick,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse}),_react.default.createElement(StyledEntityTreeItemWrapper,{size:size,hideBorder:hideBorder||"xs"===size},_react.default.createElement(_EntityItemBody.EntityItemBody,{size:size,tabIndex:tabIndex,description:description,renderLabel:renderLabel,renderLeft:renderLeft,renderRight:renderRight,checkboxProps:checkboxProps}))),isExpanded&&children)};

package/build/cjs/components/Form/Combobox/StyledSelectComponents.d.ts

@@ -1,7 +1,7 @@
 export declare const StyledContainer: import("@emotion/styled").StyledComponent<{
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType;
-}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 type StyledOptionProps = {
     active: boolean;
     preSelected: boolean;
@@ -10,13 +10,13 @@ type StyledOptionProps = {
 export declare const StyledOption: import("@emotion/styled").StyledComponent<{
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType;
-} & StyledOptionProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+} & StyledOptionProps, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 export declare const StyledFakeInputWrap: import("@emotion/styled").StyledComponent<{
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType;
-}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 export declare const StyledDropdown: import("@emotion/styled").StyledComponent<{
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType;
-}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 export {};

package/build/cjs/components/Icon/Icon.d.ts

@@ -20,4 +20,4 @@ export type IconProps = {
     "data-e2e-test-id"?: string;
     "data-testid"?: string;
 } & Omit<HTMLAttributes<HTMLDivElement>, "color">;
-export declare const Icon: ({ name, hoverable, inline, size, color, variant, "data-e2e-test-id": dataE2eTestId, "data-testid": dataTestId, ...rest }: IconProps) => React.ReactElement;
+export declare const Icon: ({ name, hoverable, inline, size, color, variant, "data-e2e-test-id": dataE2eTestId, "data-testid": dataTestId, "aria-label": ariaLabel, ...rest }: IconProps) => React.ReactElement;

package/build/cjs/components/Icon/Icon.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"Icon",{enumerable:!0,get:function(){return Icon}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_react=/*#__PURE__*/_interop_require_default._(require("react")),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_ispropvalid=/*#__PURE__*/_interop_require_default._(require("@emotion/is-prop-valid")),_iconsjson=/*#__PURE__*/_interop_require_default._(require("../../web-tokens/assets/icons.json")),_icons16json=/*#__PURE__*/_interop_require_default._(require("../../web-tokens/assets/icons16.json")),_useHover=require("../../shared/useHover"),_mediaQueries=require("../../shared/mediaQueries"),handleColor=(theme,color)=>"inherit"===color?"inherit":theme.values.color.icon[color].default,handleVariant=(theme,variant)=>{switch(variant){case"inherit":return"inherit";case"primary":return theme.values.color.icon.accent.default;case"secondary":return theme.values.color.icon.primary.default;default:return theme.values.color.icon[variant].default}},StyledIcon=(0,_styled.default)("div",{shouldForwardProp:prop=>(0,_ispropvalid.default)(prop)&&"color"!==prop,target:"e1tsg83e0",label:"StyledIcon"})(({theme,variant,isHoverable,parentRef,parentIsHovered,size,as,color})=>({...(0,_mediaQueries.useResponsiveStyles)({width:[size,theme.variables.size.dimension.icon],height:[size,theme.variables.size.dimension.icon]}),"& > svg":{...(0,_mediaQueries.useResponsiveStyles)({width:[size,theme.variables.size.dimension.icon],height:[size,theme.variables.size.dimension.icon]})},color:variant?handleVariant(theme,variant):handleColor(theme,color),..."span"===as&&{verticalAlign:"middle"},...(parentIsHovered||isHoverable)&&{cursor:"pointer"},...parentRef&&{opacity:parentIsHovered?1:.6},...isHoverable&&{opacity:theme.variables.opacity.hover,":hover":{opacity:theme.variables.opacity.visible}}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvSWNvbi9JY29uLnRzeCIsInNvdXJjZXMiOlsic3JjL2NvbXBvbmVudHMvSWNvbi9JY29uLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEhUTUxBdHRyaWJ1dGVzIH0gZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgUmVhY3QgZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCBpc1Byb3BWYWxpZCBmcm9tIFwiQGVtb3Rpb24vaXMtcHJvcC12YWxpZFwiO1xuaW1wb3J0IHR5cGUgeyBUaGVtZSB9IGZyb20gXCJAZW1vdGlvbi9yZWFjdFwiO1xuaW1wb3J0IHR5cGUgeyBJY29uc1ZhcmlhdGlvbnMsIEljb25zQ29sb3JzLCBJY29uU2l6ZXMsIE1RIH0gZnJvbSBcIi4uLy4uL3R5cGVzXCI7XG5pbXBvcnQgaWNvbnMgZnJvbSBcIi4uLy4uL3dlYi10b2tlbnMvYXNzZXRzL2ljb25zLmpzb25cIjtcbmltcG9ydCBpY29uczE2IGZyb20gXCIuLi8uLi93ZWItdG9rZW5zL2Fzc2V0cy9pY29uczE2Lmpzb25cIjtcbmltcG9ydCB7IHVzZUhvdmVyIH0gZnJvbSBcIi4uLy4uL3NoYXJlZC91c2VIb3ZlclwiO1xuaW1wb3J0IHsgdXNlUmVzcG9uc2l2ZVN0eWxlcyB9IGZyb20gXCIuLi8uLi9zaGFyZWQvbWVkaWFRdWVyaWVzXCI7XG5cbmNvbnN0IGhhbmRsZUNvbG9yID0gKHRoZW1lOiBUaGVtZSwgY29sb3I6IEljb25zQ29sb3JzKSA9PiB7XG4gIHN3aXRjaCAoY29sb3IpIHtcbiAgICBjYXNlIFwiaW5oZXJpdFwiOlxuICAgICAgcmV0dXJuIFwiaW5oZXJpdFwiO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gdGhlbWUudmFsdWVzLmNvbG9yLmljb25bY29sb3JdLmRlZmF1bHQ7XG4gIH1cbn07XG5cbmNvbnN0IGhhbmRsZVZhcmlhbnQgPSAodGhlbWU6IFRoZW1lLCB2YXJpYW50OiBJY29uc1ZhcmlhdGlvbnMpID0+IHtcbiAgc3dpdGNoICh2YXJpYW50KSB7XG4gICAgY2FzZSBcImluaGVyaXRcIjpcbiAgICAgIHJldHVybiBcImluaGVyaXRcIjtcbiAgICBjYXNlIFwicHJpbWFyeVwiOlxuICAgICAgcmV0dXJuIHRoZW1lLnZhbHVlcy5jb2xvci5pY29uLmFjY2VudC5kZWZhdWx0O1xuICAgIGNhc2UgXCJzZWNvbmRhcnlcIjpcbiAgICAgIHJldHVybiB0aGVtZS52YWx1ZXMuY29sb3IuaWNvbi5wcmltYXJ5LmRlZmF1bHQ7XG4gICAgZGVmYXVsdDpcbiAgICAgIHJldHVybiB0aGVtZS52YWx1ZXMuY29sb3IuaWNvblt2YXJpYW50XS5kZWZhdWx0O1xuICB9XG59O1xuXG5jb25zdCBTdHlsZWRJY29uID0gc3R5bGVkKFwiZGl2XCIsIHtcbiAgc2hvdWxkRm9yd2FyZFByb3A6IChwcm9wKSA9PiBpc1Byb3BWYWxpZChwcm9wKSAmJiBwcm9wICE9PSBcImNvbG9yXCIsXG59KTxcbiAgUGFydGlhbDxJY29uUHJvcHM+ICYge1xuICAgIGlzSG92ZXJhYmxlOiBib29sZWFuO1xuICAgIHBhcmVudFJlZjogUmVhY3QuTXV0YWJsZVJlZk9iamVjdDxhbnk+O1xuICAgIHBhcmVudElzSG92ZXJlZDogYm9vbGVhbjtcbiAgfVxuPihcbiAgKHtcbiAgICB0aGVtZSxcbiAgICB2YXJpYW50LFxuICAgIGlzSG92ZXJhYmxlLFxuICAgIHBhcmVudFJlZixcbiAgICBwYXJlbnRJc0hvdmVyZWQsXG4gICAgc2l6ZSxcbiAgICBhcyxcbiAgICBjb2xvcixcbiAgfSkgPT4gKHtcbiAgICAuLi51c2VSZXNwb25zaXZlU3R5bGVzKHtcbiAgICAgIHdpZHRoOiBbc2l6ZSwgdGhlbWUudmFyaWFibGVzLnNpemUuZGltZW5zaW9uLmljb25dLFxuICAgICAgaGVpZ2h0OiBbc2l6ZSwgdGhlbWUudmFyaWFibGVzLnNpemUuZGltZW5zaW9uLmljb25dLFxuICAgIH0pLFxuICAgIFwiJiA+IHN2Z1wiOiB7XG4gICAgICAuLi51c2VSZXNwb25zaXZlU3R5bGVzKHtcbiAgICAgICAgd2lkdGg6IFtzaXplLCB0aGVtZS52YXJpYWJsZXMuc2l6ZS5kaW1lbnNpb24uaWNvbl0sXG4gICAgICAgIGhlaWdodDogW3NpemUsIHRoZW1lLnZhcmlhYmxlcy5zaXplLmRpbWVuc2lvbi5pY29uXSxcbiAgICAgIH0pLFxuICAgIH0sXG4gICAgLy8gdmFyaWFudCBwcm9wIGlzIGRlcHJlY2F0ZWRcbiAgICBjb2xvcjogdmFyaWFudCA/IGhhbmRsZVZhcmlhbnQodGhlbWUsIHZhcmlhbnQpIDogaGFuZGxlQ29sb3IodGhlbWUsIGNvbG9yKSxcbiAgICAuLi4oYXMgPT09IFwic3BhblwiICYmIHtcbiAgICAgIHZlcnRpY2FsQWxpZ246IFwibWlkZGxlXCIsXG4gICAgfSksXG4gICAgLi4uKChwYXJlbnRJc0hvdmVyZWQgfHwgaXNIb3ZlcmFibGUpICYmIHtcbiAgICAgIGN1cnNvcjogXCJwb2ludGVyXCIsXG4gICAgfSksXG4gICAgLi4uKHBhcmVudFJlZiAmJiB7XG4gICAgICBvcGFjaXR5OiBwYXJlbnRJc0hvdmVyZWQgPyAxIDogMC42LFxuICAgIH0pLFxuICAgIC4uLihpc0hvdmVyYWJsZSAmJiB7XG4gICAgICBvcGFjaXR5OiB0aGVtZS52YXJpYWJsZXMub3BhY2l0eS5ob3ZlcixcbiAgICAgIFwiOmhvdmVyXCI6IHtcbiAgICAgICAgb3BhY2l0eTogdGhlbWUudmFyaWFibGVzLm9wYWNpdHkudmlzaWJsZSxcbiAgICAgIH0sXG4gICAgfSksXG4gIH0pXG4pO1xuXG5leHBvcnQgdHlwZSBJY29uTmFtZSA9IGtleW9mIHR5cGVvZiBpY29ucztcbmV4cG9ydCB0eXBlIEljb25OYW1lMTYgPSBrZXlvZiB0eXBlb2YgaWNvbnMxNjtcblxuZXhwb3J0IHR5cGUgSWNvblByb3BzID0ge1xuICAvKiogSWNvbiBuYW1lICovXG4gIG5hbWU6IEljb25OYW1lO1xuICAvKiogc2V0IHRvIHRydWUgdG8gbWFrZSB0aGUgaWNvbiBob3ZlcmFibGUsIHBhc3MgYSBwYXJlbnQncyByZWYgdG8gbWFrZSB0aGUgaWNvbiBtYXRjaCB0aGUgcGFyZW50IGhvdmVyICovXG4gIGhvdmVyYWJsZT86IGJvb2xlYW4gfCBSZWFjdC5NdXRhYmxlUmVmT2JqZWN0PGFueT47XG4gIC8qKiBzZXQgdG8gdHJ1ZSB0byBoYXZlIGFuIGlubGluZSBpY29uIHdyYXBwZWQgaW4gYSBzcGFuIGluc3RlYWQgb2YgZGl2ICovXG4gIGlubGluZT86IGJvb2xlYW47XG4gIC8qKiBAZGVwcmVjYXRlZCB2YXJpYW50LCBwbGVhc2UgdXNlIFwiY29sb3JcIiBwcm9wIGluc3RlYWQgKi9cbiAgdmFyaWFudD86IEljb25zVmFyaWF0aW9ucztcbiAgLyoqIEljb24gY29sb3IgY2FuIGluaGVyaXQgcGFyZW50IHN0eWxlLiAqL1xuICBjb2xvcj86IEljb25zQ29sb3JzO1xuICBzaXplPzogSWNvblNpemVzIHwgTVE8SWNvblNpemVzPjtcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI/OiBzdHJpbmc7XG4gIFwiZGF0YS10ZXN0aWRcIj86IHN0cmluZztcbn0gJiBPbWl0PEhUTUxBdHRyaWJ1dGVzPEhUTUxEaXZFbGVtZW50PiwgXCJjb2xvclwiPjtcblxuLyogZXNsaW50LWRpc2FibGUgcmVhY3QvanN4LXByb3BzLW5vLXNwcmVhZGluZyAqL1xuZXhwb3J0IGNvbnN0IEljb24gPSAoe1xuICBuYW1lLFxuICBob3ZlcmFibGUgPSBmYWxzZSxcbiAgaW5saW5lID0gZmFsc2UsXG4gIHNpemUgPSBcIm1cIixcbiAgY29sb3IgPSBcImluaGVyaXRcIixcbiAgdmFyaWFudCxcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI6IGRhdGFFMmVUZXN0SWQsXG4gIFwiZGF0YS10ZXN0aWRcIjogZGF0YVRlc3RJZCxcbiAgLi4ucmVzdFxufTogSWNvblByb3BzKTogUmVhY3QuUmVhY3RFbGVtZW50ID0+IHtcbiAgY29uc3QgaXNIb3ZlcmFibGUgPSB0eXBlb2YgaG92ZXJhYmxlID09PSBcImJvb2xlYW5cIiAmJiBob3ZlcmFibGU7XG4gIGNvbnN0IHBhcmVudFJlZiA9IHR5cGVvZiBob3ZlcmFibGUgIT09IFwiYm9vbGVhblwiICYmIGhvdmVyYWJsZTtcbiAgY29uc3QgcGFyZW50SXNIb3ZlcmVkID0gdXNlSG92ZXIocGFyZW50UmVmKTtcbiAgY29uc3QgYXMgPSBpbmxpbmUgPyBcInNwYW5cIiA6IFwiZGl2XCI7XG5cbiAgcmV0dXJuIChcbiAgICA8U3R5bGVkSWNvblxuICAgICAgYXM9e2FzfVxuICAgICAgZGF0YS1lMmUtdGVzdC1pZD17ZGF0YUUyZVRlc3RJZH1cbiAgICAgIGRhdGEtdGVzdGlkPXtkYXRhVGVzdElkfVxuICAgICAgZGF0YS1kcy1pZD1cIkljb25cIlxuICAgICAgZGF0YS12YXJpYW50PXtjb2xvcn1cbiAgICAgIHZhcmlhbnQ9e3ZhcmlhbnR9XG4gICAgICBjb2xvcj17Y29sb3J9XG4gICAgICBpc0hvdmVyYWJsZT17aXNIb3ZlcmFibGV9XG4gICAgICBwYXJlbnRSZWY9e3BhcmVudFJlZn1cbiAgICAgIHBhcmVudElzSG92ZXJlZD17cGFyZW50SXNIb3ZlcmVkfVxuICAgICAgc2l6ZT17c2l6ZX1cbiAgICAgIGRhbmdlcm91c2x5U2V0SW5uZXJIVE1MPXt7XG4gICAgICAgIF9faHRtbDogKHNpemUgPT09IFwic1wiICYmIGljb25zMTZbbmFtZSBhcyBJY29uTmFtZTE2XSkgfHwgaWNvbnNbbmFtZV0sXG4gICAgICB9fVxuICAgICAgey4uLnJlc3R9XG4gICAgLz5cbiAgKTtcbn07XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBaUNtQiJ9 */"),Icon=({name,hoverable=!1,inline=!1,size="m",color="inherit",variant,"data-e2e-test-id":dataE2eTestId,"data-testid":dataTestId,...rest})=>{let isHoverable="boolean"==typeof hoverable&&hoverable,parentRef="boolean"!=typeof hoverable&&hoverable,parentIsHovered=(0,_useHover.useHover)(parentRef);return _react.default.createElement(StyledIcon,{as:inline?"span":"div","data-e2e-test-id":dataE2eTestId,"data-testid":dataTestId,"data-ds-id":"Icon","data-variant":color,variant:variant,color:color,isHoverable:isHoverable,parentRef:parentRef,parentIsHovered:parentIsHovered,size:size,dangerouslySetInnerHTML:{__html:"s"===size&&_icons16json.default[name]||_iconsjson.default[name]},...rest})};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"Icon",{enumerable:!0,get:function(){return Icon}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_react=/*#__PURE__*/_interop_require_default._(require("react")),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_ispropvalid=/*#__PURE__*/_interop_require_default._(require("@emotion/is-prop-valid")),_iconsjson=/*#__PURE__*/_interop_require_default._(require("../../web-tokens/assets/icons.json")),_icons16json=/*#__PURE__*/_interop_require_default._(require("../../web-tokens/assets/icons16.json")),_useHover=require("../../shared/useHover"),_mediaQueries=require("../../shared/mediaQueries"),handleColor=(theme,color)=>"inherit"===color?"inherit":theme.values.color.icon[color].default,handleVariant=(theme,variant)=>{switch(variant){case"inherit":return"inherit";case"primary":return theme.values.color.icon.accent.default;case"secondary":return theme.values.color.icon.primary.default;default:return theme.values.color.icon[variant].default}},StyledIcon=(0,_styled.default)("div",{shouldForwardProp:prop=>(0,_ispropvalid.default)(prop)&&"color"!==prop,target:"e1f0bgf10",label:"StyledIcon"})(({theme,variant,isHoverable,parentRef,parentIsHovered,size,as,color})=>({...(0,_mediaQueries.useResponsiveStyles)({width:[size,theme.variables.size.dimension.icon],height:[size,theme.variables.size.dimension.icon]}),"& > svg":{...(0,_mediaQueries.useResponsiveStyles)({width:[size,theme.variables.size.dimension.icon],height:[size,theme.variables.size.dimension.icon]})},color:variant?handleVariant(theme,variant):handleColor(theme,color),..."span"===as&&{verticalAlign:"middle"},...(parentIsHovered||isHoverable)&&{cursor:"pointer"},...parentRef&&{opacity:parentIsHovered?1:.6},...isHoverable&&{opacity:theme.variables.opacity.hover,":hover":{opacity:theme.variables.opacity.visible}}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),Icon=({name,hoverable=!1,inline=!1,size="m",color="inherit",variant,"data-e2e-test-id":dataE2eTestId,"data-testid":dataTestId,"aria-label":ariaLabel,...rest})=>{let isHoverable="boolean"==typeof hoverable&&hoverable,parentRef="boolean"!=typeof hoverable&&hoverable,parentIsHovered=(0,_useHover.useHover)(parentRef),hasAriaLabel=!!ariaLabel;return _react.default.createElement(StyledIcon,{as:inline?"span":"div","data-e2e-test-id":dataE2eTestId,"data-testid":dataTestId,"data-ds-id":"Icon","data-variant":color,variant:variant,color:color,isHoverable:isHoverable,parentRef:parentRef,parentIsHovered:parentIsHovered,size:size,dangerouslySetInnerHTML:{__html:"s"===size&&_icons16json.default[name]||_iconsjson.default[name]},...rest,"aria-hidden":hasAriaLabel?void 0:"true",role:hasAriaLabel?"img":void 0,"aria-label":ariaLabel||void 0})};

package/build/cjs/components/Notification/Notification.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"Notification",{enumerable:!0,get:function(){return Notification}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_react=/*#__PURE__*/require("@swc/helpers/_/_interop_require_wildcard")._(require("react")),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_Card=require("../Card/Card"),_Box=require("../Box/Box"),_Columns=require("../Column/Columns"),_Button=require("../Button/Button"),_Icon=require("../Icon/Icon"),_Text=require("../Typography/Text/Text"),_SubThemeProvider=require("../SubThemeProvider/SubThemeProvider"),_SubThemeContext=require("../SubThemeProvider/SubThemeContext"),StyledExpandingContainer=(0,_styled.default)("div",{target:"e92ldbd0",label:"StyledExpandingContainer"})(({isDismissed})=>({transform:`translateY(${isDismissed?"calc(-100% - 8px)":"0%"})`,transition:`transform ${200*!!isDismissed}ms cubic-bezier(0.0, 0.0, 0.25, 1.0)`}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Notification/Notification.tsx","sources":["src/components/Notification/Notification.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React, { useState, useContext } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { ReactElement } from \"react\";\nimport { Card } from \"../Card/Card\";\nimport type { BoxProps } from \"../Box/Box\";\nimport { Box } from \"../Box/Box\";\nimport { Columns, Column } from \"../Column/Columns\";\nimport { Button } from \"../Button/Button\";\nimport type { IconName } from \"../Icon/Icon\";\nimport { Icon } from \"../Icon/Icon\";\nimport { Text } from \"../Typography/Text/Text\";\nimport {\n  SubThemeProvider,\n  type SubThemeName,\n} from \"../SubThemeProvider/SubThemeProvider\";\nimport { SubThemeContext } from \"../SubThemeProvider/SubThemeContext\";\n\nconst ANIMATION_TIME = 200;\n\nexport type NotificationProps = {\n  \"data-e2e-test-id\"?: string;\n  type?: Extract<SubThemeName, \"info\" | \"success\" | \"error\">;\n  text?: string | ReactElement;\n  icon?: IconName | null;\n  isDismissable?: boolean;\n  callToActionLabel?: string;\n  expandButtonLabel?: string;\n  shrinkButtonLabel?: string;\n  expandable?: boolean;\n  /** This prop introduces additional space to the left to account for the side navigation collapse button in ui-amboss */\n  adjustForSideNavToggle?: boolean;\n  closeButtonAriaLabel?: string;\n  onClickCallToAction?: (e: React.MouseEvent) => void;\n  onClickDismiss?: () => void;\n  children?: React.ReactNode;\n};\n\nconst StyledExpandingContainer = styled.div<{\n  isDismissed: boolean;\n}>(({ isDismissed }) => ({\n  transform: `translateY(${isDismissed ? \"calc(-100% - 8px)\" : \"0%\"})`,\n  transition: `transform ${\n    isDismissed ? ANIMATION_TIME : 0\n  }ms cubic-bezier(0.0, 0.0, 0.25, 1.0)`,\n}));\n\nconst StyledContainer = styled.div(() => ({\n  overflow: \"hidden\",\n}));\n\nconst DEFAULT_ICONS_BY_TYPE: Record<NotificationProps[\"type\"], IconName> = {\n  info: \"info\",\n  success: \"check-circle\",\n  error: \"alert-triangle\",\n};\n\nexport function Notification({\n  type,\n  text,\n  icon,\n  isDismissable,\n  callToActionLabel,\n  onClickDismiss,\n  onClickCallToAction,\n  expandable,\n  expandButtonLabel,\n  shrinkButtonLabel,\n  children,\n  adjustForSideNavToggle,\n  closeButtonAriaLabel = \"Dismiss notification\",\n  \"data-e2e-test-id\": dataE2eTestId,\n  ...ariaAttributes\n}: NotificationProps): React.ReactElement {\n  const [isExpanded, setIsExpanded] = useState(false);\n  const [isDismissed, setIsDismissed] = useState(false);\n  /* Derive notification type from subtheme to provide backward compatibility with the old usage where SubThemeProvider was external  */\n  const subTheme = useContext(SubThemeContext);\n  const subThemeName = Object.keys(DEFAULT_ICONS_BY_TYPE).includes(subTheme)\n    ? type ?? subTheme ?? \"info\"\n    : type ?? \"info\";\n  const iconName =\n    typeof icon === \"undefined\"\n      ? DEFAULT_ICONS_BY_TYPE[subThemeName as NotificationProps[\"type\"]]\n      : icon;\n\n  const dismiss = () => {\n    setIsDismissed(true);\n    setTimeout(onClickDismiss, ANIMATION_TIME);\n  };\n\n  const leftSpaceProp: Partial<BoxProps> = adjustForSideNavToggle && {\n    lSpace: [\"s\", \"l\"],\n  };\n\n  if (isDismissed) return null;\n\n  return (\n    <StyledContainer data-ds-id=\"Notification\" {...ariaAttributes} role=\"alert\">\n      <SubThemeProvider name={subThemeName}>\n        <StyledExpandingContainer isDismissed={isDismissed}>\n          <Card squareCorners data-e2e-test-id={dataE2eTestId}>\n            <Box space=\"s\" {...leftSpaceProp}>\n              <Columns gap=\"s\" vAlignItems=\"top\">\n                {iconName && (\n                  <Column size=\"narrow\">\n                    <Box vSpace=\"xxs\" space=\"zero\">\n                      <Icon\n                        role=\"img\"\n                        aria-label={subThemeName}\n                        name={iconName}\n                        color=\"primary\"\n                        data-testid=\"icon\"\n                      />\n                    </Box>\n                  </Column>\n                )}\n                <Column size=\"fill\">\n                  <Box vSpace=\"xxs\" space=\"zero\">\n                    <Text>{text}</Text>\n                  </Box>\n                </Column>{\" \"}\n                {(callToActionLabel || expandable) && (\n                  <Column\n                    size={[12, \"narrow\", \"narrow\"]}\n                    order={[\"last\", \"unset\", \"unset\"]}\n                  >\n                    {callToActionLabel && (\n                      <Button size=\"s\" fullWidth onClick={onClickCallToAction}>\n                        {callToActionLabel}\n                      </Button>\n                    )}\n                    {expandable && (\n                      <Button\n                        size=\"s\"\n                        fullWidth\n                        onClick={() => setIsExpanded(!isExpanded)}\n                        rightIcon={isExpanded ? \"chevron-up\" : \"chevron-down\"}\n                      >\n                        {isExpanded ? shrinkButtonLabel : expandButtonLabel}\n                      </Button>\n                    )}\n                  </Column>\n                )}\n                {isDismissable && (\n                  <Column size=\"narrow\">\n                    <Button\n                      aria-label={closeButtonAriaLabel}\n                      leftIcon=\"x\"\n                      variant=\"tertiary\"\n                      size=\"s\"\n                      onClick={dismiss}\n                    />\n                  </Column>\n                )}\n              </Columns>\n              {isExpanded && children}\n            </Box>\n          </Card>\n        </StyledExpandingContainer>\n      </SubThemeProvider>\n    </StyledContainer>\n  );\n}\n"],"names":[],"mappings":"AAsCiC"} */"),StyledContainer=(0,_styled.default)("div",{target:"e92ldbd1",label:"StyledContainer"})(()=>({overflow:"hidden"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Notification/Notification.tsx","sources":["src/components/Notification/Notification.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React, { useState, useContext } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { ReactElement } from \"react\";\nimport { Card } from \"../Card/Card\";\nimport type { BoxProps } from \"../Box/Box\";\nimport { Box } from \"../Box/Box\";\nimport { Columns, Column } from \"../Column/Columns\";\nimport { Button } from \"../Button/Button\";\nimport type { IconName } from \"../Icon/Icon\";\nimport { Icon } from \"../Icon/Icon\";\nimport { Text } from \"../Typography/Text/Text\";\nimport {\n  SubThemeProvider,\n  type SubThemeName,\n} from \"../SubThemeProvider/SubThemeProvider\";\nimport { SubThemeContext } from \"../SubThemeProvider/SubThemeContext\";\n\nconst ANIMATION_TIME = 200;\n\nexport type NotificationProps = {\n  \"data-e2e-test-id\"?: string;\n  type?: Extract<SubThemeName, \"info\" | \"success\" | \"error\">;\n  text?: string | ReactElement;\n  icon?: IconName | null;\n  isDismissable?: boolean;\n  callToActionLabel?: string;\n  expandButtonLabel?: string;\n  shrinkButtonLabel?: string;\n  expandable?: boolean;\n  /** This prop introduces additional space to the left to account for the side navigation collapse button in ui-amboss */\n  adjustForSideNavToggle?: boolean;\n  closeButtonAriaLabel?: string;\n  onClickCallToAction?: (e: React.MouseEvent) => void;\n  onClickDismiss?: () => void;\n  children?: React.ReactNode;\n};\n\nconst StyledExpandingContainer = styled.div<{\n  isDismissed: boolean;\n}>(({ isDismissed }) => ({\n  transform: `translateY(${isDismissed ? \"calc(-100% - 8px)\" : \"0%\"})`,\n  transition: `transform ${\n    isDismissed ? ANIMATION_TIME : 0\n  }ms cubic-bezier(0.0, 0.0, 0.25, 1.0)`,\n}));\n\nconst StyledContainer = styled.div(() => ({\n  overflow: \"hidden\",\n}));\n\nconst DEFAULT_ICONS_BY_TYPE: Record<NotificationProps[\"type\"], IconName> = {\n  info: \"info\",\n  success: \"check-circle\",\n  error: \"alert-triangle\",\n};\n\nexport function Notification({\n  type,\n  text,\n  icon,\n  isDismissable,\n  callToActionLabel,\n  onClickDismiss,\n  onClickCallToAction,\n  expandable,\n  expandButtonLabel,\n  shrinkButtonLabel,\n  children,\n  adjustForSideNavToggle,\n  closeButtonAriaLabel = \"Dismiss notification\",\n  \"data-e2e-test-id\": dataE2eTestId,\n  ...ariaAttributes\n}: NotificationProps): React.ReactElement {\n  const [isExpanded, setIsExpanded] = useState(false);\n  const [isDismissed, setIsDismissed] = useState(false);\n  /* Derive notification type from subtheme to provide backward compatibility with the old usage where SubThemeProvider was external  */\n  const subTheme = useContext(SubThemeContext);\n  const subThemeName = Object.keys(DEFAULT_ICONS_BY_TYPE).includes(subTheme)\n    ? type ?? subTheme ?? \"info\"\n    : type ?? \"info\";\n  const iconName =\n    typeof icon === \"undefined\"\n      ? DEFAULT_ICONS_BY_TYPE[subThemeName as NotificationProps[\"type\"]]\n      : icon;\n\n  const dismiss = () => {\n    setIsDismissed(true);\n    setTimeout(onClickDismiss, ANIMATION_TIME);\n  };\n\n  const leftSpaceProp: Partial<BoxProps> = adjustForSideNavToggle && {\n    lSpace: [\"s\", \"l\"],\n  };\n\n  if (isDismissed) return null;\n\n  return (\n    <StyledContainer data-ds-id=\"Notification\" {...ariaAttributes} role=\"alert\">\n      <SubThemeProvider name={subThemeName}>\n        <StyledExpandingContainer isDismissed={isDismissed}>\n          <Card squareCorners data-e2e-test-id={dataE2eTestId}>\n            <Box space=\"s\" {...leftSpaceProp}>\n              <Columns gap=\"s\" vAlignItems=\"top\">\n                {iconName && (\n                  <Column size=\"narrow\">\n                    <Box vSpace=\"xxs\" space=\"zero\">\n                      <Icon\n                        role=\"img\"\n                        aria-label={subThemeName}\n                        name={iconName}\n                        color=\"primary\"\n                        data-testid=\"icon\"\n                      />\n                    </Box>\n                  </Column>\n                )}\n                <Column size=\"fill\">\n                  <Box vSpace=\"xxs\" space=\"zero\">\n                    <Text>{text}</Text>\n                  </Box>\n                </Column>{\" \"}\n                {(callToActionLabel || expandable) && (\n                  <Column\n                    size={[12, \"narrow\", \"narrow\"]}\n                    order={[\"last\", \"unset\", \"unset\"]}\n                  >\n                    {callToActionLabel && (\n                      <Button size=\"s\" fullWidth onClick={onClickCallToAction}>\n                        {callToActionLabel}\n                      </Button>\n                    )}\n                    {expandable && (\n                      <Button\n                        size=\"s\"\n                        fullWidth\n                        onClick={() => setIsExpanded(!isExpanded)}\n                        rightIcon={isExpanded ? \"chevron-up\" : \"chevron-down\"}\n                      >\n                        {isExpanded ? shrinkButtonLabel : expandButtonLabel}\n                      </Button>\n                    )}\n                  </Column>\n                )}\n                {isDismissable && (\n                  <Column size=\"narrow\">\n                    <Button\n                      aria-label={closeButtonAriaLabel}\n                      leftIcon=\"x\"\n                      variant=\"tertiary\"\n                      size=\"s\"\n                      onClick={dismiss}\n                    />\n                  </Column>\n                )}\n              </Columns>\n              {isExpanded && children}\n            </Box>\n          </Card>\n        </StyledExpandingContainer>\n      </SubThemeProvider>\n    </StyledContainer>\n  );\n}\n"],"names":[],"mappings":"AA+CwB"} */"),DEFAULT_ICONS_BY_TYPE={info:"info",success:"check-circle",error:"alert-triangle"};function Notification({type,text,icon,isDismissable,callToActionLabel,onClickDismiss,onClickCallToAction,expandable,expandButtonLabel,shrinkButtonLabel,children,adjustForSideNavToggle,closeButtonAriaLabel="Dismiss notification","data-e2e-test-id":dataE2eTestId,...ariaAttributes}){let[isExpanded,setIsExpanded]=(0,_react.useState)(!1),[isDismissed,setIsDismissed]=(0,_react.useState)(!1),subTheme=(0,_react.useContext)(_SubThemeContext.SubThemeContext),subThemeName=Object.keys(DEFAULT_ICONS_BY_TYPE).includes(subTheme)?type??subTheme??"info":type??"info",iconName=void 0===icon?DEFAULT_ICONS_BY_TYPE[subThemeName]:icon;return isDismissed?null:_react.default.createElement(StyledContainer,{"data-ds-id":"Notification",...ariaAttributes,role:"alert"},_react.default.createElement(_SubThemeProvider.SubThemeProvider,{name:subThemeName},_react.default.createElement(StyledExpandingContainer,{isDismissed:isDismissed},_react.default.createElement(_Card.Card,{squareCorners:!0,"data-e2e-test-id":dataE2eTestId},_react.default.createElement(_Box.Box,{space:"s",...adjustForSideNavToggle&&{lSpace:["s","l"]}},_react.default.createElement(_Columns.Columns,{gap:"s",vAlignItems:"top"},iconName&&_react.default.createElement(_Columns.Column,{size:"narrow"},_react.default.createElement(_Box.Box,{vSpace:"xxs",space:"zero"},_react.default.createElement(_Icon.Icon,{role:"img","aria-label":subThemeName,name:iconName,color:"primary","data-testid":"icon"}))),_react.default.createElement(_Columns.Column,{size:"fill"},_react.default.createElement(_Box.Box,{vSpace:"xxs",space:"zero"},_react.default.createElement(_Text.Text,null,text)))," ",(callToActionLabel||expandable)&&_react.default.createElement(_Columns.Column,{size:[12,"narrow","narrow"],order:["last","unset","unset"]},callToActionLabel&&_react.default.createElement(_Button.Button,{size:"s",fullWidth:!0,onClick:onClickCallToAction},callToActionLabel),expandable&&_react.default.createElement(_Button.Button,{size:"s",fullWidth:!0,onClick:()=>setIsExpanded(!isExpanded),rightIcon:isExpanded?"chevron-up":"chevron-down"},isExpanded?shrinkButtonLabel:expandButtonLabel)),isDismissable&&_react.default.createElement(_Columns.Column,{size:"narrow"},_react.default.createElement(_Button.Button,{"aria-label":closeButtonAriaLabel,leftIcon:"x",variant:"tertiary",size:"s",onClick:()=>{setIsDismissed(!0),setTimeout(onClickDismiss,200)}}))),isExpanded&&children)))))}
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"Notification",{enumerable:!0,get:function(){return Notification}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_react=/*#__PURE__*/require("@swc/helpers/_/_interop_require_wildcard")._(require("react")),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_Card=require("../Card/Card"),_Box=require("../Box/Box"),_Columns=require("../Column/Columns"),_Button=require("../Button/Button"),_Icon=require("../Icon/Icon"),_Text=require("../Typography/Text/Text"),_SubThemeProvider=require("../SubThemeProvider/SubThemeProvider"),_SubThemeContext=require("../SubThemeProvider/SubThemeContext"),StyledExpandingContainer=(0,_styled.default)("div",{target:"e1knnt2b0",label:"StyledExpandingContainer"})(({isDismissed})=>({transform:`translateY(${isDismissed?"calc(-100% - 8px)":"0%"})`,transition:`transform ${200*!!isDismissed}ms cubic-bezier(0.0, 0.0, 0.25, 1.0)`}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvTm90aWZpY2F0aW9uL05vdGlmaWNhdGlvbi50c3giLCJzb3VyY2VzIjpbInNyYy9jb21wb25lbnRzL05vdGlmaWNhdGlvbi9Ob3RpZmljYXRpb24udHN4Il0sInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIHJlYWN0L2pzeC1wcm9wcy1uby1zcHJlYWRpbmcgKi9cbmltcG9ydCBSZWFjdCwgeyB1c2VTdGF0ZSwgdXNlQ29udGV4dCB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHN0eWxlZCBmcm9tIFwiQGVtb3Rpb24vc3R5bGVkXCI7XG5pbXBvcnQgdHlwZSB7IFJlYWN0RWxlbWVudCB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHsgQ2FyZCB9IGZyb20gXCIuLi9DYXJkL0NhcmRcIjtcbmltcG9ydCB0eXBlIHsgQm94UHJvcHMgfSBmcm9tIFwiLi4vQm94L0JveFwiO1xuaW1wb3J0IHsgQm94IH0gZnJvbSBcIi4uL0JveC9Cb3hcIjtcbmltcG9ydCB7IENvbHVtbnMsIENvbHVtbiB9IGZyb20gXCIuLi9Db2x1bW4vQ29sdW1uc1wiO1xuaW1wb3J0IHsgQnV0dG9uIH0gZnJvbSBcIi4uL0J1dHRvbi9CdXR0b25cIjtcbmltcG9ydCB0eXBlIHsgSWNvbk5hbWUgfSBmcm9tIFwiLi4vSWNvbi9JY29uXCI7XG5pbXBvcnQgeyBJY29uIH0gZnJvbSBcIi4uL0ljb24vSWNvblwiO1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gXCIuLi9UeXBvZ3JhcGh5L1RleHQvVGV4dFwiO1xuaW1wb3J0IHtcbiAgU3ViVGhlbWVQcm92aWRlcixcbiAgdHlwZSBTdWJUaGVtZU5hbWUsXG59IGZyb20gXCIuLi9TdWJUaGVtZVByb3ZpZGVyL1N1YlRoZW1lUHJvdmlkZXJcIjtcbmltcG9ydCB7IFN1YlRoZW1lQ29udGV4dCB9IGZyb20gXCIuLi9TdWJUaGVtZVByb3ZpZGVyL1N1YlRoZW1lQ29udGV4dFwiO1xuXG5jb25zdCBBTklNQVRJT05fVElNRSA9IDIwMDtcblxuZXhwb3J0IHR5cGUgTm90aWZpY2F0aW9uUHJvcHMgPSB7XG4gIFwiZGF0YS1lMmUtdGVzdC1pZFwiPzogc3RyaW5nO1xuICB0eXBlPzogRXh0cmFjdDxTdWJUaGVtZU5hbWUsIFwiaW5mb1wiIHwgXCJzdWNjZXNzXCIgfCBcImVycm9yXCI+O1xuICB0ZXh0Pzogc3RyaW5nIHwgUmVhY3RFbGVtZW50O1xuICBpY29uPzogSWNvbk5hbWUgfCBudWxsO1xuICBpc0Rpc21pc3NhYmxlPzogYm9vbGVhbjtcbiAgY2FsbFRvQWN0aW9uTGFiZWw/OiBzdHJpbmc7XG4gIGV4cGFuZEJ1dHRvbkxhYmVsPzogc3RyaW5nO1xuICBzaHJpbmtCdXR0b25MYWJlbD86IHN0cmluZztcbiAgZXhwYW5kYWJsZT86IGJvb2xlYW47XG4gIC8qKiBUaGlzIHByb3AgaW50cm9kdWNlcyBhZGRpdGlvbmFsIHNwYWNlIHRvIHRoZSBsZWZ0IHRvIGFjY291bnQgZm9yIHRoZSBzaWRlIG5hdmlnYXRpb24gY29sbGFwc2UgYnV0dG9uIGluIHVpLWFtYm9zcyAqL1xuICBhZGp1c3RGb3JTaWRlTmF2VG9nZ2xlPzogYm9vbGVhbjtcbiAgY2xvc2VCdXR0b25BcmlhTGFiZWw/OiBzdHJpbmc7XG4gIG9uQ2xpY2tDYWxsVG9BY3Rpb24/OiAoZTogUmVhY3QuTW91c2VFdmVudCkgPT4gdm9pZDtcbiAgb25DbGlja0Rpc21pc3M/OiAoKSA9PiB2b2lkO1xuICBjaGlsZHJlbj86IFJlYWN0LlJlYWN0Tm9kZTtcbn07XG5cbmNvbnN0IFN0eWxlZEV4cGFuZGluZ0NvbnRhaW5lciA9IHN0eWxlZC5kaXY8e1xuICBpc0Rpc21pc3NlZDogYm9vbGVhbjtcbn0+KCh7IGlzRGlzbWlzc2VkIH0pID0+ICh7XG4gIHRyYW5zZm9ybTogYHRyYW5zbGF0ZVkoJHtpc0Rpc21pc3NlZCA/IFwiY2FsYygtMTAwJSAtIDhweClcIiA6IFwiMCVcIn0pYCxcbiAgdHJhbnNpdGlvbjogYHRyYW5zZm9ybSAke1xuICAgIGlzRGlzbWlzc2VkID8gQU5JTUFUSU9OX1RJTUUgOiAwXG4gIH1tcyBjdWJpYy1iZXppZXIoMC4wLCAwLjAsIDAuMjUsIDEuMClgLFxufSkpO1xuXG5jb25zdCBTdHlsZWRDb250YWluZXIgPSBzdHlsZWQuZGl2KCgpID0+ICh7XG4gIG92ZXJmbG93OiBcImhpZGRlblwiLFxufSkpO1xuXG5jb25zdCBERUZBVUxUX0lDT05TX0JZX1RZUEU6IFJlY29yZDxOb3RpZmljYXRpb25Qcm9wc1tcInR5cGVcIl0sIEljb25OYW1lPiA9IHtcbiAgaW5mbzogXCJpbmZvXCIsXG4gIHN1Y2Nlc3M6IFwiY2hlY2stY2lyY2xlXCIsXG4gIGVycm9yOiBcImFsZXJ0LXRyaWFuZ2xlXCIsXG59O1xuXG5leHBvcnQgZnVuY3Rpb24gTm90aWZpY2F0aW9uKHtcbiAgdHlwZSxcbiAgdGV4dCxcbiAgaWNvbixcbiAgaXNEaXNtaXNzYWJsZSxcbiAgY2FsbFRvQWN0aW9uTGFiZWwsXG4gIG9uQ2xpY2tEaXNtaXNzLFxuICBvbkNsaWNrQ2FsbFRvQWN0aW9uLFxuICBleHBhbmRhYmxlLFxuICBleHBhbmRCdXR0b25MYWJlbCxcbiAgc2hyaW5rQnV0dG9uTGFiZWwsXG4gIGNoaWxkcmVuLFxuICBhZGp1c3RGb3JTaWRlTmF2VG9nZ2xlLFxuICBjbG9zZUJ1dHRvbkFyaWFMYWJlbCA9IFwiRGlzbWlzcyBub3RpZmljYXRpb25cIixcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI6IGRhdGFFMmVUZXN0SWQsXG4gIC4uLmFyaWFBdHRyaWJ1dGVzXG59OiBOb3RpZmljYXRpb25Qcm9wcyk6IFJlYWN0LlJlYWN0RWxlbWVudCB7XG4gIGNvbnN0IFtpc0V4cGFuZGVkLCBzZXRJc0V4cGFuZGVkXSA9IHVzZVN0YXRlKGZhbHNlKTtcbiAgY29uc3QgW2lzRGlzbWlzc2VkLCBzZXRJc0Rpc21pc3NlZF0gPSB1c2VTdGF0ZShmYWxzZSk7XG4gIC8qIERlcml2ZSBub3RpZmljYXRpb24gdHlwZSBmcm9tIHN1YnRoZW1lIHRvIHByb3ZpZGUgYmFja3dhcmQgY29tcGF0aWJpbGl0eSB3aXRoIHRoZSBvbGQgdXNhZ2Ugd2hlcmUgU3ViVGhlbWVQcm92aWRlciB3YXMgZXh0ZXJuYWwgICovXG4gIGNvbnN0IHN1YlRoZW1lID0gdXNlQ29udGV4dChTdWJUaGVtZUNvbnRleHQpO1xuICBjb25zdCBzdWJUaGVtZU5hbWUgPSBPYmplY3Qua2V5cyhERUZBVUxUX0lDT05TX0JZX1RZUEUpLmluY2x1ZGVzKHN1YlRoZW1lKVxuICAgID8gdHlwZSA/PyBzdWJUaGVtZSA/PyBcImluZm9cIlxuICAgIDogdHlwZSA/PyBcImluZm9cIjtcbiAgY29uc3QgaWNvbk5hbWUgPVxuICAgIHR5cGVvZiBpY29uID09PSBcInVuZGVmaW5lZFwiXG4gICAgICA/IERFRkFVTFRfSUNPTlNfQllfVFlQRVtzdWJUaGVtZU5hbWUgYXMgTm90aWZpY2F0aW9uUHJvcHNbXCJ0eXBlXCJdXVxuICAgICAgOiBpY29uO1xuXG4gIGNvbnN0IGRpc21pc3MgPSAoKSA9PiB7XG4gICAgc2V0SXNEaXNtaXNzZWQodHJ1ZSk7XG4gICAgc2V0VGltZW91dChvbkNsaWNrRGlzbWlzcywgQU5JTUFUSU9OX1RJTUUpO1xuICB9O1xuXG4gIGNvbnN0IGxlZnRTcGFjZVByb3A6IFBhcnRpYWw8Qm94UHJvcHM+ID0gYWRqdXN0Rm9yU2lkZU5hdlRvZ2dsZSAmJiB7XG4gICAgbFNwYWNlOiBbXCJzXCIsIFwibFwiXSxcbiAgfTtcblxuICBpZiAoaXNEaXNtaXNzZWQpIHJldHVybiBudWxsO1xuXG4gIHJldHVybiAoXG4gICAgPFN0eWxlZENvbnRhaW5lciBkYXRhLWRzLWlkPVwiTm90aWZpY2F0aW9uXCIgey4uLmFyaWFBdHRyaWJ1dGVzfSByb2xlPVwiYWxlcnRcIj5cbiAgICAgIDxTdWJUaGVtZVByb3ZpZGVyIG5hbWU9e3N1YlRoZW1lTmFtZX0+XG4gICAgICAgIDxTdHlsZWRFeHBhbmRpbmdDb250YWluZXIgaXNEaXNtaXNzZWQ9e2lzRGlzbWlzc2VkfT5cbiAgICAgICAgICA8Q2FyZCBzcXVhcmVDb3JuZXJzIGRhdGEtZTJlLXRlc3QtaWQ9e2RhdGFFMmVUZXN0SWR9PlxuICAgICAgICAgICAgPEJveCBzcGFjZT1cInNcIiB7Li4ubGVmdFNwYWNlUHJvcH0+XG4gICAgICAgICAgICAgIDxDb2x1bW5zIGdhcD1cInNcIiB2QWxpZ25JdGVtcz1cInRvcFwiPlxuICAgICAgICAgICAgICAgIHtpY29uTmFtZSAmJiAoXG4gICAgICAgICAgICAgICAgICA8Q29sdW1uIHNpemU9XCJuYXJyb3dcIj5cbiAgICAgICAgICAgICAgICAgICAgPEJveCB2U3BhY2U9XCJ4eHNcIiBzcGFjZT1cInplcm9cIj5cbiAgICAgICAgICAgICAgICAgICAgICA8SWNvblxuICAgICAgICAgICAgICAgICAgICAgICAgYXJpYS1sYWJlbD17c3ViVGhlbWVOYW1lfVxuICAgICAgICAgICAgICAgICAgICAgICAgbmFtZT17aWNvbk5hbWV9XG4gICAgICAgICAgICAgICAgICAgICAgICBjb2xvcj1cInByaW1hcnlcIlxuICAgICAgICAgICAgICAgICAgICAgICAgZGF0YS10ZXN0aWQ9XCJpY29uXCJcbiAgICAgICAgICAgICAgICAgICAgICAvPlxuICAgICAgICAgICAgICAgICAgICA8L0JveD5cbiAgICAgICAgICAgICAgICAgIDwvQ29sdW1uPlxuICAgICAgICAgICAgICAgICl9XG4gICAgICAgICAgICAgICAgPENvbHVtbiBzaXplPVwiZmlsbFwiPlxuICAgICAgICAgICAgICAgICAgPEJveCB2U3BhY2U9XCJ4eHNcIiBzcGFjZT1cInplcm9cIj5cbiAgICAgICAgICAgICAgICAgICAgPFRleHQ+e3RleHR9PC9UZXh0PlxuICAgICAgICAgICAgICAgICAgPC9Cb3g+XG4gICAgICAgICAgICAgICAgPC9Db2x1bW4+e1wiIFwifVxuICAgICAgICAgICAgICAgIHsoY2FsbFRvQWN0aW9uTGFiZWwgfHwgZXhwYW5kYWJsZSkgJiYgKFxuICAgICAgICAgICAgICAgICAgPENvbHVtblxuICAgICAgICAgICAgICAgICAgICBzaXplPXtbMTIsIFwibmFycm93XCIsIFwibmFycm93XCJdfVxuICAgICAgICAgICAgICAgICAgICBvcmRlcj17W1wibGFzdFwiLCBcInVuc2V0XCIsIFwidW5zZXRcIl19XG4gICAgICAgICAgICAgICAgICA+XG4gICAgICAgICAgICAgICAgICAgIHtjYWxsVG9BY3Rpb25MYWJlbCAmJiAoXG4gICAgICAgICAgICAgICAgICAgICAgPEJ1dHRvbiBzaXplPVwic1wiIGZ1bGxXaWR0aCBvbkNsaWNrPXtvbkNsaWNrQ2FsbFRvQWN0aW9ufT5cbiAgICAgICAgICAgICAgICAgICAgICAgIHtjYWxsVG9BY3Rpb25MYWJlbH1cbiAgICAgICAgICAgICAgICAgICAgICA8L0J1dHRvbj5cbiAgICAgICAgICAgICAgICAgICAgKX1cbiAgICAgICAgICAgICAgICAgICAge2V4cGFuZGFibGUgJiYgKFxuICAgICAgICAgICAgICAgICAgICAgIDxCdXR0b25cbiAgICAgICAgICAgICAgICAgICAgICAgIHNpemU9XCJzXCJcbiAgICAgICAgICAgICAgICAgICAgICAgIGZ1bGxXaWR0aFxuICAgICAgICAgICAgICAgICAgICAgICAgb25DbGljaz17KCkgPT4gc2V0SXNFeHBhbmRlZCghaXNFeHBhbmRlZCl9XG4gICAgICAgICAgICAgICAgICAgICAgICByaWdodEljb249e2lzRXhwYW5kZWQgPyBcImNoZXZyb24tdXBcIiA6IFwiY2hldnJvbi1kb3duXCJ9XG4gICAgICAgICAgICAgICAgICAgICAgPlxuICAgICAgICAgICAgICAgICAgICAgICAge2lzRXhwYW5kZWQgPyBzaHJpbmtCdXR0b25MYWJlbCA6IGV4cGFuZEJ1dHRvbkxhYmVsfVxuICAgICAgICAgICAgICAgICAgICAgIDwvQnV0dG9uPlxuICAgICAgICAgICAgICAgICAgICApfVxuICAgICAgICAgICAgICAgICAgPC9Db2x1bW4+XG4gICAgICAgICAgICAgICAgKX1cbiAgICAgICAgICAgICAgICB7aXNEaXNtaXNzYWJsZSAmJiAoXG4gICAgICAgICAgICAgICAgICA8Q29sdW1uIHNpemU9XCJuYXJyb3dcIj5cbiAgICAgICAgICAgICAgICAgICAgPEJ1dHRvblxuICAgICAgICAgICAgICAgICAgICAgIGFyaWEtbGFiZWw9e2Nsb3NlQnV0dG9uQXJpYUxhYmVsfVxuICAgICAgICAgICAgICAgICAgICAgIGxlZnRJY29uPVwieFwiXG4gICAgICAgICAgICAgICAgICAgICAgdmFyaWFudD1cInRlcnRpYXJ5XCJcbiAgICAgICAgICAgICAgICAgICAgICBzaXplPVwic1wiXG4gICAgICAgICAgICAgICAgICAgICAgb25DbGljaz17ZGlzbWlzc31cbiAgICAgICAgICAgICAgICAgICAgLz5cbiAgICAgICAgICAgICAgICAgIDwvQ29sdW1uPlxuICAgICAgICAgICAgICAgICl9XG4gICAgICAgICAgICAgIDwvQ29sdW1ucz5cbiAgICAgICAgICAgICAge2lzRXhwYW5kZWQgJiYgY2hpbGRyZW59XG4gICAgICAgICAgICA8L0JveD5cbiAgICAgICAgICA8L0NhcmQ+XG4gICAgICAgIDwvU3R5bGVkRXhwYW5kaW5nQ29udGFpbmVyPlxuICAgICAgPC9TdWJUaGVtZVByb3ZpZGVyPlxuICAgIDwvU3R5bGVkQ29udGFpbmVyPlxuICApO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXNDaUMifQ== */"),StyledContainer=(0,_styled.default)("div",{target:"e1knnt2b1",label:"StyledContainer"})(()=>({overflow:"hidden"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvTm90aWZpY2F0aW9uL05vdGlmaWNhdGlvbi50c3giLCJzb3VyY2VzIjpbInNyYy9jb21wb25lbnRzL05vdGlmaWNhdGlvbi9Ob3RpZmljYXRpb24udHN4Il0sInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIHJlYWN0L2pzeC1wcm9wcy1uby1zcHJlYWRpbmcgKi9cbmltcG9ydCBSZWFjdCwgeyB1c2VTdGF0ZSwgdXNlQ29udGV4dCB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHN0eWxlZCBmcm9tIFwiQGVtb3Rpb24vc3R5bGVkXCI7XG5pbXBvcnQgdHlwZSB7IFJlYWN0RWxlbWVudCB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHsgQ2FyZCB9IGZyb20gXCIuLi9DYXJkL0NhcmRcIjtcbmltcG9ydCB0eXBlIHsgQm94UHJvcHMgfSBmcm9tIFwiLi4vQm94L0JveFwiO1xuaW1wb3J0IHsgQm94IH0gZnJvbSBcIi4uL0JveC9Cb3hcIjtcbmltcG9ydCB7IENvbHVtbnMsIENvbHVtbiB9IGZyb20gXCIuLi9Db2x1bW4vQ29sdW1uc1wiO1xuaW1wb3J0IHsgQnV0dG9uIH0gZnJvbSBcIi4uL0J1dHRvbi9CdXR0b25cIjtcbmltcG9ydCB0eXBlIHsgSWNvbk5hbWUgfSBmcm9tIFwiLi4vSWNvbi9JY29uXCI7XG5pbXBvcnQgeyBJY29uIH0gZnJvbSBcIi4uL0ljb24vSWNvblwiO1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gXCIuLi9UeXBvZ3JhcGh5L1RleHQvVGV4dFwiO1xuaW1wb3J0IHtcbiAgU3ViVGhlbWVQcm92aWRlcixcbiAgdHlwZSBTdWJUaGVtZU5hbWUsXG59IGZyb20gXCIuLi9TdWJUaGVtZVByb3ZpZGVyL1N1YlRoZW1lUHJvdmlkZXJcIjtcbmltcG9ydCB7IFN1YlRoZW1lQ29udGV4dCB9IGZyb20gXCIuLi9TdWJUaGVtZVByb3ZpZGVyL1N1YlRoZW1lQ29udGV4dFwiO1xuXG5jb25zdCBBTklNQVRJT05fVElNRSA9IDIwMDtcblxuZXhwb3J0IHR5cGUgTm90aWZpY2F0aW9uUHJvcHMgPSB7XG4gIFwiZGF0YS1lMmUtdGVzdC1pZFwiPzogc3RyaW5nO1xuICB0eXBlPzogRXh0cmFjdDxTdWJUaGVtZU5hbWUsIFwiaW5mb1wiIHwgXCJzdWNjZXNzXCIgfCBcImVycm9yXCI+O1xuICB0ZXh0Pzogc3RyaW5nIHwgUmVhY3RFbGVtZW50O1xuICBpY29uPzogSWNvbk5hbWUgfCBudWxsO1xuICBpc0Rpc21pc3NhYmxlPzogYm9vbGVhbjtcbiAgY2FsbFRvQWN0aW9uTGFiZWw/OiBzdHJpbmc7XG4gIGV4cGFuZEJ1dHRvbkxhYmVsPzogc3RyaW5nO1xuICBzaHJpbmtCdXR0b25MYWJlbD86IHN0cmluZztcbiAgZXhwYW5kYWJsZT86IGJvb2xlYW47XG4gIC8qKiBUaGlzIHByb3AgaW50cm9kdWNlcyBhZGRpdGlvbmFsIHNwYWNlIHRvIHRoZSBsZWZ0IHRvIGFjY291bnQgZm9yIHRoZSBzaWRlIG5hdmlnYXRpb24gY29sbGFwc2UgYnV0dG9uIGluIHVpLWFtYm9zcyAqL1xuICBhZGp1c3RGb3JTaWRlTmF2VG9nZ2xlPzogYm9vbGVhbjtcbiAgY2xvc2VCdXR0b25BcmlhTGFiZWw/OiBzdHJpbmc7XG4gIG9uQ2xpY2tDYWxsVG9BY3Rpb24/OiAoZTogUmVhY3QuTW91c2VFdmVudCkgPT4gdm9pZDtcbiAgb25DbGlja0Rpc21pc3M/OiAoKSA9PiB2b2lkO1xuICBjaGlsZHJlbj86IFJlYWN0LlJlYWN0Tm9kZTtcbn07XG5cbmNvbnN0IFN0eWxlZEV4cGFuZGluZ0NvbnRhaW5lciA9IHN0eWxlZC5kaXY8e1xuICBpc0Rpc21pc3NlZDogYm9vbGVhbjtcbn0+KCh7IGlzRGlzbWlzc2VkIH0pID0+ICh7XG4gIHRyYW5zZm9ybTogYHRyYW5zbGF0ZVkoJHtpc0Rpc21pc3NlZCA/IFwiY2FsYygtMTAwJSAtIDhweClcIiA6IFwiMCVcIn0pYCxcbiAgdHJhbnNpdGlvbjogYHRyYW5zZm9ybSAke1xuICAgIGlzRGlzbWlzc2VkID8gQU5JTUFUSU9OX1RJTUUgOiAwXG4gIH1tcyBjdWJpYy1iZXppZXIoMC4wLCAwLjAsIDAuMjUsIDEuMClgLFxufSkpO1xuXG5jb25zdCBTdHlsZWRDb250YWluZXIgPSBzdHlsZWQuZGl2KCgpID0+ICh7XG4gIG92ZXJmbG93OiBcImhpZGRlblwiLFxufSkpO1xuXG5jb25zdCBERUZBVUxUX0lDT05TX0JZX1RZUEU6IFJlY29yZDxOb3RpZmljYXRpb25Qcm9wc1tcInR5cGVcIl0sIEljb25OYW1lPiA9IHtcbiAgaW5mbzogXCJpbmZvXCIsXG4gIHN1Y2Nlc3M6IFwiY2hlY2stY2lyY2xlXCIsXG4gIGVycm9yOiBcImFsZXJ0LXRyaWFuZ2xlXCIsXG59O1xuXG5leHBvcnQgZnVuY3Rpb24gTm90aWZpY2F0aW9uKHtcbiAgdHlwZSxcbiAgdGV4dCxcbiAgaWNvbixcbiAgaXNEaXNtaXNzYWJsZSxcbiAgY2FsbFRvQWN0aW9uTGFiZWwsXG4gIG9uQ2xpY2tEaXNtaXNzLFxuICBvbkNsaWNrQ2FsbFRvQWN0aW9uLFxuICBleHBhbmRhYmxlLFxuICBleHBhbmRCdXR0b25MYWJlbCxcbiAgc2hyaW5rQnV0dG9uTGFiZWwsXG4gIGNoaWxkcmVuLFxuICBhZGp1c3RGb3JTaWRlTmF2VG9nZ2xlLFxuICBjbG9zZUJ1dHRvbkFyaWFMYWJlbCA9IFwiRGlzbWlzcyBub3RpZmljYXRpb25cIixcbiAgXCJkYXRhLWUyZS10ZXN0LWlkXCI6IGRhdGFFMmVUZXN0SWQsXG4gIC4uLmFyaWFBdHRyaWJ1dGVzXG59OiBOb3RpZmljYXRpb25Qcm9wcyk6IFJlYWN0LlJlYWN0RWxlbWVudCB7XG4gIGNvbnN0IFtpc0V4cGFuZGVkLCBzZXRJc0V4cGFuZGVkXSA9IHVzZVN0YXRlKGZhbHNlKTtcbiAgY29uc3QgW2lzRGlzbWlzc2VkLCBzZXRJc0Rpc21pc3NlZF0gPSB1c2VTdGF0ZShmYWxzZSk7XG4gIC8qIERlcml2ZSBub3RpZmljYXRpb24gdHlwZSBmcm9tIHN1YnRoZW1lIHRvIHByb3ZpZGUgYmFja3dhcmQgY29tcGF0aWJpbGl0eSB3aXRoIHRoZSBvbGQgdXNhZ2Ugd2hlcmUgU3ViVGhlbWVQcm92aWRlciB3YXMgZXh0ZXJuYWwgICovXG4gIGNvbnN0IHN1YlRoZW1lID0gdXNlQ29udGV4dChTdWJUaGVtZUNvbnRleHQpO1xuICBjb25zdCBzdWJUaGVtZU5hbWUgPSBPYmplY3Qua2V5cyhERUZBVUxUX0lDT05TX0JZX1RZUEUpLmluY2x1ZGVzKHN1YlRoZW1lKVxuICAgID8gdHlwZSA/PyBzdWJUaGVtZSA/PyBcImluZm9cIlxuICAgIDogdHlwZSA/PyBcImluZm9cIjtcbiAgY29uc3QgaWNvbk5hbWUgPVxuICAgIHR5cGVvZiBpY29uID09PSBcInVuZGVmaW5lZFwiXG4gICAgICA/IERFRkFVTFRfSUNPTlNfQllfVFlQRVtzdWJUaGVtZU5hbWUgYXMgTm90aWZpY2F0aW9uUHJvcHNbXCJ0eXBlXCJdXVxuICAgICAgOiBpY29uO1xuXG4gIGNvbnN0IGRpc21pc3MgPSAoKSA9PiB7XG4gICAgc2V0SXNEaXNtaXNzZWQodHJ1ZSk7XG4gICAgc2V0VGltZW91dChvbkNsaWNrRGlzbWlzcywgQU5JTUFUSU9OX1RJTUUpO1xuICB9O1xuXG4gIGNvbnN0IGxlZnRTcGFjZVByb3A6IFBhcnRpYWw8Qm94UHJvcHM+ID0gYWRqdXN0Rm9yU2lkZU5hdlRvZ2dsZSAmJiB7XG4gICAgbFNwYWNlOiBbXCJzXCIsIFwibFwiXSxcbiAgfTtcblxuICBpZiAoaXNEaXNtaXNzZWQpIHJldHVybiBudWxsO1xuXG4gIHJldHVybiAoXG4gICAgPFN0eWxlZENvbnRhaW5lciBkYXRhLWRzLWlkPVwiTm90aWZpY2F0aW9uXCIgey4uLmFyaWFBdHRyaWJ1dGVzfSByb2xlPVwiYWxlcnRcIj5cbiAgICAgIDxTdWJUaGVtZVByb3ZpZGVyIG5hbWU9e3N1YlRoZW1lTmFtZX0+XG4gICAgICAgIDxTdHlsZWRFeHBhbmRpbmdDb250YWluZXIgaXNEaXNtaXNzZWQ9e2lzRGlzbWlzc2VkfT5cbiAgICAgICAgICA8Q2FyZCBzcXVhcmVDb3JuZXJzIGRhdGEtZTJlLXRlc3QtaWQ9e2RhdGFFMmVUZXN0SWR9PlxuICAgICAgICAgICAgPEJveCBzcGFjZT1cInNcIiB7Li4ubGVmdFNwYWNlUHJvcH0+XG4gICAgICAgICAgICAgIDxDb2x1bW5zIGdhcD1cInNcIiB2QWxpZ25JdGVtcz1cInRvcFwiPlxuICAgICAgICAgICAgICAgIHtpY29uTmFtZSAmJiAoXG4gICAgICAgICAgICAgICAgICA8Q29sdW1uIHNpemU9XCJuYXJyb3dcIj5cbiAgICAgICAgICAgICAgICAgICAgPEJveCB2U3BhY2U9XCJ4eHNcIiBzcGFjZT1cInplcm9cIj5cbiAgICAgICAgICAgICAgICAgICAgICA8SWNvblxuICAgICAgICAgICAgICAgICAgICAgICAgYXJpYS1sYWJlbD17c3ViVGhlbWVOYW1lfVxuICAgICAgICAgICAgICAgICAgICAgICAgbmFtZT17aWNvbk5hbWV9XG4gICAgICAgICAgICAgICAgICAgICAgICBjb2xvcj1cInByaW1hcnlcIlxuICAgICAgICAgICAgICAgICAgICAgICAgZGF0YS10ZXN0aWQ9XCJpY29uXCJcbiAgICAgICAgICAgICAgICAgICAgICAvPlxuICAgICAgICAgICAgICAgICAgICA8L0JveD5cbiAgICAgICAgICAgICAgICAgIDwvQ29sdW1uPlxuICAgICAgICAgICAgICAgICl9XG4gICAgICAgICAgICAgICAgPENvbHVtbiBzaXplPVwiZmlsbFwiPlxuICAgICAgICAgICAgICAgICAgPEJveCB2U3BhY2U9XCJ4eHNcIiBzcGFjZT1cInplcm9cIj5cbiAgICAgICAgICAgICAgICAgICAgPFRleHQ+e3RleHR9PC9UZXh0PlxuICAgICAgICAgICAgICAgICAgPC9Cb3g+XG4gICAgICAgICAgICAgICAgPC9Db2x1bW4+e1wiIFwifVxuICAgICAgICAgICAgICAgIHsoY2FsbFRvQWN0aW9uTGFiZWwgfHwgZXhwYW5kYWJsZSkgJiYgKFxuICAgICAgICAgICAgICAgICAgPENvbHVtblxuICAgICAgICAgICAgICAgICAgICBzaXplPXtbMTIsIFwibmFycm93XCIsIFwibmFycm93XCJdfVxuICAgICAgICAgICAgICAgICAgICBvcmRlcj17W1wibGFzdFwiLCBcInVuc2V0XCIsIFwidW5zZXRcIl19XG4gICAgICAgICAgICAgICAgICA+XG4gICAgICAgICAgICAgICAgICAgIHtjYWxsVG9BY3Rpb25MYWJlbCAmJiAoXG4gICAgICAgICAgICAgICAgICAgICAgPEJ1dHRvbiBzaXplPVwic1wiIGZ1bGxXaWR0aCBvbkNsaWNrPXtvbkNsaWNrQ2FsbFRvQWN0aW9ufT5cbiAgICAgICAgICAgICAgICAgICAgICAgIHtjYWxsVG9BY3Rpb25MYWJlbH1cbiAgICAgICAgICAgICAgICAgICAgICA8L0J1dHRvbj5cbiAgICAgICAgICAgICAgICAgICAgKX1cbiAgICAgICAgICAgICAgICAgICAge2V4cGFuZGFibGUgJiYgKFxuICAgICAgICAgICAgICAgICAgICAgIDxCdXR0b25cbiAgICAgICAgICAgICAgICAgICAgICAgIHNpemU9XCJzXCJcbiAgICAgICAgICAgICAgICAgICAgICAgIGZ1bGxXaWR0aFxuICAgICAgICAgICAgICAgICAgICAgICAgb25DbGljaz17KCkgPT4gc2V0SXNFeHBhbmRlZCghaXNFeHBhbmRlZCl9XG4gICAgICAgICAgICAgICAgICAgICAgICByaWdodEljb249e2lzRXhwYW5kZWQgPyBcImNoZXZyb24tdXBcIiA6IFwiY2hldnJvbi1kb3duXCJ9XG4gICAgICAgICAgICAgICAgICAgICAgPlxuICAgICAgICAgICAgICAgICAgICAgICAge2lzRXhwYW5kZWQgPyBzaHJpbmtCdXR0b25MYWJlbCA6IGV4cGFuZEJ1dHRvbkxhYmVsfVxuICAgICAgICAgICAgICAgICAgICAgIDwvQnV0dG9uPlxuICAgICAgICAgICAgICAgICAgICApfVxuICAgICAgICAgICAgICAgICAgPC9Db2x1bW4+XG4gICAgICAgICAgICAgICAgKX1cbiAgICAgICAgICAgICAgICB7aXNEaXNtaXNzYWJsZSAmJiAoXG4gICAgICAgICAgICAgICAgICA8Q29sdW1uIHNpemU9XCJuYXJyb3dcIj5cbiAgICAgICAgICAgICAgICAgICAgPEJ1dHRvblxuICAgICAgICAgICAgICAgICAgICAgIGFyaWEtbGFiZWw9e2Nsb3NlQnV0dG9uQXJpYUxhYmVsfVxuICAgICAgICAgICAgICAgICAgICAgIGxlZnRJY29uPVwieFwiXG4gICAgICAgICAgICAgICAgICAgICAgdmFyaWFudD1cInRlcnRpYXJ5XCJcbiAgICAgICAgICAgICAgICAgICAgICBzaXplPVwic1wiXG4gICAgICAgICAgICAgICAgICAgICAgb25DbGljaz17ZGlzbWlzc31cbiAgICAgICAgICAgICAgICAgICAgLz5cbiAgICAgICAgICAgICAgICAgIDwvQ29sdW1uPlxuICAgICAgICAgICAgICAgICl9XG4gICAgICAgICAgICAgIDwvQ29sdW1ucz5cbiAgICAgICAgICAgICAge2lzRXhwYW5kZWQgJiYgY2hpbGRyZW59XG4gICAgICAgICAgICA8L0JveD5cbiAgICAgICAgICA8L0NhcmQ+XG4gICAgICAgIDwvU3R5bGVkRXhwYW5kaW5nQ29udGFpbmVyPlxuICAgICAgPC9TdWJUaGVtZVByb3ZpZGVyPlxuICAgIDwvU3R5bGVkQ29udGFpbmVyPlxuICApO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQStDd0IifQ== */"),DEFAULT_ICONS_BY_TYPE={info:"info",success:"check-circle",error:"alert-triangle"};function Notification({type,text,icon,isDismissable,callToActionLabel,onClickDismiss,onClickCallToAction,expandable,expandButtonLabel,shrinkButtonLabel,children,adjustForSideNavToggle,closeButtonAriaLabel="Dismiss notification","data-e2e-test-id":dataE2eTestId,...ariaAttributes}){let[isExpanded,setIsExpanded]=(0,_react.useState)(!1),[isDismissed,setIsDismissed]=(0,_react.useState)(!1),subTheme=(0,_react.useContext)(_SubThemeContext.SubThemeContext),subThemeName=Object.keys(DEFAULT_ICONS_BY_TYPE).includes(subTheme)?type??subTheme??"info":type??"info",iconName=void 0===icon?DEFAULT_ICONS_BY_TYPE[subThemeName]:icon;return isDismissed?null:_react.default.createElement(StyledContainer,{"data-ds-id":"Notification",...ariaAttributes,role:"alert"},_react.default.createElement(_SubThemeProvider.SubThemeProvider,{name:subThemeName},_react.default.createElement(StyledExpandingContainer,{isDismissed:isDismissed},_react.default.createElement(_Card.Card,{squareCorners:!0,"data-e2e-test-id":dataE2eTestId},_react.default.createElement(_Box.Box,{space:"s",...adjustForSideNavToggle&&{lSpace:["s","l"]}},_react.default.createElement(_Columns.Columns,{gap:"s",vAlignItems:"top"},iconName&&_react.default.createElement(_Columns.Column,{size:"narrow"},_react.default.createElement(_Box.Box,{vSpace:"xxs",space:"zero"},_react.default.createElement(_Icon.Icon,{"aria-label":subThemeName,name:iconName,color:"primary","data-testid":"icon"}))),_react.default.createElement(_Columns.Column,{size:"fill"},_react.default.createElement(_Box.Box,{vSpace:"xxs",space:"zero"},_react.default.createElement(_Text.Text,null,text)))," ",(callToActionLabel||expandable)&&_react.default.createElement(_Columns.Column,{size:[12,"narrow","narrow"],order:["last","unset","unset"]},callToActionLabel&&_react.default.createElement(_Button.Button,{size:"s",fullWidth:!0,onClick:onClickCallToAction},callToActionLabel),expandable&&_react.default.createElement(_Button.Button,{size:"s",fullWidth:!0,onClick:()=>setIsExpanded(!isExpanded),rightIcon:isExpanded?"chevron-up":"chevron-down"},isExpanded?shrinkButtonLabel:expandButtonLabel)),isDismissable&&_react.default.createElement(_Columns.Column,{size:"narrow"},_react.default.createElement(_Button.Button,{"aria-label":closeButtonAriaLabel,leftIcon:"x",variant:"tertiary",size:"s",onClick:()=>{setIsDismissed(!0),setTimeout(onClickDismiss,200)}}))),isExpanded&&children)))))}

package/build/cjs/components/Patterns/Dialog/DialogContext.d.ts

@@ -1 +1 @@
-export declare const DialogContext: import("react").Context<boolean>;
+export declare const DialogContext: React.Context<boolean>;

package/build/cjs/components/SubThemeProvider/SubThemeContext.d.ts

@@ -1 +1 @@
-export declare const SubThemeContext: import("react").Context<import("./SubThemeProvider").SubThemeName>;
+export declare const SubThemeContext: React.Context<import("./SubThemeProvider").SubThemeName>;

package/build/cjs/components/Utilities/ContainerQuery/ContainerQueryContext.d.ts

@@ -1,2 +1,2 @@
 import type { ContainerQueryBreakpoints } from "../../../shared/mediaQueries";
-export declare const ContainerQueryContext: import("react").Context<ContainerQueryBreakpoints>;
+export declare const ContainerQueryContext: React.Context<ContainerQueryBreakpoints>;

package/build/cjs/components/Utilities/ScreenReaderText/ScreenReaderText.d.ts

@@ -1,4 +1,4 @@
 export declare const ScreenReaderText: import("@emotion/styled").StyledComponent<{
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType;
-}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/build/cjs/components/VirtualScrollList/VirtualScrollList.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"VirtualScrollList",{enumerable:!0,get:function(){return VirtualScrollList}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_interop_require_wildcard=require("@swc/helpers/_/_interop_require_wildcard"),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_react=/*#__PURE__*/_interop_require_wildcard._(require("react")),_VirtualScrollListReducer=require("./VirtualScrollListReducer"),StyledContainer=(0,_styled.default)("div",{target:"eq4r19g0",label:"StyledContainer"})(({maxHeight})=>({overflow:"auto",width:"100%",height:"100%",maxHeight}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledScrollableContent=(0,_styled.default)("div",{target:"eq4r19g1",label:"StyledScrollableContent"})(({maxContentHeight})=>({overflow:"hidden",boxSizing:"border-box",height:maxContentHeight}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");function VirtualScrollList({id,maxHeight,itemHeight,itemAmount,emptyState=()=>null,itemInView,itemTemplate,containerStyle,"data-e2e-test-id":dataE2eTestId,onContentHeightChange,role,...ariaAttributes}){let scrollableContainerRef=(0,_react.useRef)(null),viewportRef=(0,_react.useRef)(null),adjustedForReflow=(0,_react.useRef)(!1),[{scrolledItemCount,amountOfItemsInView,scrolledInPx,maxContentHeight=maxHeight,recommendedScrollPosition},dispatch]=(0,_react.useReducer)(_VirtualScrollListReducer.VirtualScrollReducer,{});(0,_react.useLayoutEffect)(()=>{dispatch({type:"reset",itemHeight,maxHeight,overscan:10}),scrollableContainerRef.current.scrollTop=0},[itemHeight,itemAmount,maxHeight]),(0,_react.useEffect)(()=>{dispatch({type:"recommendScrollPosition",scrollTop:scrollableContainerRef.current.scrollTop,itemToBeInView:itemInView})},[itemInView]),(0,_react.useEffect)(()=>{null!==recommendedScrollPosition&&(scrollableContainerRef.current.scrollTop=recommendedScrollPosition)},[recommendedScrollPosition]),(0,_react.useLayoutEffect)(()=>{viewportRef.current&&dispatch({type:"updateViewport",viewportNode:viewportRef.current,itemAmount})},[itemAmount,scrolledItemCount]),(0,_react.useEffect)(()=>{onContentHeightChange?.()},[maxContentHeight,onContentHeightChange]);let itemCountToBeRendered=Math.min(Math.max(0,itemAmount-scrolledItemCount),amountOfItemsInView);return maxContentHeight>maxHeight&&!adjustedForReflow.current&&viewportRef.current&&(setTimeout(()=>{dispatch({type:"updateViewport",viewportNode:viewportRef.current,itemAmount})}),adjustedForReflow.current=!0),_react.default.createElement(StyledContainer,{ref:scrollableContainerRef,maxHeight:maxHeight,style:{maxHeight,...containerStyle},"data-e2e-test-id":dataE2eTestId,"data-ds-id":"VirtualScrollList",onScroll:e=>{dispatch({type:"scroll",scrollTop:e.currentTarget.scrollTop})}},0===itemAmount?emptyState():_react.default.createElement(StyledScrollableContent,{maxContentHeight:maxContentHeight},_react.default.createElement("ul",{ref:viewportRef,style:{transform:`translateY(${scrolledInPx}px`},role:role,id:id,...ariaAttributes},!!itemCountToBeRendered&&Array(itemCountToBeRendered).fill(0).map((_,index)=>itemTemplate(scrolledItemCount+index)))))}
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"VirtualScrollList",{enumerable:!0,get:function(){return VirtualScrollList}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default"),_interop_require_wildcard=require("@swc/helpers/_/_interop_require_wildcard"),_styled=/*#__PURE__*/_interop_require_default._(require("@emotion/styled")),_react=/*#__PURE__*/_interop_require_wildcard._(require("react")),_VirtualScrollListReducer=require("./VirtualScrollListReducer"),StyledContainer=(0,_styled.default)("div",{target:"e1727xf20",label:"StyledContainer"})(({maxHeight})=>({overflow:"auto",width:"100%",height:"100%",maxHeight}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledScrollableContent=(0,_styled.default)("div",{target:"e1727xf21",label:"StyledScrollableContent"})(({maxContentHeight})=>({overflow:"hidden",boxSizing:"border-box",height:maxContentHeight}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");function VirtualScrollList({id,maxHeight,itemHeight,itemAmount,emptyState=()=>null,itemInView,itemTemplate,containerStyle,"data-e2e-test-id":dataE2eTestId,onContentHeightChange,role,...ariaAttributes}){let scrollableContainerRef=(0,_react.useRef)(null),viewportRef=(0,_react.useRef)(null),adjustedForReflow=(0,_react.useRef)(!1),[{scrolledItemCount,amountOfItemsInView,scrolledInPx,maxContentHeight=maxHeight,recommendedScrollPosition},dispatch]=(0,_react.useReducer)(_VirtualScrollListReducer.VirtualScrollReducer,{});(0,_react.useLayoutEffect)(()=>{dispatch({type:"reset",itemHeight,maxHeight,overscan:10}),scrollableContainerRef.current.scrollTop=0},[itemHeight,itemAmount,maxHeight]),(0,_react.useEffect)(()=>{dispatch({type:"recommendScrollPosition",scrollTop:scrollableContainerRef.current.scrollTop,itemToBeInView:itemInView})},[itemInView]),(0,_react.useEffect)(()=>{null!==recommendedScrollPosition&&(scrollableContainerRef.current.scrollTop=recommendedScrollPosition)},[recommendedScrollPosition]),(0,_react.useLayoutEffect)(()=>{viewportRef.current&&dispatch({type:"updateViewport",viewportNode:viewportRef.current,itemAmount})},[itemAmount,scrolledItemCount]),(0,_react.useEffect)(()=>{onContentHeightChange?.()},[maxContentHeight,onContentHeightChange]);let itemCountToBeRendered=Math.min(Math.max(0,itemAmount-scrolledItemCount),amountOfItemsInView);return maxContentHeight>maxHeight&&!adjustedForReflow.current&&viewportRef.current&&(setTimeout(()=>{dispatch({type:"updateViewport",viewportNode:viewportRef.current,itemAmount})}),adjustedForReflow.current=!0),_react.default.createElement(StyledContainer,{ref:scrollableContainerRef,maxHeight:maxHeight,style:{maxHeight,...containerStyle},"data-e2e-test-id":dataE2eTestId,"data-ds-id":"VirtualScrollList",onScroll:e=>{dispatch({type:"scroll",scrollTop:e.currentTarget.scrollTop})}},0===itemAmount?emptyState():_react.default.createElement(StyledScrollableContent,{maxContentHeight:maxContentHeight},_react.default.createElement("div",{ref:viewportRef,style:{transform:`translateY(${scrolledInPx}px`},role:role,id:id,...ariaAttributes},!!itemCountToBeRendered&&Array(itemCountToBeRendered).fill(0).map((_,index)=>itemTemplate(scrolledItemCount+index)))))}

package/build/cjs/shared/components/SelectableButton.d.ts

@@ -15,4 +15,4 @@ export declare const SelectableButton: import("@emotion/styled").StyledComponent
     as?: React.ElementType;
 } & {
     isActive?: boolean;
-}, import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {}>;
+}, React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {}>;