@alfalab/core-components-calendar-range 7.3.28 → 7.4.0

package/moderncssm/components/divider/index.module.css

@@ -0,0 +1,55 @@
+/* */
+:root {
+
+    /* Кнопки выбора месяцев и годов */
+
+    /* Шапка */
+
+    /* День */
+
+    /* today */
+
+    /* highlighted */
+
+    /* holidays */
+
+    /* range */
+
+    /* selected */
+
+    /* disabled */
+
+    /* marker */
+}
+.component {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 16px;
+    margin: 0 var(--gap-8)
+}
+.component:after {
+        content: '';
+        display: block;
+        width: 100%;
+        height: 1px;
+        background-color: var(--color-light-neutral-translucent-1300);
+    }
+.outer {
+    position: relative;
+
+    /* FormControl .above height + margin-bottom */
+    top: 24px;
+}
+.s {
+    height: var(--size-s-height);
+}
+.m {
+    height: var(--size-m-height);
+}
+.l {
+    height: var(--size-l-height);
+}
+.xl {
+    height: var(--size-xl-height);
+}

package/moderncssm/hooks.d.ts

@@ -0,0 +1,28 @@
+declare function usePopoverViewMonthes({ dateFrom, dateTo, defaultMonth, resetKey, }: {
+    defaultMonth: number;
+    dateFrom: number | null;
+    dateTo: number | null;
+    resetKey?: number;
+}): {
+    monthFrom: number | undefined;
+    monthTo: number | undefined;
+    handleMonthFromChange: (newMonthFrom: number) => void;
+    handleMonthToChange: (newMonthTo: number) => void;
+};
+declare function useStaticViewMonthes({ selectedFrom, selectedTo, defaultMonth, defaultMonthPosition, }: {
+    selectedFrom?: number;
+    selectedTo?: number;
+    defaultMonth: number;
+    defaultMonthPosition?: 'left' | 'right';
+}): {
+    monthFrom: number;
+    monthTo: number;
+    handleMonthFromChange: (newMonthFrom: number) => void;
+    handleMonthToChange: (newMonthTo: number) => void;
+};
+declare function useSelectionProps(from?: number, to?: number, highlighted?: number): {
+    rangeComplete: boolean;
+    selectedFrom: number | undefined;
+    selectedTo: number | undefined;
+};
+export { usePopoverViewMonthes, useStaticViewMonthes, useSelectionProps };

package/moderncssm/hooks.js

@@ -0,0 +1,134 @@
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import addMonths from 'date-fns/addMonths';
+import isEqual from 'date-fns/isEqual';
+import max from 'date-fns/max';
+import min from 'date-fns/min';
+import startOfMonth from 'date-fns/startOfMonth';
+import subMonths from 'date-fns/subMonths';
+
+function usePopoverViewMonthes({ dateFrom, dateTo, defaultMonth, resetKey, }) {
+    const [monthFrom, setMonthFrom] = useState();
+    const [monthTo, setMonthTo] = useState();
+    const handleMonthFromChange = useCallback((newMonthFrom) => {
+        setMonthFrom(newMonthFrom);
+        if (!dateTo) {
+            setMonthTo(newMonthFrom);
+        }
+    }, [dateTo]);
+    const handleMonthToChange = useCallback((newMonthTo) => {
+        setMonthTo(newMonthTo);
+        if (!dateFrom) {
+            setMonthFrom(newMonthTo);
+        }
+    }, [dateFrom]);
+    useEffect(() => {
+        setMonthFrom(dateFrom ? startOfMonth(dateFrom).getTime() : defaultMonth);
+    }, [defaultMonth, dateFrom, resetKey]);
+    useEffect(() => {
+        setMonthTo(dateTo ? startOfMonth(dateTo).getTime() : monthFrom);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [dateTo, resetKey]);
+    return {
+        monthFrom,
+        monthTo,
+        handleMonthFromChange,
+        handleMonthToChange,
+    };
+}
+function useStaticViewMonthes({ selectedFrom, selectedTo, defaultMonth, defaultMonthPosition, }) {
+    /**
+     * Если указана начальная дата — левый месяц равен ей, иначе используется дата конца.
+     * Если обе даты не указаны, то используется дефолтный месяц
+     */
+    let initialMonthFrom = useMemo(() => startOfMonth(selectedFrom || selectedTo || defaultMonth).getTime(), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    /**
+     * Правый месяц должен быть как минимум на 1 месяц больше левого
+     */
+    let initialMonthTo = useMemo(() => max([
+        selectedTo ? startOfMonth(selectedTo) : 0,
+        addMonths(initialMonthFrom, 1),
+    ]).getTime(), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    if (defaultMonthPosition === 'right') {
+        initialMonthTo = initialMonthFrom;
+        initialMonthFrom = subMonths(initialMonthFrom, 1).getTime();
+    }
+    const [monthFrom, setMonthFrom] = useState(initialMonthFrom);
+    const [monthTo, setMonthTo] = useState(initialMonthTo);
+    const handleMonthFromChange = useCallback((newMonthFrom) => {
+        setMonthFrom(newMonthFrom);
+        if (monthTo && isEqual(newMonthFrom, monthTo)) {
+            const nextMonth = addMonths(newMonthFrom, 1).getTime();
+            setMonthTo(nextMonth);
+        }
+    }, [monthTo]);
+    const handleMonthToChange = useCallback((newMonthTo) => {
+        setMonthTo(newMonthTo);
+        if (monthFrom && isEqual(newMonthTo, monthFrom)) {
+            const prevMonth = subMonths(newMonthTo, 1).getTime();
+            setMonthFrom(prevMonth);
+        }
+    }, [monthFrom]);
+    // eslint-disable-next-line complexity
+    useEffect(() => {
+        const selectedFromMonth = selectedFrom ? startOfMonth(selectedFrom).getTime() : undefined;
+        const selectedToMonth = selectedTo ? startOfMonth(selectedTo).getTime() : undefined;
+        // Проверяем, показываются ли выбранные месяцы в левой или правой части компонента
+        const fromMonthOnLeft = selectedFromMonth && selectedFromMonth === monthFrom;
+        const fromMonthOnRight = selectedFromMonth && selectedFromMonth === monthTo;
+        const toMonthOnRight = selectedToMonth && selectedToMonth === monthTo;
+        const toMonthOnLeft = selectedToMonth && selectedToMonth === monthFrom;
+        const fromMonthOnScreen = fromMonthOnLeft || fromMonthOnRight;
+        const toMonthOnScreen = toMonthOnLeft || toMonthOnRight;
+        if (fromMonthOnLeft && toMonthOnLeft) {
+            setMonthTo(max([addMonths(selectedFromMonth, 1), monthTo]).getTime());
+            return;
+        }
+        if (fromMonthOnRight && toMonthOnRight) {
+            setMonthFrom(min([subMonths(selectedToMonth, 1), monthFrom]).getTime());
+            return;
+        }
+        if (selectedFromMonth && selectedToMonth) {
+            setMonthFrom(selectedFromMonth);
+            setMonthTo(max([addMonths(selectedFromMonth, 1), selectedToMonth]).getTime());
+            return;
+        }
+        if (selectedFromMonth && !selectedToMonth && !fromMonthOnScreen) {
+            setMonthFrom(selectedFromMonth);
+            setMonthTo(max([addMonths(selectedFromMonth, 1), monthTo]).getTime());
+        }
+        if (selectedToMonth && !selectedFromMonth && !toMonthOnScreen) {
+            setMonthTo(selectedToMonth);
+            setMonthFrom(min([subMonths(selectedToMonth, 1), monthFrom]).getTime());
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [selectedFrom, selectedTo]);
+    return {
+        monthFrom,
+        monthTo,
+        handleMonthFromChange,
+        handleMonthToChange,
+    };
+}
+function useSelectionProps(from, to, highlighted) {
+    return useMemo(() => {
+        if (from && to) {
+            return {
+                rangeComplete: true,
+                selectedFrom: min([from, to]).getTime(),
+                selectedTo: max([from, to]).getTime(),
+            };
+        }
+        const dates = [from, to, highlighted].filter((date) => date !== undefined);
+        return {
+            rangeComplete: false,
+            selectedFrom: from || dates.length === 2 ? min(dates).getTime() : undefined,
+            selectedTo: to || dates.length === 2 ? max(dates).getTime() : undefined,
+        };
+    }, [from, highlighted, to]);
+}
+
+export { usePopoverViewMonthes, useSelectionProps, useStaticViewMonthes };

package/moderncssm/index.d.ts

@@ -0,0 +1 @@
+export * from "./Component";

package/moderncssm/index.js

@@ -0,0 +1 @@
+export { CalendarRange } from './Component.js';

package/moderncssm/utils.d.ts

@@ -0,0 +1,2 @@
+declare const isDayButton: (node: HTMLElement | null) => string | false | null | undefined;
+export { isDayButton };

package/moderncssm/utils.js

@@ -0,0 +1,3 @@
+const isDayButton = (node) => node && node.tagName === 'BUTTON' && node.dataset.date;
+
+export { isDayButton };

package/moderncssm/views/index.module.css

@@ -0,0 +1,42 @@
+/* */
+:root {
+    --calendar-inner-width: 280px;
+
+    /* Кнопки выбора месяцев и годов */
+
+    /* Шапка */
+
+    /* День */
+
+    /* today */
+
+    /* highlighted */
+
+    /* holidays */
+
+    /* range */
+
+    /* selected */
+
+    /* disabled */
+
+    /* marker */
+}
+.component {
+    display: flex
+}
+.component button[aria-selected='true'] {
+        cursor: pointer;
+    }
+.component *[class*='errorIcon_'] {
+        display: none;
+    }
+.component *[class*='calendarIcon_'] {
+        margin-right: 0;
+    }
+.static .calendar {
+        width: var(--calendar-inner-width)
+    }
+.static .calendar > div:first-child {
+            padding: var(--gap-16) 0 var(--gap-12);
+        }

package/moderncssm/views/popover.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { CalendarRangeProps } from "../Component";
+type CalendarRangePopoverProps = Omit<CalendarRangeProps, 'calendarPosition'>;
+declare const CalendarRangePopover: FC<CalendarRangePopoverProps>;
+export { CalendarRangePopoverProps, CalendarRangePopover };

package/moderncssm/views/popover.js

@@ -0,0 +1,128 @@
+import React, { useState, useCallback, useEffect } from 'react';
+import cn from 'classnames';
+import startOfMonth from 'date-fns/startOfMonth';
+import { CalendarInput } from '@alfalab/core-components-calendar-input/moderncssm';
+import { isValidInputValue, parseDateString } from '@alfalab/core-components-calendar-input/moderncssm/shared';
+import { isCompleteDateInput } from '@alfalab/core-components-date-input/moderncssm';
+import { useDidUpdateEffect } from '@alfalab/hooks';
+import { Divider } from '../components/divider/Component.js';
+import { usePopoverViewMonthes } from '../hooks.js';
+import styles from './index.module.css';
+
+const CalendarRangePopover = ({ className, defaultMonth = startOfMonth(new Date()).getTime(), minDate, maxDate, valueFrom = '', valueTo = '', onDateFromChange = () => null, onDateToChange = () => null, onChange = () => null, onError, inputFromProps = {}, inputToProps = {}, offDays, events, returnInvalidDates = false, dataTestId, }) => {
+    const [inputFromValue, setInputFromValue] = useState(valueFrom);
+    const [inputToValue, setInputToValue] = useState(valueTo);
+    /**
+     * Ключ для сброса календарей
+     * Пользователь открыл календарь, изменил месяц, но ничего не выбрал
+     * — при следующем открытии в календаре будет установлен начальный месяц
+     */
+    const [resetKey, setResetKey] = useState(0);
+    const dateFrom = isValidInputValue(inputFromValue, minDate, maxDate, offDays)
+        ? parseDateString(inputFromValue).getTime()
+        : null;
+    const dateTo = isValidInputValue(inputToValue, dateFrom || minDate, maxDate, offDays)
+        ? parseDateString(inputToValue).getTime()
+        : null;
+    const [inputFromInvalid, setInputFromInvalid] = useState(isCompleteDateInput(inputFromValue) && dateFrom === null);
+    const [inputToInvalid, setInputToInvalid] = useState(isCompleteDateInput(inputToValue) && dateTo === null);
+    const bothInvalid = isCompleteDateInput(inputFromValue) &&
+        isCompleteDateInput(inputToValue) &&
+        parseDateString(inputFromValue).getTime() > parseDateString(inputToValue).getTime();
+    const hasValidateError = inputFromInvalid || inputToInvalid || bothInvalid;
+    const { monthFrom, monthTo, handleMonthFromChange, handleMonthToChange } = usePopoverViewMonthes({
+        dateFrom,
+        dateTo,
+        defaultMonth,
+        resetKey,
+    });
+    const handleValidInputFrom = useCallback(() => {
+        setInputFromInvalid(inputFromValue !== '' && !isValidInputValue(inputFromValue, minDate, maxDate, offDays));
+    }, [inputFromValue, maxDate, minDate, offDays]);
+    const handleValidInputTo = useCallback(() => {
+        setInputToInvalid(inputToValue !== '' &&
+            !isValidInputValue(inputToValue, dateFrom || minDate, maxDate, offDays));
+    }, [dateFrom, inputToValue, maxDate, minDate, offDays]);
+    const handleInputFromChange = (event, payload) => {
+        setInputFromValue(payload.value);
+        inputFromProps.onInputChange?.(event, payload);
+    };
+    const handleInputToChange = (event, payload) => {
+        setInputToValue(payload.value);
+        inputToProps.onInputChange?.(event, payload);
+    };
+    const handleInputFromBlur = useCallback(() => {
+        handleValidInputFrom();
+        setResetKey(+new Date());
+    }, [handleValidInputFrom]);
+    const handleInputToBlur = useCallback(() => {
+        handleValidInputTo();
+        setResetKey(+new Date());
+    }, [handleValidInputTo]);
+    const handleFromChange = useCallback((_, payload) => {
+        setInputFromValue(payload.value);
+    }, []);
+    const handleToChange = useCallback((_, payload) => {
+        setInputToValue(payload.value);
+    }, []);
+    useEffect(() => {
+        setInputFromValue(valueFrom);
+    }, [valueFrom]);
+    useEffect(() => {
+        setInputToValue(valueTo);
+    }, [valueTo]);
+    useDidUpdateEffect(() => {
+        onDateFromChange({ value: inputFromValue, date: dateFrom });
+        onChange({
+            valueFrom: inputFromValue,
+            valueTo: inputToValue,
+            dateFrom,
+            dateTo,
+        });
+        if (!inputFromValue || isCompleteDateInput(inputFromValue)) {
+            handleValidInputFrom();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [inputFromValue]);
+    useDidUpdateEffect(() => {
+        onDateToChange({ value: inputToValue, date: dateTo });
+        // eslint-disable-next-line no-nested-ternary
+        const inputDateTo = returnInvalidDates
+            ? isCompleteDateInput(inputToValue)
+                ? parseDateString(inputToValue).getTime()
+                : null
+            : dateTo;
+        onChange({
+            valueFrom: inputFromValue,
+            valueTo: inputToValue,
+            dateFrom,
+            dateTo: inputDateTo,
+        });
+        if (!inputToValue || isCompleteDateInput(inputToValue)) {
+            handleValidInputTo();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [inputToValue]);
+    useEffect(() => {
+        if (onError) {
+            onError(hasValidateError);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [hasValidateError]);
+    return (React.createElement("div", { className: cn(styles.component, className), "data-test-id": dataTestId },
+        React.createElement(CalendarInput, { ...inputFromProps, useAnchorWidth: false, calendarPosition: 'popover', popoverPosition: 'bottom-start', error: inputFromInvalid || bothInvalid || inputFromProps.error, onChange: handleFromChange, onInputChange: handleInputFromChange, onBlur: handleInputFromBlur, value: inputFromValue, minDate: minDate, maxDate: maxDate, offDays: offDays, events: events, calendarProps: {
+                ...inputFromProps.calendarProps,
+                month: monthFrom,
+                onMonthChange: handleMonthFromChange,
+                selectorView: 'full',
+            } }),
+        React.createElement(Divider, { inputFromProps: inputFromProps, inputToProps: inputToProps }),
+        React.createElement(CalendarInput, { ...inputToProps, useAnchorWidth: false, calendarPosition: 'popover', popoverPosition: 'bottom-end', error: inputToInvalid || bothInvalid || inputToProps.error, onChange: handleToChange, onInputChange: handleInputToChange, onBlur: handleInputToBlur, value: inputToValue, minDate: dateFrom || minDate, maxDate: maxDate, offDays: offDays, events: events, calendarProps: {
+                ...inputToProps.calendarProps,
+                month: monthTo,
+                onMonthChange: handleMonthToChange,
+                selectorView: 'full',
+            } })));
+};
+
+export { CalendarRangePopover };

package/moderncssm/views/static.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { CalendarRangeProps } from "../Component";
+type CalendarRangeStaticProps = Omit<CalendarRangeProps, 'calendarPosition'> & {
+    /**
+     * Отображать начальный месяц слева или справа (влияет только на начальный рендер)
+     */
+    defaultMonthPosition?: 'left' | 'right';
+};
+declare const CalendarRangeStatic: FC<CalendarRangeStaticProps>;
+export { CalendarRangeStaticProps, CalendarRangeStatic };

package/moderncssm/views/static.js

@@ -0,0 +1,176 @@
+import React, { useState, useCallback, useEffect } from 'react';
+import cn from 'classnames';
+import addMonths from 'date-fns/addMonths';
+import endOfMonth from 'date-fns/endOfMonth';
+import isSameMonth from 'date-fns/isSameMonth';
+import max from 'date-fns/max';
+import startOfMonth from 'date-fns/startOfMonth';
+import subMonths from 'date-fns/subMonths';
+import { CalendarDesktop } from '@alfalab/core-components-calendar/moderncssm/desktop';
+import { usePeriodWithReset } from '@alfalab/core-components-calendar/moderncssm/shared';
+import { isValidInputValue, parseDateString, formatDate } from '@alfalab/core-components-calendar-input/moderncssm/shared';
+import { isCompleteDateInput, DateInput } from '@alfalab/core-components-date-input/moderncssm';
+import { Divider } from '../components/divider/Component.js';
+import { useStaticViewMonthes, useSelectionProps } from '../hooks.js';
+import { isDayButton } from '../utils.js';
+import styles from './index.module.css';
+
+/* eslint-disable complexity */
+const CalendarRangeStatic = ({ className, defaultMonth = startOfMonth(new Date()).getTime(), defaultMonthPosition = 'left', minDate, maxDate, valueFrom = '', valueTo = '', onDateFromChange = () => null, onDateToChange = () => null, onChange = () => null, onError, inputFromProps = {}, inputToProps = {}, offDays, events, returnInvalidDates = false, dataTestId, }) => {
+    const [inputFromValue, setInputFromValue] = useState(valueFrom);
+    const [inputToValue, setInputToValue] = useState(valueTo);
+    let dateFrom = isValidInputValue(inputFromValue, minDate, maxDate, offDays)
+        ? parseDateString(inputFromValue).getTime()
+        : null;
+    const dateTo = isValidInputValue(inputToValue, dateFrom || minDate, maxDate, offDays)
+        ? parseDateString(inputToValue).getTime()
+        : null;
+    if (isCompleteDateInput(inputToValue) && !dateTo && !returnInvalidDates) {
+        dateFrom = null;
+    }
+    const bothInvalid = isCompleteDateInput(inputFromValue) &&
+        isCompleteDateInput(inputToValue) &&
+        parseDateString(inputFromValue).getTime() > parseDateString(inputToValue).getTime();
+    const [highlightedDate, setHighlightedDate] = useState(undefined);
+    const period = usePeriodWithReset({
+        initialSelectedFrom: dateFrom ? parseDateString(inputFromValue).getTime() : undefined,
+        initialSelectedTo: dateTo ? parseDateString(inputToValue).getTime() : undefined,
+    });
+    const validateInputFromValue = useCallback((value) => isValidInputValue(value, minDate, dateFrom || maxDate, offDays), [dateFrom, maxDate, minDate, offDays]);
+    const validateInputToValue = useCallback((value) => isValidInputValue(value, dateFrom || minDate, maxDate, offDays), [dateFrom, minDate, maxDate, offDays]);
+    const [inputFromInvalid, setInputFromInvalid] = useState(isCompleteDateInput(inputFromValue) && dateFrom === null);
+    const [inputToInvalid, setInputToInvalid] = useState(isCompleteDateInput(inputToValue) && dateTo === null);
+    const hasValidateError = bothInvalid || inputFromInvalid || inputToInvalid;
+    const { calendarProps: calendarFromProps, onInputChange: onInputChangeFrom, ...dateInputFromProps } = inputFromProps;
+    const { calendarProps: calendarToProps, onInputChange: onInputChangeTo, ...dateInputToProps } = inputToProps;
+    const { monthFrom, monthTo, handleMonthFromChange, handleMonthToChange } = useStaticViewMonthes({
+        selectedFrom: period.selectedFrom,
+        selectedTo: period.selectedTo,
+        defaultMonth,
+        defaultMonthPosition,
+    });
+    const handleValidInputFrom = useCallback(() => {
+        setInputFromInvalid(inputFromValue !== '' && !validateInputFromValue(inputFromValue));
+    }, [inputFromValue, validateInputFromValue]);
+    const handleValidInputTo = useCallback(() => {
+        setInputToInvalid(inputToValue !== '' && !validateInputToValue(inputToValue));
+    }, [inputToValue, validateInputToValue]);
+    const handleInputFromChange = (event, payload) => {
+        setInputFromValue(payload.value);
+        onInputChangeFrom?.(event, payload);
+    };
+    const handleInputToChange = (event, payload) => {
+        setInputToValue(payload.value);
+        onInputChangeTo?.(event, payload);
+    };
+    const handleMouseOver = useCallback((event) => {
+        const target = event.target;
+        const mouseOverDayButton = isDayButton(target) || isDayButton(target.parentElement);
+        let date;
+        if (mouseOverDayButton) {
+            const button = target.tagName === 'BUTTON' ? target : target.parentElement;
+            if (button.dataset.date) {
+                date = +button.dataset.date;
+            }
+        }
+        setHighlightedDate(date);
+    }, []);
+    const handleClearFrom = useCallback(() => {
+        setInputFromValue('');
+    }, []);
+    const handleClearTo = useCallback(() => {
+        setInputToValue('');
+    }, []);
+    useEffect(() => {
+        setInputFromValue(period.selectedFrom ? formatDate(period.selectedFrom) : '');
+    }, [period.selectedFrom]);
+    useEffect(() => {
+        setInputToValue(period.selectedTo ? formatDate(period.selectedTo) : '');
+    }, [period.selectedTo]);
+    useEffect(() => {
+        setInputFromValue(valueFrom);
+    }, [valueFrom]);
+    useEffect(() => {
+        setInputToValue(valueTo);
+    }, [valueTo]);
+    useEffect(() => {
+        if (!inputFromValue || isCompleteDateInput(inputFromValue)) {
+            handleValidInputFrom();
+        }
+        period.setStart(dateFrom || undefined);
+        if (dateTo) {
+            period.setEnd(dateTo);
+        }
+        if (inputFromValue !== valueFrom) {
+            onDateFromChange({
+                value: inputFromValue,
+                date: dateFrom,
+            });
+            onChange({
+                valueFrom: inputFromValue,
+                valueTo: inputToValue,
+                dateFrom,
+                dateTo,
+            });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [inputFromValue]);
+    useEffect(() => {
+        if (!inputToValue || isCompleteDateInput(inputToValue)) {
+            handleValidInputTo();
+        }
+        period.setEnd(dateTo || undefined);
+        if (dateFrom) {
+            period.setStart(dateFrom);
+        }
+        if (inputToValue !== valueTo) {
+            // eslint-disable-next-line no-nested-ternary
+            const inputDateTo = returnInvalidDates
+                ? isCompleteDateInput(inputToValue)
+                    ? parseDateString(inputToValue).getTime()
+                    : null
+                : dateTo;
+            onDateToChange({
+                value: inputToValue,
+                date: inputDateTo,
+            });
+            onChange({
+                valueFrom: inputFromValue,
+                valueTo: inputToValue,
+                dateFrom,
+                dateTo: inputDateTo,
+            });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [inputToValue]);
+    useEffect(() => {
+        if (onError) {
+            onError(hasValidateError);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [hasValidateError]);
+    const rangeProps = useSelectionProps(period.selectedFrom, period.selectedTo, highlightedDate);
+    const CalendarFromComponent = dateInputFromProps.Calendar || CalendarDesktop;
+    const CalendarToComponent = dateInputToProps.Calendar || CalendarDesktop;
+    const minMaxInSameMonth = minDate && maxDate && isSameMonth(minDate, maxDate);
+    return (
+    // eslint-disable-next-line jsx-a11y/mouse-events-have-key-events
+    React.createElement("div", { className: cn(styles.component, styles.static, className), onMouseOver: handleMouseOver, "data-test-id": dataTestId },
+        React.createElement("div", null,
+            React.createElement(DateInput, { ...dateInputFromProps, mobileMode: dateInputFromProps.mobileMode === 'popover'
+                    ? 'input'
+                    : dateInputFromProps.mobileMode, value: inputFromValue, onChange: handleInputFromChange, onClear: handleClearFrom, onBlur: handleValidInputFrom, error: bothInvalid || inputFromInvalid || dateInputFromProps.error, clear: true, block: true }),
+            React.createElement(CalendarFromComponent, { ...calendarFromProps, className: cn(styles.calendar, calendarFromProps?.className), month: monthFrom, selectorView: 'month-only', offDays: offDays, events: events, onChange: period.updatePeriod, onMonthChange: handleMonthFromChange, minDate: minDate, maxDate: minMaxInSameMonth
+                    ? maxDate
+                    : maxDate && max([maxDate, endOfMonth(subMonths(maxDate, 1))]).getTime(), ...rangeProps })),
+        React.createElement(Divider, { inputFromProps: inputFromProps, inputToProps: inputToProps }),
+        React.createElement("div", null,
+            React.createElement(DateInput, { ...dateInputToProps, mobileMode: dateInputToProps.mobileMode === 'popover'
+                    ? 'input'
+                    : dateInputToProps.mobileMode, value: inputToValue, onChange: handleInputToChange, onClear: handleClearTo, onBlur: handleValidInputTo, error: bothInvalid || inputToInvalid || dateInputToProps.error, clear: true, block: true }),
+            React.createElement(CalendarToComponent, { ...calendarToProps, className: cn(styles.calendar, calendarToProps?.className), month: monthTo, selectorView: 'month-only', offDays: offDays, events: events, onChange: period.updatePeriod, onMonthChange: handleMonthToChange, minDate: minMaxInSameMonth
+                    ? minDate
+                    : minDate && startOfMonth(addMonths(minDate, 1)).getTime(), maxDate: maxDate, ...rangeProps }))));
+};
+
+export { CalendarRangeStatic };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@alfalab/core-components-calendar-range",
-    "version": "7.3.28",
+    "version": "7.4.0",
     "description": "Calendar range component",
     "keywords": [],
     "license": "MIT",
@@ -15,14 +15,14 @@
         "react-dom": "^16.9.0 || ^17.0.1 || ^18.0.0"
     },
     "dependencies": {
-        "@alfalab/core-components-calendar": "^7.10.1",
-        "@alfalab/core-components-calendar-input": "^10.2.26",
-        "@alfalab/core-components-date-input": "^4.3.37",
+        "@alfalab/core-components-calendar": "^7.11.0",
+        "@alfalab/core-components-calendar-input": "^10.3.0",
+        "@alfalab/core-components-date-input": "^4.4.0",
         "@alfalab/hooks": "^1.13.0",
         "classnames": "^2.3.1",
         "date-fns": "^2.16.1",
         "tslib": "^2.4.0"
     },
-    "themesVersion": "13.0.2",
-    "varsVersion": "9.11.1"
+    "themesVersion": "13.1.0",
+    "varsVersion": "9.12.0"
 }

package/src/components/divider/index.module.css

@@ -1,4 +1,4 @@
-@import '@alfalab/core-components-themes/src/default.css';
+@import '@alfalab/core-components-vars/src/index.css';
 @import '@alfalab/core-components-calendar/src/vars.css';
 
 .component {

package/src/views/index.module.css

@@ -1,4 +1,4 @@
-@import '@alfalab/core-components-themes/src/default.css';
+@import '@alfalab/core-components-vars/src/index.css';
 @import '@alfalab/core-components-calendar/src/vars.css';
 
 .component {