♻️ Refactor: Remove deprecated overlap tests and streamline event adjustment logic

Author: tyler-dane

packages/web/src/common/utils/overlap/overlap.find.test.ts

@@ -1,4 +1,3 @@
-import { v4 as uuidv4 } from "uuid";
 import { Categories_Event } from "@core/types/event.types";
 import { getUserId } from "@web/auth/auth.util";
 import { Schema_GridEvent } from "@web/common/types/web.event.types";

…mon/utils/overlap/overlap.adjust.test.ts …src/common/utils/overlap/overlap.test.tspackages/web/src/common/utils/overlap/overlap.adjust.test.ts renamed to packages/web/src/common/utils/overlap/overlap.test.ts packages/web/src/common/utils/overlap/overlap.adjust.test.ts renamed to packages/web/src/common/utils/overlap/overlap.test.ts

@@ -4,65 +4,22 @@ import { Schema_GridEvent } from "@web/common/types/web.event.types";
 export const adjustOverlappingEvents = (
   events: Schema_GridEvent[]
 ): Schema_GridEvent[] => {
-  // Deep copy events
-  let adjustedEvents: Schema_GridEvent[] = events.map((event) => ({
-    ...event,
-    position: { ...event.position },
-  }));
-
-  // Sort by start time first
+  let adjustedEvents = deepCopyEvents(events);
   adjustedEvents.sort((a, b) => dayjs(a.startDate).diff(dayjs(b.startDate)));
 
   const processedEvents = new Set<string>();
 
-  for (let i = 0; i < adjustedEvents.length; i++) {
-    const targetEvent = adjustedEvents[i];
-
-    // Skip if already processed
-    if (processedEvents.has(targetEvent._id)) {
-      continue;
-    }
+  for (const event of adjustedEvents) {
+    if (processedEvents.has(event._id)) continue;
 
-    const overlappingEventsSet = findOverlaps(
-      targetEvent,
-      adjustedEvents,
-      new Set([targetEvent])
-    );
+    const overlappingEventsSet = findOverlaps(event, adjustedEvents);
     const eventGroup = Array.from(overlappingEventsSet);
 
     if (eventGroup.length > 1) {
-      // If there are any overlaps, calculate width multiplier
-      let multiplier = 1 / eventGroup.length;
-      // Round to 2 decimal places (in case we have way too many decimal places from the division)
-      multiplier = Math.round(multiplier * 100) / 100;
-
-      // Set adjustments for all events in the group
-      eventGroup.forEach((event, i) => {
-        event.position.isOverlapping = true;
-        event.position.widthMultiplier *= multiplier;
-        event.position.horizontalOrder = i + 1;
-        processedEvents.add(event._id);
-      });
-
-      // If exact start and end times match, sort alphabetically by title
-      if (
-        eventGroup.every(
-          (event) =>
-            dayjs(event.startDate).isSame(targetEvent.startDate) &&
-            dayjs(event.endDate).isSame(targetEvent.endDate)
-        )
-      ) {
-        eventGroup.sort((a, b) => {
-          if (!a.title || !b.title) {
-            return 0;
-          }
-
-          return a.title.localeCompare(b.title);
-        });
-      }
+      adjustEventGroup(eventGroup);
+      eventGroup.forEach((e) => processedEvents.add(e._id));
     }
   }
-
   return adjustedEvents;
 };
 
@@ -73,31 +30,57 @@ export const findOverlaps = (
 ): Set<Schema_GridEvent> => {
   const directOverlaps = adjustedEvents.filter(
     (otherEvent) =>
-      otherEvent !== event && // Skip itself
-      !accumulatedEvents.has(otherEvent) && // Skip if already processed
+      otherEvent !== event &&
+      !accumulatedEvents.has(otherEvent) &&
       dayjs(event.startDate).isBefore(dayjs(otherEvent.endDate)) &&
       dayjs(event.endDate).isAfter(dayjs(otherEvent.startDate))
   );
 
-  directOverlaps.forEach((event) => {
-    accumulatedEvents.add(event);
-    // Recursively find overlaps for each overlapping event
-    findOverlaps(event, adjustedEvents, accumulatedEvents);
+  directOverlaps.forEach((overlappingEvent) => {
+    accumulatedEvents.add(overlappingEvent);
+    findOverlaps(overlappingEvent, adjustedEvents, accumulatedEvents);
   });
 
   return accumulatedEvents;
 };
 
-export const findOverlappingEvents = (events: Schema_GridEvent[]) => {
-  const overlappingEventsMap: { [key: string]: Schema_GridEvent[] } = {};
+const adjustEventGroup = (eventGroup: Schema_GridEvent[]) => {
+  eventGroup.sort((a, b) => dayjs(a.startDate).diff(dayjs(b.startDate)));
 
-  events.forEach((event, i) => {
-    const overlappingEvents = findOverlaps(event, events);
-    if (overlappingEvents.size > 1) {
-      const key = event._id || `no-id-${i}`;
-      overlappingEventsMap[key] = Array.from(overlappingEvents);
-    }
+  if (eventsHaveExactSameTimes(eventGroup)) {
+    sortEventsByTitle(eventGroup);
+  }
+
+  const multiplier = roundToTwoDecimals(1 / eventGroup.length);
+
+  eventGroup.forEach((event, index) => {
+    event.position.isOverlapping = true;
+    event.position.widthMultiplier *= multiplier;
+    event.position.horizontalOrder = index + 1;
   });
+};
 
-  return overlappingEventsMap;
+const roundToTwoDecimals = (value: number): number => {
+  return Math.round(value * 100) / 100;
+};
+
+const eventsHaveExactSameTimes = (eventGroup: Schema_GridEvent[]): boolean => {
+  return eventGroup.every(
+    (event) =>
+      dayjs(event.startDate).isSame(eventGroup[0].startDate) &&
+      dayjs(event.endDate).isSame(eventGroup[0].endDate)
+  );
+};
+
+const sortEventsByTitle = (eventGroup: Schema_GridEvent[]) => {
+  eventGroup.sort((a, b) =>
+    a.title && b.title ? a.title.localeCompare(b.title) : 0
+  );
+};
+
+const deepCopyEvents = (events: Schema_GridEvent[]): Schema_GridEvent[] => {
+  return events.map((event) => ({
+    ...event,
+    position: { ...event.position },
+  }));
 };