✨ Adds option to decide whether to include the edge while merging the…

… overlapping events or not.

- Fixes issue #290

lib/src/calendar_event_data.dart

@@ -70,7 +70,7 @@ class CalendarEventData<T extends Object?> {
       };
 
   @override
-  String toString() => toJson().toString();
+  String toString() => '${toJson()}';
 
   @override
   bool operator ==(Object other) {

lib/src/event_arrangers/event_arrangers.dart

@@ -13,6 +13,12 @@ import '../extensions.dart';
 part 'merge_event_arranger.dart';
 part 'side_event_arranger.dart';
 
+/// {@template event_arranger_arrange_method_doc}
+/// This method will arrange all the events in and return List of
+/// [OrganizedCalendarEventData].
+///
+/// {@endtemplate}
+
 abstract class EventArranger<T extends Object?> {
   /// [EventArranger] defines how simultaneous events will be arranged.
   /// Implement [arrange] method to define how events will be arranged.
@@ -23,9 +29,7 @@ abstract class EventArranger<T extends Object?> {
   ///
   const EventArranger();
 
-  /// This method will arrange all the events in and return List of
-  /// [OrganizedCalendarEventData].
-  ///
+  /// {@macro event_arranger_arrange_method_doc}
   List<OrganizedCalendarEventData<T>> arrange({
     required List<CalendarEventData<T>> events,
     required double height,

lib/src/event_arrangers/merge_event_arranger.dart

@@ -9,18 +9,36 @@ class MergeEventArranger<T extends Object?> extends EventArranger<T> {
   /// events. and that will act like one single event.
   /// [OrganizedCalendarEventData.events] will gives
   /// list of all the combined events.
-  const MergeEventArranger();
-
+  const MergeEventArranger({
+    this.includeEdges = true,
+  });
+
+  /// Decides whether events that are overlapping on edge
+  /// (ex, event1 has the same end-time as the start-time of event 2)
+  /// should be merged together or not.
+  ///
+  /// If includeEdges is true, it will merge the events else it will not.
+  ///
+  final bool includeEdges;
+
+  /// {@macro event_arranger_arrange_method_doc}
+  ///
+  /// Make sure that all the events that are passed in [events], must be in
+  /// ascending order of start time.
   @override
   List<OrganizedCalendarEventData<T>> arrange({
     required List<CalendarEventData<T>> events,
     required double height,
     required double width,
     required double heightPerMinute,
   }) {
+    // TODO: Right now all the events that are passed in this function must be
+    // sorted in ascending order of the start time.
+    //
     final arrangedEvents = <OrganizedCalendarEventData<T>>[];
 
     for (final event in events) {
+      // Checks if an event has valid start and end time.
       if (event.startTime == null ||
           event.endTime == null ||
           event.endTime!.getTotalMinutes <= event.startTime!.getTotalMinutes) {
@@ -56,6 +74,7 @@ class MergeEventArranger<T extends Object?> extends EventArranger<T> {
       for (var i = 0; i < arrangeEventLen; i++) {
         final arrangedEventStart =
             arrangedEvents[i].startDuration.getTotalMinutes;
+
         final arrangedEventEnd =
             arrangedEvents[i].endDuration.getTotalMinutes == 0
                 ? Constants.minutesADay
@@ -122,17 +141,17 @@ class MergeEventArranger<T extends Object?> extends EventArranger<T> {
     return arrangedEvents;
   }
 
-  bool _checkIsOverlapping(int arrangedEventStart, int arrangedEventEnd,
-      int eventStart, int eventEnd) {
-    var result = (arrangedEventStart >= eventStart &&
-            arrangedEventStart <= eventEnd) ||
-        (arrangedEventEnd >= eventStart && arrangedEventEnd <= eventEnd) ||
-        (eventStart >= arrangedEventStart && eventStart <= arrangedEventEnd) ||
-        (eventEnd >= arrangedEventStart && eventEnd <= arrangedEventEnd);
+  bool _checkIsOverlapping(int eStart1, int eEnd1, int eStart2, int eEnd2) {
+    final result = (eStart1 >= eStart2 && eStart1 < eEnd2) ||
+        (eEnd1 > eStart2 && eEnd1 <= eEnd2) ||
+        (eStart2 >= eStart1 && eStart2 < eEnd1) ||
+        (eEnd2 > eStart1 && eEnd2 <= eEnd1) ||
+        (includeEdges &&
+            (eStart1 == eEnd2 ||
+                eEnd1 == eStart2 ||
+                eStart2 == eEnd1 ||
+                eEnd2 == eStart1));
 
-    if (result) {
-      result = result && (arrangedEventEnd != eventStart);
-    }
     return result;
   }
 }

lib/src/event_arrangers/side_event_arranger.dart

@@ -7,16 +7,32 @@ part of 'event_arrangers.dart';
 class SideEventArranger<T extends Object?> extends EventArranger<T> {
   /// This class will provide method that will arrange
   /// all the events side by side.
-  const SideEventArranger();
+  const SideEventArranger({
+    this.includeEdges = false,
+  });
 
+  /// Decides whether events that are overlapping on edge
+  /// (ex, event1 has the same end-time as the start-time of event 2)
+  /// should be offset or not.
+  ///
+  /// If includeEdges is true, it will offset the events else it will not.
+  ///
+  final bool includeEdges;
+
+  /// {@macro event_arranger_arrange_method_doc}
+  ///
+  /// Make sure that all the events that are passed in [events], must be in
+  /// ascending order of start time.
   @override
   List<OrganizedCalendarEventData<T>> arrange({
     required List<CalendarEventData<T>> events,
     required double height,
     required double width,
     required double heightPerMinute,
   }) {
-    final mergedEvents = MergeEventArranger<T>().arrange(
+    final mergedEvents = MergeEventArranger<T>(
+      includeEdges: includeEdges,
+    ).arrange(
       events: events,
       height: height,
       width: width,