@mailstep/design-system 0.8.26 → 0.8.27

package/ui/Blocks/Scheduler/components/TimeSlots/hooks/useRangeSelection.js

@@ -0,0 +1,117 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { useCallback, useState } from "react";
+import { convertIndexToISOString } from "../../../utils/convertIndexToISOString";
+var useRangeSelection = function useRangeSelection(param) {
+    var handleSelectTimeSlot = param.handleSelectTimeSlot, date = param.date;
+    var _useState = _sliced_to_array(useState(false), 2), isSelecting = _useState[0], setIsSelecting = _useState[1];
+    var _useState1 = _sliced_to_array(useState([]), 2), selectionRange = _useState1[0], setSelectionRange = _useState1[1];
+    var _useState2 = _sliced_to_array(useState(null), 2), selectedGroup = _useState2[0], setSelectedGroup = _useState2[1];
+    var handleMouseDown = useCallback(function(index, groupId) {
+        return function() {
+            setSelectionRange([
+                index
+            ]);
+            setIsSelecting(true);
+            setSelectedGroup(groupId);
+        };
+    }, []);
+    var handleMouseOver = useCallback(function(index) {
+        return function() {
+            if (!isSelecting) return;
+            setSelectionRange(function(prevRange) {
+                var start = prevRange[0];
+                var end = prevRange.at(-1);
+                if (end && (end < index ? end + 1 !== index : end - 1 !== index)) {
+                    return [
+                        index
+                    ];
+                }
+                return Array.from({
+                    length: Math.abs(index - start) + 1
+                }, function(_, i) {
+                    return start < index ? start + i : start - i;
+                });
+            });
+        };
+    }, [
+        isSelecting
+    ]);
+    var handleMouseUp = useCallback(function() {
+        setIsSelecting(false);
+        if (selectedGroup && (selectionRange === null || selectionRange === void 0 ? void 0 : selectionRange.length)) {
+            var _selectionRange_at;
+            var start = selectionRange[0];
+            var end = ((_selectionRange_at = selectionRange.at(-1)) !== null && _selectionRange_at !== void 0 ? _selectionRange_at : 0) + 1;
+            handleSelectTimeSlot === null || handleSelectTimeSlot === void 0 ? void 0 : handleSelectTimeSlot({
+                groupId: selectedGroup,
+                from: convertIndexToISOString(start, date),
+                to: convertIndexToISOString(end, date)
+            });
+        }
+        setSelectedGroup(null);
+        setSelectionRange([]);
+    }, [
+        date,
+        handleSelectTimeSlot,
+        selectedGroup,
+        selectionRange
+    ]);
+    var isSlotSelected = useCallback(function(index, groupId) {
+        return groupId === selectedGroup && selectionRange.includes(index);
+    }, [
+        selectionRange,
+        selectedGroup
+    ]);
+    return {
+        handleMouseDown: handleMouseDown,
+        handleMouseOver: handleMouseOver,
+        handleMouseUp: handleMouseUp,
+        isSlotSelected: isSlotSelected
+    };
+};
+export { useRangeSelection };

package/ui/Blocks/Scheduler/components/TimeSlots/hooks/useScroll.d.ts

@@ -1,5 +1,4 @@
 import { MutableRefObject } from 'react';
-
 type HookType = () => {
     containerRef: MutableRefObject<HTMLTableSectionElement | null>;
 };

package/ui/Blocks/Scheduler/components/TimeSlots/hooks/useScroll.js

@@ -0,0 +1,20 @@
+import { useEffect, useRef } from "react";
+var useScroll = function useScroll() {
+    var containerRef = useRef(null);
+    useEffect(function() {
+        var _containerRef_current;
+        var now = /* @__PURE__ */ new Date();
+        var hours = String(now.getHours()).padStart(2, "0");
+        var timeElement = containerRef === null || containerRef === void 0 ? void 0 : (_containerRef_current = containerRef.current) === null || _containerRef_current === void 0 ? void 0 : _containerRef_current.querySelector('[data-time="'.concat(hours, ':00"]'));
+        if (timeElement) {
+            timeElement.scrollIntoView({
+                behavior: "smooth",
+                block: "center"
+            });
+        }
+    }, []);
+    return {
+        containerRef: containerRef
+    };
+};
+export { useScroll };

package/ui/Blocks/Scheduler/components/TimeSlots/index.d.ts

@@ -1,6 +1,5 @@
-import { FC } from 'react';
-import { SchedulerProps, TimeSlotType } from '../../types';
-
+import { type FC } from 'react';
+import { type SchedulerProps, type TimeSlotType } from '../../types';
 type TimeSlotsProps = {
     timeArray: string[];
     groups?: SchedulerProps['groups'];

package/ui/Blocks/Scheduler/components/TimeSlots/index.js

@@ -0,0 +1,56 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { isActiveTime } from "../../utils/isActiveTime";
+import { BookedTimeSlots } from "../BookedTimeSlots";
+import { CurrentTimeMarker } from "../CurrentTimeMarker";
+import { useRangeSelection } from "./hooks/useRangeSelection";
+import { useScroll } from "./hooks/useScroll";
+import { EmptyTimeSlot, TimeInterval, TimeRow, TimeSlotsContainer } from "./styles";
+var TimeSlots = function TimeSlots(param) {
+    var timeArray = param.timeArray, groups = param.groups, activeHours = param.activeHours, timeSlots = param.timeSlots, handleSelectTimeSlot = param.handleSelectTimeSlot, handleTimeSlotClick = param.handleTimeSlotClick, isTodayDate = param.isTodayDate, date = param.date, timeSlotDefinitions = param.timeSlotDefinitions;
+    var containerRef = useScroll().containerRef;
+    var _useRangeSelection = useRangeSelection({
+        handleSelectTimeSlot: handleSelectTimeSlot,
+        date: date
+    }), handleMouseUp = _useRangeSelection.handleMouseUp, handleMouseDown = _useRangeSelection.handleMouseDown, handleMouseOver = _useRangeSelection.handleMouseOver, isSlotSelected = _useRangeSelection.isSlotSelected;
+    return /* @__PURE__ */ jsxs(TimeSlotsContainer, {
+        ref: containerRef,
+        children: [
+            timeArray.map(function(time, index) {
+                var activeTime = isActiveTime({
+                    activeHours: activeHours,
+                    time: time
+                });
+                return /* @__PURE__ */ jsxs(TimeRow, {
+                    disabled: !activeTime,
+                    "data-time": time,
+                    children: [
+                        /* @__PURE__ */ jsx(TimeInterval, {
+                            children: time
+                        }),
+                        groups === null || groups === void 0 ? void 0 : groups.map(function(group) {
+                            var _ref;
+                            var bookedTimeSlots = (_ref = timeSlots === null || timeSlots === void 0 ? void 0 : timeSlots["".concat(group.id, "-").concat(time)]) !== null && _ref !== void 0 ? _ref : [];
+                            var canSelectSlot = !bookedTimeSlots.length && activeTime;
+                            return /* @__PURE__ */ jsx(EmptyTimeSlot, {
+                                groupsCount: groups === null || groups === void 0 ? void 0 : groups.length,
+                                activeTime: activeTime,
+                                isSlotSelected: canSelectSlot && isSlotSelected(index, group.id),
+                                onMouseDown: canSelectSlot ? handleMouseDown(index, group.id) : void 0,
+                                onMouseOver: canSelectSlot ? handleMouseOver(index) : void 0,
+                                onMouseUp: canSelectSlot ? handleMouseUp : void 0,
+                                children: /* @__PURE__ */ jsx(BookedTimeSlots, {
+                                    bookedTimeSlots: bookedTimeSlots,
+                                    timeSlotDefinitions: timeSlotDefinitions,
+                                    time: time,
+                                    handleTimeSlotClick: handleTimeSlotClick
+                                })
+                            }, group.id);
+                        })
+                    ]
+                }, time);
+            }),
+            isTodayDate && /* @__PURE__ */ jsx(CurrentTimeMarker, {})
+        ]
+    });
+};
+export { TimeSlots };

package/ui/Blocks/Scheduler/components/TimeSlots/styles.d.ts

@@ -1,10 +1,10 @@
-export declare const TimeSlotsContainer: import('styled-components').StyledComponent<"div", import('@xstyled/system').Theme, {}, never>;
-export declare const TimeRow: import('styled-components').StyledComponent<"div", import('@xstyled/system').Theme, {
+export declare const TimeSlotsContainer: import("styled-components").StyledComponent<"div", import("@xstyled/system").Theme, {}, never>;
+export declare const TimeRow: import("styled-components").StyledComponent<"div", import("@xstyled/system").Theme, {
     disabled: boolean;
 }, never>;
-export declare const EmptyTimeSlot: import('styled-components').StyledComponent<"div", import('@xstyled/system').Theme, {
+export declare const EmptyTimeSlot: import("styled-components").StyledComponent<"div", import("@xstyled/system").Theme, {
     isSlotSelected?: boolean;
     activeTime: boolean;
     groupsCount: number;
 }, never>;
-export declare const TimeInterval: import('styled-components').StyledComponent<"div", import('@xstyled/system').Theme, {}, never>;
+export declare const TimeInterval: import("styled-components").StyledComponent<"div", import("@xstyled/system").Theme, {}, never>;

package/ui/Blocks/Scheduler/components/TimeSlots/styles.js

@@ -0,0 +1,76 @@
+function _tagged_template_literal(strings, raw) {
+    if (!raw) {
+        raw = strings.slice(0);
+    }
+    return Object.freeze(Object.defineProperties(strings, {
+        raw: {
+            value: Object.freeze(raw)
+        }
+    }));
+}
+function _templateObject() {
+    var data = _tagged_template_literal([
+        "\n  position: relative;\n  overflow-y: auto;\n  flex-grow: 1;\n  width: fit-content;\n\n  -ms-overflow-style: none;\n  scrollbar-width: none;\n  scroll-behavior: smooth;\n\n  &::-webkit-scrollbar {\n    display: none;\n  }\n"
+    ]);
+    _templateObject = function _templateObject() {
+        return data;
+    };
+    return data;
+}
+function _templateObject1() {
+    var data = _tagged_template_literal([
+        "\n  background-color: ",
+        ";\n  display: flex;\n  width: fit-content;\n  border-bottom: 1px solid ",
+        ";\n"
+    ]);
+    _templateObject1 = function _templateObject() {
+        return data;
+    };
+    return data;
+}
+function _templateObject2() {
+    var data = _tagged_template_literal([
+        "\n  height: ",
+        "px;\n  flex-shrink: 0;\n  min-width: 350px;\n  box-sizing: border-box;\n  position: relative;\n  background-color: ",
+        ";\n  cursor: ",
+        ";\n  border-right: 1px solid ",
+        ";\n\n  &:last-child {\n    border-right: none;\n  }\n\n  &:hover {\n    background-color: ",
+        ";\n  }\n"
+    ]);
+    _templateObject2 = function _templateObject() {
+        return data;
+    };
+    return data;
+}
+function _templateObject3() {
+    var data = _tagged_template_literal([
+        "\n  font-size: 12px;\n  font-weight: 500;\n  height: ",
+        "px;\n  width: ",
+        "px;\n  border-right: 1px solid ",
+        ";\n  padding: 10px;\n  min-width: ",
+        "px;\n"
+    ]);
+    _templateObject3 = function _templateObject() {
+        return data;
+    };
+    return data;
+}
+import { minuteHeight, stepInMinutes, timeIntervalWidth } from "../../utils/constants";
+import styled, { th } from "@xstyled/styled-components";
+var TimeSlotsContainer = styled.div(_templateObject());
+var TimeRow = styled.div(_templateObject1(), function(param) {
+    var disabled = param.disabled;
+    return disabled ? th.color("lightGray7") : "white";
+}, th.color("lightGray6"));
+var EmptyTimeSlot = styled.div(_templateObject2(), minuteHeight * stepInMinutes, function(param) {
+    var isSlotSelected = param.isSlotSelected;
+    return isSlotSelected ? th.color("blue20") : "";
+}, function(param) {
+    var isSlotSelected = param.isSlotSelected, activeTime = param.activeTime;
+    return isSlotSelected || !activeTime ? "default" : "pointer";
+}, th.color("lightGray6"), function(param) {
+    var isSlotSelected = param.isSlotSelected, activeTime = param.activeTime;
+    return !isSlotSelected && activeTime ? th.color("blue10") : "";
+});
+var TimeInterval = styled.div(_templateObject3(), minuteHeight * stepInMinutes, timeIntervalWidth, th.color("lightGray6"), timeIntervalWidth);
+export { EmptyTimeSlot, TimeInterval, TimeRow, TimeSlotsContainer };

package/ui/Blocks/Scheduler/hooks/useChangeDate.d.ts

@@ -1,6 +1,5 @@
-import { DatePickerType } from '../../../Elements/DatePicker/DatePicker';
-import { SchedulerProps } from '../types';
-
+import { type DatePickerType } from '../../../Elements/DatePicker/DatePicker';
+import type { SchedulerProps } from '../types';
 type Props = {
     closeDatePicker: () => void;
     handleReloadTimeSlots: SchedulerProps['handleReloadTimeSlots'];

package/ui/Blocks/Scheduler/hooks/useChangeDate.js

@@ -0,0 +1,86 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { useCallback, useEffect, useState } from "react";
+import { isToday } from "../utils/isToday";
+var useChangeDate = function useChangeDate(param) {
+    var closeDatePicker = param.closeDatePicker, handleReloadTimeSlots = param.handleReloadTimeSlots;
+    var _useState = _sliced_to_array(useState(/* @__PURE__ */ new Date()), 2), date = _useState[0], setDate = _useState[1];
+    var handlePrevDay = useCallback(function() {
+        var newDate = new Date(date);
+        newDate.setDate(date.getDate() - 1);
+        setDate(newDate);
+    }, [
+        date
+    ]);
+    var handleNextDay = useCallback(function() {
+        var newDate = new Date(date);
+        newDate.setDate(date.getDate() + 1);
+        setDate(newDate);
+    }, [
+        date
+    ]);
+    var handleChangeDate = useCallback(function(dateValue) {
+        var date2 = new Date(dateValue);
+        date2 && setDate(date2);
+        closeDatePicker();
+    }, []);
+    var isTodayDate = isToday(date);
+    useEffect(function() {
+        if (!handleReloadTimeSlots) return;
+        handleReloadTimeSlots(date).catch(console.error);
+    }, [
+        date
+    ]);
+    return {
+        handlePrevDay: handlePrevDay,
+        handleNextDay: handleNextDay,
+        handleChangeDate: handleChangeDate,
+        isTodayDate: isTodayDate,
+        date: date
+    };
+};
+export { useChangeDate };

package/ui/Blocks/Scheduler/index.js

@@ -0,0 +1,2 @@
+import { Scheduler } from "./Scheduler";
+export { Scheduler as default };

package/ui/Blocks/Scheduler/stories/Scheduler.stories.d.ts

@@ -1,5 +1,4 @@
-import { FC } from 'react';
-
+import { type FC } from 'react';
 declare const meta: {
     title: string;
     tags: string[];

package/ui/Blocks/Scheduler/styles.d.ts

@@ -1,2 +1,2 @@
-export declare const Block: import('styled-components').StyledComponent<"div", import('@xstyled/system').Theme, {}, never>;
-export declare const Container: import('styled-components').StyledComponent<"div", import('@xstyled/system').Theme, {}, never>;
+export declare const Block: import("styled-components").StyledComponent<"div", import("@xstyled/system").Theme, {}, never>;
+export declare const Container: import("styled-components").StyledComponent<"div", import("@xstyled/system").Theme, {}, never>;

package/ui/Blocks/Scheduler/styles.js

@@ -0,0 +1,34 @@
+function _tagged_template_literal(strings, raw) {
+    if (!raw) {
+        raw = strings.slice(0);
+    }
+    return Object.freeze(Object.defineProperties(strings, {
+        raw: {
+            value: Object.freeze(raw)
+        }
+    }));
+}
+function _templateObject() {
+    var data = _tagged_template_literal([
+        "\n  background-color: white;\n  color: ",
+        ";\n  overflow-x: auto;\n  text-align: center;\n  display: flex;\n  flex-direction: column;\n  border: 1px solid ",
+        ";\n  user-select: none;\n  width: fit-content;\n  height: 100%;\n}\n"
+    ]);
+    _templateObject = function _templateObject() {
+        return data;
+    };
+    return data;
+}
+function _templateObject1() {
+    var data = _tagged_template_literal([
+        "\n  display: flex;\n  flex-direction: column;\n  overflow-y: hidden;\n  width: 100%;\n"
+    ]);
+    _templateObject1 = function _templateObject() {
+        return data;
+    };
+    return data;
+}
+import styled, { th } from "@xstyled/styled-components";
+var Block = styled.div(_templateObject(), th.color("typoPrimary"), th.color("lightGray6"));
+var Container = styled.div(_templateObject1());
+export { Block, Container };

package/ui/Blocks/Scheduler/types.d.ts

@@ -1,5 +1,4 @@
-import { ReactNode } from 'react';
-
+import type { ReactNode } from 'react';
 export type GroupType = {
     id: string;
     name: string;

package/ui/Blocks/Scheduler/utils/constants.js

@@ -0,0 +1,7 @@
+var groupsHeight = 38;
+var timeIntervalWidth = 53;
+var minuteHeight = 5;
+var stepInMinutes = 15;
+var currentTimeHeight = 22;
+var currentTimeWidth = 35;
+export { currentTimeHeight, currentTimeWidth, groupsHeight, minuteHeight, stepInMinutes, timeIntervalWidth };

package/ui/Blocks/Scheduler/utils/convertDateToTime.js

@@ -0,0 +1,6 @@
+var convertDateToTime = function convertDateToTime(date) {
+    var hours = String(date.getHours()).padStart(2, "0");
+    var minutes = String(date.getMinutes()).padStart(2, "0");
+    return "".concat(hours, ":").concat(minutes);
+};
+export { convertDateToTime };

package/ui/Blocks/Scheduler/utils/convertIndexToISOString.js

@@ -0,0 +1,9 @@
+import { stepInMinutes } from "./constants";
+var convertIndexToISOString = function convertIndexToISOString(index, date) {
+    var totalMinutes = stepInMinutes * index;
+    var hours = Math.floor(totalMinutes / 60);
+    var minutes = totalMinutes % 60;
+    date.setHours(hours, minutes, 0, 0);
+    return date.toISOString();
+};
+export { convertIndexToISOString };

package/ui/Blocks/Scheduler/utils/convertMinutesToDuration.js

@@ -0,0 +1,12 @@
+var convertMinutesToDuration = function convertMinutesToDuration(minutes) {
+    var hours = Math.floor(minutes / 60);
+    var minutesLeft = minutes % 60;
+    if (!hours) {
+        return "".concat(minutesLeft, " min");
+    }
+    if (!minutesLeft) {
+        return "".concat(hours, "h");
+    }
+    return "".concat(hours, "h ").concat(minutesLeft, "m");
+};
+export { convertMinutesToDuration };

package/ui/Blocks/Scheduler/utils/formatDate.js

@@ -0,0 +1,9 @@
+var formatDate = function formatDate(date) {
+    var locale = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "en-GB";
+    return date.toLocaleDateString(locale, {
+        day: "2-digit",
+        month: "long",
+        year: "numeric"
+    });
+};
+export { formatDate };

package/ui/Blocks/Scheduler/utils/generateTimeArray.js

@@ -0,0 +1,17 @@
+import { stepInMinutes } from "./constants";
+var generateTimeArray = function generateTimeArray() {
+    var times = [];
+    var hours = 0;
+    var minutes = 0;
+    while(hours < 24 || hours === 24 && minutes === 0){
+        var time = "".concat(String(hours).padStart(2, "0"), ":").concat(String(minutes).padStart(2, "0"));
+        times.push(time);
+        minutes += stepInMinutes;
+        if (minutes === 60) {
+            minutes = 0;
+            hours += 1;
+        }
+    }
+    return times;
+};
+export { generateTimeArray };

package/ui/Blocks/Scheduler/utils/getClosestStep.js

@@ -0,0 +1,10 @@
+import { stepInMinutes } from "./constants";
+import { getMinutesFromString } from "./getMinutesFromString";
+var getClosestStep = function getClosestStep(date) {
+    var totalMinutes = getMinutesFromString(date);
+    var closestStep = Math.round(totalMinutes / stepInMinutes) * stepInMinutes;
+    var hours = Math.floor(closestStep / 60);
+    var minutes = closestStep % 60;
+    return "".concat(String(hours).padStart(2, "0"), ":").concat(String(minutes).padStart(2, "0"));
+};
+export { getClosestStep };

package/ui/Blocks/Scheduler/utils/getMinutesFromString.js

@@ -0,0 +1,6 @@
+import { convertDateToTime } from "./convertDateToTime";
+import { getMinutesFromTime } from "./getMinutesFromTime";
+var getMinutesFromString = function getMinutesFromString(date) {
+    return getMinutesFromTime(convertDateToTime(new Date(date)));
+};
+export { getMinutesFromString };

package/ui/Blocks/Scheduler/utils/getMinutesFromTime.js

@@ -0,0 +1,51 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var getMinutesFromTime = function getMinutesFromTime(time) {
+    var _time_split_map = _sliced_to_array(time.split(":").map(Number), 2), hours = _time_split_map[0], minutes = _time_split_map[1];
+    return hours * 60 + minutes;
+};
+export { getMinutesFromTime };

package/ui/Blocks/Scheduler/utils/isActiveTime.d.ts

@@ -1,5 +1,4 @@
 import { ActiveHours } from '../types';
-
 type Props = {
     activeHours?: ActiveHours;
     time: string;

package/ui/Blocks/Scheduler/utils/isActiveTime.js

@@ -0,0 +1,10 @@
+import { getMinutesFromTime } from "./getMinutesFromTime";
+var isActiveTime = function isActiveTime(param) {
+    var activeHours = param.activeHours, time = param.time;
+    if (!activeHours) return true;
+    var startMinutes = getMinutesFromTime(activeHours.start);
+    var endMinutes = getMinutesFromTime(activeHours.end);
+    var timeInMinutes = getMinutesFromTime(time);
+    return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
+};
+export { isActiveTime };

package/ui/Blocks/Scheduler/utils/isToday.js

@@ -0,0 +1,5 @@
+var isToday = function isToday(date) {
+    var today = /* @__PURE__ */ new Date();
+    return date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear();
+};
+export { isToday };

package/ui/Blocks/SideMenu/MenuItem.d.ts

@@ -1,6 +1,5 @@
-import { default as React } from 'react';
-import { MenuItemType } from './types';
-
+import React from 'react';
+import { type MenuItemType } from './types';
 type Props = MenuItemType & {
     isSubitem?: boolean;
     isCompact: boolean;