@consta/uikit 3.9.1 → 3.11.0

package/__internal__/cjs-src/components/SliderCanary/helper.d.ts

@@ -0,0 +1,73 @@
+import React from 'react';
+import { IconProps } from '../../icons/Icon/Icon';
+import { PropsWithHTMLAttributes } from '../../utils/types/PropsWithHTMLAttributes';
+import { ActiveButton } from './useSlider/helper';
+export declare const propStatus: readonly ["alert", "warning", "success"];
+export declare type PropStatus = typeof propStatus[number];
+export declare const defaultPropStatus: "alert";
+export declare type PropView = 'default' | 'division';
+export declare const propSize: readonly ["s", "xs", "m", "l"];
+export declare type PropSize = typeof propSize[number];
+export declare const defaultPropSize: PropSize;
+export declare type SliderValue<RANGE> = RANGE extends true ? [number, number] : number;
+export declare type PropOnChange<RANGE> = (prop: {
+    e?: Event | React.TouchEvent | React.MouseEvent | React.KeyboardEvent | React.ChangeEvent;
+    value: SliderValue<RANGE>;
+}) => void;
+declare type PropToolipFormatter = (value: number | undefined) => string;
+declare type Props<RANGE extends boolean = false> = {
+    className?: string;
+    step?: number | number[];
+    view?: PropView;
+    disabled?: boolean;
+    range?: RANGE;
+    withTooltip?: boolean;
+    value: SliderValue<RANGE>;
+    label?: string;
+    caption?: string;
+    status?: PropStatus;
+    min?: number;
+    size?: PropSize;
+    max?: number;
+    onChange?: PropOnChange<RANGE>;
+    onAfterChange?: PropOnChange<RANGE>;
+    leftSide?: React.FC<IconProps> | 'input';
+    tooltipFormatter?: PropToolipFormatter;
+    rightSide?: React.FC<IconProps>;
+};
+export declare type Line = {
+    width: number;
+    active: boolean;
+    size?: number[];
+};
+export declare type SliderLineProps = {
+    view?: PropView;
+    lines: Line[];
+    disabled?: boolean;
+    hovered?: boolean;
+    onHover?: (hovered: boolean) => void;
+};
+export declare type SliderPointProps = PropsWithHTMLAttributes<{
+    value?: number | string;
+    disabled?: boolean;
+    focused?: boolean;
+    hovered?: boolean;
+    withTooltip?: boolean;
+    buttonLabel?: ActiveButton;
+    buttonRef?: React.RefObject<HTMLButtonElement>;
+    popoverPosition?: TrackPosition;
+    onFocus?: (e: React.FocusEvent<HTMLButtonElement> | React.MouseEvent, button: ActiveButton) => void;
+    onKeyPress?: (e: React.KeyboardEvent, typeButton: ActiveButton) => void;
+    onHover?: (hovered: boolean) => void;
+    position: number;
+}, HTMLButtonElement>;
+export declare type SliderProps<RANGE extends boolean> = PropsWithHTMLAttributes<Props<RANGE>, HTMLDivElement>;
+export declare type SliderComponent = <RANGE extends boolean>(props: SliderProps<RANGE>) => React.ReactElement | null;
+export declare const isRangeParams: (params: Props<boolean>) => params is Props<true>;
+export declare const isNotRangeParams: (params: Props<boolean>) => params is Props<false>;
+export declare const defaultTooltipFormatter: PropToolipFormatter;
+export declare type TrackPosition = {
+    x: number;
+    y: number;
+} | null;
+export {};

package/__internal__/cjs-src/components/SliderCanary/helper.js

@@ -0,0 +1,14 @@
+"use strict";
+exports.__esModule = true;
+exports.defaultTooltipFormatter = exports.isNotRangeParams = exports.isRangeParams = exports.defaultPropSize = exports.propSize = exports.defaultPropStatus = exports.propStatus = void 0;
+exports.propStatus = ['alert', 'warning', 'success'];
+exports.defaultPropStatus = exports.propStatus[0];
+exports.propSize = ['s', 'xs', 'm', 'l'];
+exports.defaultPropSize = exports.propSize[0];
+exports.isRangeParams = function (params) {
+    return !!params.range;
+};
+exports.isNotRangeParams = function (params) {
+    return !params.range;
+};
+exports.defaultTooltipFormatter = function (value) { return (value === null || value === void 0 ? void 0 : value.toString()) || ''; };

package/__internal__/cjs-src/components/SliderCanary/useSlider/helper.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { PropOnChange, SliderValue, TrackPosition } from '../helper';
+export declare type ActiveButton = 'left' | 'right' | null | undefined;
+export declare type Stationing = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare type UseSliderProps<RANGE extends boolean = false> = {
+    disabled: boolean;
+    range?: RANGE;
+    value: SliderValue<RANGE>;
+    min: number;
+    max: number;
+    step?: number | number[];
+    onChange?: PropOnChange<RANGE>;
+    onAfterChange?: PropOnChange<RANGE>;
+    sliderRef: React.RefObject<HTMLDivElement>;
+    buttonRefs: React.RefObject<HTMLButtonElement>[];
+};
+export declare type UseSliderValues = {
+    onKeyPress: (e: React.KeyboardEvent, typeButton: ActiveButton) => void;
+    onFocus: (e: React.FocusEvent<HTMLButtonElement> | React.MouseEvent, button: ActiveButton) => void;
+    activeButton: ActiveButton;
+    dragPoint: () => void;
+    currentValue: number | [number, number];
+    popoverPosition: TrackPosition[];
+};
+export declare const isRangeParams: (params: UseSliderProps<boolean>) => params is UseSliderProps<true>;
+export declare const isNotRangeParams: (params: UseSliderProps<boolean>) => params is UseSliderProps<false>;
+export declare const trackPosition: (event: Event | React.TouchEvent | React.MouseEvent) => TrackPosition;
+export declare const getActiveValue: (value: number | [number, number], active: ActiveButton) => number;
+export declare const detectActiveButton: (posittion: TrackPosition, buttons: React.RefObject<HTMLButtonElement>[]) => ActiveButton;
+export declare const getValidValue: (value: number, min: number, max: number, step?: number | number[] | undefined) => number;
+export declare const isValidValue: (value: number, min: number, max: number, step?: number | number[] | undefined) => boolean;
+export declare const getValueByPosition: (position: TrackPosition, sliderRef: React.RefObject<HTMLDivElement>, min: number, max: number) => number;
+export declare const getNewValue: (changedValue: number, currentValue: number | [number, number], step: number | number[], min: number, max: number, activeButton: ActiveButton) => number | [number, number];
+export declare const analyzeDivisionValue: (value: number, step: number | number[], min: number, max: number) => number;

package/__internal__/cjs-src/components/SliderCanary/useSlider/helper.js

@@ -0,0 +1,136 @@
+"use strict";
+exports.__esModule = true;
+exports.analyzeDivisionValue = exports.getNewValue = exports.getValueByPosition = exports.isValidValue = exports.getValidValue = exports.detectActiveButton = exports.getActiveValue = exports.trackPosition = exports.isNotRangeParams = exports.isRangeParams = void 0;
+var tslib_1 = require("tslib");
+var useSliderStationing_1 = require("../useSliderStationing");
+exports.isRangeParams = function (params) {
+    return !!params.range;
+};
+exports.isNotRangeParams = function (params) {
+    return !params.range;
+};
+exports.trackPosition = function (event) {
+    if ('clientX' in event) {
+        return {
+            x: event.clientX,
+            y: event.clientY
+        };
+    }
+    return null;
+};
+exports.getActiveValue = function (value, active) {
+    if (Array.isArray(value)) {
+        return active === 'left' ? value[0] : value[1];
+    }
+    return value;
+};
+exports.detectActiveButton = function (position, buttons) {
+    var activeButton = null;
+    buttons.forEach(function (buttonRef, index) {
+        var button = buttonRef.current;
+        if (button && position) {
+            var _a = button.getBoundingClientRect(), x = _a.x, y = _a.y, width = _a.width, height = _a.height;
+            if (x <= position.x &&
+                x + width >= position.x &&
+                y <= position.y &&
+                y + height >= position.y) {
+                activeButton = index === 0 ? 'left' : 'right';
+                button.focus();
+            }
+        }
+    });
+    return activeButton;
+};
+exports.getValidValue = function (value, min, max, step) {
+    if (typeof value === 'number') {
+        if (value > max)
+            return max;
+        if (value < min)
+            return min;
+        if (!Array.isArray(step)) {
+            var division = step === null || step === void 0 ? void 0 : step.toString().split('.')[1];
+            var stepValue = step || 1;
+            return (Math.ceil(Number(value.toFixed(division ? division.length : 0)) / stepValue) * stepValue);
+        }
+        var resultValue_1 = value;
+        var stepsArr_1 = step;
+        if (step[0] !== min) {
+            stepsArr_1 = tslib_1.__spread([min], stepsArr_1);
+        }
+        else if (step[step.length - 1] !== max) {
+            stepsArr_1 = tslib_1.__spread(stepsArr_1, [max]);
+        }
+        stepsArr_1.forEach(function (stepPoint, index) {
+            var minValue = min;
+            var maxValue = max;
+            if (index === 0) {
+                maxValue = stepsArr_1[index + 1];
+            }
+            else if (index === stepsArr_1.length - 1) {
+                minValue = stepPoint;
+                maxValue = max;
+            }
+            else {
+                maxValue = stepsArr_1[index + 1];
+                minValue = stepPoint;
+            }
+            if (value <= maxValue && value >= minValue) {
+                if ((maxValue + minValue) / 2 > value) {
+                    resultValue_1 = minValue;
+                }
+                else {
+                    resultValue_1 = maxValue;
+                }
+            }
+        });
+        return resultValue_1;
+    }
+    return value;
+};
+exports.isValidValue = function (value, min, max, step) {
+    return exports.getValidValue(value, min, max, step) === value;
+};
+exports.getValueByPosition = function (position, sliderRef, min, max) {
+    if (sliderRef.current && position) {
+        var _a = sliderRef.current.getBoundingClientRect(), x = _a.x, width = _a.width;
+        var absoluteSize = Math.abs(max - min);
+        var value = min + ((position.x - x) * absoluteSize) / width;
+        return exports.getValidValue(value, min, max);
+    }
+    return 0;
+};
+exports.getNewValue = function (changedValue, currentValue, step, min, max, activeButton) {
+    var maxRangeValue = max;
+    var minRangeValue = min;
+    if (Array.isArray(currentValue)) {
+        var _a = tslib_1.__read(currentValue, 2), left = _a[0], right = _a[1];
+        if (activeButton === 'right') {
+            minRangeValue = left;
+        }
+        else {
+            maxRangeValue = right;
+        }
+    }
+    var analyzedValue = exports.getValidValue(exports.analyzeDivisionValue(changedValue, step, min, max), minRangeValue, maxRangeValue, step);
+    if (Array.isArray(currentValue)) {
+        return activeButton === 'right'
+            ? [currentValue[0], analyzedValue]
+            : [analyzedValue, currentValue[1]];
+    }
+    return analyzedValue;
+};
+exports.analyzeDivisionValue = function (value, step, min, max) {
+    var steps = useSliderStationing_1.getSteps(step, min, max);
+    var newValue = value;
+    steps.forEach(function (stepSize) {
+        if (value && stepSize.min < value && stepSize.max >= value) {
+            if ((stepSize.max + stepSize.min) / 2 > value) {
+                newValue = stepSize.min;
+            }
+            else {
+                newValue = stepSize.max;
+            }
+        }
+    });
+    return newValue;
+};

package/__internal__/cjs-src/components/SliderCanary/useSlider/useSlider.d.ts

@@ -0,0 +1,2 @@
+import { UseSliderProps, UseSliderValues } from './helper';
+export declare function useSlider<RANGE extends boolean>(props: UseSliderProps<RANGE>): UseSliderValues;

package/__internal__/cjs-src/components/SliderCanary/useSlider/useSlider.js

@@ -0,0 +1,231 @@
+"use strict";
+exports.__esModule = true;
+exports.useSlider = void 0;
+var tslib_1 = require("tslib");
+var react_1 = require("react");
+var useComponentSize_1 = require("../../../hooks/useComponentSize/useComponentSize");
+var useFlag_1 = require("../../../hooks/useFlag/useFlag");
+var helper_1 = require("./helper");
+function useSlider(props) {
+    var disabled = props.disabled, range = props.range, value = props.value, min = props.min, max = props.max, _a = props.step, step = _a === void 0 ? 1 : _a, onChange = props.onChange, onAfterChange = props.onAfterChange, sliderRef = props.sliderRef, buttonRefs = props.buttonRefs;
+    var minValue = max > min ? min : 0;
+    var maxValue = max > min ? max : 100;
+    var _b = tslib_1.__read(react_1.useState(value), 2), currentValue = _b[0], setCurrentValue = _b[1];
+    var _c = tslib_1.__read(react_1.useState(null), 2), leftPopover = _c[0], setLeftPopover = _c[1];
+    var _d = tslib_1.__read(react_1.useState(null), 2), rightPopover = _d[0], setRightPopover = _d[1];
+    var _e = tslib_1.__read(useFlag_1.useFlag(false), 2), draggable = _e[0], _f = _e[1], on = _f.on, off = _f.off;
+    var activeButton = react_1.useRef(null);
+    var sizeSlider = useComponentSize_1.useComponentSize(sliderRef);
+    var addListeners = function () {
+        document.addEventListener('mouseup', handleTouchEnd);
+        document.addEventListener('touchend', handleTouchEnd);
+        document.addEventListener('mousemove', handleTouchMove);
+        document.addEventListener('touchmove', handleTouchMove);
+    };
+    var removeListeners = function () {
+        document.removeEventListener('mouseup', handleTouchEnd);
+        document.removeEventListener('touchend', handleTouchEnd);
+        document.removeEventListener('mousemove', handleTouchMove);
+        document.removeEventListener('touchmove', handleTouchMove);
+    };
+    react_1.useEffect(function () {
+        addListeners();
+        return function () {
+            removeListeners();
+        };
+    }, [
+        activeButton.current,
+        step,
+        currentValue,
+        value,
+        min,
+        max,
+        sliderRef.current,
+        buttonRefs,
+        disabled,
+        draggable,
+    ]);
+    react_1.useEffect(function () {
+        if (Array.isArray(currentValue)) {
+            setTooltipPosition(currentValue[0], 'left');
+            setTooltipPosition(currentValue[1], 'right');
+        }
+        else {
+            setTooltipPosition(currentValue, 'left');
+        }
+    }, [currentValue]);
+    react_1.useEffect(function () {
+        if (JSON.stringify(value) !== JSON.stringify(currentValue)) {
+            setCurrentValue(value);
+            setTooltipPosition(helper_1.getActiveValue(value, activeButton.current), 'left');
+            activeButton.current = null;
+        }
+    }, [value]);
+    react_1.useEffect(function () {
+        onChange === null || onChange === void 0 ? void 0 : onChange({
+            value: Array.isArray(currentValue)
+                ? [
+                    helper_1.getNewValue(currentValue[0], currentValue[0], step, min, max, 'left'),
+                    helper_1.getNewValue(currentValue[1], currentValue[1], step, min, max, 'right'),
+                ]
+                : helper_1.getNewValue(currentValue, currentValue, step, min, max, 'left')
+        });
+    }, [step]);
+    react_1.useEffect(function () {
+        if (typeof value !== 'undefined' && typeof step !== 'undefined') {
+            var targetValue = helper_1.isRangeParams(props)
+                ? [
+                    helper_1.getValidValue(props.value[0], min, max, step),
+                    helper_1.getValidValue(props.value[1], min, max, step),
+                ]
+                : helper_1.getValidValue(props.value, min, max, step);
+            setCurrentValue(targetValue);
+        }
+    }, [range, typeof value]);
+    react_1.useEffect(function () {
+        var _a;
+        if (helper_1.isRangeParams(props)) {
+            if (props.value[0] > props.value[1]) {
+                var newValue = [props.value[1], props.value[1]];
+                (_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props, { value: newValue });
+            }
+        }
+    }, []);
+    var onKeyPress = react_1.useCallback(function (event, typeButton) {
+        if (!disabled && typeof typeButton === 'string' && typeof currentValue !== 'undefined') {
+            var stepIncrement_1 = !Array.isArray(step) ? step || 1 : 1;
+            var validKeyCode = false;
+            var changedValue_1 = helper_1.getActiveValue(currentValue, typeButton);
+            switch (event.key) {
+                case 'ArrowUp':
+                case 'ArrowRight':
+                case '+':
+                    validKeyCode = true;
+                    break;
+                case 'ArrowLeft':
+                case 'ArrowDown':
+                case '-':
+                    validKeyCode = true;
+                    stepIncrement_1 *= -1;
+                    break;
+                default:
+                    break;
+            }
+            if (validKeyCode) {
+                if (Array.isArray(step)) {
+                    var stepsArr_1 = tslib_1.__spread(step);
+                    if (step[0] !== minValue) {
+                        stepsArr_1 = tslib_1.__spread([minValue], stepsArr_1);
+                    }
+                    if (step[step.length - 1] !== maxValue) {
+                        stepsArr_1 = tslib_1.__spread(stepsArr_1, [maxValue]);
+                    }
+                    stepsArr_1.forEach(function (stepPoint, index) {
+                        if (typeof typeButton === 'string' && changedValue_1 === stepPoint) {
+                            if (stepIncrement_1 >= 0) {
+                                if (index === 0) {
+                                    stepIncrement_1 = stepsArr_1[1] - minValue;
+                                }
+                                else {
+                                    stepIncrement_1 =
+                                        (typeof stepsArr_1[index + 1] !== 'undefined'
+                                            ? stepsArr_1[index + 1]
+                                            : maxValue) - stepPoint;
+                                }
+                            }
+                            else if (index === 0) {
+                                stepIncrement_1 = minValue - stepsArr_1[1];
+                            }
+                            else {
+                                stepIncrement_1 =
+                                    (typeof stepsArr_1[index - 1] !== 'undefined' ? stepsArr_1[index - 1] : minValue) -
+                                        stepPoint;
+                            }
+                        }
+                    });
+                }
+                var newValue = helper_1.getNewValue(changedValue_1 + stepIncrement_1, currentValue, step, min, max, typeButton);
+                setCurrentValue(newValue);
+                setTooltipPosition(helper_1.getActiveValue(newValue, typeButton), typeButton);
+                onChange === null || onChange === void 0 ? void 0 : onChange({
+                    e: event,
+                    value: newValue
+                });
+            }
+        }
+    }, [currentValue, step, min, max]);
+    var setTooltipPosition = function (value, position) {
+        if (sliderRef.current && position) {
+            var button = buttonRefs[position === 'left' ? 0 : 1].current || sliderRef.current;
+            var _a = sliderRef.current.getBoundingClientRect(), x = _a.x, width = _a.width;
+            var newPosition = {
+                y: button.offsetTop + button.offsetHeight + 50,
+                x: x + Math.abs((value - minValue) / (maxValue - minValue)) * width
+            };
+            if (position === 'left') {
+                setLeftPopover(newPosition);
+            }
+            else {
+                setRightPopover(newPosition);
+            }
+        }
+    };
+    var changePosition = function (event) {
+        var nativeEvent = event;
+        if (typeof activeButton.current !== 'string') {
+            return value;
+        }
+        var position = helper_1.trackPosition(nativeEvent);
+        var positionValue = helper_1.getValueByPosition(position, sliderRef, minValue, maxValue);
+        return helper_1.getNewValue(positionValue, currentValue, step, min, max, activeButton.current);
+    };
+    var onFocus = function (e, button) {
+        activeButton.current = button;
+    };
+    var handleTouchMove = function (event) {
+        if (typeof activeButton.current === 'string' && draggable) {
+            var position = changePosition(event);
+            var oldValue = helper_1.getActiveValue(currentValue, activeButton.current);
+            var newValue = helper_1.getActiveValue(position, activeButton.current);
+            if (oldValue !== newValue) {
+                setCurrentValue(position);
+                onAfterChange === null || onAfterChange === void 0 ? void 0 : onAfterChange({ e: event, value: position });
+            }
+        }
+    };
+    var handleTouchEnd = function (event) {
+        var position = changePosition(event);
+        if (typeof position !== 'undefined') {
+            setCurrentValue(position);
+            onChange === null || onChange === void 0 ? void 0 : onChange({ e: event, value: position });
+        }
+        off();
+        if (JSON.stringify(position) !== JSON.stringify(currentValue)) {
+            buttonRefs.forEach(function (button) {
+                var _a;
+                (_a = button.current) === null || _a === void 0 ? void 0 : _a.blur();
+            });
+            activeButton.current = null;
+        }
+    };
+    react_1.useEffect(function () {
+        if (helper_1.isRangeParams(props)) {
+            props.value.forEach(function (val, index) {
+                setTooltipPosition(helper_1.getActiveValue(val, activeButton.current), index === 0 ? 'left' : 'right');
+            });
+        }
+        if (helper_1.isNotRangeParams(props)) {
+            setTooltipPosition(helper_1.getActiveValue(value, activeButton.current), 'left');
+        }
+        activeButton.current = null;
+    }, [sizeSlider, typeof value]);
+    return {
+        onKeyPress: onKeyPress,
+        onFocus: onFocus,
+        dragPoint: on,
+        activeButton: activeButton.current,
+        popoverPosition: [leftPopover, rightPopover],
+        currentValue: currentValue
+    };
+}
+exports.useSlider = useSlider;

package/__internal__/cjs-src/components/SliderCanary/useSliderStationing.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Line, PropView } from './helper';
+declare type UseSliderStationing = (value: number | [number, number] | undefined, min: number, max: number, view: PropView, range: boolean | undefined, step: number | number[] | undefined, buttonRefs: [React.RefObject<HTMLButtonElement>, React.RefObject<HTMLButtonElement>], sliderLineRef: React.RefObject<HTMLDivElement>) => {
+    lineSizes: Line[];
+    buttonPositions: number[];
+};
+export declare const getSteps: (step: number | number[], min: number, max: number) => {
+    min: number;
+    max: number;
+}[];
+export declare const useSliderStationing: UseSliderStationing;
+export {};

package/__internal__/cjs-src/components/SliderCanary/useSliderStationing.js

@@ -0,0 +1,131 @@
+"use strict";
+exports.__esModule = true;
+exports.useSliderStationing = exports.getSteps = void 0;
+var tslib_1 = require("tslib");
+var react_1 = require("react");
+exports.getSteps = function (step, min, max) {
+    var stepsArray = [];
+    var size = min;
+    if (Array.isArray(step)) {
+        step.forEach(function (stepSize) {
+            stepsArray.push({
+                min: size,
+                max: stepSize
+            });
+            size += stepSize - size;
+        });
+        if (size !== max) {
+            stepsArray.push({
+                min: size,
+                max: max
+            });
+        }
+    }
+    else {
+        for (var i = min; i < max; i += step) {
+            stepsArray.push({
+                min: size,
+                max: size + (max - i < step ? max - i : step)
+            });
+            size += step;
+        }
+    }
+    return stepsArray;
+};
+exports.useSliderStationing = function (value, min, max, view, range, step, buttonRefs, sliderLineRef) {
+    var _a = tslib_1.__read(react_1.useState([]), 2), lineSizes = _a[0], setLineSizes = _a[1];
+    var _b = tslib_1.__read(react_1.useState([]), 2), buttonPositions = _b[0], setButtonPositions = _b[1];
+    var calculateLines = function () {
+        var sizesArray = [];
+        var absoluteSize = Math.abs(max - min);
+        if (typeof value !== 'undefined') {
+            if (view === 'default') {
+                if (!Array.isArray(value) && typeof value === 'number') {
+                    sizesArray.push({
+                        width: (1 - (max - value) / absoluteSize) * 100,
+                        active: true
+                    });
+                    sizesArray.push({
+                        width: ((max - value) / absoluteSize) * 100,
+                        active: false
+                    });
+                }
+                else if (Array.isArray(value) && value) {
+                    sizesArray.push({
+                        width: ((value[0] - min) / absoluteSize) * 100,
+                        active: false
+                    });
+                    sizesArray.push({
+                        width: ((value[1] - value[0]) / absoluteSize) * 100,
+                        active: true
+                    });
+                    sizesArray.push({
+                        width: ((max - value[1]) / absoluteSize) * 100,
+                        active: false
+                    });
+                }
+                else {
+                    sizesArray.push({
+                        width: 100,
+                        active: false
+                    });
+                }
+            }
+            else if (typeof step !== 'undefined') {
+                exports.getSteps(step, min, max).forEach(function (stepSize) {
+                    sizesArray.push({
+                        width: (Math.abs(stepSize.max - stepSize.min) * 100) / absoluteSize,
+                        active: (typeof value === 'number' || Array.isArray(value)) &&
+                            (range && Array.isArray(value)
+                                ? stepSize.max > value[0] && stepSize.min < value[1]
+                                : stepSize.max <= value)
+                    });
+                });
+            }
+        }
+        else {
+            sizesArray.push({
+                width: 100,
+                active: false
+            });
+        }
+        return sizesArray;
+    };
+    var getValidValue = function (value) {
+        if (value < min)
+            return min;
+        if (value > max)
+            return max;
+        return value;
+    };
+    var calculateButtonPositions = react_1.useCallback(function () {
+        var absoluteSize = Math.abs(max - min);
+        var defaultPaddingValue = 0;
+        var positions = [];
+        buttonRefs.forEach(function (buttonRef, index) {
+            var _a, _b;
+            if (buttonRef.current &&
+                buttonRef.current.offsetWidth &&
+                sliderLineRef.current &&
+                sliderLineRef.current.offsetWidth) {
+                defaultPaddingValue =
+                    (absoluteSize * ((_a = buttonRef.current) === null || _a === void 0 ? void 0 : _a.offsetWidth)) /
+                        (2 * ((_b = sliderLineRef.current) === null || _b === void 0 ? void 0 : _b.offsetWidth)) || 0;
+            }
+            if (typeof value === 'number' || Array.isArray(value)) {
+                positions.push(typeof value === 'number'
+                    ? (1 - (max - getValidValue(value) + defaultPaddingValue) / absoluteSize) * 100
+                    : (1 - (max - getValidValue(value[index]) + defaultPaddingValue) / absoluteSize) * 100);
+            }
+        });
+        return positions;
+    }, [buttonRefs, sliderLineRef]);
+    react_1.useEffect(function () {
+        setLineSizes(calculateLines());
+        setButtonPositions(calculateButtonPositions());
+    }, [value, min, max, range, step, view]);
+    return {
+        lineSizes: lineSizes,
+        buttonPositions: buttonPositions
+    };
+};

package/__internal__/cjs-src/components/SnackBar/SnackBar.css

@@ -6,6 +6,12 @@
   -webkit-box-direction: reverse;
       -ms-flex-direction: column-reverse;
           flex-direction: column-reverse;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  width: 100%;
+  max-width: calc(400px + var(--space-xs) * 2);
+  padding-right: var(--space-xs);
+  padding-left: var(--space-xs);
 }
 
   .SnackBar-Item_animate_appear,