@hitachivantara/uikit-react-core 5.0.1 → 5.1.0

package/dist/esm/components/Slider/Slider.styles.js

@@ -0,0 +1,330 @@
+import _styled from "@emotion/styled/base";
+import { theme } from "@hitachivantara/uikit-styles";
+import Tooltip from "rc-tooltip";
+import Slider from "rc-slider";
+import { transientOptions } from "../../utils/transientOptions.js";
+import base from "./base.js";
+import { jsx } from "@emotion/react/jsx-runtime";
+import { HvFormElement } from "../Forms/FormElement/FormElement.js";
+import { HvWarningText } from "../Forms/WarningText/WarningText.js";
+import { outlineStyles } from "../../utils/focusUtils.js";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+const dot = {
+  position: "absolute",
+  bottom: "-1px",
+  marginLeft: "0px",
+  width: "1px",
+  height: "4px",
+  border: "none",
+  borderRadius: "0%",
+  backgroundColor: theme.colors.atmo4,
+  cursor: "pointer",
+  verticalAlign: "middle",
+  zIndex: "-3"
+};
+const dragSquare = {
+  cursor: "grab",
+  width: "calc(100% - 40px)",
+  left: "20px",
+  height: "27px",
+  position: "absolute",
+  top: "-12px",
+  content: "''",
+  background: "transparent",
+  borderTop: `12px solid ${theme.slider.dragBarColor}`,
+  borderBottom: `12px solid ${theme.slider.dragBarColor}`,
+  zIndex: "-2"
+};
+const ring = {
+  width: "32px",
+  height: "32px",
+  borderRadius: "50%",
+  border: `9px solid ${theme.slider.ringColor}`,
+  opacity: theme.slider.ringOpacity,
+  content: "''",
+  position: "absolute",
+  top: "-10px",
+  left: "-10px"
+};
+const border = {
+  width: "20px",
+  height: "20px",
+  borderRadius: "50%",
+  border: `2px solid ${theme.colors.atmo1}`,
+  content: "''",
+  position: "absolute",
+  top: "-4px",
+  left: "-4px"
+};
+const sliderStyles = {
+  mark: {
+    ...theme.typography.caption1,
+    fontFamily: theme.fontFamily.body,
+    top: "-2px",
+    zIndex: -1
+  },
+  disabledMark: {
+    ...theme.typography.caption1,
+    fontFamily: theme.fontFamily.body,
+    color: `${theme.colors.secondary_60}`,
+    cursor: "not-allowed",
+    top: "-2px"
+  },
+  dot: {
+    ...dot
+  },
+  dotDisabled: {
+    ...dot,
+    cursor: "not-allowed"
+  },
+  knobHidden: {
+    display: "none"
+  },
+  knobHiddenLast: {
+    borderColor: "transparent",
+    height: "3px",
+    width: "2px",
+    marginLeft: "-1px",
+    border: "none",
+    borderRadius: "0",
+    marginTop: "0px",
+    left: "100%",
+    touchAction: "none",
+    cursor: "default"
+  },
+  knobInner: {
+    borderColor: "transparent",
+    boxShadow: "none",
+    backgroundColor: theme.colors.secondary,
+    width: "16px",
+    height: "16px"
+  },
+  knobOuter: {
+    position: "relative",
+    borderColor: "transparent",
+    borderRadius: "50%",
+    boxShadow: "none",
+    backgroundColor: theme.colors.atmo4,
+    width: "32px",
+    height: "32px",
+    top: "-80%",
+    left: "-80%",
+    zIndex: "-1"
+  },
+  track: {
+    backgroundColor: theme.colors.secondary,
+    height: "3px",
+    zIndex: "-1",
+    marginTop: "-1px"
+  },
+  rail: {
+    backgroundColor: theme.colors.atmo4,
+    height: "1px",
+    zIndex: "-3"
+  }
+};
+const StyledFormElement = /* @__PURE__ */ _styled((props) => /* @__PURE__ */ jsx(HvFormElement, {
+  ...props
+}), process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "e153xy1v6"
+}, transientOptions) : _extends({}, {
+  target: "e153xy1v6",
+  label: "StyledFormElement"
+}, transientOptions))(({
+  $dragging,
+  $standBy,
+  $disabled
+}) => ({
+  ...$dragging && {
+    cursor: "grabbing",
+    "& .rc-slider-track": {
+      "&::before": {
+        ...dragSquare,
+        cursor: "grabbing"
+      }
+    }
+  },
+  ...$standBy && {
+    "& .rc-slider-track": {
+      "&:hover": {
+        "&::before": {
+          ...dragSquare
+        }
+      }
+    }
+  },
+  ...$disabled && {
+    cursor: "not-allowed",
+    "&& .rc-slider-disabled": {
+      background: "transparent"
+    }
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAwIiC","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */");
+const StyledLabelContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "e153xy1v5"
+}, transientOptions) : _extends({}, {
+  target: "e153xy1v5",
+  label: "StyledLabelContainer"
+}, transientOptions))(({
+  $hasLabel
+}) => ({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  marginBottom: "12px",
+  marginLeft: "20px",
+  marginRight: "20px",
+  ...$hasLabel && {
+    justifyContent: "space-between"
+  },
+  ...!$hasLabel && {
+    justifyContent: "flex-end"
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAmLoC","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */");
+const StyledWarning = /* @__PURE__ */ _styled(HvWarningText, process.env.NODE_ENV === "production" ? {
+  target: "e153xy1v4"
+} : {
+  target: "e153xy1v4",
+  label: "StyledWarning"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1qu8ll8",
+  styles: "padding:0 8px"
+} : {
+  name: "1qu8ll8",
+  styles: "padding:0 8px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAmM6B","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const StyledSlider = /* @__PURE__ */ _styled(Slider, process.env.NODE_ENV === "production" ? {
+  target: "e153xy1v3"
+} : {
+  target: "e153xy1v3",
+  label: "StyledSlider"
+})(process.env.NODE_ENV === "production" ? {
+  name: "125wnaz",
+  styles: "z-index:0"
+} : {
+  name: "125wnaz",
+  styles: "z-index:0",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAqM4B","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const StyledTooltipContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "e153xy1v2"
+}, transientOptions) : _extends({}, {
+  target: "e153xy1v2",
+  label: "StyledTooltipContainer"
+}, transientOptions))(({
+  $hidden,
+  $disabled,
+  $active
+}) => ({
+  ...$active && {
+    "& .rc-slider-handle": {
+      cursor: "pointer",
+      marginTop: "-8px",
+      opacity: 1,
+      "&:active": {
+        cursor: "grab",
+        "&::before": {
+          ...ring
+        },
+        "&::after": {
+          ...border
+        }
+      },
+      "&:hover": {
+        "&::before": {
+          ...ring
+        },
+        "&::after": {
+          ...border
+        }
+      },
+      // Note about the usage of `!important below`: the way the rc-slider allows us to
+      // style the knobs is through inline styles. This means that the `box-shadow`, which
+      // is an inline style and is set to `none` to prevent the default rc-slider style to
+      // show, can't be overridden for the focus scenario unless we use the `!important` flag.
+      "&:focus-visible": {
+        ...outlineStyles,
+        boxShadow: "0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important",
+        "&::after": {
+          ...border
+        }
+      }
+    }
+  },
+  ...$disabled && {
+    "&& .rc-slider-handle": {
+      cursor: "not-allowed",
+      marginTop: "-8px",
+      opacity: 1,
+      "&:active": {
+        cursor: "not-allowed"
+      },
+      "&:hover": {
+        cursor: "not-allowed"
+      }
+    }
+  },
+  ...$hidden && {
+    display: "none"
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAyMsC","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */");
+const StyledTooltip = /* @__PURE__ */ _styled(Tooltip, process.env.NODE_ENV === "production" ? {
+  target: "e153xy1v1"
+} : {
+  target: "e153xy1v1",
+  label: "StyledTooltip"
+})({
+  "& .rc-slider-tooltip-inner": {
+    background: theme.colors.atmo1,
+    borderRadius: 0,
+    maxWidth: "532px",
+    height: "100%",
+    padding: theme.space.sm,
+    ...theme.typography.body,
+    fontFamily: theme.fontFamily.body,
+    boxShadow: "none"
+  },
+  "& .rc-slider-tooltip-arrow": {
+    visibility: "hidden"
+  }
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAgR6B","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */");
+const StyledSliderContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e153xy1v0"
+} : {
+  target: "e153xy1v0",
+  label: "StyledSliderContainer"
+})({
+  ...base,
+  marginBottom: "18px",
+  padding: "0 23px"
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx"],"names":[],"mappings":"AAiSqC","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/Slider/Slider.styles.tsx","sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"]} */");
+export {
+  StyledFormElement,
+  StyledLabelContainer,
+  StyledSlider,
+  StyledSliderContainer,
+  StyledTooltip,
+  StyledTooltipContainer,
+  StyledWarning,
+  sliderStyles
+};
+//# sourceMappingURL=Slider.styles.js.map

package/dist/esm/components/Slider/Slider.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slider.styles.js","sources":["../../../../src/components/Slider/Slider.styles.tsx"],"sourcesContent":["import styled from \"@emotion/styled\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { CSSProperties } from \"react\";\nimport Tooltip from \"rc-tooltip\";\nimport Slider from \"rc-slider\";\nimport { HvFormElement, HvFormElementProps, HvWarningText } from \"~/components\";\nimport { transientOptions } from \"~/utils/transientOptions\";\nimport { outlineStyles } from \"~/utils\";\nimport base from \"./base\";\n\nconst dot: CSSProperties = {\n  position: \"absolute\",\n  bottom: \"-1px\",\n  marginLeft: \"0px\",\n  width: \"1px\",\n  height: \"4px\",\n  border: \"none\",\n  borderRadius: \"0%\",\n  backgroundColor: theme.colors.atmo4,\n  cursor: \"pointer\",\n  verticalAlign: \"middle\",\n  zIndex: \"-3\",\n};\n\nconst dragSquare: CSSProperties = {\n  cursor: \"grab\",\n  width: \"calc(100% - 40px)\",\n  left: \"20px\",\n  height: \"27px\",\n  position: \"absolute\",\n  top: \"-12px\",\n  content: \"''\",\n  background: \"transparent\",\n  borderTop: `12px solid ${theme.slider.dragBarColor}`,\n  borderBottom: `12px solid ${theme.slider.dragBarColor}`,\n  zIndex: \"-2\",\n};\n\nconst ring: CSSProperties = {\n  width: \"32px\",\n  height: \"32px\",\n  borderRadius: \"50%\",\n  border: `9px solid ${theme.slider.ringColor}`,\n  opacity: theme.slider.ringOpacity,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-10px\",\n  left: \"-10px\",\n};\n\nconst border: CSSProperties = {\n  width: \"20px\",\n  height: \"20px\",\n  borderRadius: \"50%\",\n  border: `2px solid ${theme.colors.atmo1}`,\n  content: \"''\",\n  position: \"absolute\",\n  top: \"-4px\",\n  left: \"-4px\",\n};\n\nexport interface SliderStyles {\n  disabledMark: CSSProperties;\n  mark: CSSProperties;\n  dotDisabled: CSSProperties;\n  dot: CSSProperties;\n  knobInner: CSSProperties;\n  knobOuter: CSSProperties;\n  knobHidden: CSSProperties;\n  knobHiddenLast: CSSProperties;\n  track: CSSProperties;\n  rail: CSSProperties;\n}\n\nexport const sliderStyles: SliderStyles = {\n  mark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    top: \"-2px\",\n    zIndex: -1,\n  },\n  disabledMark: {\n    ...(theme.typography.caption1 as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    color: `${theme.colors.secondary_60}`,\n    cursor: \"not-allowed\",\n    top: \"-2px\",\n  },\n  dot: {\n    ...dot,\n  },\n  dotDisabled: {\n    ...dot,\n    cursor: \"not-allowed\",\n  },\n  knobHidden: { display: \"none\" },\n  knobHiddenLast: {\n    borderColor: \"transparent\",\n    height: \"3px\",\n    width: \"2px\",\n    marginLeft: \"-1px\",\n    border: \"none\",\n    borderRadius: \"0\",\n    marginTop: \"0px\",\n    left: \"100%\",\n    touchAction: \"none\",\n    cursor: \"default\",\n  },\n  knobInner: {\n    borderColor: \"transparent\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.secondary,\n    width: \"16px\",\n    height: \"16px\",\n  },\n  knobOuter: {\n    position: \"relative\",\n    borderColor: \"transparent\",\n    borderRadius: \"50%\",\n    boxShadow: \"none\",\n    backgroundColor: theme.colors.atmo4,\n    width: \"32px\",\n    height: \"32px\",\n    top: \"-80%\",\n    left: \"-80%\",\n    zIndex: \"-1\",\n  },\n  track: {\n    backgroundColor: theme.colors.secondary,\n    height: \"3px\",\n    zIndex: \"-1\",\n    marginTop: \"-1px\",\n  },\n  rail: { backgroundColor: theme.colors.atmo4, height: \"1px\", zIndex: \"-3\" },\n};\n\nexport const StyledFormElement = styled(\n  (props: HvFormElementProps) => <HvFormElement {...props} />,\n  transientOptions\n)(\n  ({\n    $dragging,\n    $standBy,\n    $disabled,\n  }: {\n    $dragging: boolean;\n    $standBy: boolean;\n    $disabled: boolean;\n  }) => ({\n    ...($dragging && {\n      cursor: \"grabbing\",\n\n      \"& .rc-slider-track\": {\n        \"&::before\": {\n          ...dragSquare,\n          cursor: \"grabbing\",\n        },\n      },\n    }),\n\n    ...($standBy && {\n      \"& .rc-slider-track\": {\n        \"&:hover\": {\n          \"&::before\": {\n            ...dragSquare,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      \"&& .rc-slider-disabled\": {\n        background: \"transparent\",\n      },\n    }),\n  })\n);\n\nexport const StyledLabelContainer = styled(\n  \"div\",\n  transientOptions\n)(({ $hasLabel }: { $hasLabel: boolean }) => ({\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"space-between\",\n  marginBottom: \"12px\",\n  marginLeft: \"20px\",\n  marginRight: \"20px\",\n\n  ...($hasLabel && { justifyContent: \"space-between\" }),\n\n  ...(!$hasLabel && { justifyContent: \"flex-end\" }),\n}));\n\nexport const StyledWarning = styled(HvWarningText)({ padding: \"0 8px\" });\n\nexport const StyledSlider = styled(Slider)({\n  zIndex: 0,\n});\n\nexport const StyledTooltipContainer = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $hidden,\n    $disabled,\n    $active,\n  }: {\n    $hidden: boolean;\n    $disabled: boolean;\n    $active: boolean;\n  }) => ({\n    ...($active && {\n      \"& .rc-slider-handle\": {\n        cursor: \"pointer\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"grab\",\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n        \"&:hover\": {\n          \"&::before\": {\n            ...ring,\n          },\n          \"&::after\": {\n            ...border,\n          },\n        },\n\n        // Note about the usage of `!important below`: the way the rc-slider allows us to\n        // style the knobs is through inline styles. This means that the `box-shadow`, which\n        // is an inline style and is set to `none` to prevent the default rc-slider style to\n        // show, can't be overridden for the focus scenario unless we use the `!important` flag.\n        \"&:focus-visible\": {\n          ...outlineStyles,\n          boxShadow:\n            \"0 0 0 3px #52A8EC, 0 0 0 7px rgba(29,155,209,.3)!important\",\n          \"&::after\": {\n            ...border,\n          },\n        },\n      },\n    }),\n\n    ...($disabled && {\n      \"&& .rc-slider-handle\": {\n        cursor: \"not-allowed\",\n        marginTop: \"-8px\",\n        opacity: 1,\n        \"&:active\": {\n          cursor: \"not-allowed\",\n        },\n        \"&:hover\": {\n          cursor: \"not-allowed\",\n        },\n      },\n    }),\n\n    ...($hidden && {\n      display: \"none\",\n    }),\n  })\n);\n\nexport const StyledTooltip = styled(Tooltip)({\n  \"& .rc-slider-tooltip-inner\": {\n    background: theme.colors.atmo1,\n    borderRadius: 0,\n    maxWidth: \"532px\",\n    height: \"100%\",\n    padding: theme.space.sm,\n    ...(theme.typography.body as CSSProperties),\n    fontFamily: theme.fontFamily.body,\n    boxShadow: \"none\",\n  },\n\n  \"& .rc-slider-tooltip-arrow\": {\n    visibility: \"hidden\",\n  },\n});\n\nexport const StyledSliderContainer = styled(\"div\")({\n  ...(base as CSSProperties),\n\n  marginBottom: \"18px\",\n  padding: \"0 23px\",\n});\n"],"names":["dot","position","bottom","marginLeft","width","height","border","borderRadius","backgroundColor","theme","colors","atmo4","cursor","verticalAlign","zIndex","dragSquare","left","top","content","background","borderTop","slider","dragBarColor","borderBottom","ring","ringColor","opacity","ringOpacity","atmo1","sliderStyles","mark","typography","caption1","fontFamily","body","disabledMark","color","secondary_60","dotDisabled","knobHidden","display","knobHiddenLast","borderColor","marginTop","touchAction","knobInner","boxShadow","secondary","knobOuter","track","rail","StyledFormElement","_styled","props","HvFormElement","process","env","NODE_ENV","_extends","target","transientOptions","label","$dragging","$standBy","$disabled","StyledLabelContainer","$hasLabel","alignItems","justifyContent","marginBottom","marginRight","StyledWarning","HvWarningText","name","styles","map","toString","_EMOTION_STRINGIFIED_CSS_ERROR__","StyledSlider","Slider","StyledTooltipContainer","$hidden","$active","outlineStyles","StyledTooltip","Tooltip","maxWidth","padding","space","sm","visibility","StyledSliderContainer","base"],"mappings":"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"}

package/dist/esm/components/Slider/SliderInput/SliderInput.js

@@ -0,0 +1,64 @@
+import { useState, useEffect } from "react";
+import clsx from "clsx";
+import { Remove } from "@hitachivantara/uikit-react-icons";
+import { knobsValuesToString, stringValuesToKnobs } from "../utils.js";
+import { StyledRoot, StyledInputContainer, StyledInput } from "./SliderInput.styles.js";
+import sliderInputClasses from "./sliderInputClasses.js";
+import { jsx, jsxs } from "@emotion/react/jsx-runtime";
+import { setId } from "../../../utils/setId.js";
+const HvSliderInput = ({
+  classes,
+  className,
+  id,
+  label,
+  status,
+  values: valuesProp = [],
+  inputProps = [],
+  readOnly = false,
+  disabled = false,
+  markDigits = 0,
+  onChange,
+  ...others
+}) => {
+  const [inputValues, setInputValues] = useState(knobsValuesToString(valuesProp, markDigits));
+  const handleChange = (index) => {
+    if (disabled)
+      return;
+    onChange == null ? void 0 : onChange(stringValuesToKnobs(inputValues), index);
+  };
+  useEffect(() => {
+    setInputValues(knobsValuesToString(valuesProp, markDigits));
+  }, [markDigits, valuesProp]);
+  return /* @__PURE__ */ jsx(StyledRoot, {
+    className: clsx(className, classes == null ? void 0 : classes.inputRoot, sliderInputClasses.inputRoot),
+    ...others,
+    children: inputValues.map((value, index) => /* @__PURE__ */ jsxs(StyledInputContainer, {
+      className: clsx(classes == null ? void 0 : classes.inputContainer, sliderInputClasses.inputContainer),
+      children: [index !== 0 && /* @__PURE__ */ jsx(Remove, {
+        color: disabled ? ["atmo4"] : void 0
+      }), /* @__PURE__ */ jsx(StyledInput, {
+        id: setId(id, index),
+        "aria-label": `${label}-${index}`,
+        className: clsx(classes == null ? void 0 : classes.input, sliderInputClasses.input),
+        disabled,
+        type: "number",
+        value: Number.isNaN(value) || value == null ? "" : value.toString(),
+        onEnter: () => handleChange(index),
+        onBlur: () => handleChange(index),
+        onChange: (_, inputValue) => {
+          const newValues = [...inputValues];
+          newValues[index] = inputValue;
+          setInputValues(newValues);
+        },
+        status: (status == null ? void 0 : status[index]) || "standBy",
+        readOnly,
+        disableClear: true,
+        ...inputProps[index]
+      })]
+    }, setId(id, index)))
+  });
+};
+export {
+  HvSliderInput
+};
+//# sourceMappingURL=SliderInput.js.map

package/dist/esm/components/Slider/SliderInput/SliderInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SliderInput.js","sources":["../../../../../src/components/Slider/SliderInput/SliderInput.tsx"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport clsx from \"clsx\";\nimport { Remove } from \"@hitachivantara/uikit-react-icons\";\nimport { knobsValuesToString, stringValuesToKnobs } from \"../utils\";\nimport {\n  StyledInput,\n  StyledInputContainer,\n  StyledRoot,\n} from \"./SliderInput.styles\";\nimport sliderInputClasses, { HvSliderInputClasses } from \"./sliderInputClasses\";\nimport { setId } from \"~/utils\";\nimport { HvFormStatus, HvInputProps } from \"~/components\";\nimport { HvBaseProps } from \"~/types\";\n\nexport interface HvSliderInputProps\n  extends HvBaseProps<HTMLDivElement, { onChange }> {\n  /**\n   * Used to generate the aria-label for the inputs.\n   */\n  label?: React.ReactNode;\n  /**\n   * Input status.\n   */\n  status?: HvFormStatus[];\n  /**\n   * The values array to apply to the component\n   */\n  values?: number[];\n  /**\n   * Callback function to be triggered when the selected date has changed.\n   */\n  onChange?: (values: number[], index: number) => void;\n  /**\n   * Attributes applied to the input element.\n   */\n  inputProps?: HvInputProps[];\n  /**\n   * Indicates that the form element is disabled.\n   */\n  disabled?: boolean;\n  /**\n   * Indicates that the form element is read only.\n   */\n  readOnly?: boolean;\n  /**\n   * Indicates how many decimals to use.\n   */\n  markDigits?: number;\n  /**\n   * Styles applied from the theme.\n   */\n  classes?: HvSliderInputClasses;\n}\n\nexport const HvSliderInput = ({\n  classes,\n  className,\n  id,\n  label,\n  status,\n  values: valuesProp = [],\n  inputProps = [],\n  readOnly = false,\n  disabled = false,\n  markDigits = 0,\n  onChange,\n  ...others\n}: HvSliderInputProps) => {\n  const [inputValues, setInputValues] = useState<string[]>(\n    knobsValuesToString(valuesProp, markDigits)\n  );\n\n  const handleChange = (index: number) => {\n    if (disabled) return;\n\n    onChange?.(stringValuesToKnobs(inputValues), index);\n  };\n\n  useEffect(() => {\n    setInputValues(knobsValuesToString(valuesProp, markDigits));\n  }, [markDigits, valuesProp]);\n\n  return (\n    <StyledRoot\n      className={clsx(\n        className,\n        classes?.inputRoot,\n        sliderInputClasses.inputRoot\n      )}\n      {...others}\n    >\n      {inputValues.map((value, index) => (\n        <StyledInputContainer\n          key={setId(id, index)}\n          className={clsx(\n            classes?.inputContainer,\n            sliderInputClasses.inputContainer\n          )}\n        >\n          {index !== 0 && <Remove color={disabled ? [\"atmo4\"] : undefined} />}\n          <StyledInput\n            id={setId(id, index)}\n            aria-label={`${label}-${index}`}\n            className={clsx(classes?.input, sliderInputClasses.input)}\n            disabled={disabled}\n            type=\"number\"\n            value={Number.isNaN(value) || value == null ? \"\" : value.toString()}\n            onEnter={() => handleChange(index)}\n            onBlur={() => handleChange(index)}\n            onChange={(_, inputValue) => {\n              const newValues = [...inputValues];\n              newValues[index] = inputValue;\n              setInputValues(newValues);\n            }}\n            status={status?.[index] || \"standBy\"}\n            readOnly={readOnly}\n            disableClear\n            {...inputProps[index]}\n          />\n        </StyledInputContainer>\n      ))}\n    </StyledRoot>\n  );\n};\n"],"names":["HvSliderInput","classes","className","id","label","status","values","valuesProp","inputProps","readOnly","disabled","markDigits","onChange","others","inputValues","setInputValues","useState","knobsValuesToString","handleChange","index","stringValuesToKnobs","useEffect","StyledRoot","clsx","inputRoot","sliderInputClasses","children","map","value","StyledInputContainer","inputContainer","Remove","color","undefined","_jsx","StyledInput","setId","input","type","Number","isNaN","toString","onEnter","onBlur","_","inputValue","newValues","disableClear"],"mappings":";;;;;;;;AAsDO,MAAMA,gBAAgBA,CAAC;AAAA,EAC5BC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC,QAAQC,aAAa,CAAE;AAAA,EACvBC,aAAa,CAAE;AAAA,EACfC,WAAW;AAAA,EACXC,WAAW;AAAA,EACXC,aAAa;AAAA,EACbC;AAAAA,EACA,GAAGC;AACe,MAAM;AAClB,QAAA,CAACC,aAAaC,cAAc,IAAIC,SACpCC,oBAAoBV,YAAYI,UAAU,CAAC;AAGvCO,QAAAA,eAAeA,CAACC,UAAkB;AAClCT,QAAAA;AAAU;AAEHU,yCAAAA,oBAAoBN,WAAW,GAAGK;AAAAA,EAAK;AAGpDE,YAAU,MAAM;AACCJ,mBAAAA,oBAAoBV,YAAYI,UAAU,CAAC;AAAA,EAAA,GACzD,CAACA,YAAYJ,UAAU,CAAC;AAE3B,6BACGe,YAAU;AAAA,IACTpB,WAAWqB,KACTrB,WACAD,mCAASuB,WACTC,mBAAmBD,SAAS;AAAA,IAC5B,GACEX;AAAAA,IAAMa,UAETZ,YAAYa,IAAI,CAACC,OAAOT,+BACtBU,sBAAoB;AAAA,MAEnB3B,WAAWqB,KACTtB,mCAAS6B,gBACTL,mBAAmBK,cAAc;AAAA,MACjCJ,WAEDP,UAAU,yBAAMY,QAAM;AAAA,QAACC,OAAOtB,WAAW,CAAC,OAAO,IAAIuB;AAAAA,MAAAA,CAAa,GACnEC,oBAACC,aAAW;AAAA,QACVhC,IAAIiC,MAAMjC,IAAIgB,KAAK;AAAA,QACnB,cAAa,GAAEf,SAASe;AAAAA,QACxBjB,WAAWqB,KAAKtB,mCAASoC,OAAOZ,mBAAmBY,KAAK;AAAA,QACxD3B;AAAAA,QACA4B,MAAK;AAAA,QACLV,OAAOW,OAAOC,MAAMZ,KAAK,KAAKA,SAAS,OAAO,KAAKA,MAAMa,SAAW;AAAA,QACpEC,SAASA,MAAMxB,aAAaC,KAAK;AAAA,QACjCwB,QAAQA,MAAMzB,aAAaC,KAAK;AAAA,QAChCP,UAAUA,CAACgC,GAAGC,eAAe;AACrBC,gBAAAA,YAAY,CAAC,GAAGhC,WAAW;AACjCgC,oBAAU3B,KAAK,IAAI0B;AACnB9B,yBAAe+B,SAAS;AAAA,QAC1B;AAAA,QACAzC,SAAQA,iCAASc,WAAU;AAAA,QAC3BV;AAAAA,QACAsC,cAAY;AAAA,QAAA,GACRvC,WAAWW,KAAK;AAAA,MAAA,CACpB,CAAA;AAAA,IAzBGiB,GAAAA,MAAMjC,IAAIgB,KAAK,CAAC,CA2BxB;AAAA,EAAA,CACU;AAEjB;"}