@ultraviolet/ui 1.57.0 → 1.58.0

package/dist/components/Slider/SingleSlider.cjs

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("@emotion/react/jsx-runtime");
+const _styled = require("@emotion/styled/base");
+const react = require("@emotion/react");
+const React = require("react");
+const index$1 = require("../Stack/index.cjs");
+const index = require("../Text/index.cjs");
+const Label = require("./Label.cjs");
+const Options = require("./Options.cjs");
+const constant = require("./constant.cjs");
+const styles = require("./styles.cjs");
+const _interopDefaultCompat = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const _styled__default = /* @__PURE__ */ _interopDefaultCompat(_styled);
+const StyledTextValue = /* @__PURE__ */ _styled__default.default(index.Text, process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["double", "isColumn"].includes(prop),
+  target: "egnedph1"
+} : {
+  shouldForwardProp: (prop) => !["double", "isColumn"].includes(prop),
+  target: "egnedph1",
+  label: "StyledTextValue"
+})("min-width:", ({
+  theme,
+  double,
+  isColumn
+}) => double && isColumn ? null : theme.space["5"], ";align-self:", ({
+  double,
+  isColumn
+}) => double || !isColumn ? "center" : "end", ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx"],"names":[],"mappings":"AAkB0C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Label } from './Label'\nimport { Options } from './Options'\nimport { SLIDER_WIDTH, THUMB_SIZE } from './constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from './styles'\nimport type { SingleSliderProps } from './types'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double, isColumn }) => (double || !isColumn ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider'].includes(prop),\n})<{ themeSlider: string; disabled: boolean }>`\n    appearance: none;\n    height: ${({ theme }) => theme.space['1']};\n    width:100%;\n    min-width: ${SLIDER_WIDTH.min}px;\n    background-color: ${({ theme }) => theme.colors.neutral.borderWeak};\n\n    border-radius: ${({ theme }) => theme.radii.default};\n    background-image:linear-gradient(${({ theme }) => theme.colors.primary.border}, ${({ theme }) => theme.colors.primary.border});\n    background-repeat: no-repeat;\n    align-self: center;\n    outline: none;\n \n    &:focus {\n      &::-moz-range-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n        box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n\n        &::-webkit-slider-thumb {\n          border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n          box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n  }\n    &[data-error='true']{\n        background-image:linear-gradient(${({ theme }) => theme.colors.danger.backgroundStrong}, ${({ theme }) => theme.colors.danger.backgroundStrong});\n    }\n\n    &[data-direction='column'] {\n      align-self: baseline;\n    }\n\n    &[aria-disabled='true']{\n      background-image:linear-gradient(${({ theme }) => theme.colors.primary.borderDisabled}, ${({ theme }) => theme.colors.primary.borderDisabled});\n    }\n\n    /* Mozilla */\n    ::-moz-range-track {\n        ${trackStyle}\n    }\n    ::-moz-range-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n\n    /* Other browsers */\n    ::-webkit-slider-runnable-track {\n        ${trackStyle}\n    }\n    ::-webkit-slider-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n`\n\nexport const SingleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  unit,\n  options,\n  possibleValues,\n  onFocus,\n  className,\n  label,\n  input,\n  prefix,\n  suffix,\n  required,\n  'aria-label': ariaLabel,\n  tooltipPosition,\n}: SingleSliderProps) => {\n  const localId = useId()\n  const { theme } = useTheme()\n  const finalId = id ?? localId\n  const [computedValue, setValues] = useState(value)\n  const [valueToShow, setValuesToShow] = useState<number | null>(value)\n  const refSlider = useRef<HTMLInputElement>(null)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number>(undefined)\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue(possibleValues[computedValue])\n    }\n  }, [possibleValues, computedValue])\n\n  // Make sure that min <= value <= max\n  useEffect(() => {\n    if (value < min) {\n      setValuesToShow(min)\n      onChange?.(min)\n    }\n    if (value > max) {\n      onChange?.(max)\n      setValuesToShow(max)\n    }\n  }, [value, max, min, onChange, step])\n\n  // Sync values with valuesToShow\n  useEffect(() => {\n    setValues(valueToShow ?? min)\n    onChange?.(valueToShow ?? min)\n  }, [max, min, onChange, valueToShow])\n\n  // Get slider size\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleChange = useCallback(\n    (newValue: number) => {\n      if (possibleValues) {\n        // Custom scale\n        const optionLabel = possibleValues[newValue ?? min]\n        setCustomValue(optionLabel)\n        setValuesToShow(newValue)\n      } else {\n        setValuesToShow(newValue)\n      }\n    },\n    [min, possibleValues],\n  )\n\n  const getBackgroundSize = useMemo(\n    () => ({\n      backgroundSize: `${((computedValue - min) * 100) / (max - min)}% 100%`,\n    }),\n    [computedValue, min, max],\n  )\n\n  const styledValue = (valueNumber: string | number | null) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        aria-label=\"input\"\n        max={max}\n        step={step}\n        controls={false}\n        data-testid={dataTestId ? `${dataTestId}-input` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal) {\n            setValuesToShow(newVal)\n          } else setValuesToShow(null)\n        }}\n        onBlur={event => {\n          if (!event.target.value) setValuesToShow(min)\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction === 'column' ? 'right' : 'center'}\n        double={false}\n        isColumn={direction === 'column'}\n        data-testid={dataTestId ? `${dataTestId}-value` : 'slider-value'}\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ?? unit}\n      </StyledTextValue>\n    )\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return computedValue\n    }\n    if (tooltip) {\n      return tooltip\n    }\n\n    return undefined\n  }, [tooltip, computedValue])\n\n  const placementTooltip =\n    ((computedValue - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n    THUMB_SIZE / 2 -\n    sliderWidth / 2\n\n  return (\n    <Stack gap={1} direction={direction} justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n          {direction === 'column'\n            ? styledValue(customValue ?? valueToShow)\n            : null}\n        </Stack>\n      ) : null}\n\n      {direction === 'column' && !label\n        ? styledValue(customValue ?? valueToShow)\n        : null}\n      <Stack direction=\"column\" width=\"100%\" gap={1} justifyContent=\"center\">\n        <StyledTooltip\n          text={tooltipText}\n          placement={tooltipPosition}\n          left={placementTooltip}\n        >\n          <SliderElement\n            type=\"range\"\n            value={computedValue}\n            onChange={event => {\n              handleChange(parseFloat(event.target.value))\n            }}\n            min={min}\n            max={max}\n            tabIndex={0}\n            step={step}\n            name={name}\n            disabled={!!disabled}\n            aria-disabled={disabled}\n            data-testid={dataTestId}\n            id={finalId}\n            onBlur={onBlur}\n            onFocus={onFocus}\n            aria-label={ariaLabel ?? name}\n            className={className}\n            style={getBackgroundSize}\n            data-error={!!error}\n            data-direction={direction}\n            themeSlider={theme}\n            ref={refSlider}\n          />\n        </StyledTooltip>\n        {options || possibleValues ? (\n          <Options\n            ticks={ticks}\n            min={min}\n            max={max}\n            sliderWidth={sliderWidth}\n            unit={unit}\n            value={computedValue}\n            step={step}\n          />\n        ) : null}\n      </Stack>\n      {direction === 'row' ? styledValue(customValue ?? valueToShow) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const SliderElement = /* @__PURE__ */ _styled__default.default("input", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["themeSlider"].includes(prop),
+  target: "egnedph0"
+} : {
+  shouldForwardProp: (prop) => !["themeSlider"].includes(prop),
+  target: "egnedph0",
+  label: "SliderElement"
+})("appearance:none;height:", ({
+  theme
+}) => theme.space["1"], ";width:100%;min-width:", constant.SLIDER_WIDTH.min, "px;background-color:", ({
+  theme
+}) => theme.colors.neutral.borderWeak, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";background-image:linear-gradient(", ({
+  theme
+}) => theme.colors.primary.border, ", ", ({
+  theme
+}) => theme.colors.primary.border, ");background-repeat:no-repeat;align-self:center;outline:none;&:focus{&::-moz-range-thumb{border:", ({
+  theme,
+  disabled
+}) => disabled ? null : `1.5px solid ${theme.colors.primary.border}`, ";box-shadow:", ({
+  theme,
+  disabled
+}) => disabled ? null : theme.shadows.focusPrimary, ";}&::-webkit-slider-thumb{border:", ({
+  theme,
+  disabled
+}) => disabled ? null : `1.5px solid ${theme.colors.primary.border}`, ";box-shadow:", ({
+  theme,
+  disabled
+}) => disabled ? null : theme.shadows.focusPrimary, ";}}&[data-error='true']{background-image:linear-gradient(", ({
+  theme
+}) => theme.colors.danger.backgroundStrong, ", ", ({
+  theme
+}) => theme.colors.danger.backgroundStrong, ");}&[data-direction='column']{align-self:baseline;}&[aria-disabled='true']{background-image:linear-gradient(", ({
+  theme
+}) => theme.colors.primary.borderDisabled, ", ", ({
+  theme
+}) => theme.colors.primary.borderDisabled, ");}::-moz-range-track{", styles.trackStyle, ";}::-moz-range-thumb{", ({
+  theme,
+  themeSlider,
+  disabled
+}) => styles.thumbStyle(theme, themeSlider, disabled), ";}::-webkit-slider-runnable-track{", styles.trackStyle, ";}::-webkit-slider-thumb{", ({
+  theme,
+  themeSlider,
+  disabled
+}) => styles.thumbStyle(theme, themeSlider, disabled), ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx"],"names":[],"mappings":"AAyB8C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Label } from './Label'\nimport { Options } from './Options'\nimport { SLIDER_WIDTH, THUMB_SIZE } from './constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from './styles'\nimport type { SingleSliderProps } from './types'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double, isColumn }) => (double || !isColumn ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider'].includes(prop),\n})<{ themeSlider: string; disabled: boolean }>`\n    appearance: none;\n    height: ${({ theme }) => theme.space['1']};\n    width:100%;\n    min-width: ${SLIDER_WIDTH.min}px;\n    background-color: ${({ theme }) => theme.colors.neutral.borderWeak};\n\n    border-radius: ${({ theme }) => theme.radii.default};\n    background-image:linear-gradient(${({ theme }) => theme.colors.primary.border}, ${({ theme }) => theme.colors.primary.border});\n    background-repeat: no-repeat;\n    align-self: center;\n    outline: none;\n \n    &:focus {\n      &::-moz-range-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n        box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n\n        &::-webkit-slider-thumb {\n          border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n          box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n  }\n    &[data-error='true']{\n        background-image:linear-gradient(${({ theme }) => theme.colors.danger.backgroundStrong}, ${({ theme }) => theme.colors.danger.backgroundStrong});\n    }\n\n    &[data-direction='column'] {\n      align-self: baseline;\n    }\n\n    &[aria-disabled='true']{\n      background-image:linear-gradient(${({ theme }) => theme.colors.primary.borderDisabled}, ${({ theme }) => theme.colors.primary.borderDisabled});\n    }\n\n    /* Mozilla */\n    ::-moz-range-track {\n        ${trackStyle}\n    }\n    ::-moz-range-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n\n    /* Other browsers */\n    ::-webkit-slider-runnable-track {\n        ${trackStyle}\n    }\n    ::-webkit-slider-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n`\n\nexport const SingleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  unit,\n  options,\n  possibleValues,\n  onFocus,\n  className,\n  label,\n  input,\n  prefix,\n  suffix,\n  required,\n  'aria-label': ariaLabel,\n  tooltipPosition,\n}: SingleSliderProps) => {\n  const localId = useId()\n  const { theme } = useTheme()\n  const finalId = id ?? localId\n  const [computedValue, setValues] = useState(value)\n  const [valueToShow, setValuesToShow] = useState<number | null>(value)\n  const refSlider = useRef<HTMLInputElement>(null)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number>(undefined)\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue(possibleValues[computedValue])\n    }\n  }, [possibleValues, computedValue])\n\n  // Make sure that min <= value <= max\n  useEffect(() => {\n    if (value < min) {\n      setValuesToShow(min)\n      onChange?.(min)\n    }\n    if (value > max) {\n      onChange?.(max)\n      setValuesToShow(max)\n    }\n  }, [value, max, min, onChange, step])\n\n  // Sync values with valuesToShow\n  useEffect(() => {\n    setValues(valueToShow ?? min)\n    onChange?.(valueToShow ?? min)\n  }, [max, min, onChange, valueToShow])\n\n  // Get slider size\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleChange = useCallback(\n    (newValue: number) => {\n      if (possibleValues) {\n        // Custom scale\n        const optionLabel = possibleValues[newValue ?? min]\n        setCustomValue(optionLabel)\n        setValuesToShow(newValue)\n      } else {\n        setValuesToShow(newValue)\n      }\n    },\n    [min, possibleValues],\n  )\n\n  const getBackgroundSize = useMemo(\n    () => ({\n      backgroundSize: `${((computedValue - min) * 100) / (max - min)}% 100%`,\n    }),\n    [computedValue, min, max],\n  )\n\n  const styledValue = (valueNumber: string | number | null) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        aria-label=\"input\"\n        max={max}\n        step={step}\n        controls={false}\n        data-testid={dataTestId ? `${dataTestId}-input` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal) {\n            setValuesToShow(newVal)\n          } else setValuesToShow(null)\n        }}\n        onBlur={event => {\n          if (!event.target.value) setValuesToShow(min)\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction === 'column' ? 'right' : 'center'}\n        double={false}\n        isColumn={direction === 'column'}\n        data-testid={dataTestId ? `${dataTestId}-value` : 'slider-value'}\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ?? unit}\n      </StyledTextValue>\n    )\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return computedValue\n    }\n    if (tooltip) {\n      return tooltip\n    }\n\n    return undefined\n  }, [tooltip, computedValue])\n\n  const placementTooltip =\n    ((computedValue - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n    THUMB_SIZE / 2 -\n    sliderWidth / 2\n\n  return (\n    <Stack gap={1} direction={direction} justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n          {direction === 'column'\n            ? styledValue(customValue ?? valueToShow)\n            : null}\n        </Stack>\n      ) : null}\n\n      {direction === 'column' && !label\n        ? styledValue(customValue ?? valueToShow)\n        : null}\n      <Stack direction=\"column\" width=\"100%\" gap={1} justifyContent=\"center\">\n        <StyledTooltip\n          text={tooltipText}\n          placement={tooltipPosition}\n          left={placementTooltip}\n        >\n          <SliderElement\n            type=\"range\"\n            value={computedValue}\n            onChange={event => {\n              handleChange(parseFloat(event.target.value))\n            }}\n            min={min}\n            max={max}\n            tabIndex={0}\n            step={step}\n            name={name}\n            disabled={!!disabled}\n            aria-disabled={disabled}\n            data-testid={dataTestId}\n            id={finalId}\n            onBlur={onBlur}\n            onFocus={onFocus}\n            aria-label={ariaLabel ?? name}\n            className={className}\n            style={getBackgroundSize}\n            data-error={!!error}\n            data-direction={direction}\n            themeSlider={theme}\n            ref={refSlider}\n          />\n        </StyledTooltip>\n        {options || possibleValues ? (\n          <Options\n            ticks={ticks}\n            min={min}\n            max={max}\n            sliderWidth={sliderWidth}\n            unit={unit}\n            value={computedValue}\n            step={step}\n          />\n        ) : null}\n      </Stack>\n      {direction === 'row' ? styledValue(customValue ?? valueToShow) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const SingleSlider = ({
+  name,
+  tooltip,
+  direction,
+  disabled,
+  error,
+  "data-testid": dataTestId,
+  value,
+  onChange,
+  min = 0,
+  max = 100,
+  step = 1,
+  id,
+  onBlur,
+  unit,
+  options,
+  possibleValues,
+  onFocus,
+  className,
+  label,
+  input,
+  prefix,
+  suffix,
+  required,
+  "aria-label": ariaLabel,
+  tooltipPosition
+}) => {
+  const localId = React.useId();
+  const {
+    theme
+  } = react.useTheme();
+  const finalId = id ?? localId;
+  const [computedValue, setValues] = React.useState(value);
+  const [valueToShow, setValuesToShow] = React.useState(value);
+  const refSlider = React.useRef(null);
+  const [sliderWidth, setWidth] = React.useState(refSlider.current?.offsetWidth ?? constant.SLIDER_WIDTH.max);
+  const [customValue, setCustomValue] = React.useState(void 0);
+  const ticks = React.useMemo(() => {
+    if (options === true) {
+      return Array.from({
+        length: max - min + 1
+      }, (_, index2) => ({
+        value: min + index2 * step,
+        label: String(min + index2 * step)
+      })).filter((element) => element.value <= max && element.value >= min);
+    }
+    if (options) return options;
+    if (possibleValues) {
+      return possibleValues.map((element, index2) => ({
+        value: index2,
+        label: String(element)
+      }));
+    }
+    return [];
+  }, [max, min, options, possibleValues, step]);
+  React.useEffect(() => {
+    if (possibleValues) {
+      setCustomValue(possibleValues[computedValue]);
+    }
+  }, [possibleValues, computedValue]);
+  React.useEffect(() => {
+    if (value < min) {
+      setValuesToShow(min);
+      onChange?.(min);
+    }
+    if (value > max) {
+      onChange?.(max);
+      setValuesToShow(max);
+    }
+  }, [value, max, min, onChange, step]);
+  React.useEffect(() => {
+    setValues(valueToShow ?? min);
+    onChange?.(valueToShow ?? min);
+  }, [max, min, onChange, valueToShow]);
+  React.useEffect(() => {
+    const setWidthResize = () => {
+      setWidth(refSlider.current?.offsetWidth ?? constant.SLIDER_WIDTH.max);
+    };
+    window.addEventListener("resize", setWidthResize);
+    return () => {
+      window.removeEventListener("resize", setWidthResize);
+    };
+  }, []);
+  const handleChange = React.useCallback((newValue) => {
+    if (possibleValues) {
+      const optionLabel = possibleValues[newValue ?? min];
+      setCustomValue(optionLabel);
+      setValuesToShow(newValue);
+    } else {
+      setValuesToShow(newValue);
+    }
+  }, [min, possibleValues]);
+  const getBackgroundSize = React.useMemo(() => ({
+    backgroundSize: `${(computedValue - min) * 100 / (max - min)}% 100%`
+  }), [computedValue, min, max]);
+  const styledValue = (valueNumber) => input && (!options || options === true) && !possibleValues ? /* @__PURE__ */ jsxRuntime.jsx(styles.StyledNumberInput, { value: typeof valueNumber === "string" ? parseFloat(valueNumber) : valueNumber, size: "small", min, "aria-label": "input", max, step, controls: false, "data-testid": dataTestId ? `${dataTestId}-input` : "slider-input", unit: typeof suffix === "string" ? suffix : unit, onChange: (newVal) => {
+    if (newVal) {
+      setValuesToShow(newVal);
+    } else setValuesToShow(null);
+  }, onBlur: (event) => {
+    if (!event.target.value) setValuesToShow(min);
+  } }) : /* @__PURE__ */ jsxRuntime.jsxs(StyledTextValue, { as: "span", variant: "bodySmall", sentiment: "neutral", placement: direction === "column" ? "right" : "center", double: false, isColumn: direction === "column", "data-testid": dataTestId ? `${dataTestId}-value` : "slider-value", children: [
+    prefix,
+    valueNumber,
+    suffix ?? unit
+  ] });
+  const tooltipText = React.useMemo(() => {
+    if (tooltip === true) {
+      return computedValue;
+    }
+    if (tooltip) {
+      return tooltip;
+    }
+    return void 0;
+  }, [tooltip, computedValue]);
+  const placementTooltip = (computedValue - min) / (max - min) * (sliderWidth - constant.THUMB_SIZE) + constant.THUMB_SIZE / 2 - sliderWidth / 2;
+  return /* @__PURE__ */ jsxRuntime.jsxs(index$1.Stack, { gap: 1, direction, justifyContent: "left", children: [
+    label ? /* @__PURE__ */ jsxRuntime.jsxs(index$1.Stack, { justifyContent: "space-between", direction: "row", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Label.Label, { direction, input, finalId, label, required }),
+      direction === "column" ? styledValue(customValue ?? valueToShow) : null
+    ] }) : null,
+    direction === "column" && !label ? styledValue(customValue ?? valueToShow) : null,
+    /* @__PURE__ */ jsxRuntime.jsxs(index$1.Stack, { direction: "column", width: "100%", gap: 1, justifyContent: "center", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(styles.StyledTooltip, { text: tooltipText, placement: tooltipPosition, left: placementTooltip, children: /* @__PURE__ */ jsxRuntime.jsx(SliderElement, { type: "range", value: computedValue, onChange: (event) => {
+        handleChange(parseFloat(event.target.value));
+      }, min, max, tabIndex: 0, step, name, disabled: !!disabled, "aria-disabled": disabled, "data-testid": dataTestId, id: finalId, onBlur, onFocus, "aria-label": ariaLabel ?? name, className, style: getBackgroundSize, "data-error": !!error, "data-direction": direction, themeSlider: theme, ref: refSlider }) }),
+      options || possibleValues ? /* @__PURE__ */ jsxRuntime.jsx(Options.Options, { ticks, min, max, sliderWidth, unit, value: computedValue, step }) : null
+    ] }),
+    direction === "row" ? styledValue(customValue ?? valueToShow) : null
+  ] });
+};
+exports.SingleSlider = SingleSlider;

package/dist/components/Slider/SingleSlider.d.ts

@@ -0,0 +1,2 @@
+import type { SingleSliderProps } from './types';
+export declare const SingleSlider: ({ name, tooltip, direction, disabled, error, "data-testid": dataTestId, value, onChange, min, max, step, id, onBlur, unit, options, possibleValues, onFocus, className, label, input, prefix, suffix, required, "aria-label": ariaLabel, tooltipPosition, }: SingleSliderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/components/Slider/SingleSlider.js

@@ -0,0 +1,205 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import _styled from "@emotion/styled/base";
+import { useTheme } from "@emotion/react";
+import { useId, useState, useRef, useMemo, useEffect, useCallback } from "react";
+import { Stack } from "../Stack/index.js";
+import { Text } from "../Text/index.js";
+import { Label } from "./Label.js";
+import { Options } from "./Options.js";
+import { SLIDER_WIDTH, THUMB_SIZE } from "./constant.js";
+import { trackStyle, thumbStyle, StyledTooltip, StyledNumberInput } from "./styles.js";
+const StyledTextValue = /* @__PURE__ */ _styled(Text, process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["double", "isColumn"].includes(prop),
+  target: "egnedph1"
+} : {
+  shouldForwardProp: (prop) => !["double", "isColumn"].includes(prop),
+  target: "egnedph1",
+  label: "StyledTextValue"
+})("min-width:", ({
+  theme,
+  double,
+  isColumn
+}) => double && isColumn ? null : theme.space["5"], ";align-self:", ({
+  double,
+  isColumn
+}) => double || !isColumn ? "center" : "end", ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx"],"names":[],"mappings":"AAkB0C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Label } from './Label'\nimport { Options } from './Options'\nimport { SLIDER_WIDTH, THUMB_SIZE } from './constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from './styles'\nimport type { SingleSliderProps } from './types'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double, isColumn }) => (double || !isColumn ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider'].includes(prop),\n})<{ themeSlider: string; disabled: boolean }>`\n    appearance: none;\n    height: ${({ theme }) => theme.space['1']};\n    width:100%;\n    min-width: ${SLIDER_WIDTH.min}px;\n    background-color: ${({ theme }) => theme.colors.neutral.borderWeak};\n\n    border-radius: ${({ theme }) => theme.radii.default};\n    background-image:linear-gradient(${({ theme }) => theme.colors.primary.border}, ${({ theme }) => theme.colors.primary.border});\n    background-repeat: no-repeat;\n    align-self: center;\n    outline: none;\n \n    &:focus {\n      &::-moz-range-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n        box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n\n        &::-webkit-slider-thumb {\n          border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n          box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n  }\n    &[data-error='true']{\n        background-image:linear-gradient(${({ theme }) => theme.colors.danger.backgroundStrong}, ${({ theme }) => theme.colors.danger.backgroundStrong});\n    }\n\n    &[data-direction='column'] {\n      align-self: baseline;\n    }\n\n    &[aria-disabled='true']{\n      background-image:linear-gradient(${({ theme }) => theme.colors.primary.borderDisabled}, ${({ theme }) => theme.colors.primary.borderDisabled});\n    }\n\n    /* Mozilla */\n    ::-moz-range-track {\n        ${trackStyle}\n    }\n    ::-moz-range-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n\n    /* Other browsers */\n    ::-webkit-slider-runnable-track {\n        ${trackStyle}\n    }\n    ::-webkit-slider-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n`\n\nexport const SingleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  unit,\n  options,\n  possibleValues,\n  onFocus,\n  className,\n  label,\n  input,\n  prefix,\n  suffix,\n  required,\n  'aria-label': ariaLabel,\n  tooltipPosition,\n}: SingleSliderProps) => {\n  const localId = useId()\n  const { theme } = useTheme()\n  const finalId = id ?? localId\n  const [computedValue, setValues] = useState(value)\n  const [valueToShow, setValuesToShow] = useState<number | null>(value)\n  const refSlider = useRef<HTMLInputElement>(null)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number>(undefined)\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue(possibleValues[computedValue])\n    }\n  }, [possibleValues, computedValue])\n\n  // Make sure that min <= value <= max\n  useEffect(() => {\n    if (value < min) {\n      setValuesToShow(min)\n      onChange?.(min)\n    }\n    if (value > max) {\n      onChange?.(max)\n      setValuesToShow(max)\n    }\n  }, [value, max, min, onChange, step])\n\n  // Sync values with valuesToShow\n  useEffect(() => {\n    setValues(valueToShow ?? min)\n    onChange?.(valueToShow ?? min)\n  }, [max, min, onChange, valueToShow])\n\n  // Get slider size\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleChange = useCallback(\n    (newValue: number) => {\n      if (possibleValues) {\n        // Custom scale\n        const optionLabel = possibleValues[newValue ?? min]\n        setCustomValue(optionLabel)\n        setValuesToShow(newValue)\n      } else {\n        setValuesToShow(newValue)\n      }\n    },\n    [min, possibleValues],\n  )\n\n  const getBackgroundSize = useMemo(\n    () => ({\n      backgroundSize: `${((computedValue - min) * 100) / (max - min)}% 100%`,\n    }),\n    [computedValue, min, max],\n  )\n\n  const styledValue = (valueNumber: string | number | null) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        aria-label=\"input\"\n        max={max}\n        step={step}\n        controls={false}\n        data-testid={dataTestId ? `${dataTestId}-input` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal) {\n            setValuesToShow(newVal)\n          } else setValuesToShow(null)\n        }}\n        onBlur={event => {\n          if (!event.target.value) setValuesToShow(min)\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction === 'column' ? 'right' : 'center'}\n        double={false}\n        isColumn={direction === 'column'}\n        data-testid={dataTestId ? `${dataTestId}-value` : 'slider-value'}\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ?? unit}\n      </StyledTextValue>\n    )\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return computedValue\n    }\n    if (tooltip) {\n      return tooltip\n    }\n\n    return undefined\n  }, [tooltip, computedValue])\n\n  const placementTooltip =\n    ((computedValue - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n    THUMB_SIZE / 2 -\n    sliderWidth / 2\n\n  return (\n    <Stack gap={1} direction={direction} justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n          {direction === 'column'\n            ? styledValue(customValue ?? valueToShow)\n            : null}\n        </Stack>\n      ) : null}\n\n      {direction === 'column' && !label\n        ? styledValue(customValue ?? valueToShow)\n        : null}\n      <Stack direction=\"column\" width=\"100%\" gap={1} justifyContent=\"center\">\n        <StyledTooltip\n          text={tooltipText}\n          placement={tooltipPosition}\n          left={placementTooltip}\n        >\n          <SliderElement\n            type=\"range\"\n            value={computedValue}\n            onChange={event => {\n              handleChange(parseFloat(event.target.value))\n            }}\n            min={min}\n            max={max}\n            tabIndex={0}\n            step={step}\n            name={name}\n            disabled={!!disabled}\n            aria-disabled={disabled}\n            data-testid={dataTestId}\n            id={finalId}\n            onBlur={onBlur}\n            onFocus={onFocus}\n            aria-label={ariaLabel ?? name}\n            className={className}\n            style={getBackgroundSize}\n            data-error={!!error}\n            data-direction={direction}\n            themeSlider={theme}\n            ref={refSlider}\n          />\n        </StyledTooltip>\n        {options || possibleValues ? (\n          <Options\n            ticks={ticks}\n            min={min}\n            max={max}\n            sliderWidth={sliderWidth}\n            unit={unit}\n            value={computedValue}\n            step={step}\n          />\n        ) : null}\n      </Stack>\n      {direction === 'row' ? styledValue(customValue ?? valueToShow) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const SliderElement = /* @__PURE__ */ _styled("input", process.env.NODE_ENV === "production" ? {
+  shouldForwardProp: (prop) => !["themeSlider"].includes(prop),
+  target: "egnedph0"
+} : {
+  shouldForwardProp: (prop) => !["themeSlider"].includes(prop),
+  target: "egnedph0",
+  label: "SliderElement"
+})("appearance:none;height:", ({
+  theme
+}) => theme.space["1"], ";width:100%;min-width:", SLIDER_WIDTH.min, "px;background-color:", ({
+  theme
+}) => theme.colors.neutral.borderWeak, ";border-radius:", ({
+  theme
+}) => theme.radii.default, ";background-image:linear-gradient(", ({
+  theme
+}) => theme.colors.primary.border, ", ", ({
+  theme
+}) => theme.colors.primary.border, ");background-repeat:no-repeat;align-self:center;outline:none;&:focus{&::-moz-range-thumb{border:", ({
+  theme,
+  disabled
+}) => disabled ? null : `1.5px solid ${theme.colors.primary.border}`, ";box-shadow:", ({
+  theme,
+  disabled
+}) => disabled ? null : theme.shadows.focusPrimary, ";}&::-webkit-slider-thumb{border:", ({
+  theme,
+  disabled
+}) => disabled ? null : `1.5px solid ${theme.colors.primary.border}`, ";box-shadow:", ({
+  theme,
+  disabled
+}) => disabled ? null : theme.shadows.focusPrimary, ";}}&[data-error='true']{background-image:linear-gradient(", ({
+  theme
+}) => theme.colors.danger.backgroundStrong, ", ", ({
+  theme
+}) => theme.colors.danger.backgroundStrong, ");}&[data-direction='column']{align-self:baseline;}&[aria-disabled='true']{background-image:linear-gradient(", ({
+  theme
+}) => theme.colors.primary.borderDisabled, ", ", ({
+  theme
+}) => theme.colors.primary.borderDisabled, ");}::-moz-range-track{", trackStyle, ";}::-moz-range-thumb{", ({
+  theme,
+  themeSlider,
+  disabled
+}) => thumbStyle(theme, themeSlider, disabled), ";}::-webkit-slider-runnable-track{", trackStyle, ";}::-webkit-slider-thumb{", ({
+  theme,
+  themeSlider,
+  disabled
+}) => thumbStyle(theme, themeSlider, disabled), ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx"],"names":[],"mappings":"AAyB8C","file":"/home/runner/work/ultraviolet/ultraviolet/packages/ui/src/components/Slider/SingleSlider.tsx","sourcesContent":["import { useTheme } from '@emotion/react'\nimport styled from '@emotion/styled'\nimport { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'\nimport { Stack } from '../Stack'\nimport { Text } from '../Text'\nimport { Label } from './Label'\nimport { Options } from './Options'\nimport { SLIDER_WIDTH, THUMB_SIZE } from './constant'\nimport {\n  StyledNumberInput,\n  StyledTooltip,\n  thumbStyle,\n  trackStyle,\n} from './styles'\nimport type { SingleSliderProps } from './types'\n\nconst StyledTextValue = styled(Text, {\n  shouldForwardProp: prop => !['double', 'isColumn'].includes(prop),\n})<{ double: boolean; isColumn: boolean }>`\n  min-width: ${({ theme, double, isColumn }) => (double && isColumn ? null : theme.space['5'])};\n  align-self: ${({ double, isColumn }) => (double || !isColumn ? 'center' : 'end')};\n`\n\nconst SliderElement = styled('input', {\n  shouldForwardProp: prop => !['themeSlider'].includes(prop),\n})<{ themeSlider: string; disabled: boolean }>`\n    appearance: none;\n    height: ${({ theme }) => theme.space['1']};\n    width:100%;\n    min-width: ${SLIDER_WIDTH.min}px;\n    background-color: ${({ theme }) => theme.colors.neutral.borderWeak};\n\n    border-radius: ${({ theme }) => theme.radii.default};\n    background-image:linear-gradient(${({ theme }) => theme.colors.primary.border}, ${({ theme }) => theme.colors.primary.border});\n    background-repeat: no-repeat;\n    align-self: center;\n    outline: none;\n \n    &:focus {\n      &::-moz-range-thumb {\n        border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n        box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n\n        &::-webkit-slider-thumb {\n          border: ${({ theme, disabled }) => (disabled ? null : `1.5px solid ${theme.colors.primary.border}`)};\n          box-shadow: ${({ theme, disabled }) => (disabled ? null : theme.shadows.focusPrimary)};\n        }\n  }\n    &[data-error='true']{\n        background-image:linear-gradient(${({ theme }) => theme.colors.danger.backgroundStrong}, ${({ theme }) => theme.colors.danger.backgroundStrong});\n    }\n\n    &[data-direction='column'] {\n      align-self: baseline;\n    }\n\n    &[aria-disabled='true']{\n      background-image:linear-gradient(${({ theme }) => theme.colors.primary.borderDisabled}, ${({ theme }) => theme.colors.primary.borderDisabled});\n    }\n\n    /* Mozilla */\n    ::-moz-range-track {\n        ${trackStyle}\n    }\n    ::-moz-range-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n\n    /* Other browsers */\n    ::-webkit-slider-runnable-track {\n        ${trackStyle}\n    }\n    ::-webkit-slider-thumb {\n        ${({ theme, themeSlider, disabled }) => thumbStyle(theme, themeSlider, disabled)}\n    }\n`\n\nexport const SingleSlider = ({\n  name,\n  tooltip,\n  direction,\n  disabled,\n  error,\n  'data-testid': dataTestId,\n  value,\n  onChange,\n  min = 0,\n  max = 100,\n  step = 1,\n  id,\n  onBlur,\n  unit,\n  options,\n  possibleValues,\n  onFocus,\n  className,\n  label,\n  input,\n  prefix,\n  suffix,\n  required,\n  'aria-label': ariaLabel,\n  tooltipPosition,\n}: SingleSliderProps) => {\n  const localId = useId()\n  const { theme } = useTheme()\n  const finalId = id ?? localId\n  const [computedValue, setValues] = useState(value)\n  const [valueToShow, setValuesToShow] = useState<number | null>(value)\n  const refSlider = useRef<HTMLInputElement>(null)\n  const [sliderWidth, setWidth] = useState(\n    refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max,\n  )\n  const [customValue, setCustomValue] = useState<undefined | number>(undefined)\n\n  const ticks = useMemo(() => {\n    if (options === true) {\n      return Array.from({ length: max - min + 1 }, (_, index) => ({\n        value: min + index * step,\n        label: String(min + index * step),\n      })).filter(element => element.value <= max && element.value >= min)\n    }\n    if (options) return options\n    if (possibleValues) {\n      return possibleValues.map((element, index) => ({\n        value: index,\n        label: String(element),\n      }))\n    }\n\n    return []\n  }, [max, min, options, possibleValues, step])\n\n  // Default value to be coherent with a custom scale when one is defined\n  useEffect(() => {\n    if (possibleValues) {\n      setCustomValue(possibleValues[computedValue])\n    }\n  }, [possibleValues, computedValue])\n\n  // Make sure that min <= value <= max\n  useEffect(() => {\n    if (value < min) {\n      setValuesToShow(min)\n      onChange?.(min)\n    }\n    if (value > max) {\n      onChange?.(max)\n      setValuesToShow(max)\n    }\n  }, [value, max, min, onChange, step])\n\n  // Sync values with valuesToShow\n  useEffect(() => {\n    setValues(valueToShow ?? min)\n    onChange?.(valueToShow ?? min)\n  }, [max, min, onChange, valueToShow])\n\n  // Get slider size\n  useEffect(() => {\n    const setWidthResize = () => {\n      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max)\n    }\n    window.addEventListener('resize', setWidthResize)\n\n    return () => {\n      window.removeEventListener('resize', setWidthResize)\n    }\n  }, [])\n\n  const handleChange = useCallback(\n    (newValue: number) => {\n      if (possibleValues) {\n        // Custom scale\n        const optionLabel = possibleValues[newValue ?? min]\n        setCustomValue(optionLabel)\n        setValuesToShow(newValue)\n      } else {\n        setValuesToShow(newValue)\n      }\n    },\n    [min, possibleValues],\n  )\n\n  const getBackgroundSize = useMemo(\n    () => ({\n      backgroundSize: `${((computedValue - min) * 100) / (max - min)}% 100%`,\n    }),\n    [computedValue, min, max],\n  )\n\n  const styledValue = (valueNumber: string | number | null) =>\n    input && (!options || options === true) && !possibleValues ? (\n      <StyledNumberInput\n        value={\n          typeof valueNumber === 'string'\n            ? parseFloat(valueNumber)\n            : valueNumber\n        }\n        size=\"small\"\n        min={min}\n        aria-label=\"input\"\n        max={max}\n        step={step}\n        controls={false}\n        data-testid={dataTestId ? `${dataTestId}-input` : 'slider-input'}\n        unit={typeof suffix === 'string' ? suffix : unit}\n        onChange={newVal => {\n          if (newVal) {\n            setValuesToShow(newVal)\n          } else setValuesToShow(null)\n        }}\n        onBlur={event => {\n          if (!event.target.value) setValuesToShow(min)\n        }}\n      />\n    ) : (\n      <StyledTextValue\n        as=\"span\"\n        variant=\"bodySmall\"\n        sentiment=\"neutral\"\n        placement={direction === 'column' ? 'right' : 'center'}\n        double={false}\n        isColumn={direction === 'column'}\n        data-testid={dataTestId ? `${dataTestId}-value` : 'slider-value'}\n      >\n        {prefix}\n        {valueNumber}\n        {suffix ?? unit}\n      </StyledTextValue>\n    )\n\n  const tooltipText = useMemo(() => {\n    if (tooltip === true) {\n      return computedValue\n    }\n    if (tooltip) {\n      return tooltip\n    }\n\n    return undefined\n  }, [tooltip, computedValue])\n\n  const placementTooltip =\n    ((computedValue - min) / (max - min)) * (sliderWidth - THUMB_SIZE) +\n    THUMB_SIZE / 2 -\n    sliderWidth / 2\n\n  return (\n    <Stack gap={1} direction={direction} justifyContent=\"left\">\n      {label ? (\n        <Stack justifyContent=\"space-between\" direction=\"row\">\n          <Label\n            direction={direction}\n            input={input}\n            finalId={finalId}\n            label={label}\n            required={required}\n          />\n          {direction === 'column'\n            ? styledValue(customValue ?? valueToShow)\n            : null}\n        </Stack>\n      ) : null}\n\n      {direction === 'column' && !label\n        ? styledValue(customValue ?? valueToShow)\n        : null}\n      <Stack direction=\"column\" width=\"100%\" gap={1} justifyContent=\"center\">\n        <StyledTooltip\n          text={tooltipText}\n          placement={tooltipPosition}\n          left={placementTooltip}\n        >\n          <SliderElement\n            type=\"range\"\n            value={computedValue}\n            onChange={event => {\n              handleChange(parseFloat(event.target.value))\n            }}\n            min={min}\n            max={max}\n            tabIndex={0}\n            step={step}\n            name={name}\n            disabled={!!disabled}\n            aria-disabled={disabled}\n            data-testid={dataTestId}\n            id={finalId}\n            onBlur={onBlur}\n            onFocus={onFocus}\n            aria-label={ariaLabel ?? name}\n            className={className}\n            style={getBackgroundSize}\n            data-error={!!error}\n            data-direction={direction}\n            themeSlider={theme}\n            ref={refSlider}\n          />\n        </StyledTooltip>\n        {options || possibleValues ? (\n          <Options\n            ticks={ticks}\n            min={min}\n            max={max}\n            sliderWidth={sliderWidth}\n            unit={unit}\n            value={computedValue}\n            step={step}\n          />\n        ) : null}\n      </Stack>\n      {direction === 'row' ? styledValue(customValue ?? valueToShow) : null}\n    </Stack>\n  )\n}\n"]} */"));
+const SingleSlider = ({
+  name,
+  tooltip,
+  direction,
+  disabled,
+  error,
+  "data-testid": dataTestId,
+  value,
+  onChange,
+  min = 0,
+  max = 100,
+  step = 1,
+  id,
+  onBlur,
+  unit,
+  options,
+  possibleValues,
+  onFocus,
+  className,
+  label,
+  input,
+  prefix,
+  suffix,
+  required,
+  "aria-label": ariaLabel,
+  tooltipPosition
+}) => {
+  const localId = useId();
+  const {
+    theme
+  } = useTheme();
+  const finalId = id ?? localId;
+  const [computedValue, setValues] = useState(value);
+  const [valueToShow, setValuesToShow] = useState(value);
+  const refSlider = useRef(null);
+  const [sliderWidth, setWidth] = useState(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max);
+  const [customValue, setCustomValue] = useState(void 0);
+  const ticks = useMemo(() => {
+    if (options === true) {
+      return Array.from({
+        length: max - min + 1
+      }, (_, index) => ({
+        value: min + index * step,
+        label: String(min + index * step)
+      })).filter((element) => element.value <= max && element.value >= min);
+    }
+    if (options) return options;
+    if (possibleValues) {
+      return possibleValues.map((element, index) => ({
+        value: index,
+        label: String(element)
+      }));
+    }
+    return [];
+  }, [max, min, options, possibleValues, step]);
+  useEffect(() => {
+    if (possibleValues) {
+      setCustomValue(possibleValues[computedValue]);
+    }
+  }, [possibleValues, computedValue]);
+  useEffect(() => {
+    if (value < min) {
+      setValuesToShow(min);
+      onChange?.(min);
+    }
+    if (value > max) {
+      onChange?.(max);
+      setValuesToShow(max);
+    }
+  }, [value, max, min, onChange, step]);
+  useEffect(() => {
+    setValues(valueToShow ?? min);
+    onChange?.(valueToShow ?? min);
+  }, [max, min, onChange, valueToShow]);
+  useEffect(() => {
+    const setWidthResize = () => {
+      setWidth(refSlider.current?.offsetWidth ?? SLIDER_WIDTH.max);
+    };
+    window.addEventListener("resize", setWidthResize);
+    return () => {
+      window.removeEventListener("resize", setWidthResize);
+    };
+  }, []);
+  const handleChange = useCallback((newValue) => {
+    if (possibleValues) {
+      const optionLabel = possibleValues[newValue ?? min];
+      setCustomValue(optionLabel);
+      setValuesToShow(newValue);
+    } else {
+      setValuesToShow(newValue);
+    }
+  }, [min, possibleValues]);
+  const getBackgroundSize = useMemo(() => ({
+    backgroundSize: `${(computedValue - min) * 100 / (max - min)}% 100%`
+  }), [computedValue, min, max]);
+  const styledValue = (valueNumber) => input && (!options || options === true) && !possibleValues ? /* @__PURE__ */ jsx(StyledNumberInput, { value: typeof valueNumber === "string" ? parseFloat(valueNumber) : valueNumber, size: "small", min, "aria-label": "input", max, step, controls: false, "data-testid": dataTestId ? `${dataTestId}-input` : "slider-input", unit: typeof suffix === "string" ? suffix : unit, onChange: (newVal) => {
+    if (newVal) {
+      setValuesToShow(newVal);
+    } else setValuesToShow(null);
+  }, onBlur: (event) => {
+    if (!event.target.value) setValuesToShow(min);
+  } }) : /* @__PURE__ */ jsxs(StyledTextValue, { as: "span", variant: "bodySmall", sentiment: "neutral", placement: direction === "column" ? "right" : "center", double: false, isColumn: direction === "column", "data-testid": dataTestId ? `${dataTestId}-value` : "slider-value", children: [
+    prefix,
+    valueNumber,
+    suffix ?? unit
+  ] });
+  const tooltipText = useMemo(() => {
+    if (tooltip === true) {
+      return computedValue;
+    }
+    if (tooltip) {
+      return tooltip;
+    }
+    return void 0;
+  }, [tooltip, computedValue]);
+  const placementTooltip = (computedValue - min) / (max - min) * (sliderWidth - THUMB_SIZE) + THUMB_SIZE / 2 - sliderWidth / 2;
+  return /* @__PURE__ */ jsxs(Stack, { gap: 1, direction, justifyContent: "left", children: [
+    label ? /* @__PURE__ */ jsxs(Stack, { justifyContent: "space-between", direction: "row", children: [
+      /* @__PURE__ */ jsx(Label, { direction, input, finalId, label, required }),
+      direction === "column" ? styledValue(customValue ?? valueToShow) : null
+    ] }) : null,
+    direction === "column" && !label ? styledValue(customValue ?? valueToShow) : null,
+    /* @__PURE__ */ jsxs(Stack, { direction: "column", width: "100%", gap: 1, justifyContent: "center", children: [
+      /* @__PURE__ */ jsx(StyledTooltip, { text: tooltipText, placement: tooltipPosition, left: placementTooltip, children: /* @__PURE__ */ jsx(SliderElement, { type: "range", value: computedValue, onChange: (event) => {
+        handleChange(parseFloat(event.target.value));
+      }, min, max, tabIndex: 0, step, name, disabled: !!disabled, "aria-disabled": disabled, "data-testid": dataTestId, id: finalId, onBlur, onFocus, "aria-label": ariaLabel ?? name, className, style: getBackgroundSize, "data-error": !!error, "data-direction": direction, themeSlider: theme, ref: refSlider }) }),
+      options || possibleValues ? /* @__PURE__ */ jsx(Options, { ticks, min, max, sliderWidth, unit, value: computedValue, step }) : null
+    ] }),
+    direction === "row" ? styledValue(customValue ?? valueToShow) : null
+  ] });
+};
+export {
+  SingleSlider
+};

package/dist/components/Slider/constant.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const SLIDER_WIDTH = {
+  min: 220,
+  max: 640
+};
+const THUMB_SIZE = 16;
+exports.SLIDER_WIDTH = SLIDER_WIDTH;
+exports.THUMB_SIZE = THUMB_SIZE;

package/dist/components/Slider/constant.d.ts

@@ -0,0 +1,5 @@
+export declare const SLIDER_WIDTH: {
+    min: number;
+    max: number;
+};
+export declare const THUMB_SIZE = 16;

package/dist/components/Slider/constant.js

@@ -0,0 +1,9 @@
+const SLIDER_WIDTH = {
+  min: 220,
+  max: 640
+};
+const THUMB_SIZE = 16;
+export {
+  SLIDER_WIDTH,
+  THUMB_SIZE
+};

package/dist/components/Slider/index.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("@emotion/react/jsx-runtime");
+const React = require("react");
+const index = require("../Text/index.cjs");
+const DoubleSlider = require("./DoubleSlider.cjs");
+const SingleSlider = require("./SingleSlider.cjs");
+const styles = require("./styles.cjs");
+const Slider = ({
+  name,
+  label,
+  helper,
+  tooltip,
+  direction = "column",
+  input,
+  prefix,
+  unit,
+  suffix,
+  required,
+  possibleValues,
+  disabled,
+  error,
+  options,
+  "data-testid": dataTestId,
+  value,
+  onChange,
+  min = 0,
+  double,
+  max = 100,
+  step = 1,
+  id,
+  onBlur,
+  onFocus,
+  className,
+  tooltipPosition = "top",
+  "aria-label": ariaLabel
+}) => {
+  const correctedBounds = possibleValues ? {
+    min: 0,
+    max: possibleValues.length - 1
+  } : {
+    min,
+    max
+  };
+  const gap = React.useMemo(() => {
+    if (options) return 3;
+    if (input && double) return 0;
+    return 1;
+  }, [options, input, double]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(styles.SliderContainer, { "aria-label": ariaLabel, "data-options": !!options, gap, children: [
+    double ? /* @__PURE__ */ jsxRuntime.jsx(DoubleSlider.DoubleSlider, { name, min: correctedBounds.min, max: correctedBounds.max, label, step, value, tooltip, disabled, error, onChange, "data-testid": dataTestId, id, onBlur, tooltipPosition, onFocus, className, options, input, unit, prefix, suffix, required, possibleValues, direction, "aria-label": ariaLabel }) : /* @__PURE__ */ jsxRuntime.jsx(SingleSlider.SingleSlider, { name, min: correctedBounds.min, max: correctedBounds.max, step, value, tooltip, disabled, error, onChange, options, "data-testid": dataTestId, id, tooltipPosition, onBlur, onFocus, className, direction, input, prefix, label, unit, suffix, required, possibleValues, "aria-label": ariaLabel }),
+    error || helper ? /* @__PURE__ */ jsxRuntime.jsx(index.Text, { as: "p", variant: "caption", sentiment: error ? "danger" : "neutral", prominence: "default", children: typeof error === "string" ? error : helper }) : null
+  ] });
+};
+exports.Slider = Slider;

package/dist/components/Slider/index.d.ts

@@ -0,0 +1,7 @@
+import type { SliderProps } from './types';
+/**
+ * You can define simple or double sliders with the slider component.
+ * - For a simple slider (one handle) : prop `value` must be number.
+ * - For a double slider (two handles):  prop `value` must be an array of numbers (of length 2) and prop `double` must be set to `true`. **Make sure that others props have the correct type.**
+ */
+export declare const Slider: ({ name, label, helper, tooltip, direction, input, prefix, unit, suffix, required, possibleValues, disabled, error, options, "data-testid": dataTestId, value, onChange, min, double, max, step, id, onBlur, onFocus, className, tooltipPosition, "aria-label": ariaLabel, }: SliderProps) => import("@emotion/react/jsx-runtime").JSX.Element;