npm - @amboss/design-system - Versions diffs - 3.7.0 → 3.7.2 - Mend

@amboss/design-system 3.7.0 → 3.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (289) hide show

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

	@@ -1 +1 @@
1	- import styled from"@emotion/styled";import{mq,mqValue}from"../../shared/mediaQueries";export const getOffsetMqStyle=(cssProp,{theme,size})=>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}]});export const StyledList=/#__PURE__/styled("ul",{target:"e10ll6940",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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 /");export const StyledEntityItemLi=/#__PURE__/styled("li",{target:"e10ll6941",label:"StyledEntityItemLi"})({listStyleType:"none"},"/# sourceMappingURL=data:application/json;charset=utf-8;base64,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 /");export const StyledShowMore=/#__PURE__/styled("div",{target:"e10ll6942",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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 /");export const StyledWrapperOffset=/#__PURE__/styled("div",{target:"e10ll6943",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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 /");export const StyledEntityListItemWrapper=/#__PURE__/styled(StyledWrapperOffset,{target:"e10ll6944",label:"StyledEntityListItemWrapper"})(({theme,hideBorder})=>({width:"100%",...!hideBorder&&{borderBottom:`1px solid ${theme.values.color.border.secondary.default}`},...mqValue({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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 /");export const StyledEntityListItemButton=/#__PURE__/styled("div",{target:"e10ll6945",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},"&:focus":{outline:"none"},...isDisabled&&{cursor:"not-allowed",pointerEvents:"none",[`${StyledEntityListItemWrapper} > `]:{opacity:theme.variables.opacity.disabled}}}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
1	+ import styled from"@emotion/styled";import{mq,mqValue}from"../../shared/mediaQueries";export const getOffsetMqStyle=(cssProp,{theme,size})=>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}]});export const StyledList=styled("ul",{target:"e10ll6940",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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 /");export const StyledEntityItemLi=styled("li",{target:"e10ll6941",label:"StyledEntityItemLi"})({listStyleType:"none"},"/# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyIsInNvdXJjZXMiOlsic3JjL2NvbXBvbmVudHMvRW50aXR5TGlzdC9zdHlsZWQtY29tcG9uZW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvZXhwbGljaXQtbW9kdWxlLWJvdW5kYXJ5LXR5cGVzICovXG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IHR5cGUgVGhlbWUgfSBmcm9tIFwiQGVtb3Rpb24vcmVhY3RcIjtcbmltcG9ydCB0eXBlIHsgRW50aXR5TGlzdEl0ZW1Qcm9wcywgRW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHMgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHR5cGUgeyBMaXN0U2l6ZSB9IGZyb20gXCIuLi8uLi90eXBlc1wiO1xuaW1wb3J0IHsgbXEsIG1xVmFsdWUgfSBmcm9tIFwiLi4vLi4vc2hhcmVkL21lZGlhUXVlcmllc1wiO1xuXG5leHBvcnQgY29uc3QgZ2V0T2Zmc2V0TXFTdHlsZSA9IChcbiAgY3NzUHJvcDogc3RyaW5nLFxuICB7XG4gICAgdGhlbWUsXG4gICAgc2l6ZSxcbiAgfToge1xuICAgIHRoZW1lOiBUaGVtZTtcbiAgfSAmIFBhcnRpYWw8RW50aXR5TGlzdEl0ZW1XcmFwcGVyUHJvcHM+XG4pID0+XG4gIG1xKHtcbiAgICBbY3NzUHJvcF06IFtcbiAgICAgIHNpemUsXG4gICAgICB7XG4gICAgICAgIHhzOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLnh4cyxcbiAgICAgICAgczogdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5zLFxuICAgICAgICBtOiB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLm0sXG4gICAgICAgIGw6IHRoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcubCxcbiAgICAgIH0gYXMgYW55LFxuICAgIF0sXG4gIH0pO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkTGlzdCA9IHN0eWxlZC51bDx7IHNpemU6IExpc3RTaXplIH0+KCh7IHRoZW1lLCBzaXplIH0pID0+ICh7XG4gIC4uLihzaXplID09PSBcInhzXCIgJiYge1xuICAgIHBhZGRpbmc6IGAke3RoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHN9IDBgLFxuICB9KSxcbn0pKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEVudGl0eUl0ZW1MaSA9IHN0eWxlZC5saSh7XG4gIGxpc3RTdHlsZVR5cGU6IFwibm9uZVwiLFxufSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRTaG93TW9yZSA9IHN0eWxlZC5kaXYoKHsgdGhlbWUgfSkgPT4gKHtcbiAgbWFyZ2luVG9wOiAtMSxcbiAgYm9yZGVyVG9wOiBgMXB4IHNvbGlkICR7dGhlbWUudmFsdWVzLmNvbG9yLmJvcmRlci5zZWNvbmRhcnkuZGVmYXVsdH1gLFxufSkpO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkV3JhcHBlck9mZnNldCA9IHN0eWxlZC5kaXY8eyBzaXplOiBMaXN0U2l6ZSB9PihcbiAgKHsgdGhlbWUsIHNpemUgfSkgPT4gKHtcbiAgICAuLi5nZXRPZmZzZXRNcVN0eWxlKFwicGFkZGluZ0JvdHRvbVwiLCB7IHRoZW1lLCBzaXplIH0pLFxuICB9KSxcbiAgKHsgdGhlbWUsIHNpemUgfSkgPT4gKHtcbiAgICAuLi5nZXRPZmZzZXRNcVN0eWxlKFwicGFkZGluZ1RvcFwiLCB7IHRoZW1lLCBzaXplIH0pLFxuICB9KVxuKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEVudGl0eUxpc3RJdGVtV3JhcHBlciA9IHN0eWxlZChcbiAgU3R5bGVkV3JhcHBlck9mZnNldFxuKTxFbnRpdHlMaXN0SXRlbVdyYXBwZXJQcm9wcz4oKHsgdGhlbWUsIGhpZGVCb3JkZXIgfSkgPT4gKHtcbiAgd2lkdGg6IFwiMTAwJVwiLFxuXG4gIC4uLighaGlkZUJvcmRlciAmJiB7XG4gICAgYm9yZGVyQm90dG9tOiBgMXB4IHNvbGlkICR7dGhlbWUudmFsdWVzLmNvbG9yLmJvcmRlci5zZWNvbmRhcnkuZGVmYXVsdH1gLFxuICB9KSxcblxuICAuLi5tcVZhbHVlKHtcbiAgICBwYWRkaW5nTGVmdDogW1xuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5tLFxuICAgICAgdGhlbWUudmFyaWFibGVzLnNpemUuc3BhY2luZy5sLFxuICAgIF0sXG4gICAgcGFkZGluZ1JpZ2h0OiBbXG4gICAgICB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLm0sXG4gICAgICB0aGVtZS52YXJpYWJsZXMuc2l6ZS5zcGFjaW5nLmwsXG4gICAgXSxcbiAgfSksXG5cbiAgLy8gYnV0dG9uIGFuZCBsaW5rcyBoYXZlIGEgZ3JlYXRlZCBoZWlnaHQgdGhhbiBsaXN0IGl0ZW1cbiAgLy8gZnJvbSBkZXNpZ24gc3BlY3MgaXQgc2hvdWxkIG5vdCBleHBhbmQgdGhlIGxpc3QgaXRlbVxuICBcIiYgYnV0dG9uLCAmIGFcIjoge1xuICAgIG1hcmdpbjogYC0ke3RoZW1lLnZhcmlhYmxlcy5zaXplLnNwYWNpbmcueHhzfSAwYCxcbiAgfSxcbn0pKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEVudGl0eUxpc3RJdGVtQnV0dG9uID0gc3R5bGVkLmRpdjxcbiAgUGFydGlhbDxFbnRpdHlMaXN0SXRlbVByb3BzPlxuPigoeyB0aGVtZSwgaXNDbGlja2FibGUsIGlzQWN0aXZlLCBpc0Rpc2FibGVkIH0pID0+ICh7XG4gIGRpc3BsYXk6IFwiZmxleFwiLFxuICBmbGV4OiBcIjEgMSAxMDAlXCIsXG4gIGZsZXhXcmFwOiBcIm5vd3JhcFwiLFxuICB0cmFuc2l0aW9uOiBcImJhY2tncm91bmQtY29sb3IgMC4xcyBlYXNlLW91dFwiLFxuXG4gIC4uLihpc0NsaWNrYWJsZSAmJiB7XG4gICAgY3Vyc29yOiBcInBvaW50ZXJcIixcbiAgfSksXG5cbiAgXCImOmhvdmVyXCI6IHtcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IHRoZW1lLnZhbHVlcy5jb2xvci5iYWNrZ3JvdW5kLnRyYW5zcGFyZW50LmhvdmVyLFxuICB9LFxuXG4gIC4uLihpc0FjdGl2ZSAmJiB7XG4gICAgYmFja2dyb3VuZENvbG9yOiB0aGVtZS52YWx1ZXMuY29sb3IuYmFja2dyb3VuZC50cmFuc3BhcmVudC5hY3RpdmUsXG4gIH0pLFxuXG4gIFwiJjpmb2N1c1wiOiB7XG4gICAgb3V0bGluZTogXCJub25lXCIsXG4gIH0sXG5cbiAgLi4uKGlzRGlzYWJsZWQgJiYge1xuICAgIGN1cnNvcjogXCJub3QtYWxsb3dlZFwiLFxuICAgIHBvaW50ZXJFdmVudHM6IFwibm9uZVwiLFxuXG4gICAgW2Ake1N0eWxlZEVudGl0eUxpc3RJdGVtV3JhcHBlcn0gPiAqYF06IHtcbiAgICAgIG9wYWNpdHk6IHRoZW1lLnZhcmlhYmxlcy5vcGFjaXR5LmRpc2FibGVkLFxuICAgIH0sXG4gIH0pLFxufSkpO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWtDa0MifQ== /");export const StyledShowMore=styled("div",{target:"e10ll6942",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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 /");export const StyledWrapperOffset=styled("div",{target:"e10ll6943",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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 /");export const StyledEntityListItemWrapper=styled(StyledWrapperOffset,{target:"e10ll6944",label:"StyledEntityListItemWrapper"})(({theme,hideBorder})=>({width:"100%",...!hideBorder&&{borderBottom:`1px solid ${theme.values.color.border.secondary.default}`},...mqValue({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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 /");export const StyledEntityListItemButton=styled("div",{target:"e10ll6945",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},"&:focus":{outline:"none"},...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/esm/components/EntityTree/BaseEntityTree.js CHANGED Viewed

	@@ -1 +1 @@
1	- import React,{useMemo,useState,useEffect,useCallback}from"react";import{Button}from"../Button/Button";import{Box}from"../Box/Box";import{StyledList,StyledShowMore}from"../EntityList/styled-components";import{EntityTreeItem}from"./EntityTreeItem";import{useEntityTreeKeyboard}from"./useEntityTreeKeyboard";import{Text}from"../Typography/Text/Text";import{getNodeChildrenMap,getTreeCheckboxState,getVisibleActiveNodeId,getLeafNodeIds,filterTree,mapTree,trimDataByMaxSize}from"./tree";let flattenTree=(data,expandedIds,expadedAll)=>{let flattened=[];return data.forEach(node=>{flattened.push(node.id),(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]=useState(chunkSize),{result,hasMoreNodes}=useMemo(()=>trimDataByMaxSize(data,nodeExpandedState,expandAll,maxNodesCount),[data,nodeExpandedState,expandAll,maxNodesCount]);return{handleIncreaseMaxNodeCount:useCallback(()=>{setMaxNodesCount(prev=>prev+chunkSize)},[chunkSize]),result,hasMoreNodes}},Node=({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange,handleToggle,expandAll,hideBorder,size,showItemsCount,renderRightContent,activeId,focusedNodeId,changeFocusIndex,setFocusedNodeId,node,isFirstNode,level,renderFn,isLastNodeOfList,ariaLabelExpand,ariaLabelCollapse})=>{let readOnly=null===nodeCheckboxState,hasChildren=node.children.length>0,expandedState=!!expandAll\|\|!!nodeExpandedState[node.id],leafItems=getLeafNodeIds(nodeChildrenMap,node.id),totalItemsCount=leafItems.length,selectedItemsCount=nodeCheckboxState?leafItems.filter(leafId=>"checked"===nodeCheckboxState[leafId]).length:null,countLabel=nodeCheckboxState?`(${selectedItemsCount}/${totalItemsCount})`:`(${totalItemsCount})`,lastLeaf=!hasChildren&&!node.isFiltered,isExpanded=lastLeaf?void 0:expandedState,{ref:itemRef,setFakeKeybordFocus,isFocused}=useEntityTreeKeyboard({isActive:focusedNodeId===node.id,config:{ArrowUp:()=>{changeFocusIndex(-1)},ArrowDown:()=>{changeFocusIndex(1)},ArrowRight:()=>{hasChildren&&!isExpanded&&handleToggle(node.id)},ArrowLeft:()=>{hasChildren&&isExpanded&&handleToggle(node.id)}}}),handleClick=readOnly?()=>handleToggle(node.id):()=>handleSelectionChange(node.id),tabIndex=isFirstNode\|\|isFocused?0:-1;return ~~/#__PURE__/~~React.createElement(EntityTreeItem,{ref:itemRef,key:node.id,hideBorder:hideBorder\|\|isLastNodeOfList&&(!isExpanded\|\|node.isFiltered),tabIndex:tabIndex,size:size,lSpaceStep:level,onKeyDown:()=>handleClick(),description:node.description,renderLabel:({textSize})~~=>/#__PURE__/~~React.createElement(React.Fragment,null,node.label,showItemsCount&&!lastLeaf~~&&/#__PURE__/~~React.createElement(Text,{as:"span",size:textSize,color:"tertiary"}," ",countLabel)),isActive:isFocused\|\|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)},onFocus:()=>{setFocusedNodeId(node.id),setFakeKeybordFocus(!0)},onExpandClick:e=>{e.stopPropagation(),handleToggle(node.id)},isClickable:readOnly&&!renderRightContent,onClick:()=>handleToggle(node.id),renderRight:renderRightContent?sizeProps=>renderRightContent({...sizeProps,...node}):void 0,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse,"aria-label":node.label,"aria-level":level+1},hasChildren~~&&/#__PURE__/~~React.createElement("ul",{role:"group"},renderFn({data:node.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 ~~/#__PURE__/~~React.createElement(Node,{key:node.id,level:level,node:node,isFirstNode:isFirstNode,renderFn:renderFn,isLastNodeOfList:isLastNodeOfList,...renderTreeArgs})});export const BaseEntityTree=({ariaAttributes,data,selectedIds,onSelectionChange,expandedIds=[],onToggle,activeId,chunkSize=10,filterFn,onTreeChange,hideBorder=!1,size="m",showItemsCount=!0,showMoreButtonLabel,renderRightContent,"data-e2e-test-id":dataE2eTestId})=>{let nodeChildrenMap=Object.assign({},...data.map(tree=>getNodeChildrenMap(tree))),nodeCheckboxState=selectedIds?Object.assign({},...data.map(tree=>getTreeCheckboxState(nodeChildrenMap,tree.id,selectedIds))):null,nodeExpandedState=expandedIds.reduce((acc,id)=>(acc[id]=!0,acc),{}),visibleActiveNodeId=getVisibleActiveNodeId(nodeChildrenMap,nodeExpandedState,activeId),dataShown=filterFn?data.map(tree=>filterTree(tree,filterFn)).filter(Boolean):data;useEffect(()=>{onTreeChange&&onTreeChange(dataShown.map(tree=>mapTree(tree,node=>({...node,checkedState:!!nodeCheckboxState&&nodeCheckboxState[node.id],isExpanded:!!nodeExpandedState[node.id]}))))},[dataShown,nodeCheckboxState,nodeExpandedState,onTreeChange]);let expandAll=!!filterFn,[focusedNodeId,setFocusedNodeId]=useState(null),listRef=React.useRef(null),handleBlur=useCallback(()=>{setTimeout(()=>{listRef.current&&!listRef.current.contains(document.activeElement)&&setFocusedNodeId(null)},0)},[listRef,setFocusedNodeId]),{hasMoreNodes,handleIncreaseMaxNodeCount,result}=useTreeTruncation({chunkSize,data:dataShown,nodeExpandedState,expandAll}),renderTreeBranches=makeRenderTreeBranches({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange:targetId=>{if(onSelectionChange){let updatedSelectedIds=[];if(0===nodeChildrenMap[targetId].length)updatedSelectedIds=selectedIds.includes(targetId)?selectedIds.filter(id=>id!==targetId):selectedIds.concat([targetId]);else{let affectedLeafNodeIds=getLeafNodeIds(nodeChildrenMap,targetId);updatedSelectedIds="checked"===nodeCheckboxState[targetId]?selectedIds.filter(id=>!affectedLeafNodeIds.includes(id)):selectedIds.concat(affectedLeafNodeIds)}onSelectionChange(updatedSelectedIds)}},handleToggle:targetId=>{onToggle&&onToggle(expandedIds.includes(targetId)?expandedIds.filter(id=>id!==targetId):expandedIds.concat([targetId]))},expandAll,hideBorder,size,showItemsCount,renderRightContent,activeId:visibleActiveNodeId,focusedNodeId,changeFocusIndex:index=>{let flatTreeIds=flattenTree(dataShown,nodeExpandedState,expandAll),newIndex=index+flatTreeIds.indexOf(focusedNodeId);newIndex>=0&&newIndex<flatTreeIds.length&&setFocusedNodeId(flatTreeIds[newIndex])},setFocusedNodeId,ariaLabelExpand:ariaAttributes?.ariaLabelExpand,ariaLabelCollapse:ariaAttributes?.ariaLabelCollapse});return ~~/#__PURE__/~~React.createElement(StyledList,{ref:listRef,role:"tree","aria-multiselectable":!!nodeCheckboxState\|\|void 0,"data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityTree",size:size,onBlur:handleBlur},renderTreeBranches({data:result,level:0,renderFn:renderTreeBranches}),hasMoreNodes~~&&/#__PURE__/~~React.createElement(StyledShowMore,null~~,/#__PURE__/~~React.createElement(Box,{alignText:"center",space:"xs"}~~,/#__PURE__/~~React.createElement(Button,{fullWidth:!0,size:"s",variant:"tertiary",onClick:handleIncreaseMaxNodeCount},showMoreButtonLabel))))};
1	+ import React,{useMemo,useState,useEffect,useCallback}from"react";import{Button}from"../Button/Button";import{Box}from"../Box/Box";import{StyledList,StyledShowMore}from"../EntityList/styled-components";import{EntityTreeItem}from"./EntityTreeItem";import{useEntityTreeKeyboard}from"./useEntityTreeKeyboard";import{Text}from"../Typography/Text/Text";import{getNodeChildrenMap,getTreeCheckboxState,getVisibleActiveNodeId,getLeafNodeIds,filterTree,mapTree,trimDataByMaxSize}from"./tree";let flattenTree=(data,expandedIds,expadedAll)=>{let flattened=[];return data.forEach(node=>{flattened.push(node.id),(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]=useState(chunkSize),{result,hasMoreNodes}=useMemo(()=>trimDataByMaxSize(data,nodeExpandedState,expandAll,maxNodesCount),[data,nodeExpandedState,expandAll,maxNodesCount]);return{handleIncreaseMaxNodeCount:useCallback(()=>{setMaxNodesCount(prev=>prev+chunkSize)},[chunkSize]),result,hasMoreNodes}},Node=({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange,handleToggle,expandAll,hideBorder,size,showItemsCount,renderRightContent,activeId,focusedNodeId,changeFocusIndex,setFocusedNodeId,node,isFirstNode,level,renderFn,isLastNodeOfList,ariaLabelExpand,ariaLabelCollapse})=>{let readOnly=null===nodeCheckboxState,hasChildren=node.children.length>0,expandedState=!!expandAll\|\|!!nodeExpandedState[node.id],leafItems=getLeafNodeIds(nodeChildrenMap,node.id),totalItemsCount=leafItems.length,selectedItemsCount=nodeCheckboxState?leafItems.filter(leafId=>"checked"===nodeCheckboxState[leafId]).length:null,countLabel=nodeCheckboxState?`(${selectedItemsCount}/${totalItemsCount})`:`(${totalItemsCount})`,lastLeaf=!hasChildren&&!node.isFiltered,isExpanded=lastLeaf?void 0:expandedState,{ref:itemRef,setFakeKeybordFocus,isFocused}=useEntityTreeKeyboard({isActive:focusedNodeId===node.id,config:{ArrowUp:()=>{changeFocusIndex(-1)},ArrowDown:()=>{changeFocusIndex(1)},ArrowRight:()=>{hasChildren&&!isExpanded&&handleToggle(node.id)},ArrowLeft:()=>{hasChildren&&isExpanded&&handleToggle(node.id)}}}),handleClick=readOnly?()=>handleToggle(node.id):()=>handleSelectionChange(node.id),tabIndex=isFirstNode\|\|isFocused?0:-1;return React.createElement(EntityTreeItem,{ref:itemRef,key:node.id,hideBorder:hideBorder\|\|isLastNodeOfList&&(!isExpanded\|\|node.isFiltered),tabIndex:tabIndex,size:size,lSpaceStep:level,onKeyDown:()=>handleClick(),description:node.description,renderLabel:({textSize})=>React.createElement(React.Fragment,null,node.label,showItemsCount&&!lastLeaf&&React.createElement(Text,{as:"span",size:textSize,color:"tertiary"}," ",countLabel)),isActive:isFocused\|\|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)},onFocus:()=>{setFocusedNodeId(node.id),setFakeKeybordFocus(!0)},onExpandClick:e=>{e.stopPropagation(),handleToggle(node.id)},isClickable:readOnly&&!renderRightContent,onClick:()=>handleToggle(node.id),renderRight:renderRightContent?sizeProps=>renderRightContent({...sizeProps,...node}):void 0,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse,"aria-label":node.label,"aria-level":level+1},hasChildren&&React.createElement("ul",{role:"group"},renderFn({data:node.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.createElement(Node,{key:node.id,level:level,node:node,isFirstNode:isFirstNode,renderFn:renderFn,isLastNodeOfList:isLastNodeOfList,...renderTreeArgs})});export const BaseEntityTree=({ariaAttributes,data,selectedIds,onSelectionChange,expandedIds=[],onToggle,activeId,chunkSize=10,filterFn,onTreeChange,hideBorder=!1,size="m",showItemsCount=!0,showMoreButtonLabel,renderRightContent,"data-e2e-test-id":dataE2eTestId})=>{let nodeChildrenMap=Object.assign({},...data.map(tree=>getNodeChildrenMap(tree))),nodeCheckboxState=selectedIds?Object.assign({},...data.map(tree=>getTreeCheckboxState(nodeChildrenMap,tree.id,selectedIds))):null,nodeExpandedState=expandedIds.reduce((acc,id)=>(acc[id]=!0,acc),{}),visibleActiveNodeId=getVisibleActiveNodeId(nodeChildrenMap,nodeExpandedState,activeId),dataShown=filterFn?data.map(tree=>filterTree(tree,filterFn)).filter(Boolean):data;useEffect(()=>{onTreeChange&&onTreeChange(dataShown.map(tree=>mapTree(tree,node=>({...node,checkedState:!!nodeCheckboxState&&nodeCheckboxState[node.id],isExpanded:!!nodeExpandedState[node.id]}))))},[dataShown,nodeCheckboxState,nodeExpandedState,onTreeChange]);let expandAll=!!filterFn,[focusedNodeId,setFocusedNodeId]=useState(null),listRef=React.useRef(null),handleBlur=useCallback(()=>{setTimeout(()=>{listRef.current&&!listRef.current.contains(document.activeElement)&&setFocusedNodeId(null)},0)},[listRef,setFocusedNodeId]),{hasMoreNodes,handleIncreaseMaxNodeCount,result}=useTreeTruncation({chunkSize,data:dataShown,nodeExpandedState,expandAll}),renderTreeBranches=makeRenderTreeBranches({nodeChildrenMap,nodeCheckboxState,nodeExpandedState,handleSelectionChange:targetId=>{if(onSelectionChange){let updatedSelectedIds=[];if(0===nodeChildrenMap[targetId].length)updatedSelectedIds=selectedIds.includes(targetId)?selectedIds.filter(id=>id!==targetId):selectedIds.concat([targetId]);else{let affectedLeafNodeIds=getLeafNodeIds(nodeChildrenMap,targetId);updatedSelectedIds="checked"===nodeCheckboxState[targetId]?selectedIds.filter(id=>!affectedLeafNodeIds.includes(id)):selectedIds.concat(affectedLeafNodeIds)}onSelectionChange(updatedSelectedIds)}},handleToggle:targetId=>{onToggle&&onToggle(expandedIds.includes(targetId)?expandedIds.filter(id=>id!==targetId):expandedIds.concat([targetId]))},expandAll,hideBorder,size,showItemsCount,renderRightContent,activeId:visibleActiveNodeId,focusedNodeId,changeFocusIndex:index=>{let flatTreeIds=flattenTree(dataShown,nodeExpandedState,expandAll),newIndex=index+flatTreeIds.indexOf(focusedNodeId);newIndex>=0&&newIndex<flatTreeIds.length&&setFocusedNodeId(flatTreeIds[newIndex])},setFocusedNodeId,ariaLabelExpand:ariaAttributes?.ariaLabelExpand,ariaLabelCollapse:ariaAttributes?.ariaLabelCollapse});return React.createElement(StyledList,{ref:listRef,role:"tree","aria-multiselectable":!!nodeCheckboxState\|\|void 0,"data-e2e-test-id":dataE2eTestId,"data-ds-id":"EntityTree",size:size,onBlur:handleBlur},renderTreeBranches({data:result,level:0,renderFn:renderTreeBranches}),hasMoreNodes&&React.createElement(StyledShowMore,null,React.createElement(Box,{alignText:"center",space:"xs"},React.createElement(Button,{fullWidth:!0,size:"s",variant:"tertiary",onClick:handleIncreaseMaxNodeCount},showMoreButtonLabel))))};

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

	@@ -1 +1 @@
1	- import React from"react";import{BaseEntityTree}from"./BaseEntityTree";import{Container}from"../Container/Container";export const EntityTree=props~~=>/#__PURE__/~~React.createElement(Container,{overflow:"hidden"}~~,/#__PURE__/~~React.createElement(BaseEntityTree,props));
1	+ import React from"react";import{BaseEntityTree}from"./BaseEntityTree";import{Container}from"../Container/Container";export const EntityTree=props=>React.createElement(Container,{overflow:"hidden"},React.createElement(BaseEntityTree,props));

package/build/esm/components/EntityTree/EntityTreeItem.js CHANGED Viewed

	@@ -1 +1 @@
1	- import React,{useCallback,useImperativeHandle,useRef}from"react";import styled from"@emotion/styled";import{mqValue}from"../../shared/mediaQueries";import{EntityTreeItemExpandButton}from"./EntityTreeItemExpandButton";import{useKeyboard}from"../../shared/useKeyboard";import{EntityItemBody}from"../EntityList/EntityItemBody";import{StyledEntityItemLi,StyledEntityListItemWrapper,StyledEntityListItemButton}from"../EntityList/styled-components";let StyledEntityTreeItemWrapper=/#__PURE__/styled(StyledEntityListItemWrapper,{target:"eeonynx0",label:"StyledEntityTreeItemWrapper"})({paddingLeft:"0 !important"},"/# sourceMappingURL=data:application/json;charset=utf-8;base64,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 /"),StyledEntityTreeItemContainer=/#__PURE__/styled(StyledEntityListItemButton,{target:"eeonynx1",label:"StyledEntityTreeItemContainer"})(({theme,hasExpandableIcon,lSpaceStep})=>{let getSize=(baseOffset,deepestNodeOffset)=>`calc(${baseOffset} * ${lSpaceStep} + ${hasExpandableIcon?"0px":deepestNodeOffset} + ${theme.variables.size.spacing.xxs})`;return{...mqValue({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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 /"),useButtonKeyboard=({ref:globalRef,isActive,onKeyDown})=>{let localRef=useRef(null);return useKeyboard({"Space Enter":onKeyDown},localRef,isActive,!0),useImperativeHandle(globalRef,()=>localRef.current),localRef};export const EntityTreeItem=/#__PURE__/React.forwardRef(({checkboxProps,children,description,hideBorder,isActive,isClickable,isDisabled,isDisabledExpand,isExpanded,lSpaceStep,onClick,onExpandClick,onFocus,onKeyDown,renderLabel,renderLeft,renderRight,size="m",tabIndex,ariaLabelExpand,ariaLabelCollapse,"aria-level":ariaLevel,"aria-label":ariaLabel},ref)=>{let hasExpandableIcon=void 0!==isExpanded,handleOnClick=useCallback(e=>{isClickable&&onClick&&onClick(e)},[onClick,isClickable]),buttonRef=useButtonKeyboard({ref,isActive:isActive&&(isClickable\|\|!!checkboxProps),onKeyDown});return /#__PURE__/React.createElement(StyledEntityItemLi,{role:"treeitem","aria-expanded":hasExpandableIcon?isExpanded:void 0,"aria-checked":checkboxProps?.checked,"aria-label":ariaLabel,"aria-level":ariaLevel},/#__PURE__/React.createElement(StyledEntityTreeItemContainer,{size:size,tabIndex:tabIndex,role:"presentation",isActive:isActive,ref:buttonRef,hasExpandableIcon:hasExpandableIcon,lSpaceStep:lSpaceStep,isDisabled:isDisabled,onFocus:onFocus,onClick:handleOnClick,isClickable:isClickable},hasExpandableIcon&&/#__PURE__/React.createElement(EntityTreeItemExpandButton,{size:size,tabIndex:tabIndex,isDisabled:isDisabledExpand\|\|isDisabled,isExpanded:isExpanded,onClick:onExpandClick,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse}),/#__PURE__/React.createElement(StyledEntityTreeItemWrapper,{size:size,hideBorder:hideBorder\|\|"xs"===size},/#__PURE__/React.createElement(EntityItemBody,{size:size,tabIndex:tabIndex,description:description,renderLabel:renderLabel,renderLeft:renderLeft,renderRight:renderRight,checkboxProps:checkboxProps}))),isExpanded&&children)});
1	+ import React,{useCallback,useImperativeHandle,useRef}from"react";import styled from"@emotion/styled";import{mqValue}from"../../shared/mediaQueries";import{EntityTreeItemExpandButton}from"./EntityTreeItemExpandButton";import{useKeyboard}from"../../shared/useKeyboard";import{EntityItemBody}from"../EntityList/EntityItemBody";import{StyledEntityItemLi,StyledEntityListItemWrapper,StyledEntityListItemButton}from"../EntityList/styled-components";let StyledEntityTreeItemWrapper=styled(StyledEntityListItemWrapper,{target:"eeonynx0",label:"StyledEntityTreeItemWrapper"})({paddingLeft:"0 !important"},"/# sourceMappingURL=data:application/json;charset=utf-8;base64,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 /"),StyledEntityTreeItemContainer=styled(StyledEntityListItemButton,{target:"eeonynx1",label:"StyledEntityTreeItemContainer"})(({theme,hasExpandableIcon,lSpaceStep})=>{let getSize=(baseOffset,deepestNodeOffset)=>`calc(${baseOffset} * ${lSpaceStep} + ${hasExpandableIcon?"0px":deepestNodeOffset} + ${theme.variables.size.spacing.xxs})`;return{...mqValue({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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 /"),useButtonKeyboard=({ref:globalRef,isActive,onKeyDown})=>{let localRef=useRef(null);return useKeyboard({"Space Enter":onKeyDown},localRef,isActive,!0),useImperativeHandle(globalRef,()=>localRef.current),localRef};export const EntityTreeItem=React.forwardRef(({checkboxProps,children,description,hideBorder,isActive,isClickable,isDisabled,isDisabledExpand,isExpanded,lSpaceStep,onClick,onExpandClick,onFocus,onKeyDown,renderLabel,renderLeft,renderRight,size="m",tabIndex,ariaLabelExpand,ariaLabelCollapse,"aria-level":ariaLevel,"aria-label":ariaLabel},ref)=>{let hasExpandableIcon=void 0!==isExpanded,handleOnClick=useCallback(e=>{isClickable&&onClick&&onClick(e)},[onClick,isClickable]),buttonRef=useButtonKeyboard({ref,isActive:isActive&&(isClickable\|\|!!checkboxProps),onKeyDown});return React.createElement(StyledEntityItemLi,{role:"treeitem","aria-expanded":hasExpandableIcon?isExpanded:void 0,"aria-checked":checkboxProps?.checked,"aria-label":ariaLabel,"aria-level":ariaLevel},React.createElement(StyledEntityTreeItemContainer,{size:size,tabIndex:tabIndex,role:"presentation",isActive:isActive,ref:buttonRef,hasExpandableIcon:hasExpandableIcon,lSpaceStep:lSpaceStep,isDisabled:isDisabled,onFocus:onFocus,onClick:handleOnClick,isClickable:isClickable},hasExpandableIcon&&React.createElement(EntityTreeItemExpandButton,{size:size,tabIndex:tabIndex,isDisabled:isDisabledExpand\|\|isDisabled,isExpanded:isExpanded,onClick:onExpandClick,ariaLabelExpand:ariaLabelExpand,ariaLabelCollapse:ariaLabelCollapse}),React.createElement(StyledEntityTreeItemWrapper,{size:size,hideBorder:hideBorder\|\|"xs"===size},React.createElement(EntityItemBody,{size:size,tabIndex:tabIndex,description:description,renderLabel:renderLabel,renderLeft:renderLeft,renderRight:renderRight,checkboxProps:checkboxProps}))),isExpanded&&children)});

package/build/esm/components/EntityTree/EntityTreeItemExpandButton.js CHANGED Viewed

	@@ -1 +1 @@
1	- import React from"react";import{PictogramButton}from"../PictogramButton/PictogramButton";import{Box}from"../Box/Box";import{StyledWrapperOffset}from"../EntityList/styled-components";export function EntityTreeItemExpandButton({size,onClick,isExpanded,isDisabled,ariaLabelExpand,ariaLabelCollapse}){return ~~/#__PURE__/~~React.createElement(Box,{vSpace:"zero",space:["xs","m"]}~~,/#__PURE__/~~React.createElement(StyledWrapperOffset,{size:size}~~,/#__PURE__/~~React.createElement(PictogramButton,{disabled:isDisabled,onClick:onClick,icon:isExpanded?"chevron-down":"chevron-right","aria-label":isExpanded?ariaLabelExpand:ariaLabelCollapse,"aria-expanded":isExpanded})))}
1	+ import React from"react";import{PictogramButton}from"../PictogramButton/PictogramButton";import{Box}from"../Box/Box";import{StyledWrapperOffset}from"../EntityList/styled-components";export function EntityTreeItemExpandButton({size,onClick,isExpanded,isDisabled,ariaLabelExpand,ariaLabelCollapse}){return React.createElement(Box,{vSpace:"zero",space:["xs","m"]},React.createElement(StyledWrapperOffset,{size:size},React.createElement(PictogramButton,{disabled:isDisabled,onClick:onClick,icon:isExpanded?"chevron-down":"chevron-right","aria-label":isExpanded?ariaLabelExpand:ariaLabelCollapse,"aria-expanded":isExpanded})))}

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

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

package/build/esm/components/Form/Checkbox/Checkbox.d.ts CHANGED Viewed

@@ -1,21 +1,12 @@
+import type { InputHTMLAttributes } from "react";
 import React from "react";
 import type { FormFieldProps } from "../FormField/FormField";
+type CheckboxSizes = "s" | "m";
 export type CheckboxProps = {
-    "aria-labelledby"?: string;
-    name: string;
-    value?: string;
-    checked?: boolean | undefined;
     label?: string | React.ComponentType;
-    labelHint?: string;
-    disabled?: boolean;
     indeterminate?: boolean;
-    size?: "s" | "m";
-    tabIndex?: number;
-    onChange?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onClick?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;
-} & Omit<FormFieldProps, "labelHint">;
+    size?: CheckboxSizes;
+} & Omit<FormFieldProps, "hideLabel"> & Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type">;
 export declare const StyledCheckboxContainer: import("@emotion/styled").StyledComponent<{
     theme?: import("@emotion/react").Theme;
     as?: React.ElementType;
@@ -23,34 +14,15 @@ export declare const StyledCheckboxContainer: import("@emotion/styled").StyledCo
     disabled: boolean;
 }, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 export declare const CheckboxRaw: React.ForwardRefExoticComponent<{
-    "aria-labelledby"?: string;
-    name: string;
-    value?: string;
-    checked?: boolean | undefined;
     label?: string | React.ComponentType;
-    labelHint?: string;
-    disabled?: boolean;
     indeterminate?: boolean;
-    size?: "s" | "m";
-    tabIndex?: number;
-    onChange?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onClick?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;
-} & Omit<FormFieldProps, "labelHint"> & React.RefAttributes<HTMLInputElement>>;
+    size?: CheckboxSizes;
+} & Omit<FormFieldProps, "hideLabel"> & Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
+    labelSize?: CheckboxSizes;
+} & React.RefAttributes<HTMLInputElement>>;
 export declare const Checkbox: React.ForwardRefExoticComponent<{
-    "aria-labelledby"?: string;
-    name: string;
-    value?: string;
-    checked?: boolean | undefined;
     label?: string | React.ComponentType;
-    labelHint?: string;
-    disabled?: boolean;
     indeterminate?: boolean;
-    size?: "s" | "m";
-    tabIndex?: number;
-    onChange?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onClick?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;
-    onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;
-} & Omit<FormFieldProps, "labelHint"> & React.RefAttributes<HTMLInputElement>>;
+    size?: CheckboxSizes;
+} & Omit<FormFieldProps, "hideLabel"> & Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & React.RefAttributes<HTMLInputElement>>;
+export {};

package/build/esm/components/Form/Checkbox/Checkbox.js CHANGED Viewed

	@@ -1 +1 @@
1	- import React,{useRef,useLayoutEffect}from"react";import styled from"@emotion/styled";import{FormField}from"../FormField/FormField";import{Inline}from"../../Inline/Inline";import{Text}from"../../Typography/Text/Text";import{Icon}from"../../Icon/Icon";let StyledInputContainer=/#__PURE__/styled("div",{target:"eumwhjw0",label:"StyledInputContainer"})(({theme,size})=>({userSelect:"none",display:"block",position:"relative",width:theme.variables.size.dimension.checkbox[size],height:theme.variables.size.dimension.checkbox[size],boxSizing:"border-box"}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\n\nexport type CheckboxProps = {\n  \"aria-labelledby\"?: string;\n  name: string;\n  value?: string;\n  checked?: boolean | undefined;\n  label?: string | React.ComponentType;\n  labelHint?: string;\n  disabled?: boolean;\n  indeterminate?: boolean;\n  size?: \"s\" | \"m\";\n  tabIndex?: number;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onClick?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;\n} & Omit<FormFieldProps, \"labelHint\">;\n\ntype CheckboxSizes = Pick<CheckboxProps, \"size\">;\n\nconst StyledInputContainer = styled.div<CheckboxSizes>(({ theme, size }) => ({\n  userSelect: \"none\",\n  display: \"block\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  boxSizing: \"border-box\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<CheckboxSizes>(({ theme, size }) => ({\n  boxSizing: \"border-box\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  borderRadius: theme.variables.size.borderRadius.xs,\n  border: \"2px solid\",\n  position: \"absolute\",\n  top: size === \"s\" ? theme.variables.size.spacing.xxs : 0,\n  left: 0,\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"center\",\n  cursor: \"pointer\",\n\n  background: theme.values.color.background.primary.default,\n  color: theme.values.color.text.onAccent.default,\n  borderColor: theme.values.color.border.primary.default,\n  lineHeight: 0,\n  \"& svg\": {\n    opacity: theme.variables.opacity.hidden,\n  },\n\n  \"input: focus-visible + &\": {\n    outlineWidth: \"2px\",\n    outlineStyle: \"solid\",\n    outlineColor: \"Highlight\",\n  },\n\n  \"@media (-webkit-min-device-pixel-ratio:0)\": {\n    \"input: focus-visible + &\": {\n      outlineColor: \"-webkit-focus-ring-color\",\n      outlineStyle: \"auto\",\n    },\n  },\n\n  \"input:checked + &, input:indeterminate + &\": {\n    border: 0,\n    background: theme.values.color.background.accent.default,\n\n    svg: {\n      opacity: theme.variables.opacity.visible,\n    },\n  },\n\n  \"input:disabled + &\": {\n    pointerEvents: \"none\",\n  },\n}));\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      label = \"\",\n      labelHint = \"\",\n      disabled = false,\n      indeterminate,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer size={size}>\n            <StyledRealInput\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              aria-labelledby={ariaLabelledby}\n              type=\"checkbox\"\n              name={name}\n              value={value}\n              checked={checked}\n              disabled={disabled}\n              onChange={onChange}\n              onClick={onClick}\n              onBlur={onBlur}\n              onFocus={onFocus}\n              tabIndex={tabIndex}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? <Text>{label}</Text> : label}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      indeterminate,\n      label,\n      labelHint,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      disabled,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => (\n    <FormField\n      data-ds-id=\"Checkbox\"\n      disabled={disabled}\n      {...(rest as FormFieldProps)}\n    >\n      <CheckboxRaw\n        ref={ref}\n        name={name}\n        value={value}\n        checked={checked}\n        indeterminate={indeterminate}\n        size={size}\n        onChange={onChange}\n        onBlur={onBlur}\n        onClick={onClick}\n        onFocus={onFocus}\n        label={label}\n        labelHint={labelHint}\n        disabled={disabled}\n        tabIndex={tabIndex}\n        aria-labelledby={ariaLabelledby}\n      />\n    </FormField>\n  )\n);\n"],"names":[],"mappings":"AA6B6B"} /"),StyledRealInput=/#__PURE__/styled("input",{target:"eumwhjw1",label:"StyledRealInput"})(({theme})=>({opacity:theme.variables.opacity.hidden,cursor:"pointer",height:0,width:0,position:"absolute"}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\n\nexport type CheckboxProps = {\n  \"aria-labelledby\"?: string;\n  name: string;\n  value?: string;\n  checked?: boolean | undefined;\n  label?: string | React.ComponentType;\n  labelHint?: string;\n  disabled?: boolean;\n  indeterminate?: boolean;\n  size?: \"s\" | \"m\";\n  tabIndex?: number;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onClick?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;\n} & Omit<FormFieldProps, \"labelHint\">;\n\ntype CheckboxSizes = Pick<CheckboxProps, \"size\">;\n\nconst StyledInputContainer = styled.div<CheckboxSizes>(({ theme, size }) => ({\n  userSelect: \"none\",\n  display: \"block\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  boxSizing: \"border-box\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<CheckboxSizes>(({ theme, size }) => ({\n  boxSizing: \"border-box\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  borderRadius: theme.variables.size.borderRadius.xs,\n  border: \"2px solid\",\n  position: \"absolute\",\n  top: size === \"s\" ? theme.variables.size.spacing.xxs : 0,\n  left: 0,\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"center\",\n  cursor: \"pointer\",\n\n  background: theme.values.color.background.primary.default,\n  color: theme.values.color.text.onAccent.default,\n  borderColor: theme.values.color.border.primary.default,\n  lineHeight: 0,\n  \"& svg\": {\n    opacity: theme.variables.opacity.hidden,\n  },\n\n  \"input: focus-visible + &\": {\n    outlineWidth: \"2px\",\n    outlineStyle: \"solid\",\n    outlineColor: \"Highlight\",\n  },\n\n  \"@media (-webkit-min-device-pixel-ratio:0)\": {\n    \"input: focus-visible + &\": {\n      outlineColor: \"-webkit-focus-ring-color\",\n      outlineStyle: \"auto\",\n    },\n  },\n\n  \"input:checked + &, input:indeterminate + &\": {\n    border: 0,\n    background: theme.values.color.background.accent.default,\n\n    svg: {\n      opacity: theme.variables.opacity.visible,\n    },\n  },\n\n  \"input:disabled + &\": {\n    pointerEvents: \"none\",\n  },\n}));\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      label = \"\",\n      labelHint = \"\",\n      disabled = false,\n      indeterminate,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer size={size}>\n            <StyledRealInput\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              aria-labelledby={ariaLabelledby}\n              type=\"checkbox\"\n              name={name}\n              value={value}\n              checked={checked}\n              disabled={disabled}\n              onChange={onChange}\n              onClick={onClick}\n              onBlur={onBlur}\n              onFocus={onFocus}\n              tabIndex={tabIndex}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? <Text>{label}</Text> : label}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      indeterminate,\n      label,\n      labelHint,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      disabled,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => (\n    <FormField\n      data-ds-id=\"Checkbox\"\n      disabled={disabled}\n      {...(rest as FormFieldProps)}\n    >\n      <CheckboxRaw\n        ref={ref}\n        name={name}\n        value={value}\n        checked={checked}\n        indeterminate={indeterminate}\n        size={size}\n        onChange={onChange}\n        onBlur={onBlur}\n        onClick={onClick}\n        onFocus={onFocus}\n        label={label}\n        labelHint={labelHint}\n        disabled={disabled}\n        tabIndex={tabIndex}\n        aria-labelledby={ariaLabelledby}\n      />\n    </FormField>\n  )\n);\n"],"names":[],"mappings":"AAsCwB"} /"),StyledFakeInput=/#__PURE__/styled("span",{target:"eumwhjw2",label:"StyledFakeInput"})(({theme,size})=>({boxSizing:"border-box",width:theme.variables.size.dimension.checkbox[size],height:theme.variables.size.dimension.checkbox[size],borderRadius:theme.variables.size.borderRadius.xs,border:"2px solid",position:"absolute",top:"s"===size?theme.variables.size.spacing.xxs:0,left:0,display:"flex",alignItems:"center",justifyContent:"center",cursor:"pointer",background:theme.values.color.background.primary.default,color:theme.values.color.text.onAccent.default,borderColor:theme.values.color.border.primary.default,lineHeight:0,"& svg":{opacity:theme.variables.opacity.hidden},"input: focus-visible + &":{outlineWidth:"2px",outlineStyle:"solid",outlineColor:"Highlight"},"@media (-webkit-min-device-pixel-ratio:0)":{"input: focus-visible + &":{outlineColor:"-webkit-focus-ring-color",outlineStyle:"auto"}},"input:checked + &, input:indeterminate + &":{border:0,background:theme.values.color.background.accent.default,svg:{opacity:theme.variables.opacity.visible}},"input:disabled + &":{pointerEvents:"none"}}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\n\nexport type CheckboxProps = {\n  \"aria-labelledby\"?: string;\n  name: string;\n  value?: string;\n  checked?: boolean | undefined;\n  label?: string | React.ComponentType;\n  labelHint?: string;\n  disabled?: boolean;\n  indeterminate?: boolean;\n  size?: \"s\" | \"m\";\n  tabIndex?: number;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onClick?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;\n} & Omit<FormFieldProps, \"labelHint\">;\n\ntype CheckboxSizes = Pick<CheckboxProps, \"size\">;\n\nconst StyledInputContainer = styled.div<CheckboxSizes>(({ theme, size }) => ({\n  userSelect: \"none\",\n  display: \"block\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  boxSizing: \"border-box\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<CheckboxSizes>(({ theme, size }) => ({\n  boxSizing: \"border-box\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  borderRadius: theme.variables.size.borderRadius.xs,\n  border: \"2px solid\",\n  position: \"absolute\",\n  top: size === \"s\" ? theme.variables.size.spacing.xxs : 0,\n  left: 0,\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"center\",\n  cursor: \"pointer\",\n\n  background: theme.values.color.background.primary.default,\n  color: theme.values.color.text.onAccent.default,\n  borderColor: theme.values.color.border.primary.default,\n  lineHeight: 0,\n  \"& svg\": {\n    opacity: theme.variables.opacity.hidden,\n  },\n\n  \"input: focus-visible + &\": {\n    outlineWidth: \"2px\",\n    outlineStyle: \"solid\",\n    outlineColor: \"Highlight\",\n  },\n\n  \"@media (-webkit-min-device-pixel-ratio:0)\": {\n    \"input: focus-visible + &\": {\n      outlineColor: \"-webkit-focus-ring-color\",\n      outlineStyle: \"auto\",\n    },\n  },\n\n  \"input:checked + &, input:indeterminate + &\": {\n    border: 0,\n    background: theme.values.color.background.accent.default,\n\n    svg: {\n      opacity: theme.variables.opacity.visible,\n    },\n  },\n\n  \"input:disabled + &\": {\n    pointerEvents: \"none\",\n  },\n}));\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      label = \"\",\n      labelHint = \"\",\n      disabled = false,\n      indeterminate,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer size={size}>\n            <StyledRealInput\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              aria-labelledby={ariaLabelledby}\n              type=\"checkbox\"\n              name={name}\n              value={value}\n              checked={checked}\n              disabled={disabled}\n              onChange={onChange}\n              onClick={onClick}\n              onBlur={onBlur}\n              onFocus={onFocus}\n              tabIndex={tabIndex}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? <Text>{label}</Text> : label}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      indeterminate,\n      label,\n      labelHint,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      disabled,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => (\n    <FormField\n      data-ds-id=\"Checkbox\"\n      disabled={disabled}\n      {...(rest as FormFieldProps)}\n    >\n      <CheckboxRaw\n        ref={ref}\n        name={name}\n        value={value}\n        checked={checked}\n        indeterminate={indeterminate}\n        size={size}\n        onChange={onChange}\n        onBlur={onBlur}\n        onClick={onClick}\n        onFocus={onFocus}\n        label={label}\n        labelHint={labelHint}\n        disabled={disabled}\n        tabIndex={tabIndex}\n        aria-labelledby={ariaLabelledby}\n      />\n    </FormField>\n  )\n);\n"],"names":[],"mappings":"AA8CwB"} /");export const StyledCheckboxContainer=/#__PURE__/styled("div",{target:"eumwhjw3",label:"StyledCheckboxContainer"})(({theme,disabled})=>({"&:hover":{cursor:disabled?"not-allowed":"pointer",...!disabled&&{[`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:{background:theme.values.color.background.accent.hover}}},...!disabled&&{[`&:hover ${StyledFakeInput}`]:{borderColor:theme.values.color.border.primary.hover}}}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\n\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\n\nexport type CheckboxProps = {\n  \"aria-labelledby\"?: string;\n  name: string;\n  value?: string;\n  checked?: boolean | undefined;\n  label?: string | React.ComponentType;\n  labelHint?: string;\n  disabled?: boolean;\n  indeterminate?: boolean;\n  size?: \"s\" | \"m\";\n  tabIndex?: number;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onClick?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onBlur?: (e: React.FormEvent<HTMLInputElement>) => void;\n  onFocus?: (e: React.FormEvent<HTMLInputElement>) => void;\n} & Omit<FormFieldProps, \"labelHint\">;\n\ntype CheckboxSizes = Pick<CheckboxProps, \"size\">;\n\nconst StyledInputContainer = styled.div<CheckboxSizes>(({ theme, size }) => ({\n  userSelect: \"none\",\n  display: \"block\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  boxSizing: \"border-box\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<CheckboxSizes>(({ theme, size }) => ({\n  boxSizing: \"border-box\",\n  width: theme.variables.size.dimension.checkbox[size],\n  height: theme.variables.size.dimension.checkbox[size],\n  borderRadius: theme.variables.size.borderRadius.xs,\n  border: \"2px solid\",\n  position: \"absolute\",\n  top: size === \"s\" ? theme.variables.size.spacing.xxs : 0,\n  left: 0,\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"center\",\n  cursor: \"pointer\",\n\n  background: theme.values.color.background.primary.default,\n  color: theme.values.color.text.onAccent.default,\n  borderColor: theme.values.color.border.primary.default,\n  lineHeight: 0,\n  \"& svg\": {\n    opacity: theme.variables.opacity.hidden,\n  },\n\n  \"input: focus-visible + &\": {\n    outlineWidth: \"2px\",\n    outlineStyle: \"solid\",\n    outlineColor: \"Highlight\",\n  },\n\n  \"@media (-webkit-min-device-pixel-ratio:0)\": {\n    \"input: focus-visible + &\": {\n      outlineColor: \"-webkit-focus-ring-color\",\n      outlineStyle: \"auto\",\n    },\n  },\n\n  \"input:checked + &, input:indeterminate + &\": {\n    border: 0,\n    background: theme.values.color.background.accent.default,\n\n    svg: {\n      opacity: theme.variables.opacity.visible,\n    },\n  },\n\n  \"input:disabled + &\": {\n    pointerEvents: \"none\",\n  },\n}));\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      label = \"\",\n      labelHint = \"\",\n      disabled = false,\n      indeterminate,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer size={size}>\n            <StyledRealInput\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              aria-labelledby={ariaLabelledby}\n              type=\"checkbox\"\n              name={name}\n              value={value}\n              checked={checked}\n              disabled={disabled}\n              onChange={onChange}\n              onClick={onClick}\n              onBlur={onBlur}\n              onFocus={onFocus}\n              tabIndex={tabIndex}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? <Text>{label}</Text> : label}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      name,\n      value = \"\",\n      checked = undefined,\n      indeterminate,\n      label,\n      labelHint,\n      size = \"m\",\n      onChange,\n      onClick,\n      onBlur,\n      onFocus,\n      disabled,\n      tabIndex,\n      \"aria-labelledby\": ariaLabelledby,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => (\n    <FormField\n      data-ds-id=\"Checkbox\"\n      disabled={disabled}\n      {...(rest as FormFieldProps)}\n    >\n      <CheckboxRaw\n        ref={ref}\n        name={name}\n        value={value}\n        checked={checked}\n        indeterminate={indeterminate}\n        size={size}\n        onChange={onChange}\n        onBlur={onBlur}\n        onClick={onClick}\n        onFocus={onFocus}\n        label={label}\n        labelHint={labelHint}\n        disabled={disabled}\n        tabIndex={tabIndex}\n        aria-labelledby={ariaLabelledby}\n      />\n    </FormField>\n  )\n);\n"],"names":[],"mappings":"AA+FuC"} /");export const CheckboxRaw=/#__PURE__/React.forwardRef(({name,value="",checked,label="",labelHint="",disabled=!1,indeterminate,size="m",onChange,onClick,onBlur,onFocus,tabIndex,"aria-labelledby":ariaLabelledby},ref)=>{let internalRef=useRef(null),inputRef=internalRef\|\|ref;return useLayoutEffect(()=>{inputRef.current&&(internalRef.current.indeterminate=indeterminate)},[indeterminate,inputRef]),/#__PURE__/React.createElement(StyledCheckboxContainer,{disabled:disabled},/#__PURE__/React.createElement(Inline,{space:"xs",vAlignItems:"top",noWrap:!0},/#__PURE__/React.createElement(StyledInputContainer,{size:size},/#__PURE__/React.createElement(StyledRealInput,{ref:inputRef,"aria-checked":indeterminate?"mixed":checked,"aria-labelledby":ariaLabelledby,type:"checkbox",name:name,value:value,checked:checked,disabled:disabled,onChange:onChange,onClick:onClick,onBlur:onBlur,onFocus:onFocus,tabIndex:tabIndex}),/#__PURE__/React.createElement(StyledFakeInput,{size:size},indeterminate?/#__PURE__/React.createElement(Icon,{size:"s",name:"minus"}):/#__PURE__/React.createElement(Icon,{size:"s",name:"m"===size?"check":"check-small"}))),label&&/#__PURE__/React.createElement("div",null,"string"==typeof label?/#__PURE__/React.createElement(Text,null,label):label,labelHint&&/#__PURE__/React.createElement(Text,{color:"tertiary",size:"s"},labelHint))))});export const Checkbox=/#__PURE__/React.forwardRef(({name,value="",checked,indeterminate,label,labelHint,size="m",onChange,onClick,onBlur,onFocus,disabled,tabIndex,"aria-labelledby":ariaLabelledby,...rest},ref)=>/#__PURE__/React.createElement(FormField,{"data-ds-id":"Checkbox",disabled:disabled,...rest},/#__PURE__/React.createElement(CheckboxRaw,{ref:ref,name:name,value:value,checked:checked,indeterminate:indeterminate,size:size,onChange:onChange,onBlur:onBlur,onClick:onClick,onFocus:onFocus,label:label,labelHint:labelHint,disabled:disabled,tabIndex:tabIndex,"aria-labelledby":ariaLabelledby})));
1	+ import React,{useRef,useLayoutEffect}from"react";import styled from"@emotion/styled";import{FormField}from"../FormField/FormField";import{Inline}from"../../Inline/Inline";import{Text,getTextLineHeight}from"../../Typography/Text/Text";import{Icon}from"../../Icon/Icon";import{useFormFieldMessageId}from"../FormField/useFormFieldMessageId";let StyledInputContainer=styled("div",{target:"e1qcxs5q0",label:"StyledInputContainer"})(({theme,vSize,hSize})=>({userSelect:"none",display:"flex",position:"relative",width:theme.variables.size.dimension.checkbox[hSize],height:`calc(${theme.variables.size.font[vSize]} * ${getTextLineHeight({size:vSize,theme})})`,boxSizing:"border-box",alignItems:"center"}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport type { InputHTMLAttributes } from \"react\";\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text, getTextLineHeight } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\nimport { useFormFieldMessageId } from \"../FormField/useFormFieldMessageId\";\n\ntype CheckboxSizes = \"s\" | \"m\";\n\nexport type CheckboxProps = {\n  label?: string | React.ComponentType;\n  indeterminate?: boolean;\n  size?: CheckboxSizes; // TODO: This needs to be renamed as it overrides size from HTML attributes\n} & Omit<FormFieldProps, \"hideLabel\"> &\n  Omit<InputHTMLAttributes<HTMLInputElement>, \"size\" | \"type\">;\n\ntype CheckboxRawProps = CheckboxProps & { labelSize?: CheckboxSizes };\n\nconst StyledInputContainer = styled.div<{\n  vSize: CheckboxSizes;\n  hSize: CheckboxSizes;\n}>(({ theme, vSize, hSize }) => ({\n  userSelect: \"none\",\n  display: \"flex\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[hSize],\n  // Here the label prop used only M size\n  // We add calculation of checkbox container for S size\n  // in order to reuse it outside with S size label\n  height: `calc(${theme.variables.size.font[vSize]} * ${getTextLineHeight({\n    size: vSize,\n    theme,\n  })})`,\n  boxSizing: \"border-box\",\n  alignItems: \"center\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<Partial<CheckboxProps>>(\n  ({ theme, size }) => ({\n    boxSizing: \"border-box\",\n    width: theme.variables.size.dimension.checkbox[size],\n    height: theme.variables.size.dimension.checkbox[size],\n\n    borderRadius: theme.variables.size.borderRadius.xs,\n    border: \"2px solid\",\n\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    cursor: \"pointer\",\n\n    background: theme.values.color.background.primary.default,\n    color: theme.values.color.text.onAccent.default,\n    borderColor: theme.values.color.border.primary.default,\n    lineHeight: 0,\n    \"& svg\": {\n      opacity: theme.variables.opacity.hidden,\n    },\n\n    \"input: focus-visible + &\": {\n      outlineWidth: \"2px\",\n      outlineStyle: \"solid\",\n      outlineColor: \"Highlight\",\n    },\n\n    \"@media (-webkit-min-device-pixel-ratio:0)\": {\n      \"input: focus-visible + &\": {\n        outlineColor: \"-webkit-focus-ring-color\",\n        outlineStyle: \"auto\",\n      },\n    },\n\n    \"input:checked + &, input:indeterminate + &\": {\n      border: 0,\n      background: theme.values.color.background.accent.default,\n\n      svg: {\n        opacity: theme.variables.opacity.visible,\n      },\n    },\n\n    \"input:disabled + &\": {\n      pointerEvents: \"none\",\n    },\n  })\n);\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      indeterminate,\n      size = \"m\",\n      disabled,\n      checked,\n      label,\n      labelHint,\n      labelSize = \"m\",\n      ...rest\n    }: CheckboxRawProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer hSize={size} vSize={labelSize}>\n            <StyledRealInput\n              {...rest}\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              type=\"checkbox\"\n              disabled={disabled}\n              checked={checked}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? (\n                <Text size={labelSize}>{label}</Text>\n              ) : (\n                label\n              )}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      label,\n      labelHint,\n      hint,\n      errorMessages,\n      size = \"m\",\n      disabled,\n      \"data-e2e-test-id\": dataE2eTestId,\n      \"aria-describedby\": ariaDescribedBy,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const { id, ariaDescribedByProp } = useFormFieldMessageId({\n      ariaDescribedBy,\n      errorMessages,\n      hint,\n    });\n\n    return (\n      <FormField\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Checkbox\"\n        disabled={disabled}\n        errorMessages={errorMessages}\n        hint={hint}\n        messageId={id}\n      >\n        <CheckboxRaw\n          {...rest}\n          ref={ref}\n          size={size}\n          label={label}\n          labelHint={labelHint}\n          disabled={disabled}\n          {...ariaDescribedByProp}\n        />\n      </FormField>\n    );\n  }\n);\n"],"names":[],"mappings":"AAsB6B"} /"),StyledRealInput=styled("input",{target:"e1qcxs5q1",label:"StyledRealInput"})(({theme})=>({opacity:theme.variables.opacity.hidden,cursor:"pointer",height:0,width:0,position:"absolute"}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport type { InputHTMLAttributes } from \"react\";\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text, getTextLineHeight } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\nimport { useFormFieldMessageId } from \"../FormField/useFormFieldMessageId\";\n\ntype CheckboxSizes = \"s\" | \"m\";\n\nexport type CheckboxProps = {\n  label?: string | React.ComponentType;\n  indeterminate?: boolean;\n  size?: CheckboxSizes; // TODO: This needs to be renamed as it overrides size from HTML attributes\n} & Omit<FormFieldProps, \"hideLabel\"> &\n  Omit<InputHTMLAttributes<HTMLInputElement>, \"size\" | \"type\">;\n\ntype CheckboxRawProps = CheckboxProps & { labelSize?: CheckboxSizes };\n\nconst StyledInputContainer = styled.div<{\n  vSize: CheckboxSizes;\n  hSize: CheckboxSizes;\n}>(({ theme, vSize, hSize }) => ({\n  userSelect: \"none\",\n  display: \"flex\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[hSize],\n  // Here the label prop used only M size\n  // We add calculation of checkbox container for S size\n  // in order to reuse it outside with S size label\n  height: `calc(${theme.variables.size.font[vSize]} * ${getTextLineHeight({\n    size: vSize,\n    theme,\n  })})`,\n  boxSizing: \"border-box\",\n  alignItems: \"center\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<Partial<CheckboxProps>>(\n  ({ theme, size }) => ({\n    boxSizing: \"border-box\",\n    width: theme.variables.size.dimension.checkbox[size],\n    height: theme.variables.size.dimension.checkbox[size],\n\n    borderRadius: theme.variables.size.borderRadius.xs,\n    border: \"2px solid\",\n\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    cursor: \"pointer\",\n\n    background: theme.values.color.background.primary.default,\n    color: theme.values.color.text.onAccent.default,\n    borderColor: theme.values.color.border.primary.default,\n    lineHeight: 0,\n    \"& svg\": {\n      opacity: theme.variables.opacity.hidden,\n    },\n\n    \"input: focus-visible + &\": {\n      outlineWidth: \"2px\",\n      outlineStyle: \"solid\",\n      outlineColor: \"Highlight\",\n    },\n\n    \"@media (-webkit-min-device-pixel-ratio:0)\": {\n      \"input: focus-visible + &\": {\n        outlineColor: \"-webkit-focus-ring-color\",\n        outlineStyle: \"auto\",\n      },\n    },\n\n    \"input:checked + &, input:indeterminate + &\": {\n      border: 0,\n      background: theme.values.color.background.accent.default,\n\n      svg: {\n        opacity: theme.variables.opacity.visible,\n      },\n    },\n\n    \"input:disabled + &\": {\n      pointerEvents: \"none\",\n    },\n  })\n);\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      indeterminate,\n      size = \"m\",\n      disabled,\n      checked,\n      label,\n      labelHint,\n      labelSize = \"m\",\n      ...rest\n    }: CheckboxRawProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer hSize={size} vSize={labelSize}>\n            <StyledRealInput\n              {...rest}\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              type=\"checkbox\"\n              disabled={disabled}\n              checked={checked}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? (\n                <Text size={labelSize}>{label}</Text>\n              ) : (\n                label\n              )}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      label,\n      labelHint,\n      hint,\n      errorMessages,\n      size = \"m\",\n      disabled,\n      \"data-e2e-test-id\": dataE2eTestId,\n      \"aria-describedby\": ariaDescribedBy,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const { id, ariaDescribedByProp } = useFormFieldMessageId({\n      ariaDescribedBy,\n      errorMessages,\n      hint,\n    });\n\n    return (\n      <FormField\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Checkbox\"\n        disabled={disabled}\n        errorMessages={errorMessages}\n        hint={hint}\n        messageId={id}\n      >\n        <CheckboxRaw\n          {...rest}\n          ref={ref}\n          size={size}\n          label={label}\n          labelHint={labelHint}\n          disabled={disabled}\n          {...ariaDescribedByProp}\n        />\n      </FormField>\n    );\n  }\n);\n"],"names":[],"mappings":"AAyCwB"} /"),StyledFakeInput=styled("span",{target:"e1qcxs5q2",label:"StyledFakeInput"})(({theme,size})=>({boxSizing:"border-box",width:theme.variables.size.dimension.checkbox[size],height:theme.variables.size.dimension.checkbox[size],borderRadius:theme.variables.size.borderRadius.xs,border:"2px solid",display:"flex",alignItems:"center",justifyContent:"center",cursor:"pointer",background:theme.values.color.background.primary.default,color:theme.values.color.text.onAccent.default,borderColor:theme.values.color.border.primary.default,lineHeight:0,"& svg":{opacity:theme.variables.opacity.hidden},"input: focus-visible + &":{outlineWidth:"2px",outlineStyle:"solid",outlineColor:"Highlight"},"@media (-webkit-min-device-pixel-ratio:0)":{"input: focus-visible + &":{outlineColor:"-webkit-focus-ring-color",outlineStyle:"auto"}},"input:checked + &, input:indeterminate + &":{border:0,background:theme.values.color.background.accent.default,svg:{opacity:theme.variables.opacity.visible}},"input:disabled + &":{pointerEvents:"none"}}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport type { InputHTMLAttributes } from \"react\";\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text, getTextLineHeight } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\nimport { useFormFieldMessageId } from \"../FormField/useFormFieldMessageId\";\n\ntype CheckboxSizes = \"s\" | \"m\";\n\nexport type CheckboxProps = {\n  label?: string | React.ComponentType;\n  indeterminate?: boolean;\n  size?: CheckboxSizes; // TODO: This needs to be renamed as it overrides size from HTML attributes\n} & Omit<FormFieldProps, \"hideLabel\"> &\n  Omit<InputHTMLAttributes<HTMLInputElement>, \"size\" | \"type\">;\n\ntype CheckboxRawProps = CheckboxProps & { labelSize?: CheckboxSizes };\n\nconst StyledInputContainer = styled.div<{\n  vSize: CheckboxSizes;\n  hSize: CheckboxSizes;\n}>(({ theme, vSize, hSize }) => ({\n  userSelect: \"none\",\n  display: \"flex\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[hSize],\n  // Here the label prop used only M size\n  // We add calculation of checkbox container for S size\n  // in order to reuse it outside with S size label\n  height: `calc(${theme.variables.size.font[vSize]} * ${getTextLineHeight({\n    size: vSize,\n    theme,\n  })})`,\n  boxSizing: \"border-box\",\n  alignItems: \"center\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<Partial<CheckboxProps>>(\n  ({ theme, size }) => ({\n    boxSizing: \"border-box\",\n    width: theme.variables.size.dimension.checkbox[size],\n    height: theme.variables.size.dimension.checkbox[size],\n\n    borderRadius: theme.variables.size.borderRadius.xs,\n    border: \"2px solid\",\n\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    cursor: \"pointer\",\n\n    background: theme.values.color.background.primary.default,\n    color: theme.values.color.text.onAccent.default,\n    borderColor: theme.values.color.border.primary.default,\n    lineHeight: 0,\n    \"& svg\": {\n      opacity: theme.variables.opacity.hidden,\n    },\n\n    \"input: focus-visible + &\": {\n      outlineWidth: \"2px\",\n      outlineStyle: \"solid\",\n      outlineColor: \"Highlight\",\n    },\n\n    \"@media (-webkit-min-device-pixel-ratio:0)\": {\n      \"input: focus-visible + &\": {\n        outlineColor: \"-webkit-focus-ring-color\",\n        outlineStyle: \"auto\",\n      },\n    },\n\n    \"input:checked + &, input:indeterminate + &\": {\n      border: 0,\n      background: theme.values.color.background.accent.default,\n\n      svg: {\n        opacity: theme.variables.opacity.visible,\n      },\n    },\n\n    \"input:disabled + &\": {\n      pointerEvents: \"none\",\n    },\n  })\n);\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      indeterminate,\n      size = \"m\",\n      disabled,\n      checked,\n      label,\n      labelHint,\n      labelSize = \"m\",\n      ...rest\n    }: CheckboxRawProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer hSize={size} vSize={labelSize}>\n            <StyledRealInput\n              {...rest}\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              type=\"checkbox\"\n              disabled={disabled}\n              checked={checked}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? (\n                <Text size={labelSize}>{label}</Text>\n              ) : (\n                label\n              )}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      label,\n      labelHint,\n      hint,\n      errorMessages,\n      size = \"m\",\n      disabled,\n      \"data-e2e-test-id\": dataE2eTestId,\n      \"aria-describedby\": ariaDescribedBy,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const { id, ariaDescribedByProp } = useFormFieldMessageId({\n      ariaDescribedBy,\n      errorMessages,\n      hint,\n    });\n\n    return (\n      <FormField\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Checkbox\"\n        disabled={disabled}\n        errorMessages={errorMessages}\n        hint={hint}\n        messageId={id}\n      >\n        <CheckboxRaw\n          {...rest}\n          ref={ref}\n          size={size}\n          label={label}\n          labelHint={labelHint}\n          disabled={disabled}\n          {...ariaDescribedByProp}\n        />\n      </FormField>\n    );\n  }\n);\n"],"names":[],"mappings":"AAiDwB"} /");export const StyledCheckboxContainer=styled("div",{target:"e1qcxs5q3",label:"StyledCheckboxContainer"})(({theme,disabled})=>({"&:hover":{cursor:disabled?"not-allowed":"pointer",...!disabled&&{[`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:{background:theme.values.color.background.accent.hover}}},...!disabled&&{[`&:hover ${StyledFakeInput}`]:{borderColor:theme.values.color.border.primary.hover}}}),"/# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Form/Checkbox/Checkbox.tsx","sources":["src/components/Form/Checkbox/Checkbox.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport type { InputHTMLAttributes } from \"react\";\nimport React, { useRef, useLayoutEffect } from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { FormFieldProps } from \"../FormField/FormField\";\nimport { FormField } from \"../FormField/FormField\";\nimport { Inline } from \"../../Inline/Inline\";\nimport { Text, getTextLineHeight } from \"../../Typography/Text/Text\";\nimport { Icon } from \"../../Icon/Icon\";\nimport { useFormFieldMessageId } from \"../FormField/useFormFieldMessageId\";\n\ntype CheckboxSizes = \"s\" | \"m\";\n\nexport type CheckboxProps = {\n  label?: string | React.ComponentType;\n  indeterminate?: boolean;\n  size?: CheckboxSizes; // TODO: This needs to be renamed as it overrides size from HTML attributes\n} & Omit<FormFieldProps, \"hideLabel\"> &\n  Omit<InputHTMLAttributes<HTMLInputElement>, \"size\" | \"type\">;\n\ntype CheckboxRawProps = CheckboxProps & { labelSize?: CheckboxSizes };\n\nconst StyledInputContainer = styled.div<{\n  vSize: CheckboxSizes;\n  hSize: CheckboxSizes;\n}>(({ theme, vSize, hSize }) => ({\n  userSelect: \"none\",\n  display: \"flex\",\n  position: \"relative\",\n  width: theme.variables.size.dimension.checkbox[hSize],\n  // Here the label prop used only M size\n  // We add calculation of checkbox container for S size\n  // in order to reuse it outside with S size label\n  height: `calc(${theme.variables.size.font[vSize]} * ${getTextLineHeight({\n    size: vSize,\n    theme,\n  })})`,\n  boxSizing: \"border-box\",\n  alignItems: \"center\",\n}));\n\nconst StyledRealInput = styled.input(({ theme }) => ({\n  opacity: theme.variables.opacity.hidden,\n  cursor: \"pointer\",\n  height: 0,\n  width: 0,\n  position: \"absolute\",\n}));\n\nconst StyledFakeInput = styled.span<Partial<CheckboxProps>>(\n  ({ theme, size }) => ({\n    boxSizing: \"border-box\",\n    width: theme.variables.size.dimension.checkbox[size],\n    height: theme.variables.size.dimension.checkbox[size],\n\n    borderRadius: theme.variables.size.borderRadius.xs,\n    border: \"2px solid\",\n\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    cursor: \"pointer\",\n\n    background: theme.values.color.background.primary.default,\n    color: theme.values.color.text.onAccent.default,\n    borderColor: theme.values.color.border.primary.default,\n    lineHeight: 0,\n    \"& svg\": {\n      opacity: theme.variables.opacity.hidden,\n    },\n\n    \"input: focus-visible + &\": {\n      outlineWidth: \"2px\",\n      outlineStyle: \"solid\",\n      outlineColor: \"Highlight\",\n    },\n\n    \"@media (-webkit-min-device-pixel-ratio:0)\": {\n      \"input: focus-visible + &\": {\n        outlineColor: \"-webkit-focus-ring-color\",\n        outlineStyle: \"auto\",\n      },\n    },\n\n    \"input:checked + &, input:indeterminate + &\": {\n      border: 0,\n      background: theme.values.color.background.accent.default,\n\n      svg: {\n        opacity: theme.variables.opacity.visible,\n      },\n    },\n\n    \"input:disabled + &\": {\n      pointerEvents: \"none\",\n    },\n  })\n);\n\nexport const StyledCheckboxContainer = styled.div<{ disabled: boolean }>(\n  ({ theme, disabled }) => ({\n    \"&:hover\": {\n      cursor: disabled ? \"not-allowed\" : \"pointer\",\n      ...(!disabled && {\n        [`input:checked + ${StyledFakeInput}, input:indeterminate + ${StyledFakeInput}`]:\n          {\n            background: theme.values.color.background.accent.hover,\n          },\n      }),\n    },\n    ...(!disabled && {\n      [`&:hover ${StyledFakeInput}`]: {\n        borderColor: theme.values.color.border.primary.hover,\n      },\n    }),\n  })\n);\n\nexport const CheckboxRaw = React.forwardRef(\n  (\n    {\n      indeterminate,\n      size = \"m\",\n      disabled,\n      checked,\n      label,\n      labelHint,\n      labelSize = \"m\",\n      ...rest\n    }: CheckboxRawProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const internalRef = useRef<HTMLInputElement | null>(null);\n    const inputRef = internalRef || ref;\n\n    useLayoutEffect(() => {\n      if (inputRef.current) {\n        internalRef.current.indeterminate = indeterminate;\n      }\n    }, [indeterminate, inputRef]);\n\n    return (\n      <StyledCheckboxContainer disabled={disabled}>\n        <Inline space=\"xs\" vAlignItems=\"top\" noWrap>\n          <StyledInputContainer hSize={size} vSize={labelSize}>\n            <StyledRealInput\n              {...rest}\n              ref={inputRef}\n              aria-checked={indeterminate ? \"mixed\" : checked}\n              type=\"checkbox\"\n              disabled={disabled}\n              checked={checked}\n            />\n\n            <StyledFakeInput size={size}>\n              {indeterminate ? (\n                <Icon size=\"s\" name=\"minus\" />\n              ) : (\n                <Icon size=\"s\" name={size === \"m\" ? \"check\" : \"check-small\"} />\n              )}\n            </StyledFakeInput>\n          </StyledInputContainer>\n          {label && (\n            <div>\n              {typeof label === \"string\" ? (\n                <Text size={labelSize}>{label}</Text>\n              ) : (\n                label\n              )}\n              {labelHint && (\n                <Text color=\"tertiary\" size=\"s\">\n                  {labelHint}\n                </Text>\n              )}\n            </div>\n          )}\n        </Inline>\n      </StyledCheckboxContainer>\n    );\n  }\n);\n\nexport const Checkbox = React.forwardRef(\n  (\n    {\n      label,\n      labelHint,\n      hint,\n      errorMessages,\n      size = \"m\",\n      disabled,\n      \"data-e2e-test-id\": dataE2eTestId,\n      \"aria-describedby\": ariaDescribedBy,\n      ...rest\n    }: CheckboxProps,\n    ref: React.RefObject<HTMLInputElement>\n  ): React.ReactElement => {\n    const { id, ariaDescribedByProp } = useFormFieldMessageId({\n      ariaDescribedBy,\n      errorMessages,\n      hint,\n    });\n\n    return (\n      <FormField\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Checkbox\"\n        disabled={disabled}\n        errorMessages={errorMessages}\n        hint={hint}\n        messageId={id}\n      >\n        <CheckboxRaw\n          {...rest}\n          ref={ref}\n          size={size}\n          label={label}\n          labelHint={labelHint}\n          disabled={disabled}\n          {...ariaDescribedByProp}\n        />\n      </FormField>\n    );\n  }\n);\n"],"names":[],"mappings":"AAmGuC"} /");export const CheckboxRaw=React.forwardRef(({indeterminate,size="m",disabled,checked,label,labelHint,labelSize="m",...rest},ref)=>{let internalRef=useRef(null),inputRef=internalRef\|\|ref;return useLayoutEffect(()=>{inputRef.current&&(internalRef.current.indeterminate=indeterminate)},[indeterminate,inputRef]),React.createElement(StyledCheckboxContainer,{disabled:disabled},React.createElement(Inline,{space:"xs",vAlignItems:"top",noWrap:!0},React.createElement(StyledInputContainer,{hSize:size,vSize:labelSize},React.createElement(StyledRealInput,{...rest,ref:inputRef,"aria-checked":indeterminate?"mixed":checked,type:"checkbox",disabled:disabled,checked:checked}),React.createElement(StyledFakeInput,{size:size},indeterminate?React.createElement(Icon,{size:"s",name:"minus"}):React.createElement(Icon,{size:"s",name:"m"===size?"check":"check-small"}))),label&&React.createElement("div",null,"string"==typeof label?React.createElement(Text,{size:labelSize},label):label,labelHint&&React.createElement(Text,{color:"tertiary",size:"s"},labelHint))))});export const Checkbox=React.forwardRef(({label,labelHint,hint,errorMessages,size="m",disabled,"data-e2e-test-id":dataE2eTestId,"aria-describedby":ariaDescribedBy,...rest},ref)=>{let{id,ariaDescribedByProp}=useFormFieldMessageId({ariaDescribedBy,errorMessages,hint});return React.createElement(FormField,{"data-e2e-test-id":dataE2eTestId,"data-ds-id":"Checkbox",disabled:disabled,errorMessages:errorMessages,hint:hint,messageId:id},React.createElement(CheckboxRaw,{...rest,ref:ref,size:size,label:label,labelHint:labelHint,disabled:disabled,...ariaDescribedByProp}))});

package/build/esm/components/Form/Combobox/Combobox.d.ts CHANGED Viewed

@@ -48,6 +48,7 @@ export type CommonSelectProps = {
     onChange?: (selectedValues: SelectOption["value"][] & React.ChangeEvent<HTMLSelectElement>, actionData?: ActionData, e?: React.ChangeEvent<HTMLSelectElement>) => void;
     value: string | string[] | null;
     readOnly?: boolean;
+    "aria-describedby"?: string;
 } & Pick<PortalProps, "portalContainer">;
 export type ComboboxProps = CommonSelectProps & FormFieldProps;
-export declare function Combobox({ options, name, value, placeholder, emptyStateMessage, hasError, filterMethod, formatSelectedOptionsLabel, onChange, onBlur, onFocus, maxHeight, autoComplete, multiple, privateProps, portalContainer, optionsListWidth, readOnly, ...rest }: ComboboxProps): React.ReactElement;
+export declare function Combobox({ options, name, value, placeholder, emptyStateMessage, hasError, filterMethod, formatSelectedOptionsLabel, onChange, onBlur, onFocus, maxHeight, autoComplete, multiple, privateProps, portalContainer, optionsListWidth, readOnly, errorMessages, hint, "aria-describedby": ariaDescribedBy, ...rest }: ComboboxProps): React.ReactElement;

package/build/esm/components/Form/Combobox/Combobox.js CHANGED Viewed

	@@ -1 +1 @@
1	- import React from"react";import{FormField}from"../FormField/FormField";import{SingleSelect}from"./SingleSelect";import{MultiSelect}from"./MultiSelect";let defaultFilterMethod=(option,value)=>option.label.toLowerCase().indexOf(value.toLowerCase())>-1;export function Combobox({options=[],name,value,placeholder,emptyStateMessage,hasError,filterMethod=defaultFilterMethod,formatSelectedOptionsLabel,onChange=()=>{},onBlur=()=>null,onFocus=()=>null,maxHeight=230,autoComplete="on",multiple=!1,privateProps,portalContainer,optionsListWidth,readOnly,...rest}){let{disabled,label}=rest;return ~~/#__PURE__/~~React.createElement(FormField,{"data-ds-id":"Combobox",disabled:disabled,...rest},multiple~~?/#__PURE__/~~React.createElement(MultiSelect,{name:name,options:options,value:value,placeholder:placeholder,emptyStateMessage:emptyStateMessage,hasError:hasError,disabled:disabled,filterMethod:filterMethod,onChange:onChange,onFocus:onFocus,onBlur:onBlur,maxHeight:maxHeight,autoComplete:autoComplete,label:label,formatSelectedOptionsLabel:formatSelectedOptionsLabel,portalContainer:portalContainer,optionsListWidth:optionsListWidth})~~:/#__PURE__/~~React.createElement(SingleSelect,{name:name,options:options,value:value,placeholder:placeholder,emptyStateMessage:emptyStateMessage,hasError:hasError,disabled:disabled,filterMethod:filterMethod,onChange:onChange,onFocus:onFocus,onBlur:onBlur,maxHeight:maxHeight,autoComplete:autoComplete,label:label,privateProps:privateProps,portalContainer:portalContainer,optionsListWidth:optionsListWidth,readOnly:readOnly}))}
1	+ import React from"react";import{FormField}from"../FormField/FormField";import{SingleSelect}from"./SingleSelect";import{MultiSelect}from"./MultiSelect";import{useFormFieldMessageId}from"../FormField/useFormFieldMessageId";let defaultFilterMethod=(option,value)=>option.label.toLowerCase().indexOf(value.toLowerCase())>-1;export function Combobox({options=[],name,value,placeholder,emptyStateMessage,hasError,filterMethod=defaultFilterMethod,formatSelectedOptionsLabel,onChange=()=>{},onBlur=()=>null,onFocus=()=>null,maxHeight=230,autoComplete="on",multiple=!1,privateProps,portalContainer,optionsListWidth,readOnly,errorMessages,hint,"aria-describedby":ariaDescribedBy,...rest}){let{disabled,label}=rest,{id,ariaDescribedByProp}=useFormFieldMessageId({ariaDescribedBy,errorMessages,hint});return React.createElement(FormField,{"data-ds-id":"Combobox",disabled:disabled,errorMessages:errorMessages,hint:hint,messageId:id,...rest},multiple?React.createElement(MultiSelect,{name:name,options:options,value:value,placeholder:placeholder,emptyStateMessage:emptyStateMessage,hasError:hasError,disabled:disabled,filterMethod:filterMethod,onChange:onChange,onFocus:onFocus,onBlur:onBlur,maxHeight:maxHeight,autoComplete:autoComplete,label:label,formatSelectedOptionsLabel:formatSelectedOptionsLabel,portalContainer:portalContainer,optionsListWidth:optionsListWidth,...ariaDescribedByProp}):React.createElement(SingleSelect,{name:name,options:options,value:value,placeholder:placeholder,emptyStateMessage:emptyStateMessage,hasError:hasError,disabled:disabled,filterMethod:filterMethod,onChange:onChange,onFocus:onFocus,onBlur:onBlur,maxHeight:maxHeight,autoComplete:autoComplete,label:label,privateProps:privateProps,portalContainer:portalContainer,optionsListWidth:optionsListWidth,readOnly:readOnly,...ariaDescribedByProp}))}

package/build/esm/components/Form/Combobox/MultiSelect.d.ts CHANGED Viewed

@@ -12,5 +12,5 @@ export type UniqueMultiSelectProps = {
     formatSelectedOptionsLabel?: (count?: number) => string;
 };
 type MultiSelectProps = CommonSelectProps & Pick<FormFieldProps, "label"> & UniqueMultiSelectProps;
-export declare function MultiSelect({ options, name, value, placeholder, emptyStateMessage, hasError, filterMethod, onChange, onBlur, onFocus, maxHeight, formatSelectedOptionsLabel, autoComplete, disabled, label, portalContainer, optionsListWidth, }: MultiSelectProps): React.ReactElement;
+export declare function MultiSelect({ options, name, value, placeholder, emptyStateMessage, hasError, filterMethod, onChange, onBlur, onFocus, maxHeight, formatSelectedOptionsLabel, autoComplete, disabled, label, portalContainer, optionsListWidth, "aria-describedby": ariaDescribedBy, }: MultiSelectProps): React.ReactElement;
 export {};