@cwellt_software/cwellt-reactjs-lib 1.3.0 → 1.3.2

package/dist/index.cjs.js

@@ -5,12 +5,10 @@ var React = require('react');
 var client = require('react-dom/client');
 var reactDom = require('react-dom');
 var Draggable = require('react-draggable');
-var moment = require('moment');
 var dateFns = require('date-fns');
 var locale = require('date-fns/locale');
 var reactDayPicker = require('react-day-picker');
 require('react-day-picker/dist/style.css');
-var moment$1 = require('moment-timezone');
 var reactWindow = require('react-window');
 
 function _interopNamespaceDefault(e) {
@@ -251,7 +249,7 @@ const CwMessage = props => {
         }, props.duration ?? CW_DEFAULT_MESSAGE_DURATION);
         return () => clearTimeout(timer);
     }, [props]);
-    return (jsxRuntime.jsxs("div", { className: "cw-message", "data-message-type": Object.keys(exports.CwMessageType).find(key => exports.CwMessageType[key] === props.messageType), onClick: props.onClick, style: props.onClick ? { cursor: "pointer" } : undefined, children: [props.messageType && jsxRuntime.jsx(CwIcon, { iconId: props.messageType.toString(), size: "large" }), props.message] }));
+    return (jsxRuntime.jsxs("div", { className: "cw-message", "data-message-type": Object.keys(exports.CwMessageType).find(key => exports.CwMessageType[key] === props.messageType), children: [props.messageType && jsxRuntime.jsx(CwIcon, { iconId: props.messageType.toString(), size: "large" }), props.message] }));
 };
 /**
  * Hook for displaying inline messages within specific components.
@@ -314,11 +312,11 @@ class CwMessageManager {
         document.body.prepend(this.messageWrapper);
         this.root = client.createRoot(this.messageWrapper); // Create a root at the messageWrapper
     }
-    showMessage(message, type, duration, onClick) {
+    showMessage(message, type, duration) {
         const msg = document.createElement("div");
         this.messageWrapper?.prepend(msg);
         const msgRoot = client.createRoot(msg); // Create a root for the new message
-        msgRoot.render(jsxRuntime.jsx(CwMessage, { message: message, messageType: type, duration: duration, onClick: onClick, onClose: () => this.closeMessage(msgRoot) }));
+        msgRoot.render(jsxRuntime.jsx(CwMessage, { message: message, messageType: type, duration: duration, onClose: () => this.closeMessage(msgRoot) }));
     }
     closeMessage(msgRoot) {
         msgRoot.unmount(); // Unmount the message root
@@ -340,8 +338,8 @@ class CwMessageManager {
  *
  * @note For inline messages within components, use `CwNote` or `useCwMessage` hook instead
  */
-function CwDisplayMessage(message, type, duration, onClick) {
-    CwMessageManager.getInstance().showMessage(message, type, duration, onClick);
+function CwDisplayMessage(message, type, duration) {
+    CwMessageManager.getInstance().showMessage(message, type, duration);
 }
 
 /**
@@ -627,11 +625,7 @@ function CwLoading({ isLoading = false, text = '', size = 'regular', iconPositio
  * <CwLoading size="small" />
  */
 function CwLoadingSmall(CwelltLoadingAppointements) {
-    return (jsxRuntime.jsx("div", { children: CwelltLoadingAppointements.isLoading === true ? (
-        // * Show loading appointment
-        jsxRuntime.jsx("div", { className: "cw-loading-container", children: jsxRuntime.jsx("div", { className: "cw-loading" }) })) : (
-        // Show empty div
-        jsxRuntime.jsx("div", {})) }));
+    return (jsxRuntime.jsx("div", { children: CwelltLoadingAppointements.isLoading === true ? (jsxRuntime.jsx("div", { className: "cw-loading-container", children: jsxRuntime.jsx("div", { className: "cw-loading" }) })) : (jsxRuntime.jsx("div", {})) }));
 }
 
 var styles$p = {"cw-generic-tooltip-content":"cw-generic-tooltip-module__cw-generic-tooltip-content__la-Si","cw-generic-tooltip":"cw-generic-tooltip-module__cw-generic-tooltip__Ij76M"};
@@ -1113,11 +1107,7 @@ function CwModal(custModalProps) {
             width: custModalProps.widthModal
         }
     };
-    return (jsxRuntime.jsx("div", { children: custModalProps.modalState && (jsxRuntime.jsxs("div", { className: custModalProps.classNameModalOverlay + " cwelltModalOverlay", children: [jsxRuntime.jsx("div", { className: "cwelltModalOverlayBg", onClick: custModalProps.onCloseModal }), jsxRuntime.jsx(Draggable, { disabled: isModalDisabled, axis: "both", nodeRef: draggableRef, children: jsxRuntime.jsxs("div", { className: custModalProps.classNameModal + " cwelltContainerModal", ref: draggableRef, style: widthModalDef !== "40em" ? modalStyle.widthCustomStyle : modalStyle.widthDefStyle, children: [jsxRuntime.jsxs("div", { className: "cwelltModalHeader", onMouseOver: cwelltOnMouseOverModal, onMouseOut: cwelltOnMouseOutModal, children: [jsxRuntime.jsx("div", { className: "cwelltModalTitle", children: custModalProps.titleModal }), jsxRuntime.jsx("button", { className: "cwelltBtnCloseModal", onClick: custModalProps.onCloseModal, children: jsxRuntime.jsx("span", { className: "cwelltCloseIcon" }) })] }), jsxRuntime.jsx("div", { className: "cwelltModalBody", children: jsxRuntime.jsx("div", { className: "cwelltContainerModalBody", style: { position: "relative" }, children: custModalProps.children }) }), isHide === false ? (
-                            // [ false : show modal ]
-                            jsxRuntime.jsx("footer", { className: "legacy-modal-footer", onMouseOver: cwelltOnMouseOverModal, onMouseOut: cwelltOnMouseOutModal, children: jsxRuntime.jsx(CwButton, { variant: "icon", icon: "save", title: "Save", onClick: custModalProps.onSaveModal, form: custModalProps.formSaveModal, hidden: custModalProps.HideBtnModal, type: custModalProps.HtmlSubmitModal }) })) : (
-                            // true [ do not show the modal ]
-                            jsxRuntime.jsx("div", { style: { display: "none" } }))] }) })] })) }));
+    return (jsxRuntime.jsx("div", { children: custModalProps.modalState && (jsxRuntime.jsxs("div", { className: custModalProps.classNameModalOverlay + " cwelltModalOverlay", children: [jsxRuntime.jsx("div", { className: "cwelltModalOverlayBg", onClick: custModalProps.onCloseModal }), jsxRuntime.jsx(Draggable, { disabled: isModalDisabled, axis: "both", nodeRef: draggableRef, children: jsxRuntime.jsxs("div", { className: custModalProps.classNameModal + " cwelltContainerModal", ref: draggableRef, style: widthModalDef !== "40em" ? modalStyle.widthCustomStyle : modalStyle.widthDefStyle, children: [jsxRuntime.jsxs("div", { className: "cwelltModalHeader", onMouseOver: cwelltOnMouseOverModal, onMouseOut: cwelltOnMouseOutModal, children: [jsxRuntime.jsx("div", { className: "cwelltModalTitle", children: custModalProps.titleModal }), jsxRuntime.jsx("button", { className: "cwelltBtnCloseModal", onClick: custModalProps.onCloseModal, children: jsxRuntime.jsx("span", { className: "cwelltCloseIcon" }) })] }), jsxRuntime.jsx("div", { className: "cwelltModalBody", children: jsxRuntime.jsx("div", { className: "cwelltContainerModalBody", style: { position: "relative" }, children: custModalProps.children }) }), isHide === false ? (jsxRuntime.jsx("footer", { className: "legacy-modal-footer", onMouseOver: cwelltOnMouseOverModal, onMouseOut: cwelltOnMouseOutModal, children: jsxRuntime.jsx(CwButton, { variant: "icon", icon: "save", title: "Save", onClick: custModalProps.onSaveModal, form: custModalProps.formSaveModal, hidden: custModalProps.HideBtnModal, type: custModalProps.HtmlSubmitModal }) })) : (jsxRuntime.jsx("div", { style: { display: "none" } }))] }) })] })) }));
 }
 
 var styles$n = {"overlayPositioned":"CwConfirmationPopup-module__overlayPositioned__11qYB","popup":"CwConfirmationPopup-module__popup__ahPjM","message":"CwConfirmationPopup-module__message__MnNL4","buttons":"CwConfirmationPopup-module__buttons__fGYYE","button":"CwConfirmationPopup-module__button__ugYQE","confirmButton":"CwConfirmationPopup-module__confirmButton__rTP4S","cancelButton":"CwConfirmationPopup-module__cancelButton__Ry694"};
@@ -1470,12 +1460,10 @@ const CwDialog = props => {
     const footer = React.useMemo(() => (jsxRuntime.jsx("footer", { children: customFooter || (jsxRuntime.jsx(CwButton, { variant: "icon", icon: "save", title: "Save", onClick: onSave, tooltipPosition: "top", disabled: disableSave })) })), [customFooter, onSave, disableSave]);
     const resizeHandles = React.useMemo(() => size.autoHeight
         ? [
-            // Only horizontal handles if autoHeight is true
             jsxRuntime.jsx("div", { "data-handle-e": true, onMouseDown: handleResizeMouseDown("e") }, "handle-e"),
             jsxRuntime.jsx("div", { "data-handle-w": true, onMouseDown: handleResizeMouseDown("w") }, "handle-w")
         ]
         : [
-            // All handles if autoHeight is false
             jsxRuntime.jsx("div", { "data-handle-n": true, onMouseDown: handleResizeMouseDown("n") }, "handle-n"),
             jsxRuntime.jsx("div", { "data-handle-s": true, onMouseDown: handleResizeMouseDown("s") }, "handle-s"),
             jsxRuntime.jsx("div", { "data-handle-e": true, onMouseDown: handleResizeMouseDown("e") }, "handle-e"),
@@ -2995,9 +2983,7 @@ function CwInput(CwInputProps) {
             ? "cw-flex-column"
             : "cw-flex-row ", children: [jsxRuntime.jsx("label", { className: CwInputProps.disabled === true
                     ? CwInputProps.labelClassName + " " + "cw_label_text cw_label_text_disabled"
-                    : CwInputProps.labelClassName + " " + "cw_label_text", children: CwInputProps.labelName }), jsxRuntime.jsx("input", { id: CwInputProps.id, type: "text", value: CwInputProps.value, onChange: e => handleChange(e), className: CwInputProps.className + " " + "cw_input", placeholder: CwInputProps.placeholder === undefined ? "Write a text please" : CwInputProps.placeholder, style: CwInputProps.style, disabled: CwInputProps.disabled, required: CwInputProps.required }), CwInputProps.value && (
-            // if the component is disabled do not show clear button
-            jsxRuntime.jsx("button", { className: "cw_button_clear cwellt_flex cwellt_justify_center cwellt_align_items_center", onClick: handleClearClick }))] }));
+                    : CwInputProps.labelClassName + " " + "cw_label_text", children: CwInputProps.labelName }), jsxRuntime.jsx("input", { id: CwInputProps.id, type: "text", value: CwInputProps.value, onChange: e => handleChange(e), className: CwInputProps.className + " " + "cw_input", placeholder: CwInputProps.placeholder === undefined ? "Write a text please" : CwInputProps.placeholder, style: CwInputProps.style, disabled: CwInputProps.disabled, required: CwInputProps.required }), CwInputProps.value && (jsxRuntime.jsx("button", { className: "cw_button_clear cwellt_flex cwellt_justify_center cwellt_align_items_center", onClick: handleClearClick }))] }));
 }
 
 /**
@@ -3473,6 +3459,114 @@ function CwInputDate(props) {
 
 var classes = {"datePicker":"cw-input-date-picker-module__datePicker__jogOq","input":"cw-input-date-picker-module__input__uQshH","calendar":"cw-input-date-picker-module__calendar__q39ic","calendarHeader":"cw-input-date-picker-module__calendarHeader__1btPK","arrowButton":"cw-input-date-picker-module__arrowButton__23tNc","calendarTitle":"cw-input-date-picker-module__calendarTitle__oOODw","calendarBody":"cw-input-date-picker-module__calendarBody__-711a","calendarDay":"cw-input-date-picker-module__calendarDay__z-Mmv","selected":"cw-input-date-picker-module__selected__XQgR7","todayButton":"cw-input-date-picker-module__todayButton__oYamC","emptyDay":"cw-input-date-picker-module__emptyDay__lbI5B"};
 
+/**
+ * Converts a Date or ISO string to a Temporal.PlainDate.
+ */
+function toPlainDate$1(dateString) {
+    if (dateString instanceof Date) {
+        return Temporal.PlainDate.from({
+            year: dateString.getFullYear(),
+            month: dateString.getMonth() + 1,
+            day: dateString.getDate(),
+        });
+    }
+    // ISO "YYYY-MM-DD" → direct parse
+    return Temporal.PlainDate.from(dateString);
+}
+/**
+ * Formats a date as DD.MM.YYYY (German locale).
+ */
+function toGermanDate(dateString) {
+    const pd = toPlainDate$1(dateString);
+    const day = String(pd.day).padStart(2, "0");
+    const month = String(pd.month).padStart(2, "0");
+    return `${day}.${month}.${pd.year}`;
+}
+/**
+ * Formats a date as YYYY-MM-DD (ISO).
+ */
+function toISODate(dateString) {
+    return toPlainDate$1(dateString).toString();
+}
+/**
+ * Validates whether a string is a valid DD.MM.YYYY date.
+ */
+function isValidGermanDate(textDate) {
+    return parseGermanDate(textDate) !== null;
+}
+/**
+ * Converts a DD.MM.YYYY string to YYYY-MM-DD, or null if invalid.
+ */
+function germanDateToISO(textDate) {
+    const pd = parseGermanDate(textDate);
+    return pd ? pd.toString() : null;
+}
+/**
+ * Converts a DD.MM.YYYY string to a Date object, or null if invalid.
+ */
+function germanDateToDate(textDate) {
+    const pd = parseGermanDate(textDate);
+    if (!pd)
+        return null;
+    return new Date(pd.year, pd.month - 1, pd.day);
+}
+/**
+ * Returns the number of days in the month and the Monday-based
+ * weekday offset (0 = Monday) for the 1st of the month.
+ */
+function computeCalendarGrid(internalDate) {
+    const pd = Temporal.PlainDate.from({
+        year: internalDate.getFullYear(),
+        month: internalDate.getMonth() + 1,
+        day: 1,
+    });
+    const daysInMonth = pd.daysInMonth;
+    const startDay = pd.dayOfWeek - 1; // Temporal: 1=Mon … 7=Sun → 0-based Mon
+    return { daysInMonth, startDay };
+}
+/**
+ * Returns true when the given day in the internalDate's month/year
+ * matches the selected ISO value string.
+ */
+function isSelectedDay(internalDate, day, value) {
+    const pd = Temporal.PlainDate.from({
+        year: internalDate.getFullYear(),
+        month: internalDate.getMonth() + 1,
+        day,
+    });
+    return pd.toString() === value;
+}
+/**
+ * Returns a new Date set to the 1st of the month offset by `direction` months.
+ */
+function computeNextMonthDate(currentDate, direction) {
+    const pd = Temporal.PlainDate.from({
+        year: currentDate.getFullYear(),
+        month: currentDate.getMonth() + 1,
+        day: 1,
+    });
+    const moved = pd.add({ months: direction });
+    return new Date(moved.year, moved.month - 1, moved.day);
+}
+// ── internal helper ────────────────────────────────────────────────────
+/**
+ * Strictly parses a DD.MM.YYYY string into a Temporal.PlainDate, or null.
+ */
+function parseGermanDate(text) {
+    const match = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec(text);
+    if (!match)
+        return null;
+    const day = Number(match[1]);
+    const month = Number(match[2]);
+    const year = Number(match[3]);
+    try {
+        return Temporal.PlainDate.from({ year, month, day }, { overflow: "reject" });
+    }
+    catch {
+        return null;
+    }
+}
+
 const CwInputDatePicker = ({ value, onChange }) => {
     const [isCalendarOpen, setIsCalendarOpen] = React.useState(false);
     const [internalDate, setInternalDate] = React.useState(new Date(value || new Date().toISOString()));
@@ -3496,21 +3590,13 @@ const CwInputDatePicker = ({ value, onChange }) => {
     React.useEffect(() => {
         setTextDate(toGermanDate(value));
     }, [value]);
-    function toGermanDate(dateString) {
-        return moment(dateString).format("DD.MM.YYYY");
-    }
-    function toISODate(dateString) {
-        return moment(dateString).format("YYYY-MM-DD");
-    }
     const submitInput = () => {
-        if (moment(textDate, "DD.MM.YYYY", true).isValid()) {
-            const inputValue = textDate;
-            const momentDate = moment(inputValue, "DD.MM.YYYY", true);
-            if (momentDate.isValid()) {
-                const newDateString = momentDate.format("YYYY-MM-DD");
+        if (isValidGermanDate(textDate)) {
+            const newDateString = germanDateToISO(textDate);
+            const newDate = germanDateToDate(textDate);
+            if (newDateString && newDate) {
                 if (newDateString !== value) {
-                    const newDateString = momentDate.format("YYYY-MM-DD");
-                    setInternalDate(momentDate.toDate());
+                    setInternalDate(newDate);
                     onChange?.(newDateString);
                 }
                 setIsCalendarOpen(false);
@@ -3547,7 +3633,7 @@ const CwInputDatePicker = ({ value, onChange }) => {
         setIsCalendarOpen(false);
     };
     const handleClickMonthArrow = (direction) => {
-        setInternalDate(prevDate => new Date(prevDate.getFullYear(), prevDate.getMonth() + direction, 1));
+        setInternalDate(prevDate => computeNextMonthDate(prevDate, direction));
     };
     const handlePressEnter = (event) => {
         if (event.key === "Enter" && submitInput()) {
@@ -3560,23 +3646,21 @@ const CwInputDatePicker = ({ value, onChange }) => {
         }
     };
     const generateCalendarDays = () => {
-        const daysInMonth = new Date(internalDate.getFullYear(), internalDate.getMonth() + 1, 0).getDate();
-        const startDay = new Date(internalDate.getFullYear(), internalDate.getMonth(), 1).getDay() - 1;
+        const { daysInMonth, startDay } = computeCalendarGrid(internalDate);
         const calendarDays = new Array;
         for (let i = 0; i < startDay; i++) {
             calendarDays.push(jsxRuntime.jsx("div", { className: classes.emptyDay }, `empty-${i}`));
         }
         for (let day = 1; day <= daysInMonth; day++) {
-            const currentDate = new Date(internalDate.getFullYear(), internalDate.getMonth(), day);
-            const isSelected = moment(currentDate).format("YYYY-MM-DD") === value;
-            calendarDays.push(jsxRuntime.jsx("div", { className: `${classes.calendarDay}${isSelected ? ` ${classes.selected}` : ""}`, onClick: () => handleClickDay(day), children: day }, day));
+            const selected = isSelectedDay(internalDate, day, value);
+            calendarDays.push(jsxRuntime.jsx("div", { className: `${classes.calendarDay}${selected ? ` ${classes.selected}` : ""}`, onClick: () => handleClickDay(day), children: day }, day));
         }
         return calendarDays;
     };
     return (jsxRuntime.jsxs("div", { className: classes.datePicker, children: [jsxRuntime.jsx("input", { type: "text", value: textDate, onChange: e => setTextDate(e.currentTarget.value), onFocus: () => {
                     setInternalDate(new Date(value));
                     setIsCalendarOpen(true);
-                }, onBlur: handleBlurInput, onKeyDown: handlePressEnter, "data-valid": moment(textDate, "DD.MM.YYYY", true).isValid(), ref: inputRef, className: classes.input }), isCalendarOpen && (jsxRuntime.jsxs("div", { className: classes.calendar, ref: calendarRef, children: [jsxRuntime.jsxs("div", { className: classes.calendarHeader, children: [jsxRuntime.jsx("button", { className: classes.arrowButton, onClick: () => handleClickMonthArrow(-1), children: "<" }), jsxRuntime.jsxs("span", { className: classes.calendarTitle, children: [internalDate.toLocaleString("default", { month: "long" }), " ", internalDate.getFullYear()] }), jsxRuntime.jsx("button", { className: classes.arrowButton, onClick: () => handleClickMonthArrow(1), children: ">" })] }), jsxRuntime.jsx("div", { className: classes.calendarBody, children: generateCalendarDays() }), jsxRuntime.jsx("button", { className: classes.todayButton, onClick: handleClickToday, children: "Today" })] }))] }));
+                }, onBlur: handleBlurInput, onKeyDown: handlePressEnter, "data-valid": isValidGermanDate(textDate), ref: inputRef, className: classes.input }), isCalendarOpen && (jsxRuntime.jsxs("div", { className: classes.calendar, ref: calendarRef, children: [jsxRuntime.jsxs("div", { className: classes.calendarHeader, children: [jsxRuntime.jsx("button", { className: classes.arrowButton, onClick: () => handleClickMonthArrow(-1), children: "<" }), jsxRuntime.jsxs("span", { className: classes.calendarTitle, children: [internalDate.toLocaleString("default", { month: "long" }), " ", internalDate.getFullYear()] }), jsxRuntime.jsx("button", { className: classes.arrowButton, onClick: () => handleClickMonthArrow(1), children: ">" })] }), jsxRuntime.jsx("div", { className: classes.calendarBody, children: generateCalendarDays() }), jsxRuntime.jsx("button", { className: classes.todayButton, onClick: handleClickToday, children: "Today" })] }))] }));
 };
 
 /**
@@ -3629,6 +3713,47 @@ function CwTime(props) {
     return (jsxRuntime.jsx("div", { className: "cw-input-date", children: jsxRuntime.jsxs(CwAlign, { ...alignProps, itemProp: inputProps.required === true ? "required" : "", children: [labelProps && (jsxRuntime.jsxs(CwLabel, { ...labelProps, children: [iconProps && jsxRuntime.jsx(CwIcon, { ...iconProps }), labelProps.text] })), jsxRuntime.jsx("input", { type: "time", ...inputProps }), buttonProps && jsxRuntime.jsx(CwButton, { ...buttonProps })] }) }));
 }
 
+function parseDateParts(dateStr, format) {
+    const parts = dateStr.split(/[.\-\/]/);
+    if (parts.length !== 3)
+        return null;
+    let year, month, day;
+    switch (format) {
+        case "DD.MM.YYYY":
+        case "DD/MM/YYYY":
+            day = Number(parts[0]);
+            month = Number(parts[1]);
+            year = Number(parts[2]);
+            break;
+        case "MM/DD/YYYY":
+            month = Number(parts[0]);
+            day = Number(parts[1]);
+            year = Number(parts[2]);
+            break;
+        case "YYYY-MM-DD":
+            year = Number(parts[0]);
+            month = Number(parts[1]);
+            day = Number(parts[2]);
+            break;
+    }
+    try {
+        return Temporal.PlainDate.from({ year, month, day });
+    }
+    catch {
+        return null;
+    }
+}
+function formatPlainDate(pd, format) {
+    const dd = pd.day.toString().padStart(2, "0");
+    const mm = pd.month.toString().padStart(2, "0");
+    const yyyy = pd.year.toString().padStart(4, "0");
+    switch (format) {
+        case "DD.MM.YYYY": return `${dd}.${mm}.${yyyy}`;
+        case "DD/MM/YYYY": return `${dd}/${mm}/${yyyy}`;
+        case "MM/DD/YYYY": return `${mm}/${dd}/${yyyy}`;
+        case "YYYY-MM-DD": return `${yyyy}-${mm}-${dd}`;
+    }
+}
 /**
  * Input for entering a string of text as a date
  * @remarks
@@ -3658,11 +3783,8 @@ function CwInputDateText(props) {
     const format = dateFormat ?? displayFormat;
     const width = size ?? 12;
     const formattedDate = (date, inFormat, outFormat) => {
-        if (moment(date, inFormat, true).isValid()) {
-            return moment(date, inFormat).format(outFormat);
-        }
-        else
-            return "";
+        const pd = parseDateParts(date, inFormat);
+        return pd ? formatPlainDate(pd, outFormat) : "";
     };
     const [date, setDate] = React.useState("");
     const [displayedDate, setDisplayedDate] = React.useState("");
@@ -3681,8 +3803,9 @@ function CwInputDateText(props) {
     const onChangeInputText = (e) => {
         const newDate = e.target.value;
         setDisplayedDate(newDate);
-        if (moment(newDate, format, true).isValid()) {
-            setDate(moment(newDate, format).format(internalFormat));
+        const pd = parseDateParts(newDate, format);
+        if (pd) {
+            setDate(formatPlainDate(pd, internalFormat));
         }
         else {
             setDate("");
@@ -3691,8 +3814,9 @@ function CwInputDateText(props) {
     const onChangeInputDate = (e) => {
         const newDate = e.target.value;
         setDate(newDate);
-        if (moment(newDate, internalFormat, true).isValid())
-            setDisplayedDate(moment(newDate, internalFormat).format(format));
+        const pd = parseDateParts(newDate, internalFormat);
+        if (pd)
+            setDisplayedDate(formatPlainDate(pd, format));
         else
             setDisplayedDate("");
     };
@@ -6004,6 +6128,17 @@ function CwTimePicker({ value, onChange, interval = 15, minTime, maxTime, labelP
                                 }) }) }))] })] }) }));
 }
 
+/**
+ * Converts a numeric offset in hours (e.g. 0, 1, -5, 5.5) to a
+ * Temporal-compatible offset string like "+00:00", "+01:00", "-05:00", "+05:30".
+ */
+function offsetHoursToString(offset) {
+    const sign = offset >= 0 ? "+" : "-";
+    const abs = Math.abs(offset);
+    const hours = Math.floor(abs);
+    const minutes = Math.round((abs - hours) * 60);
+    return `${sign}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
 /**
  * Converts a Date to a new Date whose local year/month/day
  * reflect the date in the given UTC offset.
@@ -6017,8 +6152,9 @@ function CwTimePicker({ value, onChange, interval = 15, minTime, maxTime, labelP
  * @returns A new Date with local fields matching the target timezone's date
  */
 function getDateInOffset(date, timezoneOffset) {
-    const m = moment$1(date).utcOffset(timezoneOffset * 60);
-    return new Date(m.year(), m.month(), m.date());
+    const instant = Temporal.Instant.fromEpochMilliseconds(date.getTime());
+    const zdt = instant.toZonedDateTimeISO(offsetHoursToString(timezoneOffset));
+    return new Date(zdt.year, zdt.month - 1, zdt.day);
 }
 /**
  * Gets the time string (HH:mm) for a Date in the given UTC offset.
@@ -6028,7 +6164,25 @@ function getDateInOffset(date, timezoneOffset) {
  * @returns Time string in "HH:mm" format for the given offset
  */
 function getTimeInOffset(date, timezoneOffset) {
-    return moment$1(date).utcOffset(timezoneOffset * 60).format("HH:mm");
+    const instant = Temporal.Instant.fromEpochMilliseconds(date.getTime());
+    const zdt = instant.toZonedDateTimeISO(offsetHoursToString(timezoneOffset));
+    return `${String(zdt.hour).padStart(2, "0")}:${String(zdt.minute).padStart(2, "0")}`;
+}
+/**
+ * Combines a display date (local fields) and time components into a real Date
+ * by interpreting them in the given UTC offset.
+ *
+ * @param date - Date whose local year/month/day are the "display" values
+ * @param hours - Hour component (0-23)
+ * @param minutes - Minute component (0-59)
+ * @param timezoneOffset - Numeric offset in hours
+ * @returns A Date representing the UTC instant of that date+time in the given offset
+ */
+function combineDateTimeInOffset(date, hours, minutes, timezoneOffset) {
+    const offsetStr = offsetHoursToString(timezoneOffset);
+    const pdt = new Temporal.PlainDateTime(date.getFullYear(), date.getMonth() + 1, date.getDate(), hours, minutes);
+    const zdt = pdt.toZonedDateTime(offsetStr);
+    return new Date(zdt.epochMilliseconds);
 }
 
 function CwDateTimePicker({ value, onChange, minDateTime, maxDateTime, disabledDates, disabledMatcher, timeInterval = 15, minTime, maxTime, labelProps, alignProps, datePlaceholder = "dd.MM.yyyy", timePlaceholder = "HH:mm", disabled, required, className, showClear = true, popupPosition = "left-bottom", numberOfMonths = 1, showNowButton = false, timezoneOffset, }) {
@@ -6104,16 +6258,14 @@ function CwDateTimePicker({ value, onChange, minDateTime, maxDateTime, disabledD
         if (!date)
             return undefined;
         const [hours, minutes] = (time ?? "00:00").split(':').map(Number);
-        let m;
+        let combined;
         if (timezoneOffset !== undefined) {
-            // Interpretamos los valores como pertenecientes al offset especificado
-            m = moment$1.utc([date.getFullYear(), date.getMonth(), date.getDate(), hours, minutes]);
-            m.utcOffset(timezoneOffset * 60, true);
+            // Interpret the display date+time as belonging to the specified offset
+            combined = combineDateTimeInOffset(date, hours, minutes, timezoneOffset);
         }
         else {
-            m = moment$1(date).hours(hours).minutes(minutes).seconds(0).milliseconds(0);
+            combined = new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours, minutes, 0, 0);
         }
-        const combined = m.toDate();
         // Validate against min/max datetime
         if (normalizedMinDateTime && combined < normalizedMinDateTime)
             return undefined;
@@ -6134,31 +6286,32 @@ function CwDateTimePicker({ value, onChange, minDateTime, maxDateTime, disabledD
     const calculateTimeRestrictions = React.useCallback((selectedDate) => {
         if (!selectedDate)
             return { minTime, maxTime };
-        // selectedDate is already a "display date" (shifted for timezone),
-        // so we compare using local date fields via moment (no utcOffset needed here)
-        const mSelected = moment$1(selectedDate);
+        const isSameDay = (a, b) => a.getFullYear() === b.getFullYear() &&
+            a.getMonth() === b.getMonth() &&
+            a.getDate() === b.getDate();
+        const formatLocalTime = (d) => `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
         let calculatedMinTime = minTime;
         let calculatedMaxTime = maxTime;
         // If selected date matches minDateTime date, restrict minimum time
         if (normalizedMinDateTime) {
-            const mMin = timezoneOffset !== undefined
-                ? moment$1(getDateInOffset(normalizedMinDateTime, timezoneOffset))
-                : moment$1(normalizedMinDateTime);
-            if (mSelected.isSame(mMin, 'day')) {
+            const minDisplay = timezoneOffset !== undefined
+                ? getDateInOffset(normalizedMinDateTime, timezoneOffset)
+                : normalizedMinDateTime;
+            if (isSameDay(selectedDate, minDisplay)) {
                 calculatedMinTime = timezoneOffset !== undefined
                     ? getTimeInOffset(normalizedMinDateTime, timezoneOffset)
-                    : moment$1(normalizedMinDateTime).format("HH:mm");
+                    : formatLocalTime(normalizedMinDateTime);
             }
         }
         // If selected date matches maxDateTime date, restrict maximum time
         if (normalizedMaxDateTime) {
-            const mMax = timezoneOffset !== undefined
-                ? moment$1(getDateInOffset(normalizedMaxDateTime, timezoneOffset))
-                : moment$1(normalizedMaxDateTime);
-            if (mSelected.isSame(mMax, 'day')) {
+            const maxDisplay = timezoneOffset !== undefined
+                ? getDateInOffset(normalizedMaxDateTime, timezoneOffset)
+                : normalizedMaxDateTime;
+            if (isSameDay(selectedDate, maxDisplay)) {
                 calculatedMaxTime = timezoneOffset !== undefined
                     ? getTimeInOffset(normalizedMaxDateTime, timezoneOffset)
-                    : moment$1(normalizedMaxDateTime).format("HH:mm");
+                    : formatLocalTime(normalizedMaxDateTime);
             }
         }
         return {
@@ -6849,7 +7002,10 @@ const SchedulerContentArea = ({ now, showTimeline, timeLineLeftPx, timeSeparator
             if (reference) {
                 setContentArea(reference);
             }
-        }, children: [showTimeline && (jsxRuntime.jsx(TimeLine$1, { id: scheduler.props.id + "_timeline", marginLeft: timeLineLeftPx, zIndex: 8, toolTipTitle: moment(now).format("HH:mm") })), timeSeparatorLeftPx.map((pixels) => {
+        }, children: [showTimeline && (jsxRuntime.jsx(TimeLine$1, { id: scheduler.props.id + "_timeline", marginLeft: timeLineLeftPx, zIndex: 8, toolTipTitle: Temporal.PlainTime.from({
+                    hour: now.getHours(),
+                    minute: now.getMinutes(),
+                }).toString({ smallestUnit: "minute" }) })), timeSeparatorLeftPx.map((pixels) => {
                 return jsxRuntime.jsx(TimeLine$1, { marginLeft: pixels, color: "rgba(255,255,255,0.7)" });
             }), jsxRuntime.jsx("span", { onClick: () => {
                     if (onEmptyClick) {
@@ -7063,6 +7219,11 @@ const DaysHeader = ({ days, divisionType, maxWidth, headerType }) => {
     return jsxRuntime.jsx("tr", { className: "cwelltSchRowDate", children: headerToDraw });
 };
 
+function formatHHmm(date) {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const zdt = Temporal.Instant.fromEpochMilliseconds(date.getTime()).toZonedDateTimeISO(timeZone);
+    return `${zdt.hour.toString().padStart(2, "0")}:${zdt.minute.toString().padStart(2, "0")}`;
+}
 const getFormattedTimeForHeader = (calculatedDivType, calculatedDivision, timeHeader) => {
     let showDate = "";
     switch (calculatedDivType) {
@@ -7078,18 +7239,18 @@ const getFormattedTimeForHeader = (calculatedDivType, calculatedDivision, timeHe
                             timeHeader.getHours() === 15 ||
                             timeHeader.getHours() === 18 ||
                             timeHeader.getHours() === 21
-                            ? moment(timeHeader).format("HH:mm")
+                            ? formatHHmm(timeHeader)
                             : "";
                     break;
                 case 3:
                     showDate =
                         timeHeader.getHours() === 0 || timeHeader.getHours() === 8 || timeHeader.getHours() === 16
-                            ? moment(timeHeader).format("HH:mm")
+                            ? formatHHmm(timeHeader)
                             : "";
                     break;
                 case 2:
                     showDate =
-                        timeHeader.getHours() === 0 || timeHeader.getHours() === 12 ? moment(timeHeader).format("HH:mm") : "";
+                        timeHeader.getHours() === 0 || timeHeader.getHours() === 12 ? formatHHmm(timeHeader) : "";
                     break;
             }
             break;
@@ -7241,8 +7402,7 @@ const compareStrings = (str1, str2) => {
 const filterResources = (module, resourceName, resources, groupByFunction, endDate, startDate, scheduleName) => {
     if ((module === "CrewControl" || module === "CrewScheduling" || module === "CrewSchedulingVacations") &&
         resourceName === "Employees") {
-        resources = resources.filter(c => (c.data.Eintritt === null || (c.data.Eintritt !== null && moment(c.data.Eintritt).toDate() <= endDate)) &&
-            (c.data.Austritt === null || (c.data.Austritt !== null && moment(c.data.Austritt).toDate() >= startDate)));
+        resources = resources.filter(c => (c.data.Eintritt === null || (new Date(c.data.Eintritt) <= endDate)) && (c.data.Austritt === null || (new Date(c.data.Austritt) >= startDate)));
     }
     if (scheduleName === "crewPinnedScheduler" || (module === "CrewControl" || module === "CrewScheduling") && resourceName === "Employees") {
         const sortKey = (groupByFunction || scheduleName === "crewPinnedScheduler") ? "mainFunction" : "C3_LC";
@@ -7436,8 +7596,8 @@ class CwScheduler extends React.Component {
     arraysEqual = (a1, a2) => a1.length === a2.length && a1.every((o, idx) => this.objectsEqualDeep(o, a2[idx]));
     componentWillReceiveProps(_nextProps) {
         if (this.state.showConsoleLogs) {
-            console.log("Schedule - componentWillReceiveProps, start: ", moment(new Date()).toString());
-            console.log("Schedule - componentWillReceiveProps - has changes, start: ", moment(new Date()).toString());
+            console.log("Schedule - componentWillReceiveProps, start: ", new Date());
+            console.log("Schedule - componentWillReceiveProps - has changes, start: ", new Date());
         }
         const dateChange = _nextProps.startDate.toISOString() !== this.props.startDate.toISOString() ||
             _nextProps.endDate.toISOString() !== this.props.endDate.toISOString();
@@ -7478,8 +7638,8 @@ class CwScheduler extends React.Component {
                 pinnedResources: this.props.pinnedResources ?? [],
             });
             if (this.state.showConsoleLogs) {
-                console.log("Schedule - componentWillReceiveProps - print on schedule, end: ", moment(new Date()).toString());
-                console.log("Schedule - componentWillReceiveProps, end: ", moment(new Date()).toString());
+                console.log("Schedule - componentWillReceiveProps - print on schedule, end: ", new Date());
+                console.log("Schedule - componentWillReceiveProps, end: ", new Date());
             }
             return;
         }
@@ -7572,10 +7732,11 @@ class CwScheduler extends React.Component {
 }
 
 function dateFromPercentage(startDate, visibleDays, percentage) {
-    const endTime = moment(startDate).add(visibleDays, "day").toDate();
-    const timeSpan = endTime.getTime() - startDate.getTime();
-    const clickedDate = new Date(startDate.getTime() + (timeSpan * percentage));
-    return clickedDate;
+    const start = Temporal.Instant.fromEpochMilliseconds(startDate.getTime());
+    const spanMs = Math.round(visibleDays) * 24 * 60 * 60 * 1000;
+    const offsetMs = Math.round(spanMs * percentage);
+    const result = start.add({ milliseconds: offsetMs });
+    return new Date(result.epochMilliseconds);
 }
 
 function getPercentageFromMouseEvent(event) {
@@ -7746,20 +7907,27 @@ const TimeLine = ({ left, top = "0px", height, color, width = "2px", zIndexNumbe
             }, className: styles$3["scheduler-timeline-label"], children: timeString })) }));
 };
 
+function isToday(startDate, endDate) {
+    if (!startDate)
+        return false;
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const today = Temporal.Now.plainDateISO();
+    const start = Temporal.Instant.fromEpochMilliseconds(startDate.getTime())
+        .toZonedDateTimeISO(timeZone).toPlainDate();
+    if (endDate) {
+        const end = Temporal.Instant.fromEpochMilliseconds(endDate.getTime())
+            .toZonedDateTimeISO(timeZone).toPlainDate();
+        return Temporal.PlainDate.compare(today, start) >= 0
+            && Temporal.PlainDate.compare(today, end) <= 0;
+    }
+    return today.equals(start);
+}
+
 const SchedulerHeaderDivision = ({ topDivisions, bottomDivisions, classification, topWidth, startDate, endDate }) => {
-    const isToday = () => {
-        if (!startDate)
-            return false;
-        const today = moment();
-        if (endDate) {
-            return today.isBetween(startDate, endDate, 'day', '[]');
-        }
-        return today.isSame(startDate, 'day');
-    };
     return (jsxRuntime.jsxs("div", { style: {
             width: topWidth,
             cursor: "pointer"
-        }, children: [jsxRuntime.jsx("div", { className: `${styles$3["scheduler-dates"]} ${isToday() ? styles$3["current-day"] : ""}`, children: jsxRuntime.jsx("span", { children: topDivisions }) }), jsxRuntime.jsx("div", { style: { display: "flex", justifyContent: "space-between", flex: 1 }, children: bottomDivisions.map((element) => (jsxRuntime.jsx("div", { className: styles$3["scheduler-hours"], children: jsxRuntime.jsx("span", { children: element }) }, classification + element + topDivisions))) })] }));
+        }, children: [jsxRuntime.jsx("div", { className: `${styles$3["scheduler-dates"]} ${isToday(startDate, endDate) ? styles$3["current-day"] : ""}`, children: jsxRuntime.jsx("span", { children: topDivisions }) }), jsxRuntime.jsx("div", { style: { display: "flex", justifyContent: "space-between", flex: 1 }, children: bottomDivisions.map((element) => (jsxRuntime.jsx("div", { className: styles$3["scheduler-hours"], children: jsxRuntime.jsx("span", { children: element }) }, classification + element + topDivisions))) })] }));
 };
 
 const HeaderTitle = ({ title, dividerText, width }) => {
@@ -7783,12 +7951,23 @@ const SchedulerHeader = ({ content, divisions, visibleDays, selectedDate, width,
                         const thisTopWidth = visibleDays > 15
                             ? topWidth * day.bottom.length
                             : topWidth;
-                        const dateStr = day.startDate ? moment(day.startDate) : moment(day.top, "DD.MM.YYYY");
-                        const startDate = dateStr.toDate();
-                        const endDate = day.endDate ? moment(day.endDate).toDate() : undefined;
-                        return (jsxRuntime.jsx(SchedulerHeaderDivision, { topDivisions: day.top, bottomDivisions: day.bottom, classification: classification, topWidth: thisTopWidth + "%", startDate: startDate, endDate: endDate }, day.top + classification));
+                        const { start, end } = getStartEnd(day);
+                        return (jsxRuntime.jsx(SchedulerHeaderDivision, { topDivisions: day.top, bottomDivisions: day.bottom, classification: classification, topWidth: thisTopWidth + "%", startDate: start, endDate: end }, day.top + classification));
                     }), !(timeLinePercentage < 0 || timeLinePercentage > 100) && (jsxRuntime.jsx(TimeLine, { color: "red", left: `${timeLinePercentage}%`, top: "50%", height: "50%", isHeader: true, isUtc: isUtc }))] })] }));
 };
+function getStartEnd(day) {
+    const startDate = day.startDate
+        ? new Date(day.startDate)
+        : (() => {
+            const [dd, mm, yyyy] = day.top.split(".");
+            return new Date(Number(yyyy), Number(mm) - 1, Number(dd));
+        })();
+    const endDate = day.endDate ? new Date(day.endDate) : undefined;
+    return {
+        start: startDate,
+        end: endDate
+    };
+}
 
 var styles$2 = {"hide-scrollbar":"new-scheduler-module__hide-scrollbar__33GG9","scheduler-event":"new-scheduler-module__scheduler-event__gphwn","scheduler-event-container":"new-scheduler-module__scheduler-event-container__-h1xm","time-marker":"new-scheduler-module__time-marker__2BejU","scheduler-event-text":"new-scheduler-module__scheduler-event-text__zjvd7"};
 
@@ -8110,6 +8289,16 @@ const SchedulerRow = React.memo((props) => {
     return true;
 });
 
+const filterVisibleEvents = (events, selectedDate, visibleDays) => {
+    const schedulerEnd = Temporal.PlainDate.from({
+        year: selectedDate.getFullYear(),
+        month: selectedDate.getMonth() + 1,
+        day: selectedDate.getDate(),
+    }).add({ days: visibleDays });
+    const lastDayOfScheduler = new Date(schedulerEnd.year, schedulerEnd.month - 1, schedulerEnd.day);
+    return events.filter((event) => event.endDate > selectedDate && event.startDate < lastDayOfScheduler);
+};
+
 const DIVISION_RULES = [
     { maxDays: 2, divisions: 24 },
     { maxDays: 3, divisions: 12 },
@@ -8124,17 +8313,52 @@ const calculateDivisionsByDays = (days) => {
 };
 const getHoursFromDivisions = (divisions, useCompactHourFormat = false) => {
     const hoursInterval = 24 / divisions;
-    const hourFormat = useCompactHourFormat ? "HH[h]" : "HH:mm";
     const array = [];
     for (let i = 0; i < divisions; i++) {
-        const newHour = moment(new Date(1, 1, 1))
-            .add(hoursInterval * i, "hours")
-            .format(hourFormat);
-        array.push(newHour);
+        const totalMinutes = Math.round(hoursInterval * i * 60);
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        const hh = hours.toString().padStart(2, "0");
+        const mm = minutes.toString().padStart(2, "0");
+        array.push(useCompactHourFormat ? `${hh}h` : `${hh}:${mm}`);
     }
     return array;
 };
 
+const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+function toPlainDate(date) {
+    return Temporal.Instant.fromEpochMilliseconds(date.getTime())
+        .toZonedDateTimeISO(timeZone).toPlainDate();
+}
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+function formatDD_MM(date) {
+    const pd = toPlainDate(date);
+    return `${pd.day.toString().padStart(2, "0")}.${pd.month.toString().padStart(2, "0")}`;
+}
+function formatDD_MM_YYYY(date) {
+    const pd = toPlainDate(date);
+    return `${pd.day.toString().padStart(2, "0")}.${pd.month.toString().padStart(2, "0")}.${pd.year}`;
+}
+function formatMM_YYYY(date) {
+    const pd = toPlainDate(date);
+    return `${pd.month.toString().padStart(2, "0")}.${pd.year}`;
+}
+function getShortWeekday(date) {
+    return date.toLocaleDateString("en-US", { weekday: "short" });
+}
+function daysBetween(a, b) {
+    const aPlain = toPlainDate(a);
+    const bPlain = toPlainDate(b);
+    return Math.abs(aPlain.until(bPlain).days);
+}
+function daysInMonth(date) {
+    const pd = toPlainDate(date);
+    return pd.daysInMonth;
+}
 const getDefaultDivisions = (visibleDays, selectedDate) => {
     if (visibleDays <= 15) {
         return getDayDivisions(visibleDays, selectedDate);
@@ -8150,16 +8374,16 @@ const getDayDivisions = (visibleDays, selectedDate) => {
     const divisions = getHoursFromDivisions(divisionsNumber, visibleDays < 3);
     const calculatedDivision = [];
     for (let i = 0; i < visibleDays; i++) {
-        const currentDate = moment(selectedDate).add(i, "days");
-        const weekdayShort = currentDate.format("ddd");
+        const currentDate = addDays(selectedDate, i);
+        const weekdayShort = getShortWeekday(currentDate);
         const weekdayLabel = visibleDays < 8
             ? weekdayShort
             : weekdayShort.charAt(0).toUpperCase();
         calculatedDivision.push({
-            top: `${weekdayLabel} ${currentDate.format("DD.MM")}`,
+            top: `${weekdayLabel} ${formatDD_MM(currentDate)}`,
             bottom: divisions,
-            startDate: currentDate.toDate(),
-            endDate: currentDate.toDate()
+            startDate: currentDate,
+            endDate: currentDate
         });
     }
     return calculatedDivision;
@@ -8167,16 +8391,16 @@ const getDayDivisions = (visibleDays, selectedDate) => {
 const getWeekDivisions = (visibleDays, selectedDate) => {
     const weeks = getWeeksByDays(visibleDays, selectedDate);
     const divisions = weeks.map((week) => {
-        const days = Array.from({ length: week.days }, (_, i) => moment(week.start).add(i, "days").date().toString());
-        const weekEnd = moment(week.start).add(week.days - 1, "days");
+        const days = Array.from({ length: week.days }, (_, i) => addDays(week.start, i).getDate().toString());
+        const weekEnd = addDays(week.start, week.days - 1);
         const top = days.length > 2
-            ? moment(week.start).format("DD.MM.YYYY") + " - " + moment(week.start).add(week.days - 1, "days").format("DD.MM.YYYY")
-            : moment(week.start).format("DD.MM.YYYY");
+            ? formatDD_MM_YYYY(week.start) + " - " + formatDD_MM_YYYY(weekEnd)
+            : formatDD_MM_YYYY(week.start);
         const division = {
             top: top,
             bottom: days,
-            startDate: moment(week.start).toDate(),
-            endDate: weekEnd.toDate()
+            startDate: new Date(week.start),
+            endDate: weekEnd
         };
         return division;
     });
@@ -8185,13 +8409,13 @@ const getWeekDivisions = (visibleDays, selectedDate) => {
 const getMonthDivisions = (visibleDays, selectedDate) => {
     const months = getMonthsByDays(visibleDays, selectedDate);
     const divisions = months.map((month) => {
-        const days = Array.from({ length: month.days }, (_, i) => moment(month.start).add(i, "days").date().toString());
-        const monthEnd = moment(month.start).add(month.days - 1, "days");
+        const days = Array.from({ length: month.days }, (_, i) => addDays(month.start, i).getDate().toString());
+        const monthEnd = addDays(month.start, month.days - 1);
         const division = {
-            top: moment(month.start).format("MM.YYYY"),
+            top: formatMM_YYYY(month.start),
             bottom: days,
-            startDate: moment(month.start).toDate(), // Añadir fecha de inicio
-            endDate: monthEnd.toDate()
+            startDate: new Date(month.start),
+            endDate: monthEnd
         };
         return division;
     });
@@ -8202,23 +8426,23 @@ const getMonthsByDays = (visibleDays, selectedDate) => {
         return [];
     }
     const month = [];
-    let temporalDay = moment(selectedDate);
+    let rangeStart = new Date(selectedDate);
     for (let i = 0; i < visibleDays; i++) {
-        const currentDay = moment(selectedDate).add(i, "days");
+        const currentDay = addDays(selectedDate, i);
         const isLastLoop = i + 1 === visibleDays;
         if (isLastLoop) {
             month.push({
-                start: temporalDay.toDate(),
-                days: Math.abs(temporalDay.diff(currentDay, "days")) + 1,
+                start: rangeStart,
+                days: daysBetween(rangeStart, currentDay) + 1,
             });
             break;
         }
-        if (currentDay.date() === currentDay.daysInMonth()) {
+        if (currentDay.getDate() === daysInMonth(currentDay)) {
             month.push({
-                start: temporalDay.toDate(),
-                days: Math.abs(temporalDay.diff(currentDay, "days")) + 1,
+                start: rangeStart,
+                days: daysBetween(rangeStart, currentDay) + 1,
             });
-            temporalDay = currentDay.add(1, "days");
+            rangeStart = addDays(currentDay, 1);
         }
     }
     return month;
@@ -8229,32 +8453,37 @@ const getWeeksByDays = (visibleDays, selectedDate) => {
         return [];
     }
     const weeks = [];
-    let temporalDay = moment(selectedDate);
+    let rangeStart = new Date(selectedDate);
     for (let i = 0; i < visibleDays; i++) {
-        const currentDay = moment(selectedDate).add(i, "days");
+        const currentDay = addDays(selectedDate, i);
         const isLastLoop = i + 1 === visibleDays;
         if (isLastLoop) {
             weeks.push({
-                start: temporalDay.toDate(),
-                days: Math.abs(temporalDay.diff(currentDay, "days")) + 1,
+                start: rangeStart,
+                days: daysBetween(rangeStart, currentDay) + 1,
             });
             break;
         }
-        if (currentDay.day() === SUNDAY) {
+        if (currentDay.getDay() === SUNDAY) {
             weeks.push({
-                start: temporalDay.toDate(),
-                days: Math.abs(temporalDay.diff(currentDay, "days")) + 1,
+                start: rangeStart,
+                days: daysBetween(rangeStart, currentDay) + 1,
             });
-            temporalDay = currentDay.add(1, "days");
+            rangeStart = addDays(currentDay, 1);
         }
     }
     return weeks;
 };
 
 const eventIsVisible = (startDate, endDate, selectedDate, visibleDays) => {
-    const schedulerEnd = moment(selectedDate).add(visibleDays, "days").toDate();
+    const schedulerEnd = Temporal.PlainDate.from({
+        year: selectedDate.getFullYear(),
+        month: selectedDate.getMonth() + 1,
+        day: selectedDate.getDate(),
+    }).add({ days: visibleDays });
+    const schedulerEndDate = new Date(schedulerEnd.year, schedulerEnd.month - 1, schedulerEnd.day);
     const isBefore = selectedDate > startDate && selectedDate > endDate;
-    const isAfter = schedulerEnd < startDate && schedulerEnd < endDate;
+    const isAfter = schedulerEndDate < startDate && schedulerEndDate < endDate;
     return !isBefore && !isAfter;
 };
 
@@ -8355,11 +8584,7 @@ const Scheduler = (props) => {
     const instanceRef = React.useRef(null);
     // const rowHeaderWidth = "180px";
     const { selectedDate, visibleDays, isUtc, isHeaderVisible, visibleRows: stateVisibleRows } = props.state;
-    const events = eventsState.filter((event) => {
-        const lastDayOfScheduler = moment(selectedDate).add(visibleDays, "days");
-        return (moment(event.endDate).isAfter(selectedDate) &&
-            moment(event.startDate).isBefore(lastDayOfScheduler));
-    });
+    const events = filterVisibleEvents(eventsState, selectedDate, visibleDays);
     React.useEffect(() => {
         instanceRef.current?.resetAfterIndex(0);
     }, [orderCategories, props.rows.length, events]);
@@ -9328,6 +9553,7 @@ exports.UiEvent = UiEvent;
 exports.Weekdays = Weekdays;
 exports.cblEvent = cblEvent;
 exports.eventIsVisible = eventIsVisible;
+exports.filterVisibleEvents = filterVisibleEvents;
 exports.getDefaultDivisions = getDefaultDivisions;
 exports.getEventSizes = getEventSizes;
 exports.itemsToMultiFilterTags = itemsToMultiFilterTags;