dhtmlx-scheduler 7.2.0 → 7.2.2

package/codebase/sources/dhtmlxscheduler.es.js

@@ -1,6 +1,6 @@
 /** @license
 
-dhtmlxScheduler v.7.2.0 Standard
+dhtmlxScheduler v.7.2.2 Standard
 
 To use dhtmlxScheduler in non-GPL projects (and get Pro version of the product), please obtain Commercial/Enterprise or Ultimate license on our site https://dhtmlx.com/docs/products/dhtmlxScheduler/#licensing or contact us at sales@dhtmlx.com
 
@@ -78,6 +78,14 @@ function dragHighlightPos(scheduler2) {
     setRequiredStylesToMarker(eventNode2, layout);
     const sections = {};
     let markerObject = { start_date: event3.start_date, end_date: event3.end_date, css: "dhx_scheduler_dnd_marker", html: eventNode2 };
+    if (layout == "timeline") {
+      const viewObj = scheduler2.getView(viewName);
+      if (viewObj.round_position) {
+        const index = scheduler2._get_date_index(viewObj, event3.start_date);
+        const rounded_date = viewObj._trace_x[index];
+        markerObject.start_date = rounded_date;
+      }
+    }
     if (layout == "timeline" || layout == "month") {
       markerObject = { ...markerObject, end_date: scheduler2.date.add(event3.start_date, 1, "minute") };
     }
@@ -9015,7 +9023,7 @@ class DatePicker {
         const dayElement = document.createElement("div");
         dayElement.setAttribute("data-cell-date", scheduler2.templates.format_date(currDate));
         dayElement.setAttribute("data-day", currDate.getDay());
-        dayElement.innerHTML = currDate.getDate();
+        dayElement.innerHTML = scheduler2.templates.month_day(currDate);
         if (currDate.valueOf() < monthStart.valueOf()) {
           dayElement.classList.add("dhx_before");
         } else if (currDate.valueOf() >= monthEnd.valueOf()) {
@@ -9120,7 +9128,7 @@ class DatePicker {
   }
 }
 function factoryMethod(extensionManager) {
-  const scheduler2 = { version: "7.2.0" };
+  const scheduler2 = { version: "7.2.2" };
   scheduler2.$stateProvider = StateService();
   scheduler2.getState = scheduler2.$stateProvider.getState;
   extend$n(scheduler2);
@@ -15396,22 +15404,7 @@ function readonly(scheduler2) {
           scheduler2.form_blocks.recurring.set_value = originalRecurringSetValue;
         }
       }
-      var sns = this.config.lightbox.sections;
       if (this.config.readonly_active) {
-        for (var i = 0; i < sns.length; i++) {
-          if (sns[i].type == "recurring") {
-            if (this.config.readonly_active && scheduler2.form_blocks.recurring) {
-              scheduler2.form_blocks.recurring.set_value = function(node, value, ev) {
-                var wrapper = scheduler2.$domHelpers.closest(node, ".dhx_wrap_section");
-                var style = "none";
-                wrapper.querySelector(".dhx_cal_lsection").display = style;
-                wrapper.querySelector(".dhx_form_repeat").display = style;
-                wrapper.style.display = style;
-                scheduler2.setLightboxSize();
-              };
-            }
-          }
-        }
         var forbidden_buttons = ["dhx_delete_btn", "dhx_save_btn"];
         var button_arrays = [scheduler2.config.buttons_left, scheduler2.config.buttons_right];
         for (var i = 0; i < forbidden_buttons.length; i++) {
@@ -18096,7 +18089,16 @@ function recurring(scheduler2) {
     scheduler2.addEvent(nev);
     scheduler2._not_render = false;
   }
+  function toUTCDate(date) {
+    return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));
+  }
+  function setUTCPartsToDate(d) {
+    return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds());
+  }
   function updateFollowingEventsRRULE(ev) {
+    if (ev.rrule.includes(";UNTIL=")) {
+      ev.rrule = ev.rrule.split(";UNTIL=")[0];
+    }
     let parsedRRule = rrulestr(`RRULE:${ev.rrule};UNTIL=${toIcalString(ev._end_date || ev.end_date)}`, { dtstart: ev.start_date });
     let newRRULE = new RRule(parsedRRule.origOptions).toString().replace("RRULE:", "");
     newRRULE = newRRULE.split("\n")[1];
@@ -18127,6 +18129,20 @@ function recurring(scheduler2) {
     let ev = scheduler2.getEvent(id2);
     return !!(ev && ev._thisAndFollowing);
   };
+  scheduler2._isFirstOccurrence = function(ev) {
+    if (scheduler2._is_virtual_event(ev.id)) {
+      let pid = ev.id.split("#")[0];
+      let recEvent = scheduler2.getEvent(pid);
+      return !!(recEvent.start_date.valueOf() === ev.start_date.valueOf());
+    }
+  };
+  scheduler2._isExceptionFirstOccurrence = function(ev) {
+    if (scheduler2._is_modified_occurrence(ev)) {
+      let pid = ev.recurring_event_id;
+      let recEvent = scheduler2.getEvent(pid);
+      return !!(ev.original_start.valueOf() && ev.original_start.valueOf() === recEvent.start_date.valueOf());
+    }
+  };
   scheduler2._rec_temp = [];
   scheduler2._rec_markers_pull = {};
   scheduler2._rec_markers = {};
@@ -18206,19 +18222,51 @@ function recurring(scheduler2) {
     }
     delete this._ignore_call;
   });
-  function moveToFollowingEvents(copy2, newEv) {
-    copy2.recurring_event_id = newEv.id;
-    copy2.text = newEv.text;
-    scheduler2._not_render = true;
-    scheduler2._add_rec_marker(copy2, copy2._pid_time);
-    scheduler2.addEvent(copy2);
-    scheduler2._not_render = false;
+  function setPropsForFirstOccurrence(ev, occurrence) {
+    ev._end_date = ev.end_date;
+    if (scheduler2._isExceptionFirstOccurrence(occurrence)) {
+      ev.start_date = occurrence.start_date;
+      ev.end_date = new Date(occurrence.start_date.valueOf() + ev.duration * 1e3);
+      ev._start_date = occurrence.original_start;
+      ev._modified = true;
+    } else {
+      ev.end_date = new Date(occurrence.start_date.valueOf() + ev.duration * 1e3);
+      ev.start_date = occurrence.start_date;
+      ev._firstOccurrence = true;
+    }
+    ev._thisAndFollowing = occurrence.id;
+  }
+  function setPropsForStorageEvent(index, data, ev, tempEvent) {
+    const targetIndex = ev._modified ? tempEvent.id : index;
+    scheduler2._events[targetIndex] = { ...tempEvent, text: data.text, duration: data.duration, start_date: data.start_date, rrule: data.rrule, end_date: tempEvent._end_date, _start_date: tempEvent.start_date, _thisAndFollowing: null, _end_date: null };
+    if (ev._modified) {
+      delete scheduler2._events[index];
+    }
+    scheduler2.callEvent("onEventChanged", [scheduler2._events[targetIndex].id, scheduler2._events[targetIndex]]);
+  }
+  function deleteExceptionFromStorage(exception) {
+    for (const i in scheduler2._events) {
+      let tev = scheduler2._events[i];
+      if (tev.id == exception.id) {
+        delete scheduler2._events[i];
+      }
+    }
+  }
+  function updateTextEvents(id2, data) {
+    for (let i in scheduler2._events) {
+      let tev = scheduler2._events[i];
+      if (tev.recurring_event_id == id2 || scheduler2._is_virtual_event(tev.id) && tev.id.split("#")[0] == id2) {
+        tev.text = data.text;
+        scheduler2.updateEvent(tev.id);
+      }
+    }
   }
   function deleteEventFromSeries(idTimestamp, ev) {
     let id2 = idTimestamp;
-    idTimestamp = String(id2).split("#") || ev._pid_time;
+    let originalStartTimestamp = new Date(ev.original_start).valueOf();
+    idTimestamp = String(id2).split("#") || ev._pid_time || originalStartTimestamp;
     let nid = scheduler2.uid();
-    let tid = idTimestamp[1] ? idTimestamp[1] : ev._pid_time;
+    let tid = idTimestamp[1] ? idTimestamp[1] : ev._pid_time || originalStartTimestamp;
     let nev = scheduler2._copy_event(ev);
     nev.id = nid;
     nev.recurring_event_id = ev.recurring_event_id || idTimestamp[0];
@@ -18263,17 +18311,15 @@ function recurring(scheduler2) {
   }
   scheduler2.attachEvent("onBeforeEventChanged", function(ev, e, is_new, original) {
     if (!is_new && ev && (scheduler2._is_virtual_event(ev.id) || scheduler2._is_modified_occurrence(ev))) {
-      if (original && (original.start_date.valueOf() !== ev.start_date.valueOf() || original.end_date.valueOf() !== ev.end_date.valueOf())) {
-        if (original.start_date.getDate() !== ev.start_date.getDate()) {
-          ev._beforeEventChangedFlag = "edit";
-        } else {
-          ev._beforeEventChangedFlag = "ask";
-        }
-        if (!scheduler2.config.collision_limit || scheduler2.checkCollision(ev)) {
-          scheduler2._events["$dnd_recurring_placeholder"] = scheduler2._lame_clone(ev);
-          scheduler2._showRequiredModalBox(ev.id, ev._beforeEventChangedFlag);
-          return false;
-        }
+      if (original.start_date.getDate() !== ev.start_date.getDate()) {
+        ev._beforeEventChangedFlag = "edit";
+      } else {
+        ev._beforeEventChangedFlag = "ask";
+      }
+      if (!scheduler2.config.collision_limit || scheduler2.checkCollision(ev)) {
+        scheduler2._events["$dnd_recurring_placeholder"] = scheduler2._lame_clone(ev);
+        scheduler2._showRequiredModalBox(ev.id, ev._beforeEventChangedFlag);
+        return false;
       }
     }
     return true;
@@ -18281,8 +18327,8 @@ function recurring(scheduler2) {
   scheduler2.attachEvent("onEventChanged", function(id2, event2) {
     if (this._loading)
       return true;
-    var ev = this.getEvent(id2);
-    if (this._is_virtual_event(id2) && !this._isFollowing(id2)) {
+    let ev = this.getEvent(id2);
+    if (this._is_virtual_event(id2)) {
       createException(ev);
     } else {
       if (ev.start_date) {
@@ -18327,30 +18373,32 @@ function recurring(scheduler2) {
     return true;
   });
   scheduler2.attachEvent("onEventSave", function(id2, data, is_new_event) {
-    let tempData = { ...data };
     let ev = this.getEvent(id2);
+    let tempEvent = scheduler2._lame_clone(ev);
+    let tempDataRRULE = data.rrule;
     if (ev && isSeries(ev)) {
       if (!is_new_event && this._isFollowing(id2)) {
         if (ev._removeFollowing) {
-          ev.end_date = new Date(ev.start_date.valueOf() - 1e3);
-          ev._end_date = ev._shorten_end_date;
-          ev.start_date = ev._start_date;
-          if (ev.end_date.valueOf() <= ev.start_date.valueOf()) {
+          let occurrence = scheduler2.getEvent(ev._thisAndFollowing);
+          if (occurrence && (ev._firstOccurrence || ev._modified)) {
             scheduler2.hideLightbox();
             scheduler2.deleteEvent(ev.id);
             return false;
-          }
-          ev._shorten = true;
-          updateFollowingEventsRRULE(ev);
-          scheduler2.updateEvent(ev.id);
-          scheduler2.callEvent("onEventChanged", [ev.id, ev]);
-          let occurrence = scheduler2.getEvent(ev._thisAndFollowing);
-          if (occurrence) {
-            for (const i in scheduler2._events) {
-              let tev = scheduler2._events[i];
-              if (tev.recurring_event_id === id2) {
-                if (tev.start_date.valueOf() > tempData.start_date.valueOf()) {
-                  deleteEventFromSeries(tev.id, tev);
+          } else {
+            ev.end_date = new Date(ev.start_date.valueOf() - 1e3);
+            ev._end_date = ev._shorten_end_date;
+            ev.start_date = ev._start_date;
+            ev._shorten = true;
+            updateFollowingEventsRRULE(ev);
+            scheduler2.callEvent("onEventChanged", [ev.id, ev]);
+            let occurrence2 = scheduler2.getEvent(ev._thisAndFollowing);
+            if (occurrence2) {
+              for (const i in scheduler2._events) {
+                let tev = scheduler2._events[i];
+                if (tev.recurring_event_id === id2) {
+                  if (tev.start_date.valueOf() > tempEvent.start_date.valueOf()) {
+                    deleteEventFromSeries(tev.id, tev);
+                  }
                 }
               }
             }
@@ -18359,61 +18407,54 @@ function recurring(scheduler2) {
           return false;
         } else {
           let occurrence = scheduler2.getEvent(ev._thisAndFollowing);
-          let futureOcurrences = [];
-          for (const i in scheduler2._events) {
-            let tev = scheduler2._events[i];
-            if (tev.recurring_event_id == id2) {
-              if (tev.start_date.valueOf() > tempData.start_date.valueOf()) {
-                futureOcurrences.push(tev);
+          if (occurrence && ev._firstOccurrence) {
+            for (const i in scheduler2._events) {
+              let tev = scheduler2._events[i];
+              if (tev.id == ev.id) {
+                setPropsForStorageEvent(i, data, ev, tempEvent);
               }
             }
-          }
-          ev.end_date = ev._shorten_end_date;
-          ev._end_date = ev._shorten_end_date;
-          ev.start_date = ev._start_date;
-          ev._shorten = true;
-          updateFollowingEventsRRULE(ev);
-          scheduler2.updateEvent(ev.id);
-          scheduler2.callEvent("onEventChanged", [ev.id, ev]);
-          let followingEv = { ...tempData };
-          followingEv._start_date = followingEv.start_date;
-          followingEv._thisAndFollowing = occurrence.id;
-          followingEv.id = scheduler2.uid();
-          scheduler2.addEvent(followingEv.start_date, followingEv.end_date, followingEv.text, followingEv.id, followingEv);
-          for (let i = 0; i < futureOcurrences.length; i++) {
-            const ocr = futureOcurrences[i];
-            moveToFollowingEvents(ocr, followingEv);
-            scheduler2.callEvent("onEventChanged", [ocr.id, ocr]);
-          }
-          if (occurrence && ev._beforeEventChangedFlag) {
-            for (let i in scheduler2._events) {
+          } else if (occurrence && ev._modified) {
+            for (const i in scheduler2._events) {
               let tev = scheduler2._events[i];
-              if (tev.recurring_event_id == id2) {
-                if (tev.start_date.valueOf() >= tempData.start_date.valueOf()) {
-                  deleteEventFromSeries(tev.id, tev);
-                }
+              if (tev.recurring_event_id == id2 && tev.id == tempEvent._thisAndFollowing) {
+                setPropsForStorageEvent(i, data, ev, tempEvent);
               }
             }
+          } else {
+            if (scheduler2._is_modified_occurrence(occurrence)) {
+              deleteExceptionFromStorage(occurrence);
+            }
+            ev.end_date = ev._shorten_end_date;
+            ev._end_date = ev._shorten_end_date;
+            ev.start_date = ev._start_date;
+            ev._shorten = true;
+            updateFollowingEventsRRULE(ev);
+            scheduler2.callEvent("onEventChanged", [ev.id, ev]);
+            let followingEv = { ...tempEvent };
+            followingEv.text = data.text;
+            followingEv.duration = data.duration;
+            followingEv.rrule = tempDataRRULE;
+            followingEv._start_date = null;
+            followingEv.id = scheduler2.uid();
+            scheduler2.addEvent(followingEv.start_date, followingEv.end_date, followingEv.text, followingEv.id, followingEv);
+          }
+          if (!is_new_event) {
+            updateTextEvents(id2, data);
           }
           scheduler2.hideLightbox();
           return false;
         }
       }
-      if (!is_new_event) {
-        for (let i in scheduler2._events) {
-          let tev = scheduler2._events[i];
-          if (tev.recurring_event_id == id2) {
-            tev.text = tempData.text;
-            scheduler2.updateEvent(tev.id);
-          }
-        }
-      }
     }
-    if (tempData._ocr && tempData._beforeEventChangedFlag) {
-      ev.start_date = tempData.start_date;
-      ev.end_date = tempData.end_date;
-      ev._start_date = tempData._start_date;
-      ev._end_date = tempData._end_date;
+    if (!is_new_event) {
+      updateTextEvents(id2, data);
+    }
+    if (tempEvent._ocr && tempEvent._beforeEventChangedFlag) {
+      ev.start_date = tempEvent.start_date;
+      ev.end_date = tempEvent.end_date;
+      ev._start_date = tempEvent._start_date;
+      ev._end_date = tempEvent._end_date;
       scheduler2.updateEvent(ev.id);
       return true;
     }
@@ -18465,6 +18506,10 @@ function recurring(scheduler2) {
       ev._shorten_end_date = null;
     if (ev._removeFollowing)
       ev._removeFollowing = null;
+    if (ev._firstOccurrence)
+      ev._firstOccurrence = null;
+    if (ev._modified)
+      ev._modified = null;
   };
   scheduler2._is_virtual_event = function(id2) {
     return id2.toString().indexOf("#") != -1;
@@ -18485,13 +18530,23 @@ function recurring(scheduler2) {
     const showRequiredLightbox = function(id3, type) {
       const occurrence = scheduler2.getEvent(id3);
       const event2 = scheduler2.getEvent(pid);
+      const view = scheduler2.getView();
+      if (view && occurrence[view.y_property]) {
+        event2[view.y_property] = occurrence[view.y_property];
+      }
+      if (view && occurrence[view.property]) {
+        event2[view.property] = occurrence[view.property];
+      }
       if (type === "Occurrence") {
         return scheduler2.showLightbox_rec(id3);
       }
       if (type === "Following") {
-        if (+occurrence.start_date === +event2.start_date) {
-          event2._end_date = event2.end_date;
-          event2.end_date = new Date(occurrence.start_date.valueOf() + event2.duration * 1e3);
+        if (scheduler2._isExceptionFirstOccurrence(occurrence)) {
+          setPropsForFirstOccurrence(event2, occurrence);
+          return scheduler2.showLightbox_rec(pid);
+        }
+        if (scheduler2._isFirstOccurrence(occurrence)) {
+          setPropsForFirstOccurrence(event2, occurrence);
           return scheduler2.showLightbox_rec(pid);
         } else {
           event2._end_date = event2.end_date;
@@ -18501,9 +18556,6 @@ function recurring(scheduler2) {
           event2._start_date = event2.start_date;
           event2.start_date = occurrence.start_date;
           event2._thisAndFollowing = occurrence.id;
-          if (event2.rrule) {
-            updateFollowingWithWEEKLY(pid);
-          }
           if (ev._beforeEventChangedFlag) {
             event2._beforeEventChangedFlag = ev._beforeEventChangedFlag;
             event2._shorten_end_date = new Date(originalStart.valueOf() - 1e3);
@@ -18512,6 +18564,14 @@ function recurring(scheduler2) {
         }
       }
       if (type === "AllEvents") {
+        if (scheduler2._isExceptionFirstOccurrence(occurrence)) {
+          setPropsForFirstOccurrence(event2, occurrence);
+          return scheduler2.showLightbox_rec(pid);
+        }
+        if (scheduler2._isFirstOccurrence(occurrence)) {
+          setPropsForFirstOccurrence(event2, occurrence);
+          return scheduler2.showLightbox_rec(pid);
+        }
         const tempStart = new Date(event2.start_date);
         event2._end_date = event2.end_date;
         event2._start_date = tempStart;
@@ -18519,6 +18579,7 @@ function recurring(scheduler2) {
         event2.start_date.setMinutes(occurrence.start_date.getMinutes());
         event2.start_date.setSeconds(occurrence.start_date.getSeconds());
         event2.end_date = new Date(event2.start_date.valueOf() + event2.duration * 1e3);
+        event2._thisAndFollowing = null;
         return scheduler2.showLightbox_rec(pid);
       }
     };
@@ -18576,6 +18637,14 @@ function recurring(scheduler2) {
       pid = occurrence.id.split("#")[0];
     }
     let event2 = scheduler2.getEvent(pid);
+    const view = scheduler2.getView();
+    let tempEvent = scheduler2._lame_clone(event2);
+    if (view && occurrence[view.y_property]) {
+      tempEvent[view.y_property] = occurrence[view.y_property];
+    }
+    if (view && occurrence[view.property]) {
+      tempEvent[view.property] = occurrence[view.property];
+    }
     let tempStartDate;
     let tempEndDate;
     if (occurrence && occurrence._beforeEventChangedFlag) {
@@ -18583,34 +18652,53 @@ function recurring(scheduler2) {
       tempEndDate = occurrence.end_date;
     }
     const handleOccurrence = function(occurrence2) {
-      let tempEvent = scheduler2.getEvent("$dnd_recurring_placeholder");
+      let tempEvent2 = { ...event2, ...scheduler2.getEvent("$dnd_recurring_placeholder") };
       if (tempEndDate && tempStartDate) {
-        tempEvent.start_date = tempStartDate;
-        tempEvent.end_date = tempEndDate;
-        tempEvent._beforeEventChangedFlag = occurrence2._beforeEventChangedFlag;
-        tempEvent._ocr = true;
+        tempEvent2.start_date = tempStartDate;
+        tempEvent2.end_date = tempEndDate;
+        tempEvent2._beforeEventChangedFlag = occurrence2._beforeEventChangedFlag;
+        tempEvent2._ocr = true;
       }
-      if (!scheduler2.config.collision_limit || scheduler2.checkCollision(tempEvent)) {
+      if (!scheduler2.config.collision_limit || scheduler2.checkCollision(tempEvent2)) {
         for (const i in scheduler2._events) {
           let tev = scheduler2._events[i];
-          if (tev.id == tempEvent.id) {
-            scheduler2._events[i] = { ...tempEvent };
-            scheduler2.callEvent("onEventSave", [scheduler2._events[i].id, scheduler2._events[i], scheduler2._new_event]);
-            scheduler2.callEvent("onEventChanged", [occurrence2.id, occurrence2]);
+          if (i === "$dnd_recurring_placeholder") {
+            continue;
+          }
+          if (tev.id == tempEvent2.id) {
+            scheduler2._events[i] = { ...tempEvent2 };
+            scheduler2.callEvent("onEventChanged", [scheduler2._events[i].id, scheduler2._events[i]]);
           }
         }
       }
     };
     const handleFollowing = function(occurrence2) {
-      let tempEvent = scheduler2._lame_clone(event2);
+      let initialOccurrence = scheduler2._lame_clone(occurrence2);
       if (tempEndDate && tempStartDate) {
         occurrence2._start_date = occurrence2.start_date;
         occurrence2.start_date = tempStartDate;
         occurrence2.end_date = tempEndDate;
       }
-      if (+occurrence2.start_date === +event2.start_date) {
-        tempEvent._end_date = event2.end_date;
-        tempEvent.end_date = new Date(occurrence2.start_date.valueOf() + event2.duration * 1e3);
+      if (scheduler2._isFirstOccurrence(initialOccurrence) || scheduler2._isExceptionFirstOccurrence(initialOccurrence)) {
+        if (scheduler2._isExceptionFirstOccurrence(initialOccurrence)) {
+          deleteExceptionFromStorage(initialOccurrence);
+        }
+        tempEvent._start_date = event2.start_date;
+        tempEvent.start_date = occurrence2.start_date;
+        tempEvent.duration = (+occurrence2.end_date - +occurrence2.start_date) / 1e3;
+        tempEvent._beforeEventChangedFlag = occurrence2._beforeEventChangedFlag;
+        if (tempEvent.rrule) {
+          updateFollowingWithWEEKLY(tempEvent.id, tempEvent);
+        }
+        if (!scheduler2.config.collision_limit || scheduler2.checkCollision(tempEvent)) {
+          for (const i in scheduler2._events) {
+            let tev = scheduler2._events[i];
+            if (tev.id == tempEvent.id) {
+              scheduler2._events[i] = { ...tempEvent };
+              scheduler2.callEvent("onEventChanged", [scheduler2._events[i].id, scheduler2._events[i]]);
+            }
+          }
+        }
       } else {
         tempEvent._end_date = event2.end_date;
         const originalStart = occurrence2.original_start || scheduler2.date.date_part(new Date(occurrence2._start_date));
@@ -18622,29 +18710,34 @@ function recurring(scheduler2) {
         if (tempEvent.rrule) {
           updateFollowingWithWEEKLY(tempEvent.id, tempEvent);
         }
-      }
-      let tempEnd = tempEvent.end_date;
-      tempEvent.end_date = tempEvent._end_date;
-      if (!scheduler2.config.collision_limit || scheduler2.checkCollision(tempEvent)) {
-        tempEvent.end_date = tempEnd;
-        for (const i in scheduler2._events) {
-          let tev = scheduler2._events[i];
-          if (tev.id == tempEvent.id) {
-            scheduler2._events[i] = { ...tempEvent };
-            scheduler2.callEvent("onEventSave", [scheduler2._events[i].id, scheduler2._events[i], scheduler2._new_event]);
-            scheduler2.callEvent("onEventChanged", [scheduler2._events[i].id, scheduler2._events[i]]);
+        let tempEnd = tempEvent.end_date;
+        tempEvent.end_date = tempEvent._end_date;
+        if (!scheduler2.config.collision_limit || scheduler2.checkCollision(tempEvent)) {
+          tempEvent.end_date = tempEnd;
+          for (const i in scheduler2._events) {
+            let tev = scheduler2._events[i];
+            if (tev.id == tempEvent.id) {
+              scheduler2._events[i] = { ...tempEvent };
+              scheduler2.callEvent("onEventSave", [scheduler2._events[i].id, scheduler2._events[i], scheduler2._new_event]);
+              scheduler2.callEvent("onEventChanged", [scheduler2._events[i].id, scheduler2._events[i]]);
+            }
           }
         }
       }
     };
     const handleAllEvents = function(occurrence2) {
-      let tempEvent = scheduler2._lame_clone(event2);
+      let initialOccurrence = scheduler2._lame_clone(occurrence2);
+      if (scheduler2._isExceptionFirstOccurrence(initialOccurrence)) {
+        deleteExceptionFromStorage(initialOccurrence);
+      }
       if (tempEndDate && tempStartDate) {
         tempEvent.start_date.setHours(tempStartDate.getHours());
         tempEvent.start_date.setMinutes(tempStartDate.getMinutes());
         tempEvent.start_date.setSeconds(tempStartDate.getSeconds());
+        tempEvent.duration = (+tempEndDate - +tempStartDate) / 1e3;
       }
       tempEvent._beforeEventChangedFlag = occurrence2._beforeEventChangedFlag;
+      tempEvent._thisAndFollowing = null;
       if (!scheduler2.config.collision_limit || scheduler2.checkCollision(tempEvent)) {
         for (const i in scheduler2._events) {
           let tev = scheduler2._events[i];
@@ -18739,22 +18832,17 @@ function recurring(scheduler2) {
     if (!seriesExceptions) {
       seriesExceptions = {};
     }
-    if (!from) {
-      from = scheduler2._min_date;
-    }
-    if (!to) {
-      to = scheduler2._max_date;
-    }
-    const utcStart = new Date(Date.UTC(ev.start_date.getFullYear(), ev.start_date.getMonth(), ev.start_date.getDate(), ev.start_date.getHours(), ev.start_date.getMinutes(), ev.start_date.getSeconds()));
+    from = toUTCDate(from || new Date(scheduler2._min_date.valueOf() - 7 * 24 * 60 * 60 * 1e3));
+    to = toUTCDate(to || new Date(scheduler2._max_date.valueOf() - 1e3));
+    const utcStart = toUTCDate(ev.start_date);
     let parsedRRule;
     if (maxCount) {
       parsedRRule = rrulestr(`RRULE:${ev.rrule};UNTIL=${toIcalString(ev.end_date)};COUNT=${maxCount}`, { dtstart: utcStart });
     } else {
       parsedRRule = rrulestr(`RRULE:${ev.rrule};UNTIL=${toIcalString(ev.end_date)}`, { dtstart: utcStart });
     }
-    const utcTo = new Date(Date.UTC(to.getFullYear(), to.getMonth(), to.getDate(), to.getHours(), to.getMinutes(), to.getSeconds()));
-    const repeatedDates = parsedRRule.between(from, utcTo).map((date) => {
-      const adjustedDate = new Date(date);
+    const repeatedDates = parsedRRule.between(from, to, true).map((date) => {
+      const adjustedDate = setUTCPartsToDate(date);
       adjustedDate.setHours(ev.start_date.getHours());
       adjustedDate.setMinutes(ev.start_date.getMinutes());
       adjustedDate.setSeconds(ev.start_date.getSeconds());
@@ -18769,7 +18857,7 @@ function recurring(scheduler2) {
       const date = repeatedDates[i];
       let exception = seriesExceptions[date.valueOf()];
       if (exception) {
-        if (exception.deleted) {
+        if (exception.deleted || exception.end_date.valueOf() < scheduler2._min_date.valueOf()) {
           continue;
         } else {
           visibleCount++;
@@ -18781,6 +18869,9 @@ function recurring(scheduler2) {
         copy2.start_date = date;
         copy2.id = ev.id + "#" + Math.ceil(date.valueOf());
         copy2.end_date = new Date(date.valueOf() + eventDuration * 1e3);
+        if (copy2.end_date.valueOf() < scheduler2._min_date.valueOf()) {
+          continue;
+        }
         copy2.end_date = scheduler2._fix_daylight_saving_date(copy2.start_date, copy2.end_date, ev, date, copy2.end_date);
         copy2._timed = scheduler2.isOneDayEvent(copy2);
         if (!copy2._timed && !scheduler2._table_view && !scheduler2.config.multi_day)
@@ -18797,7 +18888,7 @@ function recurring(scheduler2) {
       for (let a in seriesExceptions) {
         let exception = seriesExceptions[a];
         if (exception) {
-          if (exception.deleted) {
+          if (exception.deleted || exception.end_date.valueOf() < scheduler2._min_date.valueOf()) {
             continue;
           } else if (from && to && exception.start_date < to && exception.end_date > from) {
             stack.push(exception);
@@ -20935,69 +21026,6 @@ function year_view(scheduler2) {
       scheduler2._hideToolTip();
     }
   };
-  scheduler2._reset_year_scale = function() {
-    this._cols = [];
-    this._colsS = {};
-    var week_starts = [];
-    var dataArea = this._els["dhx_cal_data"][0];
-    var c = this.config;
-    dataArea.scrollTop = 0;
-    dataArea.innerHTML = "";
-    Math.floor((parseInt(dataArea.style.height) - scheduler2.xy.year_top) / c.year_y);
-    var week_template = document.createElement("div");
-    var dummy_date = this.date.week_start(scheduler2._currentDate());
-    this._process_ignores(dummy_date, 7, "day", 1);
-    for (var i = 0; i < 7; i++) {
-      if (!(this._ignores && this._ignores[i])) {
-        this._cols[i] = "var(--dhx-scheduler-datepicker-cell-size)";
-        this._render_x_header(i, 0, dummy_date, week_template);
-      }
-      dummy_date = this.date.add(dummy_date, 1, "day");
-    }
-    week_template.lastChild.className += " dhx_scale_bar_last";
-    for (var i = 0; i < week_template.childNodes.length; i++) {
-      this._waiAria.yearHeadCell(week_template.childNodes[i]);
-    }
-    var sd = this.date[this._mode + "_start"](this.date.copy(this._date));
-    var ssd = sd;
-    var yearBox = null;
-    const wrapper = document.createElement("div");
-    wrapper.classList.add("dhx_year_wrapper");
-    for (var i = 0; i < c.year_y; i++) {
-      for (var j = 0; j < c.year_x; j++) {
-        yearBox = document.createElement("div");
-        yearBox.className = "dhx_year_box";
-        yearBox.setAttribute("date", this._helpers.formatDate(sd));
-        yearBox.setAttribute("data-month-date", this._helpers.formatDate(sd));
-        yearBox.innerHTML = "<div class='dhx_year_month'></div><div class='dhx_year_grid'><div class='dhx_year_week'>" + week_template.innerHTML + "</div><div class='dhx_year_body'></div></div>";
-        var header = yearBox.querySelector(".dhx_year_month");
-        var grid = yearBox.querySelector(".dhx_year_grid");
-        var body = yearBox.querySelector(".dhx_year_body");
-        var headerId = scheduler2.uid();
-        this._waiAria.yearHeader(header, headerId);
-        this._waiAria.yearGrid(grid, headerId);
-        header.innerHTML = this.templates.year_month(sd);
-        var dd = this.date.week_start(sd);
-        this._reset_month_scale(body, sd, dd, 6);
-        var days = body.querySelectorAll("td");
-        for (var day = 0; day < days.length; day++) {
-          this._waiAria.yearDayCell(days[day]);
-        }
-        wrapper.appendChild(yearBox);
-        week_starts[i * c.year_x + j] = (sd.getDay() - (this.config.start_on_monday ? 1 : 0) + 7) % 7;
-        sd = this.date.add(sd, 1, "month");
-      }
-    }
-    dataArea.appendChild(wrapper);
-    var dateElement = this._getNavDateElement();
-    if (dateElement) {
-      dateElement.innerHTML = this.templates[this._mode + "_date"](ssd, sd, this._mode);
-    }
-    this.week_starts = week_starts;
-    week_starts._month = ssd.getMonth();
-    this._min_date = ssd;
-    this._max_date = sd;
-  };
   scheduler2._reset_year_scale = function() {
     var dataArea = this._els["dhx_cal_data"][0];
     dataArea.scrollTop = 0;