npm - @hitachivantara/uikit-react-core - Versions diffs - 5.14.1 → 5.15.0 - Mend

@hitachivantara/uikit-react-core 5.14.1 → 5.15.0

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 (736) hide show

package/dist/cjs/components/VerticalNavigation/VerticalNavigationContext.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"VerticalNavigationContext.cjs","sources":["../../../../src/components/VerticalNavigation/VerticalNavigationContext.tsx"],"sourcesContent":["import { createContext } from \"react\";\nimport { NavigationData } from \".\";\n\ninterface VerticalNavigationContextValue {\n isOpen: boolean;\n useIcons: boolean;\n slider?: boolean;\n headerTitle?: string;\n setHeaderTitle?: React.Dispatch<React.SetStateAction<string \| undefined>>;\n\n parentItem?;\n setParentItem?: React.Dispatch<React.SetStateAction<any>>;\n withParentData?;\n navigateToChildHandler?: (event, item) => void;\n navigateToParentHandler?: () => void;\n\n parentData?: NavigationData[];\n setParentData?: React.Dispatch<React.SetStateAction<any>>;\n parentSelected?;\n setParentSelected?: React.Dispatch<React.SetStateAction<any>>;\n\n hasAnyChildWithData?: boolean;\n}\n\nconst VerticalNavigationContext = createContext<VerticalNavigationContextValue>(\n {\n isOpen: true,\n useIcons: false,\n slider: false,\n }\n);\n\nexport { VerticalNavigationContext };\n"],"names":["VerticalNavigationContext","createContext","isOpen","useIcons","slider"],"mappings":";;;AAwBA,MAAMA,4BAA4BC,MAAAA,cAChC;AAAA,EACEC,QAAQ;AAAA,EACRC,UAAU;AAAA,EACVC,QAAQ;AACV,~~CAAC~~;;"}
1	+ {"version":3,"file":"VerticalNavigationContext.cjs","sources":["../../../../src/components/VerticalNavigation/VerticalNavigationContext.tsx"],"sourcesContent":["import { createContext } from \"react\";\nimport { NavigationData } from \".\";\n\ninterface VerticalNavigationContextValue {\n isOpen: boolean;\n useIcons: boolean;\n slider?: boolean;\n headerTitle?: string;\n setHeaderTitle?: React.Dispatch<React.SetStateAction<string \| undefined>>;\n\n parentItem?;\n setParentItem?: React.Dispatch<React.SetStateAction<any>>;\n withParentData?;\n navigateToChildHandler?: (event, item) => void;\n navigateToParentHandler?: () => void;\n\n parentData?: NavigationData[];\n setParentData?: React.Dispatch<React.SetStateAction<any>>;\n parentSelected?;\n setParentSelected?: React.Dispatch<React.SetStateAction<any>>;\n\n hasAnyChildWithData?: boolean;\n}\n\nconst VerticalNavigationContext = createContext<VerticalNavigationContextValue>(\n {\n isOpen: true,\n useIcons: false,\n slider: false,\n }\n);\n\nexport { VerticalNavigationContext };\n"],"names":["VerticalNavigationContext","createContext","isOpen","useIcons","slider"],"mappings":";;;AAwBA,MAAMA,4BAA4BC,MAAAA,cAChC;AAAA,EACEC,QAAQ;AAAA,EACRC,UAAU;AAAA,EACVC,QAAQ;AACV,CACF;;"}

package/dist/cjs/hocs/withTooltip.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"withTooltip.cjs","sources":["../../../src/hocs/withTooltip.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport {\n HvTypography,\n HvTooltip,\n HvTooltipPlacementType,\n HvTooltipProps,\n} from \"@core/components\";\nimport { HvBaseProps } from \"@core/types\";\n\nconst styles: { truncate: React.CSSProperties } = {\n truncate: {\n overflow: \"hidden\",\n textOverflow: \"ellipsis\",\n whiteSpace: \"nowrap\",\n },\n};\n\nconst withTooltip =\n (\n Component: React.FunctionComponent,\n // eslint-disable-next-line @typescript-eslint/default-param-last\n label = \"\",\n placement: HvTooltipPlacementType,\n hideTooltip?: (event: React.MouseEvent<HTMLDivElement>) => boolean,\n tooltipProps?: Partial<HvTooltipProps>,\n tooltipContainerProps?: HvBaseProps\n ) =>\n (props) => {\n const [isHoverDisabled, setIsHoverDisabled] = useState<boolean \| undefined>(\n false\n );\n const [open, setOpen] = useState<boolean>(false);\n\n const title = <HvTypography>{label}</HvTypography>;\n\n const handleMouseEnter = (event: React.MouseEvent<HTMLDivElement>) => {\n const isHidden = hideTooltip?.(event);\n setIsHoverDisabled(isHidden);\n setOpen(!isHidden);\n };\n\n const handleMouseLeave = () => {\n setIsHoverDisabled(false);\n setOpen(false);\n };\n\n return (\n <HvTooltip\n style={{ ...styles.truncate }}\n disableHoverListener={isHoverDisabled}\n disableFocusListener\n disableTouchListener\n title={title}\n open={open}\n placement={placement}\n {...tooltipProps}\n >\n <div\n {...tooltipContainerProps}\n onMouseEnter={handleMouseEnter}\n onMouseLeave={handleMouseLeave}\n >\n <Component {...props} />\n </div>\n </HvTooltip>\n );\n };\n\nexport default withTooltip;\n"],"names":["styles","truncate","overflow","textOverflow","whiteSpace","withTooltip","Component","label","placement","hideTooltip","tooltipProps","tooltipContainerProps","props","isHoverDisabled","setIsHoverDisabled","useState","open","setOpen","title","HvTypography","children","handleMouseEnter","event","isHidden","handleMouseLeave","HvTooltip","style","disableHoverListener","disableFocusListener","disableTouchListener","onMouseEnter","onMouseLeave"],"mappings":";;;;;;AASA,MAAMA,SAA4C;AAAA,EAChDC,UAAU;AAAA,IACRC,UAAU;AAAA,IACVC,cAAc;AAAA,IACdC,YAAY;AAAA,EACd;AACF;AAEA,MAAMC,cACJA,CACEC,WAEAC,QAAQ,IACRC,WACAC,aACAC,cACAC,0BAEDC,CAAU,UAAA;AACT,QAAM,CAACC,iBAAiBC,kBAAkB,IAAIC,eAC5C,~~KAAK~~;~~AAEP~~,QAAM,CAACC,MAAMC,OAAO,IAAIF,eAAkB,KAAK;AAEzCG,QAAAA,uCAASC,yBAAY;AAAA,IAAAC,UAAEb;AAAAA,EAAAA,~~CAAqB~~;~~AAE5Cc~~,QAAAA,mBAAmBA,CAACC,UAA4C;AAC9DC,UAAAA,WAAWd,2CAAca;AAC/BR,uBAAmBS,QAAQ;AAC3BN,YAAQ,CAACM,QAAQ;AAAA,EAAA;AAGnB,QAAMC,mBAAmBA,MAAM;AAC7BV,uBAAmB,KAAK;AACxBG,YAAQ,KAAK;AAAA,EAAA;AAGf,wCACGQ,QAAAA,WAAS;AAAA,IACRC,OAAO;AAAA,MAAE,GAAG1B,OAAOC;AAAAA,IAAS;AAAA,IAC5B0B,sBAAsBd;AAAAA,IACtBe,sBAAoB;AAAA,IACpBC,sBAAoB;AAAA,IACpBX;AAAAA,IACAF;AAAAA,IACAR;AAAAA,IAAqB,GACjBE;AAAAA,IAAYU,yCAEhB,OAAA;AAAA,MAAA,GACMT;AAAAA,MACJmB,cAAcT;AAAAA,MACdU,cAAcP;AAAAA,MAAiBJ,yCAE9Bd,WAAS;AAAA,QAAA,GAAKM;AAAAA,MAAAA,~~CAAK~~;AAAA,IAAA,~~CAAI~~;AAAA,EAAA,~~CAEhB~~;~~AAEhB~~;AAEF,MAAA,gBAAeP;;"}
1	+ {"version":3,"file":"withTooltip.cjs","sources":["../../../src/hocs/withTooltip.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport {\n HvTypography,\n HvTooltip,\n HvTooltipPlacementType,\n HvTooltipProps,\n} from \"@core/components\";\nimport { HvBaseProps } from \"@core/types\";\n\nconst styles: { truncate: React.CSSProperties } = {\n truncate: {\n overflow: \"hidden\",\n textOverflow: \"ellipsis\",\n whiteSpace: \"nowrap\",\n },\n};\n\nconst withTooltip =\n (\n Component: React.FunctionComponent,\n // eslint-disable-next-line @typescript-eslint/default-param-last\n label = \"\",\n placement: HvTooltipPlacementType,\n hideTooltip?: (event: React.MouseEvent<HTMLDivElement>) => boolean,\n tooltipProps?: Partial<HvTooltipProps>,\n tooltipContainerProps?: HvBaseProps\n ) =>\n (props) => {\n const [isHoverDisabled, setIsHoverDisabled] = useState<boolean \| undefined>(\n false\n );\n const [open, setOpen] = useState<boolean>(false);\n\n const title = <HvTypography>{label}</HvTypography>;\n\n const handleMouseEnter = (event: React.MouseEvent<HTMLDivElement>) => {\n const isHidden = hideTooltip?.(event);\n setIsHoverDisabled(isHidden);\n setOpen(!isHidden);\n };\n\n const handleMouseLeave = () => {\n setIsHoverDisabled(false);\n setOpen(false);\n };\n\n return (\n <HvTooltip\n style={{ ...styles.truncate }}\n disableHoverListener={isHoverDisabled}\n disableFocusListener\n disableTouchListener\n title={title}\n open={open}\n placement={placement}\n {...tooltipProps}\n >\n <div\n {...tooltipContainerProps}\n onMouseEnter={handleMouseEnter}\n onMouseLeave={handleMouseLeave}\n >\n <Component {...props} />\n </div>\n </HvTooltip>\n );\n };\n\nexport default withTooltip;\n"],"names":["styles","truncate","overflow","textOverflow","whiteSpace","withTooltip","Component","label","placement","hideTooltip","tooltipProps","tooltipContainerProps","props","isHoverDisabled","setIsHoverDisabled","useState","open","setOpen","title","HvTypography","children","handleMouseEnter","event","isHidden","handleMouseLeave","HvTooltip","style","disableHoverListener","disableFocusListener","disableTouchListener","onMouseEnter","onMouseLeave"],"mappings":";;;;;;AASA,MAAMA,SAA4C;AAAA,EAChDC,UAAU;AAAA,IACRC,UAAU;AAAA,IACVC,cAAc;AAAA,IACdC,YAAY;AAAA,EACd;AACF;AAEA,MAAMC,cACJA,CACEC,WAEAC,QAAQ,IACRC,WACAC,aACAC,cACAC,0BAEDC,CAAU,UAAA;AACT,QAAM,CAACC,iBAAiBC,kBAAkB,IAAIC,eAC5C,KACF;AACA,QAAM,CAACC,MAAMC,OAAO,IAAIF,eAAkB,KAAK;AAEzCG,QAAAA,uCAASC,yBAAY;AAAA,IAAAC,UAAEb;AAAAA,EAAAA,CAAoB;AAE3Cc,QAAAA,mBAAmBA,CAACC,UAA4C;AAC9DC,UAAAA,WAAWd,2CAAca;AAC/BR,uBAAmBS,QAAQ;AAC3BN,YAAQ,CAACM,QAAQ;AAAA,EAAA;AAGnB,QAAMC,mBAAmBA,MAAM;AAC7BV,uBAAmB,KAAK;AACxBG,YAAQ,KAAK;AAAA,EAAA;AAGf,wCACGQ,QAAAA,WAAS;AAAA,IACRC,OAAO;AAAA,MAAE,GAAG1B,OAAOC;AAAAA,IAAS;AAAA,IAC5B0B,sBAAsBd;AAAAA,IACtBe,sBAAoB;AAAA,IACpBC,sBAAoB;AAAA,IACpBX;AAAAA,IACAF;AAAAA,IACAR;AAAAA,IAAqB,GACjBE;AAAAA,IAAYU,yCAEhB,OAAA;AAAA,MAAA,GACMT;AAAAA,MACJmB,cAAcT;AAAAA,MACdU,cAAcP;AAAAA,MAAiBJ,yCAE9Bd,WAAS;AAAA,QAAA,GAAKM;AAAAA,MAAAA,CAAQ;AAAA,IAAA,CACpB;AAAA,EAAA,CACI;AAEf;AAEF,MAAA,gBAAeP;;"}

package/dist/cjs/hooks/useClickOutside.cjs CHANGED Viewed

@@ -8,7 +8,7 @@ const useClickOutside = (ref, handler) => {
       const isKeyUp = event.type === "keyup";
       const isEscape = event.key === "Escape";
       if (!el || el.contains((event == null ? void 0 : event.target) || null)) {
-        return;
+        return {};
       }
       return isKeyUp ? isEscape ? handler(event) : null : handler(event);
     };

package/dist/cjs/hooks/useClickOutside.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useClickOutside.cjs","sources":["../../../src/hooks/useClickOutside.ts"],"sourcesContent":["import { useEffect, RefObject } from \"react\";\n\nexport type HvClickOutsideEvent = MouseEvent \| KeyboardEvent \| TouchEvent;\n\nexport const useClickOutside = <T extends HTMLElement = HTMLElement>(\n ref: RefObject<T>,\n handler: (event: HvClickOutsideEvent) => void\n) => {\n useEffect(() => {\n const listener = (event: HvClickOutsideEvent) => {\n const el = ref?.current;\n const isKeyUp = event.type === \"keyup\";\n const isEscape = (event as KeyboardEvent).key === \"Escape\";\n\n if (!el \|\| el.contains((event?.target as Node) \|\| null)) {\n return;\n }\n\n return isKeyUp ? (isEscape ? handler(event) : null) : handler(event);\n };\n\n document.addEventListener(\"click\", listener);\n document.addEventListener(\"touchstart\", listener);\n document.addEventListener(\"keyup\", listener);\n\n return () => {\n document.removeEventListener(\"click\", listener);\n document.removeEventListener(\"touchstart\", listener);\n document.removeEventListener(\"keyup\", listener);\n };\n }, [ref, handler]);\n};\n"],"names":["useClickOutside","ref","handler","useEffect","listener","event","el","current","isKeyUp","type","isEscape","key","contains","target","addEventListener","removeEventListener"],"mappings":";;;AAIaA,MAAAA,kBAAkB,CAC7BC,KACAC,YACG;AACHC,QAAAA,UAAU,MAAM;AACRC,UAAAA,WAAWA,CAACC,UAA+B;AAC/C,YAAMC,KAAKL,2BAAKM;AACVC,YAAAA,UAAUH,MAAMI,SAAS;AACzBC,YAAAA,WAAYL,MAAwBM,QAAQ;AAElD,UAAI,CAACL,MAAMA,GAAGM,UAAUP,+BAAOQ,WAAmB,IAAI,GAAG;AACvD~~;AAAA~~,~~MACF~~;AAEA,aAAOL,UAAWE,WAAWR,QAAQG,KAAK,IAAI,OAAQH,QAAQG,KAAK;AAAA,IAAA;AAG5DS,aAAAA,iBAAiB,SAASV,QAAQ;AAClCU,aAAAA,iBAAiB,cAAcV,QAAQ;AACvCU,aAAAA,iBAAiB,SAASV,QAAQ;AAE3C,WAAO,MAAM;AACFW,eAAAA,oBAAoB,SAASX,QAAQ;AACrCW,eAAAA,oBAAoB,cAAcX,QAAQ;AAC1CW,eAAAA,oBAAoB,SAASX,QAAQ;AAAA,IAAA;AAAA,EAChD,GACC,CAACH,KAAKC,OAAO,CAAC;AACnB;;"}
1	+ {"version":3,"file":"useClickOutside.cjs","sources":["../../../src/hooks/useClickOutside.ts"],"sourcesContent":["import { useEffect, RefObject } from \"react\";\n\nexport type HvClickOutsideEvent = MouseEvent \| KeyboardEvent \| TouchEvent;\n\nexport const useClickOutside = <T extends HTMLElement = HTMLElement>(\n ref: RefObject<T>,\n handler: (event: HvClickOutsideEvent) => void\n) => {\n useEffect(() => {\n const listener = (event: HvClickOutsideEvent) => {\n const el = ref?.current;\n const isKeyUp = event.type === \"keyup\";\n const isEscape = (event as KeyboardEvent).key === \"Escape\";\n\n if (!el \|\| el.contains((event?.target as Node) \|\| null)) {\n return {};\n }\n\n return isKeyUp ? (isEscape ? handler(event) : null) : handler(event);\n };\n\n document.addEventListener(\"click\", listener);\n document.addEventListener(\"touchstart\", listener);\n document.addEventListener(\"keyup\", listener);\n\n return () => {\n document.removeEventListener(\"click\", listener);\n document.removeEventListener(\"touchstart\", listener);\n document.removeEventListener(\"keyup\", listener);\n };\n }, [ref, handler]);\n};\n"],"names":["useClickOutside","ref","handler","useEffect","listener","event","el","current","isKeyUp","type","isEscape","key","contains","target","addEventListener","removeEventListener"],"mappings":";;;AAIaA,MAAAA,kBAAkB,CAC7BC,KACAC,YACG;AACHC,QAAAA,UAAU,MAAM;AACRC,UAAAA,WAAWA,CAACC,UAA+B;AAC/C,YAAMC,KAAKL,2BAAKM;AACVC,YAAAA,UAAUH,MAAMI,SAAS;AACzBC,YAAAA,WAAYL,MAAwBM,QAAQ;AAElD,UAAI,CAACL,MAAMA,GAAGM,UAAUP,+BAAOQ,WAAmB,IAAI,GAAG;AACvD,eAAO;MACT;AAEA,aAAOL,UAAWE,WAAWR,QAAQG,KAAK,IAAI,OAAQH,QAAQG,KAAK;AAAA,IAAA;AAG5DS,aAAAA,iBAAiB,SAASV,QAAQ;AAClCU,aAAAA,iBAAiB,cAAcV,QAAQ;AACvCU,aAAAA,iBAAiB,SAASV,QAAQ;AAE3C,WAAO,MAAM;AACFW,eAAAA,oBAAoB,SAASX,QAAQ;AACrCW,eAAAA,oBAAoB,cAAcX,QAAQ;AAC1CW,eAAAA,oBAAoB,SAASX,QAAQ;AAAA,IAAA;AAAA,EAChD,GACC,CAACH,KAAKC,OAAO,CAAC;AACnB;;"}

package/dist/cjs/hooks/useControlled.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useControlled.cjs","sources":["../../../src/hooks/useControlled.ts"],"sourcesContent":["// based in https://raw.githubusercontent.com/mui-org/material-ui/next/packages/material-ui/src/utils/useControlled.js\n// modifications:\n// 1. renamed default to initialState, to convey the same meaning of the useState hook.\n// 2. removed the console error when initialState changes; that is acceptable and just ignored, like in useState.\n// 3. the console error regarding switching from controlled to uncontrolled (or vice-versa) is sent synchronously\n// so the stacktrace shows the caller\n// 4. given that, the hook signature was simplified, no need for metadata\n\nimport { useRef, useState, useCallback } from \"react\";\n\nexport const useControlled = (controlledProp, initialState) => {\n const { current: isControlled } = useRef(controlledProp !== undefined);\n const [valueState, setValue] = useState(initialState);\n const value = isControlled ? controlledProp : valueState;\n\n if (\n process.env.NODE_ENV !== \"production\" &&\n isControlled !== (controlledProp !== undefined)\n ) {\n // eslint-disable-next-line no-console\n console.error(\n [\n `A component is changing the ${\n isControlled ? \"\" : \"un\"\n }controlled state to be ${isControlled ? \"un\" : \"\"}controlled.`,\n \"Elements should not switch from uncontrolled to controlled (or vice versa).\",\n \"Decide between using a controlled or uncontrolled element for the lifetime of the component.\",\n \"The nature of the state is determined during the first render, it's considered controlled if the value is not `undefined`.\",\n ].join(\"\\n\")\n );\n }\n\n const setValueIfUncontrolled = useCallback(\n (newValue) => {\n if (!isControlled) {\n setValue(newValue);\n }\n },\n [isControlled]\n );\n\n return [value, setValueIfUncontrolled];\n};\n"],"names":["useControlled","controlledProp","initialState","current","isControlled","useRef","undefined","valueState","setValue","useState","value","process","env","NODE_ENV","console","error","join","setValueIfUncontrolled","useCallback","newValue"],"mappings":";;;AAUaA,MAAAA,gBAAgBA,CAACC,gBAAgBC,iBAAiB;AACvD,QAAA;AAAA,IAAEC,SAASC;AAAAA,EAAa,IAAIC,aAAOJ,mBAAmBK,MAAS;AACrE,QAAM,CAACC,YAAYC,QAAQ,IAAIC,eAASP,YAAY;AAC9CQ,QAAAA,QAAQN,eAAeH,iBAAiBM;AAE9C,MACEI,QAAQC,IAAIC,aAAa,gBACzBT,kBAAkBH,mBAAmBK,SACrC;AAEAQ,YAAQC,MACN,CACG,+BACCX,eAAe,KAAK,8BACIA,eAAe,OAAO,iBAChD,+EACA,gGACA,4HAA4H,EAC5HY,KAAK,IAAI,~~CAAC~~;AAAA,~~EAEhB~~;AAEMC,QAAAA,yBAAyBC,kBAC5BC,CAAa,aAAA;AACZ,QAAI,CAACf,cAAc;AACjBI,eAASW,QAAQ;AAAA,IACnB;AAAA,EAAA,GAEF,CAACf,YAAY,~~CAAC~~;~~AAGT~~,SAAA,CAACM,OAAOO,sBAAsB;AACvC;;"}
1	+ {"version":3,"file":"useControlled.cjs","sources":["../../../src/hooks/useControlled.ts"],"sourcesContent":["// based in https://raw.githubusercontent.com/mui-org/material-ui/next/packages/material-ui/src/utils/useControlled.js\n// modifications:\n// 1. renamed default to initialState, to convey the same meaning of the useState hook.\n// 2. removed the console error when initialState changes; that is acceptable and just ignored, like in useState.\n// 3. the console error regarding switching from controlled to uncontrolled (or vice-versa) is sent synchronously\n// so the stacktrace shows the caller\n// 4. given that, the hook signature was simplified, no need for metadata\n\nimport { useRef, useState, useCallback } from \"react\";\n\nexport const useControlled = (controlledProp, initialState) => {\n const { current: isControlled } = useRef(controlledProp !== undefined);\n const [valueState, setValue] = useState(initialState);\n const value = isControlled ? controlledProp : valueState;\n\n if (\n process.env.NODE_ENV !== \"production\" &&\n isControlled !== (controlledProp !== undefined)\n ) {\n // eslint-disable-next-line no-console\n console.error(\n [\n `A component is changing the ${\n isControlled ? \"\" : \"un\"\n }controlled state to be ${isControlled ? \"un\" : \"\"}controlled.`,\n \"Elements should not switch from uncontrolled to controlled (or vice versa).\",\n \"Decide between using a controlled or uncontrolled element for the lifetime of the component.\",\n \"The nature of the state is determined during the first render, it's considered controlled if the value is not `undefined`.\",\n ].join(\"\\n\")\n );\n }\n\n const setValueIfUncontrolled = useCallback(\n (newValue) => {\n if (!isControlled) {\n setValue(newValue);\n }\n },\n [isControlled]\n );\n\n return [value, setValueIfUncontrolled];\n};\n"],"names":["useControlled","controlledProp","initialState","current","isControlled","useRef","undefined","valueState","setValue","useState","value","process","env","NODE_ENV","console","error","join","setValueIfUncontrolled","useCallback","newValue"],"mappings":";;;AAUaA,MAAAA,gBAAgBA,CAACC,gBAAgBC,iBAAiB;AACvD,QAAA;AAAA,IAAEC,SAASC;AAAAA,EAAa,IAAIC,aAAOJ,mBAAmBK,MAAS;AACrE,QAAM,CAACC,YAAYC,QAAQ,IAAIC,eAASP,YAAY;AAC9CQ,QAAAA,QAAQN,eAAeH,iBAAiBM;AAE9C,MACEI,QAAQC,IAAIC,aAAa,gBACzBT,kBAAkBH,mBAAmBK,SACrC;AAEAQ,YAAQC,MACN,CACG,+BACCX,eAAe,KAAK,8BACIA,eAAe,OAAO,iBAChD,+EACA,gGACA,4HAA4H,EAC5HY,KAAK,IAAI,CACb;AAAA,EACF;AAEMC,QAAAA,yBAAyBC,kBAC5BC,CAAa,aAAA;AACZ,QAAI,CAACf,cAAc;AACjBI,eAASW,QAAQ;AAAA,IACnB;AAAA,EAAA,GAEF,CAACf,YAAY,CACf;AAEO,SAAA,CAACM,OAAOO,sBAAsB;AACvC;;"}

package/dist/cjs/hooks/useCss.cjs ADDED Viewed

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const clsx = require("clsx");
+const serialize = require("@emotion/serialize");
+const utils = require("@emotion/utils");
+const useEmotionCache = require("./useEmotionCache.cjs");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const clsx__default = /* @__PURE__ */ _interopDefault(clsx);
+function getRef(args) {
+  if (args.length !== 1) {
+    return {
+      args,
+      ref: void 0
+    };
+  }
+  const [arg] = args;
+  if (!(arg instanceof Object)) {
+    return {
+      args,
+      ref: void 0
+    };
+  }
+  if (!("ref" in arg)) {
+    return {
+      args,
+      ref: void 0
+    };
+  }
+  const {
+    ref,
+    ...argCopy
+  } = arg;
+  return {
+    args: [argCopy],
+    ref
+  };
+}
+const {
+  cssFactory
+} = (() => {
+  function merge(registered, css, className) {
+    const registeredStyles = [];
+    const rawClassName = utils.getRegisteredStyles(registered, registeredStyles, className);
+    if (registeredStyles.length < 2) {
+      return className;
+    }
+    return rawClassName + css(registeredStyles);
+  }
+  function innerCssFactory(params) {
+    const {
+      cache
+    } = params;
+    const css = (...styles) => {
+      const {
+        ref,
+        args
+      } = getRef(styles);
+      const serialized = serialize.serializeStyles(args, cache.registered);
+      utils.insertStyles(cache, serialized, false);
+      return `${cache.key}-${serialized.name}${ref === void 0 ? "" : ` ${ref}`}`;
+    };
+    const cx = (...args) => merge(cache.registered, css, clsx__default.default(args));
+    return {
+      css,
+      cx
+    };
+  }
+  return {
+    cssFactory: innerCssFactory
+  };
+})();
+function useCss() {
+  const cache = useEmotionCache.useEmotionCache();
+  return React.useMemo(() => cssFactory({
+    cache
+  }), [cache]);
+}
+exports.useCss = useCss;
+//# sourceMappingURL=useCss.cjs.map

package/dist/cjs/hooks/useCss.cjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"useCss.cjs","sources":["../../../src/hooks/useCss.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport clsx from \"clsx\";\nimport { css as emotionCss, EmotionCache } from \"@emotion/css\";\nimport { serializeStyles, RegisteredCache } from \"@emotion/serialize\";\nimport { insertStyles, getRegisteredStyles } from \"@emotion/utils\";\nimport { useEmotionCache } from \"@core/hooks/useEmotionCache\";\n\ntype CSS = typeof emotionCss;\n\nfunction getRef(args: any[]) {\n if (args.length !== 1) {\n return { args, ref: undefined };\n }\n\n const [arg] = args;\n\n if (!(arg instanceof Object)) {\n return { args, ref: undefined };\n }\n\n if (!(\"ref\" in arg)) {\n return { args, ref: undefined };\n }\n\n const { ref, ...argCopy } = arg;\n return { args: [argCopy], ref };\n}\n\nconst { cssFactory } = (() => {\n function merge(registered: RegisteredCache, css: CSS, className: string) {\n const registeredStyles: string[] = [];\n\n const rawClassName = getRegisteredStyles(\n registered,\n registeredStyles,\n className\n );\n\n if (registeredStyles.length < 2) {\n return className;\n }\n\n return rawClassName + css(registeredStyles);\n }\n\n function innerCssFactory(params: { cache: EmotionCache }) {\n const { cache } = params;\n\n const css: CSS = (...styles: any) => {\n const { ref, args } = getRef(styles);\n const serialized = serializeStyles(args, cache.registered);\n insertStyles(cache as any, serialized, false);\n return `${cache.key}-${serialized.name}${\n ref === undefined ? \"\" : ` ${ref}`\n }`;\n };\n\n const cx = (...args: any) => merge(cache.registered, css, clsx(args));\n\n return { css, cx };\n }\n\n return { cssFactory: innerCssFactory };\n})();\n\nexport function useCss() {\n const cache = useEmotionCache();\n return useMemo(() => cssFactory({ cache }), [cache]);\n}\n"],"names":["getRef","args","length","ref","undefined","arg","Object","argCopy","cssFactory","merge","registered","css","className","registeredStyles","rawClassName","getRegisteredStyles","innerCssFactory","params","cache","styles","serialized","serializeStyles","key","name","cx","clsx","useCss","useEmotionCache","useMemo"],"mappings":";;;;;;;;;AASA,SAASA,OAAOC,MAAa;AACvBA,MAAAA,KAAKC,WAAW,GAAG;AACd,WAAA;AAAA,MAAED;AAAAA,MAAME,KAAKC;AAAAA,IAAAA;AAAAA,EACtB;AAEM,QAAA,CAACC,GAAG,IAAIJ;AAEV,MAAA,EAAEI,eAAeC,SAAS;AACrB,WAAA;AAAA,MAAEL;AAAAA,MAAME,KAAKC;AAAAA,IAAAA;AAAAA,EACtB;AAEI,MAAA,EAAE,SAASC,MAAM;AACZ,WAAA;AAAA,MAAEJ;AAAAA,MAAME,KAAKC;AAAAA,IAAAA;AAAAA,EACtB;AAEM,QAAA;AAAA,IAAED;AAAAA,IAAK,GAAGI;AAAAA,EAAYF,IAAAA;AACrB,SAAA;AAAA,IAAEJ,MAAM,CAACM,OAAO;AAAA,IAAGJ;AAAAA,EAAAA;AAC5B;AAEA,MAAM;AAAA,EAAEK;AAAW,KAAK,MAAM;AACnBC,WAAAA,MAAMC,YAA6BC,KAAUC,WAAmB;AACvE,UAAMC,mBAA6B,CAAA;AAEnC,UAAMC,eAAeC,MAAAA,oBACnBL,YACAG,kBACAD,SACF;AAEIC,QAAAA,iBAAiBX,SAAS,GAAG;AACxBU,aAAAA;AAAAA,IACT;AAEOE,WAAAA,eAAeH,IAAIE,gBAAgB;AAAA,EAC5C;AAEA,WAASG,gBAAgBC,QAAiC;AAClD,UAAA;AAAA,MAAEC;AAAAA,IAAUD,IAAAA;AAEZN,UAAAA,MAAWA,IAAIQ,WAAgB;AAC7B,YAAA;AAAA,QAAEhB;AAAAA,QAAKF;AAAAA,MAAAA,IAASD,OAAOmB,MAAM;AACnC,YAAMC,aAAaC,UAAAA,gBAAgBpB,MAAMiB,MAAMR,UAAU;AAC5CQ,YAAAA,aAAAA,OAAcE,YAAY,KAAK;AACpC,aAAA,GAAEF,MAAMI,OAAOF,WAAWG,OAChCpB,QAAQC,SAAY,KAAM,IAAGD;AAAAA,IAAAA;AAI3BqB,UAAAA,KAAKA,IAAIvB,SAAcQ,MAAMS,MAAMR,YAAYC,KAAKc,cAAAA,QAAKxB,IAAI,CAAC;AAE7D,WAAA;AAAA,MAAEU;AAAAA,MAAKa;AAAAA,IAAAA;AAAAA,EAChB;AAEO,SAAA;AAAA,IAAEhB,YAAYQ;AAAAA,EAAAA;AACvB;AAEO,SAASU,SAAS;AACvB,QAAMR,QAAQS,gBAAAA;AACPC,SAAAA,MAAAA,QAAQ,MAAMpB,WAAW;AAAA,IAAEU;AAAAA,EAAAA,CAAO,GAAG,CAACA,KAAK,CAAC;AACrD;;"}

package/dist/cjs/hooks/useEmotionCache.cjs ADDED Viewed

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+require("@hitachivantara/uikit-styles");
+const ThemeProvider = require("../providers/ThemeProvider.cjs");
+function useEmotionCache() {
+  var _a;
+  const cache = (_a = React.useContext(ThemeProvider.EmotionContext)) == null ? void 0 : _a.cache;
+  return cache || ThemeProvider.defaultEmotionCache;
+}
+exports.useEmotionCache = useEmotionCache;
+//# sourceMappingURL=useEmotionCache.cjs.map

package/dist/cjs/hooks/useEmotionCache.cjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"useEmotionCache.cjs","sources":["../../../src/hooks/useEmotionCache.ts"],"sourcesContent":["import { useContext } from \"react\";\nimport { EmotionContext, defaultEmotionCache } from \"..\";\n\nexport function useEmotionCache() {\n const cache = useContext(EmotionContext)?.cache;\n return cache || defaultEmotionCache;\n}\n"],"names":["useEmotionCache","cache","useContext","EmotionContext","defaultEmotionCache"],"mappings":";;;;;AAGO,SAASA,kBAAkB;;AAC1BC,QAAAA,SAAQC,WAAAA,WAAWC,cAAc,cAAA,MAAzBD,mBAA4BD;AAC1C,SAAOA,SAASG,cAAAA;AAClB;;"}

package/dist/cjs/hooks/useForkRef.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useForkRef.cjs","sources":["../../../src/hooks/useForkRef.ts"],"sourcesContent":["// copied from https://github.com/mui-org/material-ui/blob/03bd73be34424cb2cd17ac602def9ad2b9642de4/packages/material-ui-utils/src/useForkRef.js\nimport * as React from \"react\";\n\nconst setRef = (ref, value) => {\n if (typeof ref === \"function\") {\n ref(value);\n } else if (ref) {\n ~~// eslint-disable-next-line no-param-reassign\n~~ ref.current = value;\n }\n};\n\nexport default function useForkRef(refA, refB) {\n /*\n This will create a new function if the ref props change and are defined.\n * This means react will call the old forkRef with `null` and the new forkRef\n * with the ref. Cleanup naturally emerges from this behavior.\n */\n return React.useMemo(() => {\n if (refA == null && refB == null) {\n return null;\n }\n return (refValue) => {\n setRef(refA, refValue);\n setRef(refB, refValue);\n };\n }, [refA, refB]);\n}\n"],"names":["setRef","ref","value","current","useForkRef","refA","refB","React","useMemo","refValue"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAGA,MAAMA,SAASA,CAACC,KAAKC,UAAU;AACzB,MAAA,OAAOD,QAAQ,YAAY;AAC7BA,QAAIC,KAAK;AAAA,aACAD,KAAK;~~AAEdA~~,QAAIE,UAAUD;AAAAA,EAChB;AACF;AAEwBE,SAAAA,WAAWC,MAAMC,MAAM;AAMtCC,SAAAA,iBAAMC,QAAQ,MAAM;AACrBH,QAAAA,QAAQ,QAAQC,QAAQ,MAAM;AACzB,aAAA;AAAA,IACT;AACA,WAAQG,CAAa,aAAA;AACnBT,aAAOK,MAAMI,QAAQ;AACrBT,aAAOM,MAAMG,QAAQ;AAAA,IAAA;AAAA,EACvB,GACC,CAACJ,MAAMC,IAAI,CAAC;AACjB;;"}
1	+ {"version":3,"file":"useForkRef.cjs","sources":["../../../src/hooks/useForkRef.ts"],"sourcesContent":["// copied from https://github.com/mui-org/material-ui/blob/03bd73be34424cb2cd17ac602def9ad2b9642de4/packages/material-ui-utils/src/useForkRef.js\nimport * as React from \"react\";\n\nconst setRef = (ref, value) => {\n if (typeof ref === \"function\") {\n ref(value);\n } else if (ref) {\n ref.current = value;\n }\n};\n\nexport default function useForkRef(refA, refB) {\n /*\n This will create a new function if the ref props change and are defined.\n * This means react will call the old forkRef with `null` and the new forkRef\n * with the ref. Cleanup naturally emerges from this behavior.\n */\n return React.useMemo(() => {\n if (refA == null && refB == null) {\n return null;\n }\n return (refValue) => {\n setRef(refA, refValue);\n setRef(refB, refValue);\n };\n }, [refA, refB]);\n}\n"],"names":["setRef","ref","value","current","useForkRef","refA","refB","React","useMemo","refValue"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAGA,MAAMA,SAASA,CAACC,KAAKC,UAAU;AACzB,MAAA,OAAOD,QAAQ,YAAY;AAC7BA,QAAIC,KAAK;AAAA,aACAD,KAAK;AACdA,QAAIE,UAAUD;AAAAA,EAChB;AACF;AAEwBE,SAAAA,WAAWC,MAAMC,MAAM;AAMtCC,SAAAA,iBAAMC,QAAQ,MAAM;AACrBH,QAAAA,QAAQ,QAAQC,QAAQ,MAAM;AACzB,aAAA;AAAA,IACT;AACA,WAAQG,CAAa,aAAA;AACnBT,aAAOK,MAAMI,QAAQ;AACrBT,aAAOM,MAAMG,QAAQ;AAAA,IAAA;AAAA,EACvB,GACC,CAACJ,MAAMC,IAAI,CAAC;AACjB;;"}

package/dist/cjs/hooks/useTheme.cjs CHANGED Viewed

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const React = require("react");
-require("@hitachivantara/uikit-styles");
+require("../providers/ThemeProvider.cjs");
 const uikitReactShared = require("@hitachivantara/uikit-react-shared");
-require("@mui/material/styles");
-require("@emotion/react/jsx-runtime");
 const useTheme = () => {
   return React.useContext(uikitReactShared.HvThemeContext);
 };

package/dist/cjs/hooks/useTheme.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useTheme.cjs","sources":["../../../src/hooks/useTheme.ts"],"sourcesContent":["import { useContext } from \"react\";\nimport {\n HvThemeContext,\n HvThemeContextValue,\n} from \"../providers/ThemeProvider\";\n\nexport const useTheme = (): HvThemeContextValue => {\n return useContext(HvThemeContext);\n};\n"],"names":["useTheme","useContext","HvThemeContext"],"mappings":"~~;;;;;;;~~AAMO,MAAMA,WAAWA,MAA2B;AACjD,SAAOC,MAAAA,WAAWC,iBAAAA,cAAc;AAClC;;"}
1	+ {"version":3,"file":"useTheme.cjs","sources":["../../../src/hooks/useTheme.ts"],"sourcesContent":["import { useContext } from \"react\";\nimport {\n HvThemeContext,\n HvThemeContextValue,\n} from \"../providers/ThemeProvider\";\n\nexport const useTheme = (): HvThemeContextValue => {\n return useContext(HvThemeContext);\n};\n"],"names":["useTheme","useContext","HvThemeContext"],"mappings":";;;;;AAMO,MAAMA,WAAWA,MAA2B;AACjD,SAAOC,MAAAA,WAAWC,iBAAAA,cAAc;AAClC;;"}

package/dist/cjs/index.cjs CHANGED Viewed

@@ -154,9 +154,9 @@ const breadCrumbClasses = require("./components/BreadCrumb/breadCrumbClasses.cjs
 const BreadCrumb = require("./components/BreadCrumb/BreadCrumb.cjs");
 const dotPaginationClasses = require("./components/DotPagination/dotPaginationClasses.cjs");
 const DotPagination = require("./components/DotPagination/DotPagination.cjs");
-const bannerClasses = require("./components/Banner/bannerClasses.cjs");
+const Banner_styles = require("./components/Banner/Banner.styles.cjs");
 const Banner = require("./components/Banner/Banner.cjs");
-const bannerContentClasses = require("./components/Banner/BannerContent/bannerContentClasses.cjs");
+const BannerContent_styles = require("./components/Banner/BannerContent/BannerContent.styles.cjs");
 const BannerContent = require("./components/Banner/BannerContent/BannerContent.cjs");
 const snackbarClasses = require("./components/Snackbar/snackbarClasses.cjs");
 const Snackbar = require("./components/Snackbar/Snackbar.cjs");
@@ -463,9 +463,9 @@ exports.breadCrumbClasses = breadCrumbClasses.default;
 exports.HvBreadCrumb = BreadCrumb.HvBreadCrumb;
 exports.dotPaginationClasses = dotPaginationClasses.default;
 exports.HvDotPagination = DotPagination.HvDotPagination;
-exports.bannerClasses = bannerClasses.default;
+exports.bannerClasses = Banner_styles.staticClasses;
 exports.HvBanner = Banner.HvBanner;
-exports.bannerContentClasses = bannerContentClasses.default;
+exports.bannerContentClasses = BannerContent_styles.staticClasses;
 exports.HvBannerContent = BannerContent.HvBannerContent;
 exports.snackbarClasses = snackbarClasses.default;
 exports.HvSnackbar = Snackbar.HvSnackbar;
@@ -612,7 +612,10 @@ Object.defineProperty(exports, "HvThemeContext", {
   enumerable: true,
   get: () => uikitReactShared.HvThemeContext
 });
+exports.EmotionContext = ThemeProvider.EmotionContext;
 exports.HvThemeProvider = ThemeProvider.HvThemeProvider;
+exports.defaultCacheKey = ThemeProvider.defaultCacheKey;
+exports.defaultEmotionCache = ThemeProvider.defaultEmotionCache;
 exports.iconVariant = iconVariant.default;
 exports.hexToRgbA = hexToRgbA.default;
 exports.isBrowser = browser.default;
@@ -632,7 +635,9 @@ exports.processThemes = theme.processThemes;
 exports.setElementAttrs = theme.setElementAttrs;
 exports.setId = setId.setId;
 exports.setUid = setId.setUid;
+exports.createClasses = classes.createClasses;
 exports.getClasses = classes.getClasses;
+exports.replace$ = classes.replace$;
 exports.getFirstAndLastFocus = focusableElementFinder.getFirstAndLastFocus;
 exports.getFocusableList = focusableElementFinder.getFocusableList;
 exports.getPrevNextFocus = focusableElementFinder.getPrevNextFocus;

package/dist/cjs/index.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1	+ {"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/providers/Provider.cjs CHANGED Viewed

@@ -19,21 +19,22 @@ const HvProvider = ({
   themes,
   theme: theme$1,
   colorMode,
-  classNameKey = "hv-uikit-css"
+  classNameKey = ThemeProvider.defaultCacheKey
 }) => {
   const scopedRootId = useUniqueId.default(void 0, scopedRootPrefix);
   const themesList = theme.processThemes(themes);
-  const emotionCache = React.useMemo(() => createCache__default.default({
+  const emotionCache = React.useMemo(() => classNameKey === ThemeProvider.defaultCacheKey ? ThemeProvider.defaultEmotionCache : createCache__default.default({
     key: classNameKey,
     prepend: true
   }), [classNameKey]);
   return /* @__PURE__ */ jsxRuntime.jsxs(react.CacheProvider, {
     value: emotionCache,
     children: [/* @__PURE__ */ jsxRuntime.jsx(react.Global, {
-      styles: /* @__PURE__ */ react.css(cssBaseline === "global" && uikitStyles.CssBaseline, " ", uikitStyles.getThemesVars(themesList), ";" + (process.env.NODE_ENV === "production" ? "" : ";label:HvProvider;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")
+      styles: /* @__PURE__ */ react.css(cssBaseline === "global" && uikitStyles.CssBaseline, " ", uikitStyles.getThemesVars(themesList), ";" + (process.env.NODE_ENV === "production" ? "" : ";label:HvProvider;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")
     }), /* @__PURE__ */ jsxRuntime.jsx(ThemeProvider.HvThemeProvider, {
       themes: themesList,
       theme: theme$1 || themesList[0].name,
+      emotionCache,
       colorMode: colorMode || Object.keys(themesList[0].colors.modes)[0],
       themeRootId: cssTheme === "scoped" ? rootElementId || scopedRootId : void 0,
       children: /* @__PURE__ */ jsxRuntime.jsx(react.ClassNames, {

package/dist/cjs/providers/Provider.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"Provider.cjs","sources":["../../../src/providers/Provider.tsx"],"sourcesContent":["import {\n css as cssReact,\n Global,\n CacheProvider,\n ClassNames,\n} from \"@emotion/react\";\nimport {\n CssBaseline,\n CssScopedBaseline,\n getThemesVars,\n HvThemeStructure,\n} from \"@hitachivantara/uikit-styles\";\nimport { processThemes } from \"@core/utils\";\nimport { HvTheme } from \"@core/types\";\nimport React, { useMemo } from \"react\";\nimport createCache from \"@emotion/cache\";\nimport { useUniqueId } from \"@core/hooks\";\nimport { HvThemeProvider } from \"./ThemeProvider\";\n\n// Provider props\nexport interface HvProviderProps {\n /*\n Your component tree.\n /\n children?: React.ReactNode;\n /\n Id of your root element.\n /\n rootElementId?: string;\n /\n By default the baseline styles are applied globally, `global`, to the application for the UI Kit components to work properly.\n * If you need to scope the baseline styles to avoid styling conflicts, you can set this property to `scoped`.\n * To scope the baseline to your root, you need to add the `rootElementId` property.\n * If the `rootElementId` property is not set, the baseline will be scoped to a new container, `hv-uikit-scoped-root`, created around your content.\n If you are providing your own baseline styles, you can set this property to `none` to disable the baseline styles.\n /\n cssBaseline?: \"global\" \| \"scoped\" \| \"none\";\n /\n By default the theme styles are applied globally, `global`, to the application.\n * If you need to scope the theme styles to avoid styling conflicts, you can set this property to `scoped`.\n * To scope the theme to your root, you need to add the `rootElementId` property.\n * If the `rootElementId` property is not set, the theme will be scoped to a new container, `hv-uikit-scoped-root`, created around your content.\n /\n cssTheme?: \"global\" \| \"scoped\";\n /*\n The string used to prefix the class names and uniquely identify them. The key can only contain lower case alphabetical characters.\n * This is useful to avoid class name collisions.\n \n If no value is provided, the default is `hv~~-uikit-css~~`.\n /\n classNameKey?: string;\n /\n List of themes to be used by UI Kit.\n * You can provide your own themes created with the `createTheme` utility and/or the default themes `ds3` and `ds5` provided by UI Kit.\n \n If no value is provided, the `ds5` theme will be used.\n /\n themes?: (HvTheme \| HvThemeStructure)[];\n /\n The active theme. It must be one of the themes passed to `themes`.\n \n If no value is provided, the first theme from the `themes` list is used. If no `themes` list is provided, the `ds5` theme will be used.\n /\n theme?: string;\n /\n The active color mode. It must be one of the color modes of the active theme.\n \n If no value is provided, the first color mode defined in the active theme is used.\n * For the default themes `ds3` and `ds5`, the `dawn` color mode is the one used.\n /\n colorMode?: string;\n}\n\nconst scopedRootPrefix = \"hv-uikit-scoped-root\" as const;\n\n/\n Enables theming capabilities and makes cross-component theme properties available down the tree.\n */\nexport const HvProvider = ({\n children,\n rootElementId,\n cssBaseline = \"global\",\n cssTheme = \"global\",\n themes,\n theme,\n colorMode,\n classNameKey = ~~\"hv-uikit-css\"~~,\n}: HvProviderProps) => {\n const scopedRootId = useUniqueId(undefined, scopedRootPrefix);\n\n // Themes\n const themesList: (HvTheme \| HvThemeStructure)[] = processThemes(themes);\n\n // Emotion cache\n // Moves UI Kit styles to the top of the <head> so they're loaded first\n // This enables users to override the UI Kit styles if necessary\n const emotionCache = useMemo(\n () =>\n createCache({\n key: classNameKey~~,\n~~ prepend: true~~,\n~~ }),\n [classNameKey]\n );\n\n return (\n <CacheProvider value={emotionCache}>\n <Global\n styles={cssReact`\n ${cssBaseline === \"global\" && CssBaseline}\n ${getThemesVars(themesList)}\n `}\n />\n <HvThemeProvider\n themes={themesList}\n theme={theme \|\| themesList[0].name}\n colorMode={colorMode \|\| Object.keys(themesList[0].colors.modes)[0]}\n themeRootId={\n cssTheme === \"scoped\" ? rootElementId \|\| scopedRootId : undefined\n }\n >\n <ClassNames>\n {({ css }) => {\n if (cssBaseline === \"scoped\" && rootElementId) {\n const rootElement = document.getElementById(rootElementId);\n\n if (rootElement) {\n rootElement.classList.add(\n css({\n ...CssScopedBaseline,\n })\n );\n }\n }\n\n return (cssTheme === \"scoped\" \|\| cssBaseline === \"scoped\") &&\n !rootElementId ? (\n <div\n id={scopedRootId}\n className={\n cssBaseline === \"scoped\"\n ? css({ ...CssScopedBaseline })\n : undefined\n }\n >\n {children}\n </div>\n ) : (\n children\n );\n }}\n </ClassNames>\n </HvThemeProvider>\n </CacheProvider>\n );\n};\n"],"names":["scopedRootPrefix","HvProvider","children","rootElementId","cssBaseline","cssTheme","themes","theme","colorMode","classNameKey","scopedRootId","useUniqueId","undefined","themesList","processThemes","emotionCache","useMemo","createCache","key","prepend","CacheProvider","value","_jsx","Global","styles","CssBaseline","getThemesVars","process","env","NODE_ENV","HvThemeProvider","name","Object","keys","colors","modes","themeRootId","ClassNames","css","rootElement","document","getElementById","classList","add","CssScopedBaseline","id","className"],"mappings":";;;;;;;;;;;;~~AAyEA~~,MAAMA,mBAAmB;AAKlB,MAAMC,aAAaA,CAAC;AAAA,EACzBC;AAAAA,EACAC;AAAAA,EACAC,cAAc;AAAA,EACdC,WAAW;AAAA,EACXC;AAAAA,EAAAA,OACAC;AAAAA,EACAC;AAAAA,EACAC,~~eAAe~~;AACA,MAAM;AACfC,QAAAA,eAAeC,YAAYC,QAAAA,~~QAAWZ~~,gBAAgB;~~AAGtDa~~,QAAAA,aAA6CC,~~oBAAcR~~,MAAM;~~AAKjES~~,~~QAAAA~~,eAAeC,~~cACnB~~,~~MACEC~~,6BAAY;AAAA,~~IACVC~~,~~KAAKT~~;AAAAA,~~IACLU~~,SAAS;AAAA,EAAA,~~CACV~~,~~GACH~~,~~CAACV~~,YAAY,~~CAAC~~;~~AAGhB~~,~~yCACGW~~,MAAAA,eAAa;AAAA,IAACC,~~OAAON~~;AAAAA,~~IAAab~~,UAAA,~~CACjCoB~~,2BAAAA,IAACC,cAAM;AAAA,MACLC,~~kCACIpB~~,gBAAgB,~~YAAYqB~~,YAAAA,aAC5BC,KAAAA,~~0BAAcb~~,UAAU,~~GAACc~~,OAAAA,QAAAC,IAAAC,wDAAAF,QAAAC,IAAAC,aAAA,eAAA,KAAA,~~67OAAA~~;AAAA,IAAA,~~CAE7B~~,~~GACFP~~,2BAAAA,IAACQ,+BAAe;AAAA,~~MACdxB~~,~~QAAQO~~;AAAAA,~~MACRN~~,OAAOA,~~WAASM~~,WAAW,CAAC,~~EAAEkB~~;AAAAA,~~MAC9BvB~~,WAAWA,~~aAAawB~~,OAAOC,~~KAAKpB~~,WAAW,CAAC,~~EAAEqB~~,OAAOC,KAAK,EAAE,CAAC;AAAA,MACjEC,~~aACE/B~~,aAAa,WAAWF,~~iBAAiBO~~,eAAeE;AAAAA,~~MACzDV~~,~~yCAEAmC~~,kBAAU;AAAA,~~QAAAnC~~,UACRA,CAAC;AAAA,~~UAAEoC~~;AAAAA,QAAAA,MAAU;~~AACRlC~~,cAAAA,gBAAgB,YAAYD,eAAe;~~AACvCoC~~,kBAAAA,cAAcC,SAASC,~~eAAetC~~,aAAa;AAEzD,~~gBAAIoC~~,aAAa;AACHG,0BAAAA,UAAUC,IACpBL,IAAI;AAAA,gBACF,GAAGM,YAAAA;AAAAA,cACJ,CAAA,~~CAAC~~;AAAA,~~YAEN~~;AAAA,UACF;AAEA,~~kBAAQvC~~,aAAa,YAAYD,gBAAgB,aAC/C,CAACD,+CACD,OAAA;AAAA,~~YACE0C~~,~~IAAInC~~;AAAAA,~~YACJoC~~,~~WACE1C~~,gBAAgB,~~WACZkC~~,IAAI;AAAA,cAAE,GAAGM,YAAAA;AAAAA,YAAmB,CAAA,~~IAC5BhC~~;AAAAA,~~YACLV~~;AAAAA,~~UAEQ~~,CAAA,~~IAGXA~~;AAAAA,QAEJ;AAAA,MAAA,~~CAAC~~;AAAA,IAAA,~~CAEa~~,~~CAAA~~;AAAA,EAAA,~~CACJ~~;~~AAEpB~~;;"}
1	+ {"version":3,"file":"Provider.cjs","sources":["../../../src/providers/Provider.tsx"],"sourcesContent":["import {\n css as cssReact,\n Global,\n CacheProvider,\n ClassNames,\n} from \"@emotion/react\";\nimport {\n CssBaseline,\n CssScopedBaseline,\n getThemesVars,\n HvThemeStructure,\n} from \"@hitachivantara/uikit-styles\";\nimport { processThemes } from \"@core/utils\";\nimport { HvTheme } from \"@core/types\";\nimport React, { useMemo } from \"react\";\nimport createCache from \"@emotion/cache\";\nimport { useUniqueId } from \"@core/hooks\";\nimport {\n HvThemeProvider,\n defaultCacheKey,\n defaultEmotionCache,\n} from \"./ThemeProvider\";\n\n// Provider props\nexport interface HvProviderProps {\n /*\n Your component tree.\n /\n children?: React.ReactNode;\n /\n Id of your root element.\n /\n rootElementId?: string;\n /\n By default the baseline styles are applied globally, `global`, to the application for the UI Kit components to work properly.\n * If you need to scope the baseline styles to avoid styling conflicts, you can set this property to `scoped`.\n * To scope the baseline to your root, you need to add the `rootElementId` property.\n * If the `rootElementId` property is not set, the baseline will be scoped to a new container, `hv-uikit-scoped-root`, created around your content.\n If you are providing your own baseline styles, you can set this property to `none` to disable the baseline styles.\n /\n cssBaseline?: \"global\" \| \"scoped\" \| \"none\";\n /\n By default the theme styles are applied globally, `global`, to the application.\n * If you need to scope the theme styles to avoid styling conflicts, you can set this property to `scoped`.\n * To scope the theme to your root, you need to add the `rootElementId` property.\n * If the `rootElementId` property is not set, the theme will be scoped to a new container, `hv-uikit-scoped-root`, created around your content.\n /\n cssTheme?: \"global\" \| \"scoped\";\n /*\n The string used to prefix the class names and uniquely identify them. The key can only contain lower case alphabetical characters.\n * This is useful to avoid class name collisions.\n \n If no value is provided, the default is `hv`.\n /\n classNameKey?: string;\n /\n List of themes to be used by UI Kit.\n * You can provide your own themes created with the `createTheme` utility and/or the default themes `ds3` and `ds5` provided by UI Kit.\n \n If no value is provided, the `ds5` theme will be used.\n /\n themes?: (HvTheme \| HvThemeStructure)[];\n /\n The active theme. It must be one of the themes passed to `themes`.\n \n If no value is provided, the first theme from the `themes` list is used. If no `themes` list is provided, the `ds5` theme will be used.\n /\n theme?: string;\n /\n The active color mode. It must be one of the color modes of the active theme.\n \n If no value is provided, the first color mode defined in the active theme is used.\n * For the default themes `ds3` and `ds5`, the `dawn` color mode is the one used.\n /\n colorMode?: string;\n}\n\nconst scopedRootPrefix = \"hv-uikit-scoped-root\" as const;\n\n/\n Enables theming capabilities and makes cross-component theme properties available down the tree.\n */\nexport const HvProvider = ({\n children,\n rootElementId,\n cssBaseline = \"global\",\n cssTheme = \"global\",\n themes,\n theme,\n colorMode,\n classNameKey = defaultCacheKey,\n}: HvProviderProps) => {\n const scopedRootId = useUniqueId(undefined, scopedRootPrefix);\n\n // Themes\n const themesList: (HvTheme \| HvThemeStructure)[] = processThemes(themes);\n\n // Emotion cache\n // Moves UI Kit styles to the top of the <head> so they're loaded first\n // This enables users to override the UI Kit styles if necessary\n const emotionCache = useMemo(\n () =>\n classNameKey === defaultCacheKey\n ? defaultEmotionCache\n : createCache({ key: classNameKey, prepend: true }),\n [classNameKey]\n );\n\n return (\n <CacheProvider value={emotionCache}>\n <Global\n styles={cssReact`\n ${cssBaseline === \"global\" && CssBaseline}\n ${getThemesVars(themesList)}\n `}\n />\n <HvThemeProvider\n themes={themesList}\n theme={theme \|\| themesList[0].name}\n emotionCache={emotionCache}\n colorMode={colorMode \|\| Object.keys(themesList[0].colors.modes)[0]}\n themeRootId={\n cssTheme === \"scoped\" ? rootElementId \|\| scopedRootId : undefined\n }\n >\n <ClassNames>\n {({ css }) => {\n if (cssBaseline === \"scoped\" && rootElementId) {\n const rootElement = document.getElementById(rootElementId);\n\n if (rootElement) {\n rootElement.classList.add(\n css({\n ...CssScopedBaseline,\n })\n );\n }\n }\n\n return (cssTheme === \"scoped\" \|\| cssBaseline === \"scoped\") &&\n !rootElementId ? (\n <div\n id={scopedRootId}\n className={\n cssBaseline === \"scoped\"\n ? css({ ...CssScopedBaseline })\n : undefined\n }\n >\n {children}\n </div>\n ) : (\n children\n );\n }}\n </ClassNames>\n </HvThemeProvider>\n </CacheProvider>\n );\n};\n"],"names":["scopedRootPrefix","HvProvider","children","rootElementId","cssBaseline","cssTheme","themes","theme","colorMode","classNameKey","defaultCacheKey","scopedRootId","useUniqueId","undefined","themesList","processThemes","emotionCache","useMemo","defaultEmotionCache","createCache","key","prepend","CacheProvider","value","_jsx","Global","styles","CssBaseline","getThemesVars","process","env","NODE_ENV","HvThemeProvider","name","Object","keys","colors","modes","themeRootId","ClassNames","css","rootElement","document","getElementById","classList","add","CssScopedBaseline","id","className"],"mappings":";;;;;;;;;;;;AA6EA,MAAMA,mBAAmB;AAKlB,MAAMC,aAAaA,CAAC;AAAA,EACzBC;AAAAA,EACAC;AAAAA,EACAC,cAAc;AAAA,EACdC,WAAW;AAAA,EACXC;AAAAA,EAAAA,OACAC;AAAAA,EACAC;AAAAA,EACAC,eAAeC,cAAAA;AACA,MAAM;AACfC,QAAAA,eAAeC,YAAYC,QAAAA,QAAWb,gBAAgB;AAGtDc,QAAAA,aAA6CC,oBAAcT,MAAM;AAKvE,QAAMU,eAAeC,MAAAA,QACnB,MACER,iBAAiBC,cAAAA,kBACbQ,oCACAC,6BAAY;AAAA,IAAEC,KAAKX;AAAAA,IAAcY,SAAS;AAAA,EAAA,CAAM,GACtD,CAACZ,YAAY,CACf;AAEA,yCACGa,MAAAA,eAAa;AAAA,IAACC,OAAOP;AAAAA,IAAad,UAAA,CACjCsB,2BAAAA,IAACC,cAAM;AAAA,MACLC,kCACItB,gBAAgB,YAAYuB,YAAAA,aAC5BC,KAAAA,0BAAcd,UAAU,GAACe,OAAAA,QAAAC,IAAAC,wDAAAF,QAAAC,IAAAC,aAAA,eAAA,KAAA,qmPAAA;AAAA,IAAA,CAE9B,GACDP,2BAAAA,IAACQ,+BAAe;AAAA,MACd1B,QAAQQ;AAAAA,MACRP,OAAOA,WAASO,WAAW,CAAC,EAAEmB;AAAAA,MAC9BjB;AAAAA,MACAR,WAAWA,aAAa0B,OAAOC,KAAKrB,WAAW,CAAC,EAAEsB,OAAOC,KAAK,EAAE,CAAC;AAAA,MACjEC,aACEjC,aAAa,WAAWF,iBAAiBQ,eAAeE;AAAAA,MACzDX,yCAEAqC,kBAAU;AAAA,QAAArC,UACRA,CAAC;AAAA,UAAEsC;AAAAA,QAAAA,MAAU;AACRpC,cAAAA,gBAAgB,YAAYD,eAAe;AACvCsC,kBAAAA,cAAcC,SAASC,eAAexC,aAAa;AAEzD,gBAAIsC,aAAa;AACHG,0BAAAA,UAAUC,IACpBL,IAAI;AAAA,gBACF,GAAGM,YAAAA;AAAAA,cACJ,CAAA,CACH;AAAA,YACF;AAAA,UACF;AAEA,kBAAQzC,aAAa,YAAYD,gBAAgB,aAC/C,CAACD,+CACD,OAAA;AAAA,YACE4C,IAAIpC;AAAAA,YACJqC,WACE5C,gBAAgB,WACZoC,IAAI;AAAA,cAAE,GAAGM,YAAAA;AAAAA,YAAmB,CAAA,IAC5BjC;AAAAA,YACLX;AAAAA,UAGE,CAAA,IAELA;AAAAA,QAEJ;AAAA,MAAA,CACU;AAAA,IAAA,CACG,CAAC;AAAA,EAAA,CACL;AAEnB;;"}

package/dist/cjs/providers/ThemeProvider.cjs CHANGED Viewed

@@ -4,12 +4,24 @@ const React = require("react");
 const uikitStyles = require("@hitachivantara/uikit-styles");
 const uikitReactShared = require("@hitachivantara/uikit-react-shared");
 const styles = require("@mui/material/styles");
+const createCache = require("@emotion/cache");
 const jsxRuntime = require("@emotion/react/jsx-runtime");
 const theme = require("../utils/theme.cjs");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const createCache__default = /* @__PURE__ */ _interopDefault(createCache);
+const defaultCacheKey = "hv";
+const defaultEmotionCache = createCache__default.default({
+  key: defaultCacheKey,
+  prepend: true
+});
+const EmotionContext = React.createContext({
+  cache: defaultEmotionCache
+});
 const HvThemeProvider = ({
   children,
   themes: themesList,
   theme: theme$1,
+  emotionCache,
   colorMode,
   themeRootId
 }) => {
@@ -50,11 +62,17 @@ const HvThemeProvider = ({
       }
     }
   });
+  const emotionCacheValue = React.useMemo(() => ({
+    cache: emotionCache
+  }), [emotionCache]);
   return /* @__PURE__ */ jsxRuntime.jsx(styles.ThemeProvider, {
     theme: MuiTheme,
     children: /* @__PURE__ */ jsxRuntime.jsx(uikitReactShared.HvThemeContext.Provider, {
       value,
-      children
+      children: /* @__PURE__ */ jsxRuntime.jsx(EmotionContext.Provider, {
+        value: emotionCacheValue,
+        children
+      })
     })
   });
 };
@@ -62,5 +80,8 @@ Object.defineProperty(exports, "HvThemeContext", {
   enumerable: true,
   get: () => uikitReactShared.HvThemeContext
 });
+exports.EmotionContext = EmotionContext;
 exports.HvThemeProvider = HvThemeProvider;
+exports.defaultCacheKey = defaultCacheKey;
+exports.defaultEmotionCache = defaultEmotionCache;
 //# sourceMappingURL=ThemeProvider.cjs.map

package/dist/cjs/providers/ThemeProvider.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ThemeProvider.cjs","sources":["../../../src/providers/ThemeProvider.tsx"],"sourcesContent":["import { useEffect, useMemo, useState } from \"react\";\nimport { parseTheme, HvThemeStructure } from \"@hitachivantara/uikit-styles\";\nimport { HvThemeContext } from \"@hitachivantara/uikit-react-shared\";\nimport type { HvThemeContextValue } from \"@hitachivantara/uikit-react-shared\";\nimport {\n createTheme,\n ThemeProvider as MuiThemeProvider,\n} from \"@mui/material/styles\";\nimport { setElementAttrs } from \"@core/utils\";\nimport { HvTheme } from \"@core/types\";\n\nexport { HvThemeContext };\nexport type { HvThemeContextValue };\n\ninterface HvThemeProviderProps {\n children: React.ReactNode;\n themes: (HvTheme \| HvThemeStructure)[];\n theme: string;\n colorMode: string;\n themeRootId?: string;\n}\n\nexport const HvThemeProvider = ({\n children,\n themes: themesList,\n theme,\n colorMode,\n themeRootId,\n}: HvThemeProviderProps) => {\n let pTheme = parseTheme(themesList, theme, colorMode);\n\n const [rootId] = useState<string \| undefined>(themeRootId);\n const [activeTheme, setActiveTheme] = useState<HvTheme \| HvThemeStructure>(\n pTheme.theme\n );\n const [selectedTheme, setSelectedTheme] = useState<string>(\n pTheme.selectedTheme\n );\n const [selectedMode, setThemeMode] = useState<string>(pTheme.selectedMode);\n const [colorModes, setColorModes] = useState<string[]>(pTheme.colorModes);\n const [themes, setThemes] = useState<string[]>(themesList.map((t) => t.name));\n\n useEffect(() => {\n setThemes(themesList.map((t) => t.name));\n }, [themesList]);\n\n const changeTheme = (newTheme = selectedTheme, newMode = selectedMode) => {\n pTheme = parseTheme(themesList, newTheme, newMode);\n\n setActiveTheme(pTheme.theme);\n setSelectedTheme(pTheme.selectedTheme);\n setThemeMode(pTheme.selectedMode);\n setColorModes(pTheme.colorModes);\n\n setElementAttrs(\n pTheme.selectedTheme,\n pTheme.selectedMode,\n pTheme.colorScheme,\n rootId\n );\n };\n\n useEffect(() => {\n changeTheme(theme, colorMode);\n }, [theme, colorMode]);\n\n const value = useMemo(\n () => ({\n themes,\n colorModes,\n activeTheme: activeTheme as HvTheme,\n selectedTheme,\n selectedMode,\n changeTheme,\n rootId,\n }),\n [\n themes,\n colorModes,\n activeTheme,\n selectedTheme,\n selectedMode,\n changeTheme,\n rootId,\n ]\n );\n\n const MuiTheme = createTheme({\n breakpoints: {\n values: {\n ...activeTheme.breakpoints.values,\n },\n },\n });\n\n return (\n <MuiThemeProvider theme={MuiTheme}>\n <HvThemeContext.Provider value={value}>\n {children}\n </HvThemeContext.Provider>\n </MuiThemeProvider>\n );\n};\n"],"names":["HvThemeProvider","children","themes","themesList","theme","colorMode","themeRootId","pTheme","parseTheme","rootId","useState","activeTheme","setActiveTheme","selectedTheme","setSelectedTheme","selectedMode","setThemeMode","colorModes","setColorModes","setThemes","map","t","name","useEffect","changeTheme","newTheme","newMode","setElementAttrs","colorScheme","value","useMemo","MuiTheme","createTheme","breakpoints","values","MuiThemeProvider","HvThemeContext","Provider"],"mappings":"~~;;;;;;;;AAsBO~~,MAAMA,kBAAkBA,CAAC;AAAA,EAC9BC;AAAAA,EACAC,QAAQC;AAAAA,EAAAA,OACRC;AAAAA,EACAC;AAAAA,EACAC;AACoB,MAAM;AAC1B,MAAIC,SAASC,YAAAA,~~WAAWL~~,YAAYC,~~SAAOC~~,SAAS;AAEpD,QAAM,CAACI,MAAM,IAAIC,MAAAA,SAA6BJ,WAAW;AACzD,QAAM,CAACK,aAAaC,cAAc,IAAIF,MAAAA,SACpCH,~~OAAOH~~,~~KAAK~~;~~AAEd~~,QAAM,~~CAACS~~,eAAeC,gBAAgB,IAAIJ,MAAAA,SACxCH,OAAOM,~~aAAa~~;~~AAEtB~~,QAAM,CAACE,cAAcC,YAAY,IAAIN,MAAAA,SAAiBH,OAAOQ,YAAY;AACzE,QAAM,CAACE,YAAYC,aAAa,IAAIR,MAAAA,SAAmBH,OAAOU,UAAU;AAClE,QAAA,~~CAACf~~,~~QAAQiB~~,SAAS,IAAIT,~~eAAmBP~~,~~WAAWiB~~,IAAKC,CAAAA,MAAMA,EAAEC,IAAI,CAAC;AAE5EC,QAAAA,UAAU,MAAM;AACdJ,~~cAAUhB~~,~~WAAWiB~~,IAAKC,CAAMA,MAAAA,EAAEC,IAAI,CAAC;AAAA,EAAA,GACtC,~~CAACnB~~,UAAU,CAAC;AAEf,~~QAAMqB~~,cAAcA,CAACC,WAAWZ,eAAea,UAAUX,iBAAiB;AAC/DP,aAAAA,YAAAA,~~WAAWL~~,~~YAAYsB~~,UAAUC,OAAO;AAEjDd,mBAAeL,~~OAAOH~~,KAAK;~~AAC3BU~~,qBAAiBP,OAAOM,aAAa;AACrCG,iBAAaT,OAAOQ,YAAY;AAChCG,kBAAcX,OAAOU,UAAU;AAE/BU,0BACEpB,OAAOM,eACPN,OAAOQ,cACPR,OAAOqB,aACPnB,~~MAAM~~;AAAA,EAAA;~~AAIVc~~,QAAAA,UAAU,MAAM;AACdC,~~gBAAYpB~~,~~SAAOC~~,SAAS;AAAA,EAAA,GAC3B,~~CAACD~~,~~SAAOC~~,SAAS,CAAC;AAEfwB,QAAAA,QAAQC,MAAAA,QACZ,OAAO;AAAA,~~IACL5B~~;AAAAA,~~IACAe~~;AAAAA,IACAN;AAAAA,IACAE;AAAAA,IACAE;AAAAA,IACAS;AAAAA,IACAf;AAAAA,EAAAA,IAEF,~~CACEP~~,~~QACAe~~,YACAN,aACAE,eACAE,cACAS,aACAf,MAAM,~~CACP~~;~~AAGH~~,QAAMsB,WAAWC,OAAAA,YAAY;AAAA,IAC3BC,aAAa;AAAA,MACXC,QAAQ;AAAA,QACN,GAAGvB,YAAYsB,YAAYC;AAAAA,MAC7B;AAAA,IACF;AAAA,EAAA,CACD;~~AAED~~,~~wCACGC~~,OAAAA,eAAgB;AAAA,~~IAAC/B~~,~~OAAO2B~~;AAAAA,~~IAAS9B~~,UAC/~~BmC~~,2BAAAA,IAAAA,iBAAAA,eAAeC,UAAQ;AAAA,~~MAACR~~;AAAAA,~~MAAa5B~~;AAAAA,~~IAAAA~~,~~CAC3B~~;AAAA,EAAA,~~CAEM~~;~~AAEvB;;;;;;~~"}
1	+ {"version":3,"file":"ThemeProvider.cjs","sources":["../../../src/providers/ThemeProvider.tsx"],"sourcesContent":["import { createContext, useEffect, useMemo, useState } from \"react\";\nimport { parseTheme, HvThemeStructure } from \"@hitachivantara/uikit-styles\";\nimport { HvThemeContext } from \"@hitachivantara/uikit-react-shared\";\nimport type { HvThemeContextValue } from \"@hitachivantara/uikit-react-shared\";\nimport {\n createTheme,\n ThemeProvider as MuiThemeProvider,\n} from \"@mui/material/styles\";\nimport createCache, { EmotionCache } from \"@emotion/cache\";\nimport { setElementAttrs } from \"@core/utils\";\nimport { HvTheme } from \"@core/types\";\n\nexport { HvThemeContext };\nexport type { HvThemeContextValue };\n\nexport const defaultCacheKey = \"hv\";\n\nexport const defaultEmotionCache = createCache({\n key: defaultCacheKey,\n prepend: true,\n});\n\nexport const EmotionContext = createContext<{ cache: EmotionCache }>({\n cache: defaultEmotionCache,\n});\n\ninterface HvThemeProviderProps {\n children: React.ReactNode;\n themes: (HvTheme \| HvThemeStructure)[];\n theme: string;\n emotionCache: EmotionCache;\n colorMode: string;\n themeRootId?: string;\n}\n\nexport const HvThemeProvider = ({\n children,\n themes: themesList,\n theme,\n emotionCache,\n colorMode,\n themeRootId,\n}: HvThemeProviderProps) => {\n let pTheme = parseTheme(themesList, theme, colorMode);\n\n const [rootId] = useState<string \| undefined>(themeRootId);\n const [activeTheme, setActiveTheme] = useState<HvTheme \| HvThemeStructure>(\n pTheme.theme\n );\n const [selectedTheme, setSelectedTheme] = useState<string>(\n pTheme.selectedTheme\n );\n const [selectedMode, setThemeMode] = useState<string>(pTheme.selectedMode);\n const [colorModes, setColorModes] = useState<string[]>(pTheme.colorModes);\n const [themes, setThemes] = useState<string[]>(themesList.map((t) => t.name));\n\n useEffect(() => {\n setThemes(themesList.map((t) => t.name));\n }, [themesList]);\n\n const changeTheme = (newTheme = selectedTheme, newMode = selectedMode) => {\n pTheme = parseTheme(themesList, newTheme, newMode);\n\n setActiveTheme(pTheme.theme);\n setSelectedTheme(pTheme.selectedTheme);\n setThemeMode(pTheme.selectedMode);\n setColorModes(pTheme.colorModes);\n\n setElementAttrs(\n pTheme.selectedTheme,\n pTheme.selectedMode,\n pTheme.colorScheme,\n rootId\n );\n };\n\n useEffect(() => {\n changeTheme(theme, colorMode);\n }, [theme, colorMode]);\n\n const value = useMemo<HvThemeContextValue>(\n () => ({\n themes,\n colorModes,\n activeTheme: activeTheme as HvTheme,\n selectedTheme,\n selectedMode,\n changeTheme,\n rootId,\n }),\n [\n themes,\n colorModes,\n activeTheme,\n selectedTheme,\n selectedMode,\n changeTheme,\n rootId,\n ]\n );\n\n const MuiTheme = createTheme({\n breakpoints: {\n values: {\n ...activeTheme.breakpoints.values,\n },\n },\n });\n\n const emotionCacheValue = useMemo(\n () => ({ cache: emotionCache }),\n [emotionCache]\n );\n\n return (\n <MuiThemeProvider theme={MuiTheme}>\n <HvThemeContext.Provider value={value}>\n <EmotionContext.Provider value={emotionCacheValue}>\n {children}\n </EmotionContext.Provider>\n </HvThemeContext.Provider>\n </MuiThemeProvider>\n );\n};\n"],"names":["defaultCacheKey","defaultEmotionCache","createCache","key","prepend","EmotionContext","createContext","cache","HvThemeProvider","children","themes","themesList","theme","emotionCache","colorMode","themeRootId","pTheme","parseTheme","rootId","useState","activeTheme","setActiveTheme","selectedTheme","setSelectedTheme","selectedMode","setThemeMode","colorModes","setColorModes","setThemes","map","t","name","useEffect","changeTheme","newTheme","newMode","setElementAttrs","colorScheme","value","useMemo","MuiTheme","createTheme","breakpoints","values","emotionCacheValue","MuiThemeProvider","HvThemeContext","Provider"],"mappings":";;;;;;;;;;;AAeO,MAAMA,kBAAkB;AAExB,MAAMC,sBAAsBC,qBAAAA,QAAY;AAAA,EAC7CC,KAAKH;AAAAA,EACLI,SAAS;AACX,CAAC;AAEM,MAAMC,iBAAiBC,MAAAA,cAAuC;AAAA,EACnEC,OAAON;AACT,CAAC;AAWM,MAAMO,kBAAkBA,CAAC;AAAA,EAC9BC;AAAAA,EACAC,QAAQC;AAAAA,EAAAA,OACRC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AACoB,MAAM;AAC1B,MAAIC,SAASC,YAAAA,WAAWN,YAAYC,SAAOE,SAAS;AAEpD,QAAM,CAACI,MAAM,IAAIC,MAAAA,SAA6BJ,WAAW;AACzD,QAAM,CAACK,aAAaC,cAAc,IAAIF,MAAAA,SACpCH,OAAOJ,KACT;AACA,QAAM,CAACU,eAAeC,gBAAgB,IAAIJ,MAAAA,SACxCH,OAAOM,aACT;AACA,QAAM,CAACE,cAAcC,YAAY,IAAIN,MAAAA,SAAiBH,OAAOQ,YAAY;AACzE,QAAM,CAACE,YAAYC,aAAa,IAAIR,MAAAA,SAAmBH,OAAOU,UAAU;AAClE,QAAA,CAAChB,QAAQkB,SAAS,IAAIT,eAAmBR,WAAWkB,IAAKC,CAAAA,MAAMA,EAAEC,IAAI,CAAC;AAE5EC,QAAAA,UAAU,MAAM;AACdJ,cAAUjB,WAAWkB,IAAKC,CAAMA,MAAAA,EAAEC,IAAI,CAAC;AAAA,EAAA,GACtC,CAACpB,UAAU,CAAC;AAEf,QAAMsB,cAAcA,CAACC,WAAWZ,eAAea,UAAUX,iBAAiB;AAC/DP,aAAAA,YAAAA,WAAWN,YAAYuB,UAAUC,OAAO;AAEjDd,mBAAeL,OAAOJ,KAAK;AAC3BW,qBAAiBP,OAAOM,aAAa;AACrCG,iBAAaT,OAAOQ,YAAY;AAChCG,kBAAcX,OAAOU,UAAU;AAE/BU,0BACEpB,OAAOM,eACPN,OAAOQ,cACPR,OAAOqB,aACPnB,MACF;AAAA,EAAA;AAGFc,QAAAA,UAAU,MAAM;AACdC,gBAAYrB,SAAOE,SAAS;AAAA,EAAA,GAC3B,CAACF,SAAOE,SAAS,CAAC;AAEfwB,QAAAA,QAAQC,MAAAA,QACZ,OAAO;AAAA,IACL7B;AAAAA,IACAgB;AAAAA,IACAN;AAAAA,IACAE;AAAAA,IACAE;AAAAA,IACAS;AAAAA,IACAf;AAAAA,EAAAA,IAEF,CACER,QACAgB,YACAN,aACAE,eACAE,cACAS,aACAf,MAAM,CAEV;AAEA,QAAMsB,WAAWC,OAAAA,YAAY;AAAA,IAC3BC,aAAa;AAAA,MACXC,QAAQ;AAAA,QACN,GAAGvB,YAAYsB,YAAYC;AAAAA,MAC7B;AAAA,IACF;AAAA,EAAA,CACD;AAEKC,QAAAA,oBAAoBL,MAAAA,QACxB,OAAO;AAAA,IAAEhC,OAAOM;AAAAA,EAAAA,IAChB,CAACA,YAAY,CACf;AAEA,wCACGgC,OAAAA,eAAgB;AAAA,IAACjC,OAAO4B;AAAAA,IAAS/B,UAC/BqC,2BAAAA,IAAAA,iBAAAA,eAAeC,UAAQ;AAAA,MAACT;AAAAA,MAAa7B,UACnCJ,2BAAAA,IAAAA,eAAe0C,UAAQ;AAAA,QAACT,OAAOM;AAAAA,QAAkBnC;AAAAA,MAAAA,CAEzB;AAAA,IAAA,CACF;AAAA,EAAA,CACT;AAEtB;;;;;;;;;"}

package/dist/cjs/utils/browser.cjs CHANGED Viewed

@@ -5,5 +5,6 @@ const isBrowser = (browsers) => {
   const browser = detectBrowser.detect();
   return browser && (Array.isArray(browsers) ? browsers.indexOf(browser.name) > 0 : browsers === browser.name);
 };
-exports.default = isBrowser;
+const isBrowser$1 = isBrowser;
+exports.default = isBrowser$1;
 //# sourceMappingURL=browser.cjs.map

package/dist/cjs/utils/browser.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"browser.cjs","sources":["../../../src/utils/browser.ts"],"sourcesContent":["import { detect } from \"detect-browser\";\n\nconst isBrowser = (browsers) => {\n const browser = detect();\n return (\n browser &&\n (Array.isArray(browsers)\n ? browsers.indexOf(browser.name) > 0\n : browsers === browser.name)\n );\n};\n\nexport { isBrowser ~~as default }~~;\n"],"names":["isBrowser","browsers","browser","detect","Array","isArray","indexOf","name"],"mappings":";;;AAEA,MAAMA,YAAaC,CAAa,aAAA;AAC9B,QAAMC,UAAUC,cAAAA;AAChB,SACED,YACCE,MAAMC,QAAQJ,QAAQ,IACnBA,SAASK,QAAQJ,QAAQK,IAAI,IAAI,IACjCN,aAAaC,QAAQK;AAE7B;;"}
1	+ {"version":3,"file":"browser.cjs","sources":["../../../src/utils/browser.ts"],"sourcesContent":["import { detect } from \"detect-browser\";\n\nconst isBrowser = (browsers) => {\n const browser = detect();\n return (\n browser &&\n (Array.isArray(browsers)\n ? browsers.indexOf(browser.name) > 0\n : browsers === browser.name)\n );\n};\n\nexport default isBrowser;\n"],"names":["isBrowser","browsers","browser","detect","Array","isArray","indexOf","name"],"mappings":";;;AAEA,MAAMA,YAAaC,CAAa,aAAA;AAC9B,QAAMC,UAAUC,cAAAA;AAChB,SACED,YACCE,MAAMC,QAAQJ,QAAQ,IACnBA,SAASK,QAAQJ,QAAQK,IAAI,IAAI,IACjCN,aAAaC,QAAQK;AAE7B;AAEA,MAAA,cAAeP;;"}

package/dist/cjs/utils/classes.cjs CHANGED Viewed

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useCss = require("../hooks/useCss.cjs");
 const getClasses = (keys, name) => {
   const classesObj = {};
   keys.forEach((key) => {
@@ -7,5 +8,47 @@ const getClasses = (keys, name) => {
   });
   return classesObj;
 };
+const deepRenameKeys = (obj, mapFn) => {
+  const result = {};
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      const newKey = mapFn(key);
+      const value = obj[key];
+      result[newKey] = typeof value === "object" ? deepRenameKeys(value, mapFn) : value;
+    }
+  }
+  return result;
+};
+const replace$ = (stylesObj, name) => {
+  return deepRenameKeys(stylesObj, (key) => {
+    const matches = key.match(/\$\w+/g);
+    if (!(matches == null ? void 0 : matches.length))
+      return key;
+    const newKey = matches.reduce((acc, match) => acc.replace(match, `.${name}-${match.slice(1)}`), key);
+    return newKey ?? key;
+  });
+};
+function createClasses(name, stylesObject) {
+  const styles = replace$(stylesObject, name);
+  const staticClasses = getClasses(Object.keys(styles), name);
+  function useClasses(classesProp) {
+    const {
+      cx,
+      css
+    } = useCss.useCss();
+    const mergeClasses = (key) => cx(`${name}-${key}`, css(styles[key]), classesProp == null ? void 0 : classesProp[key]);
+    const classes = Object.fromEntries(Object.keys(styles).map((key) => [key, mergeClasses(key)]));
+    return {
+      cx,
+      classes
+    };
+  }
+  return {
+    useClasses,
+    staticClasses
+  };
+}
+exports.createClasses = createClasses;
 exports.getClasses = getClasses;
+exports.replace$ = replace$;
 //# sourceMappingURL=classes.cjs.map

package/dist/cjs/utils/classes.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"classes.cjs","sources":["../../../src/utils/classes.ts"],"sourcesContent":["~~export~~ const getClasses = <T extends string, N extends string>(\n keys: T[],\n name: N\n) => {\n const classesObj: Record<string, string> = {};\n keys.forEach((key: string) => {\n classesObj[key] = `${name}-${key}`;\n });\n return classesObj as { [P in T]: `${N}-${P}` };\n};\n"],"names":["getClasses","keys","name","classesObj","forEach","key"],"mappings":"~~;;AAAaA~~,MAAAA,aAAa,CACxBC,MACAC,SACG;AACH,QAAMC,aAAqC,CAAA;AACtCC,OAAAA,QAAQ,CAACC,QAAgB;AACjBA,eAAAA,GAAG,IAAK,GAAEH,QAAQG;AAAAA,EAAAA,CAC9B;AACMF,SAAAA;AACT;;"}
1	+ {"version":3,"file":"classes.cjs","sources":["../../../src/utils/classes.ts"],"sourcesContent":["import { CSSInterpolation } from \"@emotion/css\";\nimport { useCss } from \"@core/hooks/useCss\";\n\nexport type ExtractNames<\n T extends (...args: any) => { classes: Record<string, any>; cx: any }\n> = ReturnType<T>[\"classes\"];\n\nexport const getClasses = <T extends string, N extends string>(\n keys: T[],\n name: N\n) => {\n const classesObj: Record<string, string> = {};\n keys.forEach((key: string) => {\n classesObj[key] = `${name}-${key}`;\n });\n return classesObj as { [P in T]: `${N}-${P}` };\n};\n\nconst deepRenameKeys = <T extends object>(\n obj: T,\n mapFn: (key: string) => string\n): T => {\n const result: any = {};\n for (const key in obj) {\n if (Object.hasOwn(obj, key)) {\n const newKey = mapFn(key);\n const value = obj[key];\n result[newKey] =\n typeof value === \"object\" ? deepRenameKeys(value as any, mapFn) : value;\n }\n }\n return result;\n};\n\n/** Given a `stylesObj`, replaces its keys' `$myClass` with `.{name}-myClass`. /\nexport const replace$ = <T extends object>(stylesObj: T, name: string): T => {\n return deepRenameKeys(stylesObj, (key) => {\n const matches = key.match(/\\$\\w+/g);\n if (!matches?.length) return key;\n const newKey = matches.reduce(\n (acc, match) => acc.replace(match, `.${name}-${match.slice(1)}`),\n key\n );\n return newKey ?? key;\n });\n};\n\n/* Utility function to create classes for a component. /\nexport function createClasses<Name extends string, ClassName extends string>(\n /* Component name in PascalCase (ie. `HvTableCell`). */\n name: Name,\n stylesObject: Record<ClassName, CSSInterpolation>\n) {\n const styles = replace$(stylesObject, name);\n\n const staticClasses = getClasses(Object.keys(styles) as ClassName[], name);\n\n function useClasses(classesProp: Partial<Record<ClassName, string>>) {\n const { cx, css } = useCss();\n\n const mergeClasses = (key: string) =>\n cx(`${name}-${key}`, css(styles[key]), classesProp?.[key]);\n\n const classes = Object.fromEntries(\n Object.keys(styles).map((key) => [key, mergeClasses(key)])\n ) as { [P in ClassName]: string };\n\n return { cx, classes };\n }\n\n return { useClasses, staticClasses };\n}\n"],"names":["getClasses","keys","name","classesObj","forEach","key","deepRenameKeys","obj","mapFn","result","Object","hasOwn","newKey","value","replace$","stylesObj","matches","match","length","reduce","acc","replace","slice","createClasses","stylesObject","styles","staticClasses","useClasses","classesProp","cx","css","useCss","mergeClasses","classes","fromEntries","map"],"mappings":";;;AAOaA,MAAAA,aAAa,CACxBC,MACAC,SACG;AACH,QAAMC,aAAqC,CAAA;AACtCC,OAAAA,QAAQ,CAACC,QAAgB;AACjBA,eAAAA,GAAG,IAAK,GAAEH,QAAQG;AAAAA,EAAAA,CAC9B;AACMF,SAAAA;AACT;AAEA,MAAMG,iBAAiB,CACrBC,KACAC,UACM;AACN,QAAMC,SAAc,CAAA;AACpB,aAAWJ,OAAOE,KAAK;AACrB,QAAIG,OAAOC,OAAOJ,KAAKF,GAAG,GAAG;AACrBO,YAAAA,SAASJ,MAAMH,GAAG;AAClBQ,YAAAA,QAAQN,IAAIF,GAAG;AACdO,aAAAA,MAAM,IACX,OAAOC,UAAU,WAAWP,eAAeO,OAAcL,KAAK,IAAIK;AAAAA,IACtE;AAAA,EACF;AACOJ,SAAAA;AACT;AAGaK,MAAAA,WAAW,CAAmBC,WAAcb,SAAoB;AACpEI,SAAAA,eAAeS,WAAYV,CAAQ,QAAA;AAClCW,UAAAA,UAAUX,IAAIY,MAAM,QAAQ;AAClC,QAAI,EAACD,mCAASE;AAAeb,aAAAA;AAC7B,UAAMO,SAASI,QAAQG,OACrB,CAACC,KAAKH,UAAUG,IAAIC,QAAQJ,OAAQ,IAAGf,QAAQe,MAAMK,MAAM,CAAC,GAAG,GAC/DjB,GACF;AACA,WAAOO,UAAUP;AAAAA,EAAAA,CAClB;AACH;AAGgBkB,SAAAA,cAEdrB,MACAsB,cACA;AACMC,QAAAA,SAASX,SAASU,cAActB,IAAI;AAE1C,QAAMwB,gBAAgB1B,WAAWU,OAAOT,KAAKwB,MAAM,GAAkBvB,IAAI;AAEzE,WAASyB,WAAWC,aAAiD;AAC7D,UAAA;AAAA,MAAEC;AAAAA,MAAIC;AAAAA,QAAQC,OAAO,OAAA;AAE3B,UAAMC,eAAeA,CAAC3B,QACpBwB,GAAI,GAAE3B,QAAQG,OAAOyB,IAAIL,OAAOpB,GAAG,CAAC,GAAGuB,2CAAcvB,IAAI;AAE3D,UAAM4B,UAAUvB,OAAOwB,YACrBxB,OAAOT,KAAKwB,MAAM,EAAEU,IAAK9B,CAAAA,QAAQ,CAACA,KAAK2B,aAAa3B,GAAG,CAAC,CAAC,CAC3D;AAEO,WAAA;AAAA,MAAEwB;AAAAA,MAAII;AAAAA,IAAAA;AAAAA,EACf;AAEO,SAAA;AAAA,IAAEN;AAAAA,IAAYD;AAAAA,EAAAA;AACvB;;;;"}

package/dist/cjs/utils/focusableElementFinder.cjs CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const SELECTORS = 'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"]';
+const SELECTORS = 'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"])';
 const getFocusableList = (node) => node && node.querySelectorAll(SELECTORS) || [];
 const getPrevNextFocus = (nodeId) => {
   const nodes = getFocusableList(document);

package/dist/cjs/utils/focusableElementFinder.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"focusableElementFinder.cjs","sources":["../../../src/utils/focusableElementFinder.ts"],"sourcesContent":["const SELECTORS =\n 'input, button, select, textarea, a[href], [tabindex]:not([tabindex=\"-1\"]';\n\n/*\n Gets the list of focusable elements.\n * @param node\n * @returns {\|NodeListOf<HTMLElementTagNameMap[string]>\|NodeListOf<>\|NodeListOf<SVGElementTagNameMap[string]>\|[]}\n /\nconst getFocusableList = (node) =>\n (node && node.querySelectorAll(SELECTORS)) \|\| [];\n\n/*\n Auxiliary function to find adjacent nodes to focus.\n \n @param nodeId\n * @returns {{prevFocus: , nextFocus: }}\n /\nconst getPrevNextFocus = (nodeId) => {\n const nodes = getFocusableList(document);\n\n const nbNodes = nodes.length;\n let index = 0;\n for (; index < nbNodes; index += 1) {\n if (nodes[index].id === nodeId) {\n break;\n }\n }\n return {\n nextFocus: nodes[index + 1 > nbNodes - 1 ? 0 : index + 1],\n prevFocus: nodes[index - 1 < 0 ? nbNodes - 1 : index - 1],\n };\n};\n\n/\n Get the first and last focusable element from a node.\n \n @param nodeId\n * @returns {{last: , first: }}\n */\nconst getFirstAndLastFocus = (node) => {\n const focusableList = getFocusableList(node);\n\n return {\n first: focusableList[0] \|\| null,\n last: focusableList[focusableList.length - 1] \|\| null,\n };\n};\n\nexport { getFocusableList, getFirstAndLastFocus, getPrevNextFocus };\nexport default getPrevNextFocus;\n"],"names":["SELECTORS","getFocusableList","node","querySelectorAll","getPrevNextFocus","nodeId","nodes","document","nbNodes","length","index","id","nextFocus","prevFocus","getFirstAndLastFocus","focusableList","first","last"],"mappings":";;AAAA,MAAMA,YACJ;AAOF,MAAMC,mBAAoBC,CACvBA,SAAAA,QAAQA,KAAKC,iBAAiBH,SAAS,KAAM,CAAE;AAQlD,MAAMI,mBAAoBC,CAAW,WAAA;AAC7BC,QAAAA,QAAQL,iBAAiBM,QAAQ;AAEvC,QAAMC,UAAUF,MAAMG;AACtB,MAAIC,QAAQ;AACLA,SAAAA,QAAQF,SAASE,SAAS,GAAG;AAClC,QAAIJ,MAAMI,KAAK,EAAEC,OAAON,QAAQ;AAC9B;AAAA,IACF;AAAA,EACF;AACO,SAAA;AAAA,IACLO,WAAWN,MAAMI,QAAQ,IAAIF,UAAU,IAAI,IAAIE,QAAQ,CAAC;AAAA,IACxDG,WAAWP,MAAMI,QAAQ,IAAI,IAAIF,UAAU,IAAIE,QAAQ,CAAC;AAAA,EAAA;AAE5D;AAQA,MAAMI,uBAAwBZ,CAAS,SAAA;AAC/Ba,QAAAA,gBAAgBd,iBAAiBC,IAAI;AAEpC,SAAA;AAAA,IACLc,OAAOD,cAAc,CAAC,KAAK;AAAA,IAC3BE,MAAMF,cAAcA,cAAcN,SAAS,CAAC,KAAK;AAAA,EAAA;AAErD;;;;;"}
1	+ {"version":3,"file":"focusableElementFinder.cjs","sources":["../../../src/utils/focusableElementFinder.ts"],"sourcesContent":["const SELECTORS =\n 'input, button, select, textarea, a[href], [tabindex]:not([tabindex=\"-1\"])';\n\n/*\n Gets the list of focusable elements.\n * @param node\n * @returns {\|NodeListOf<HTMLElementTagNameMap[string]>\|NodeListOf<>\|NodeListOf<SVGElementTagNameMap[string]>\|[]}\n /\nconst getFocusableList = (node) =>\n (node && node.querySelectorAll(SELECTORS)) \|\| [];\n\n/*\n Auxiliary function to find adjacent nodes to focus.\n \n @param nodeId\n * @returns {{prevFocus: , nextFocus: }}\n /\nconst getPrevNextFocus = (nodeId) => {\n const nodes = getFocusableList(document);\n\n const nbNodes = nodes.length;\n let index = 0;\n for (; index < nbNodes; index += 1) {\n if (nodes[index].id === nodeId) {\n break;\n }\n }\n return {\n nextFocus: nodes[index + 1 > nbNodes - 1 ? 0 : index + 1],\n prevFocus: nodes[index - 1 < 0 ? nbNodes - 1 : index - 1],\n };\n};\n\n/\n Get the first and last focusable element from a node.\n \n @param nodeId\n * @returns {{last: , first: }}\n */\nconst getFirstAndLastFocus = (node) => {\n const focusableList = getFocusableList(node);\n\n return {\n first: focusableList[0] \|\| null,\n last: focusableList[focusableList.length - 1] \|\| null,\n };\n};\n\nexport { getFocusableList, getFirstAndLastFocus, getPrevNextFocus };\nexport default getPrevNextFocus;\n"],"names":["SELECTORS","getFocusableList","node","querySelectorAll","getPrevNextFocus","nodeId","nodes","document","nbNodes","length","index","id","nextFocus","prevFocus","getFirstAndLastFocus","focusableList","first","last"],"mappings":";;AAAA,MAAMA,YACJ;AAOF,MAAMC,mBAAoBC,CACvBA,SAAAA,QAAQA,KAAKC,iBAAiBH,SAAS,KAAM,CAAE;AAQlD,MAAMI,mBAAoBC,CAAW,WAAA;AAC7BC,QAAAA,QAAQL,iBAAiBM,QAAQ;AAEvC,QAAMC,UAAUF,MAAMG;AACtB,MAAIC,QAAQ;AACLA,SAAAA,QAAQF,SAASE,SAAS,GAAG;AAClC,QAAIJ,MAAMI,KAAK,EAAEC,OAAON,QAAQ;AAC9B;AAAA,IACF;AAAA,EACF;AACO,SAAA;AAAA,IACLO,WAAWN,MAAMI,QAAQ,IAAIF,UAAU,IAAI,IAAIE,QAAQ,CAAC;AAAA,IACxDG,WAAWP,MAAMI,QAAQ,IAAI,IAAIF,UAAU,IAAIE,QAAQ,CAAC;AAAA,EAAA;AAE5D;AAQA,MAAMI,uBAAwBZ,CAAS,SAAA;AAC/Ba,QAAAA,gBAAgBd,iBAAiBC,IAAI;AAEpC,SAAA;AAAA,IACLc,OAAOD,cAAc,CAAC,KAAK;AAAA,IAC3BE,MAAMF,cAAcA,cAAcN,SAAS,CAAC,KAAK;AAAA,EAAA;AAErD;;;;;"}

package/dist/cjs/utils/iconVariant.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"iconVariant.cjs","sources":["../../../src/utils/iconVariant.tsx"],"sourcesContent":["import {\n Fail,\n Success,\n Caution,\n Info,\n IconBaseProps,\n} from \"@hitachivantara/uikit-react-icons\";\nimport { HvDialogTitleVariant } from \"..\";\n\nconst iconVariant = (\n variant: HvDialogTitleVariant,\n color?: IconBaseProps[\"color\"],\n semantic?: true\n) => {\n switch (variant) {\n case \"success\":\n return <Success color={color} semantic={semantic && \"positive\"} />;\n case \"warning\":\n return <Caution color={color} semantic={semantic && \"warning\"} />;\n case \"error\":\n return <Fail color={color} semantic={semantic && \"negative\"} />;\n case \"info\":\n return <Info color={color} />;\n default:\n return null;\n }\n};\n\nexport default iconVariant;\n"],"names":["iconVariant","variant","color","semantic","Success","Caution","Fail","Info"],"mappings":";;;;AASA,MAAMA,cAAcA,CAClBC,SACAC,OACAC,aACG;AACH,UAAQF,SAAO;AAAA,IACb,KAAK;AACH,4CAAQG,gBAAAA,SAAO;AAAA,QAACF;AAAAA,QAAcC,UAAUA,YAAY;AAAA,MAAA,~~CAAc~~;AAAA,~~IACpE~~,KAAK;AACH,4CAAQE,gBAAAA,SAAO;AAAA,QAACH;AAAAA,QAAcC,UAAUA,YAAY;AAAA,MAAA,~~CAAa~~;AAAA,~~IACnE~~,KAAK;AACH,4CAAQG,gBAAAA,MAAI;AAAA,QAACJ;AAAAA,QAAcC,UAAUA,YAAY;AAAA,MAAA,~~CAAc~~;AAAA,~~IACjE~~,KAAK;AACH,4CAAQI,gBAAAA,MAAI;AAAA,QAACL;AAAAA,MAAAA,~~CAAgB~~;AAAA,~~IAC/B~~;AACS,aAAA;AAAA,~~EAAK~~;~~AAElB~~;AAEA,MAAA,gBAAeF;;"}
1	+ {"version":3,"file":"iconVariant.cjs","sources":["../../../src/utils/iconVariant.tsx"],"sourcesContent":["import {\n Fail,\n Success,\n Caution,\n Info,\n IconBaseProps,\n} from \"@hitachivantara/uikit-react-icons\";\nimport { HvDialogTitleVariant } from \"..\";\n\nconst iconVariant = (\n variant: HvDialogTitleVariant,\n color?: IconBaseProps[\"color\"],\n semantic?: true\n) => {\n switch (variant) {\n case \"success\":\n return <Success color={color} semantic={semantic && \"positive\"} />;\n case \"warning\":\n return <Caution color={color} semantic={semantic && \"warning\"} />;\n case \"error\":\n return <Fail color={color} semantic={semantic && \"negative\"} />;\n case \"info\":\n return <Info color={color} />;\n default:\n return null;\n }\n};\n\nexport default iconVariant;\n"],"names":["iconVariant","variant","color","semantic","Success","Caution","Fail","Info"],"mappings":";;;;AASA,MAAMA,cAAcA,CAClBC,SACAC,OACAC,aACG;AACH,UAAQF,SAAO;AAAA,IACb,KAAK;AACH,4CAAQG,gBAAAA,SAAO;AAAA,QAACF;AAAAA,QAAcC,UAAUA,YAAY;AAAA,MAAA,CAAa;AAAA,IACnE,KAAK;AACH,4CAAQE,gBAAAA,SAAO;AAAA,QAACH;AAAAA,QAAcC,UAAUA,YAAY;AAAA,MAAA,CAAY;AAAA,IAClE,KAAK;AACH,4CAAQG,gBAAAA,MAAI;AAAA,QAACJ;AAAAA,QAAcC,UAAUA,YAAY;AAAA,MAAA,CAAa;AAAA,IAChE,KAAK;AACH,4CAAQI,gBAAAA,MAAI;AAAA,QAACL;AAAAA,MAAAA,CAAe;AAAA,IAC9B;AACS,aAAA;AAAA,EACX;AACF;AAEA,MAAA,gBAAeF;;"}

package/dist/cjs/utils/multiSelectionEventHandler.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"multiSelectionEventHandler.cjs","sources":["../../../src/utils/multiSelectionEventHandler.ts"],"sourcesContent":["const cycleThroughSelection = (\n selectedState,\n index,\n allValues,\n selectionCheck\n) => {\n const newValue: any[] = [];\n selectedState.forEach((isSelected, i) => {\n if (i === index) {\n if (selectionCheck \|\| !isSelected) {\n newValue.push(allValues[i]);\n }\n } else if (isSelected) {\n newValue.push(allValues[i]);\n }\n });\n\n return newValue;\n};\n\nconst multiSelectionEventHandler = (\n evt,\n index,\n selectionAnchor,\n allValues,\n selectedState,\n selectionCheck\n) => {\n let newValue: any[] = [];\n\n if (evt.nativeEvent.shiftKey) {\n if (selectionAnchor.current === undefined) {\n selectionAnchor.current = index;\n newValue.push(allValues[index]);\n } else {\n let selectionStart;\n let selectionEnd;\n if (selectionAnchor.current > index) {\n selectionStart = index;\n selectionEnd = selectionAnchor.current + 1;\n } else {\n selectionStart = selectionAnchor.current;\n selectionEnd = index + 1;\n }\n\n const selectedValues = allValues.slice(selectionStart, selectionEnd);\n\n newValue.push(...selectedValues);\n }\n } else if (evt.nativeEvent.metaKey) {\n selectionAnchor.current = index;\n\n newValue = cycleThroughSelection(\n selectedState,\n index,\n allValues,\n selectionCheck\n );\n } else {\n selectionAnchor.current = index;\n\n newValue = cycleThroughSelection(\n selectedState,\n index,\n allValues,\n selectionCheck\n );\n }\n\n return newValue;\n};\n\nexport default multiSelectionEventHandler;\n"],"names":["cycleThroughSelection","selectedState","index","allValues","selectionCheck","newValue","forEach","isSelected","i","push","multiSelectionEventHandler","evt","selectionAnchor","nativeEvent","shiftKey","current","undefined","selectionStart","selectionEnd","selectedValues","slice","metaKey"],"mappings":";;AAAA,MAAMA,wBAAwBA,CAC5BC,eACAC,OACAC,WACAC,mBACG;AACH,QAAMC,WAAkB,CAAA;AACVC,gBAAAA,QAAQ,CAACC,YAAYC,MAAM;AACvC,QAAIA,MAAMN,OAAO;AACXE,UAAAA,kBAAkB,CAACG,YAAY;AACxBE,iBAAAA,KAAKN,UAAUK,CAAC,CAAC;AAAA,MAC5B;AAAA,eACSD,YAAY;AACZE,eAAAA,KAAKN,UAAUK,CAAC,CAAC;AAAA,IAC5B;AAAA,EAAA,CACD;AAEMH,SAAAA;AACT;AAEA,MAAMK,6BAA6BA,CACjCC,KACAT,OACAU,iBACAT,WACAF,eACAG,mBACG;AACH,MAAIC,WAAkB,CAAA;AAElBM,MAAAA,IAAIE,YAAYC,UAAU;AACxBF,QAAAA,gBAAgBG,YAAYC,QAAW;AACzCJ,sBAAgBG,UAAUb;AACjBO,eAAAA,KAAKN,UAAUD,KAAK,CAAC;AAAA,IAAA,OACzB;AACDe,UAAAA;AACAC,UAAAA;AACAN,UAAAA,gBAAgBG,UAAUb,OAAO;AAClBA,yBAAAA;AACjBgB,uBAAeN,gBAAgBG,UAAU;AAAA,MAAA,OACpC;AACLE,yBAAiBL,gBAAgBG;AACjCG,uBAAehB,QAAQ;AAAA,MACzB;AAEA,YAAMiB,iBAAiBhB,UAAUiB,MAAMH,gBAAgBC,YAAY;AAE1DT,eAAAA,KAAK,GAAGU,cAAc;AAAA,IACjC;AAAA,EAAA,WACSR,IAAIE,YAAYQ,SAAS;AAClCT,oBAAgBG,UAAUb;AAE1BG,eAAWL,sBACTC,eACAC,OACAC,WACAC,~~cAAc~~;AAAA,EAAA,~~OAEX~~;AACLQ,oBAAgBG,UAAUb;AAE1BG,eAAWL,sBACTC,eACAC,OACAC,WACAC,~~cAAc~~;AAAA,~~EAElB~~;AAEOC,SAAAA;AACT;AAEA,MAAA,+BAAeK;;"}
1	+ {"version":3,"file":"multiSelectionEventHandler.cjs","sources":["../../../src/utils/multiSelectionEventHandler.ts"],"sourcesContent":["const cycleThroughSelection = (\n selectedState,\n index,\n allValues,\n selectionCheck\n) => {\n const newValue: any[] = [];\n selectedState.forEach((isSelected, i) => {\n if (i === index) {\n if (selectionCheck \|\| !isSelected) {\n newValue.push(allValues[i]);\n }\n } else if (isSelected) {\n newValue.push(allValues[i]);\n }\n });\n\n return newValue;\n};\n\nconst multiSelectionEventHandler = (\n evt,\n index,\n selectionAnchor,\n allValues,\n selectedState,\n selectionCheck\n) => {\n let newValue: any[] = [];\n\n if (evt.nativeEvent.shiftKey) {\n if (selectionAnchor.current === undefined) {\n selectionAnchor.current = index;\n newValue.push(allValues[index]);\n } else {\n let selectionStart;\n let selectionEnd;\n if (selectionAnchor.current > index) {\n selectionStart = index;\n selectionEnd = selectionAnchor.current + 1;\n } else {\n selectionStart = selectionAnchor.current;\n selectionEnd = index + 1;\n }\n\n const selectedValues = allValues.slice(selectionStart, selectionEnd);\n\n newValue.push(...selectedValues);\n }\n } else if (evt.nativeEvent.metaKey) {\n selectionAnchor.current = index;\n\n newValue = cycleThroughSelection(\n selectedState,\n index,\n allValues,\n selectionCheck\n );\n } else {\n selectionAnchor.current = index;\n\n newValue = cycleThroughSelection(\n selectedState,\n index,\n allValues,\n selectionCheck\n );\n }\n\n return newValue;\n};\n\nexport default multiSelectionEventHandler;\n"],"names":["cycleThroughSelection","selectedState","index","allValues","selectionCheck","newValue","forEach","isSelected","i","push","multiSelectionEventHandler","evt","selectionAnchor","nativeEvent","shiftKey","current","undefined","selectionStart","selectionEnd","selectedValues","slice","metaKey"],"mappings":";;AAAA,MAAMA,wBAAwBA,CAC5BC,eACAC,OACAC,WACAC,mBACG;AACH,QAAMC,WAAkB,CAAA;AACVC,gBAAAA,QAAQ,CAACC,YAAYC,MAAM;AACvC,QAAIA,MAAMN,OAAO;AACXE,UAAAA,kBAAkB,CAACG,YAAY;AACxBE,iBAAAA,KAAKN,UAAUK,CAAC,CAAC;AAAA,MAC5B;AAAA,eACSD,YAAY;AACZE,eAAAA,KAAKN,UAAUK,CAAC,CAAC;AAAA,IAC5B;AAAA,EAAA,CACD;AAEMH,SAAAA;AACT;AAEA,MAAMK,6BAA6BA,CACjCC,KACAT,OACAU,iBACAT,WACAF,eACAG,mBACG;AACH,MAAIC,WAAkB,CAAA;AAElBM,MAAAA,IAAIE,YAAYC,UAAU;AACxBF,QAAAA,gBAAgBG,YAAYC,QAAW;AACzCJ,sBAAgBG,UAAUb;AACjBO,eAAAA,KAAKN,UAAUD,KAAK,CAAC;AAAA,IAAA,OACzB;AACDe,UAAAA;AACAC,UAAAA;AACAN,UAAAA,gBAAgBG,UAAUb,OAAO;AAClBA,yBAAAA;AACjBgB,uBAAeN,gBAAgBG,UAAU;AAAA,MAAA,OACpC;AACLE,yBAAiBL,gBAAgBG;AACjCG,uBAAehB,QAAQ;AAAA,MACzB;AAEA,YAAMiB,iBAAiBhB,UAAUiB,MAAMH,gBAAgBC,YAAY;AAE1DT,eAAAA,KAAK,GAAGU,cAAc;AAAA,IACjC;AAAA,EAAA,WACSR,IAAIE,YAAYQ,SAAS;AAClCT,oBAAgBG,UAAUb;AAE1BG,eAAWL,sBACTC,eACAC,OACAC,WACAC,cACF;AAAA,EAAA,OACK;AACLQ,oBAAgBG,UAAUb;AAE1BG,eAAWL,sBACTC,eACAC,OACAC,WACAC,cACF;AAAA,EACF;AAEOC,SAAAA;AACT;AAEA,MAAA,+BAAeK;;"}