refactor: create mock data utilities

* add dayOffset to OntimeEvent

* refactor: isNewLatest

* calculate totalDays

* refactor: getTimeFromPrevious

* add gap as dataset in OntimeEvent

* use in ui

* format overlap is just a simple text formatting, big test is not needed

* add new fields where needed

* update apply delay

* show nex day eaven if there is no gap

* create test

* use buildin day offset in timeline

* remove todo

* consistent naming

* make a calculateDayOffset util for rundownCache

* refactor: checkIsNextDay to use dayOffset

* spelling

Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>

* remove unneeded test

* remove todo

* update test db

* use data-testid

* spelling

Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>

* update comments

* remove null option

---------

Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>

apps/client/src/common/utils/eventsManager.ts

@@ -25,6 +25,8 @@ export const cloneEvent = (event: OntimeEvent): ClonedEvent => {
     colour: event.colour,
     revision: 0,
     delay: 0,
+    dayOffset: 0,
+    gap: 0,
     timeWarning: event.timeWarning,
     timeDanger: event.timeDanger,
     custom: {},

apps/client/src/features/rundown/Rundown.tsx

@@ -13,6 +13,7 @@ import {
   SupportedEvent,
 } from 'ontime-types';
 import {
+  checkIsNextDay,
   getFirstNormal,
   getLastNormal,
   getNextBlockNormal,
@@ -267,7 +268,7 @@ export default function Rundown({ data }: RundownProps) {
   let eventIndex = 0;
   // all events before the current selected are in the past
   let isPast = Boolean(featureData?.selectedEventId);
-
+  let isNextDay = false;
   const isEditMode = appMode === AppMode.Edit;
 
   return (
@@ -286,6 +287,7 @@ export default function Rundown({ data }: RundownProps) {
               if (index === 0) {
                 eventIndex = 0;
               }
+              isNextDay = false;
               previousEntryId = thisId;
               thisId = entryId;
               if (isOntimeEvent(entry)) {
@@ -294,8 +296,9 @@ export default function Rundown({ data }: RundownProps) {
                 lastEvent = thisEvent;
 
                 if (isPlayableEvent(entry)) {
-                  // populate previous entry
+                  isNextDay = checkIsNextDay(entry, lastEvent);
-                  if (isNewLatest(entry.timeStart, entry.timeEnd, lastEvent?.timeStart, lastEvent?.timeEnd)) {
+                  if (isNewLatest(entry, lastEvent)) {
+                    // populate previous entry
                     thisEvent = entry;
                   }
                 }
@@ -323,12 +326,11 @@ export default function Rundown({ data }: RundownProps) {
                         loaded={isLoaded}
                         hasCursor={hasCursor}
                         isNext={isNext}
-                        previousStart={lastEvent?.timeStart}
-                        previousEnd={lastEvent?.timeEnd}
                         previousEntryId={previousEntryId}
                         previousEventId={lastEvent?.id}
                         playback={isLoaded ? featureData.playback : undefined}
                         isRolling={featureData.playback === Playback.Roll}
+                        isNextDay={isNextDay}
                       />
                     </div>
                   </div>

apps/client/src/features/rundown/RundownEntry.tsx

@@ -32,8 +32,7 @@ interface RundownEntryProps {
   eventIndex: number;
   hasCursor: boolean;
   isNext: boolean;
-  previousStart?: number;
+  isNextDay: boolean;
-  previousEnd?: number;
   previousEntryId?: string;
   previousEventId?: string;
   playback?: Playback; // we only care about this if this event is playing
@@ -47,13 +46,12 @@ export default function RundownEntry(props: RundownEntryProps) {
     loaded,
     hasCursor,
     isNext,
-    previousStart,
-    previousEnd,
     previousEntryId,
     previousEventId,
     playback,
     isRolling,
     eventIndex,
+    isNextDay,
   } = props;
   const { emitError } = useEmitLog();
   const { addEvent, updateEvent, batchUpdateEvents, deleteEvent, swapEvents } = useEventAction();
@@ -165,8 +163,6 @@ export default function RundownEntry(props: RundownEntryProps) {
         title={data.title}
         note={data.note}
         delay={data.delay ?? 0}
-        previousStart={previousStart}
-        previousEnd={previousEnd}
         colour={data.colour}
         isPast={isPast}
         isNext={isNext}
@@ -175,6 +171,8 @@ export default function RundownEntry(props: RundownEntryProps) {
         hasCursor={hasCursor}
         playback={playback}
         isRolling={isRolling}
+        gap={data.gap}
+        isNextDay={isNextDay}
         actionHandler={actionHandler}
       />
     );

apps/client/src/features/rundown/event-block/EventBlock.tsx

@@ -39,8 +39,6 @@ interface EventBlockProps {
   title: string;
   note: string;
   delay: number;
-  previousStart?: number;
-  previousEnd?: number;
   colour: string;
   isPast: boolean;
   isNext: boolean;
@@ -49,6 +47,8 @@ interface EventBlockProps {
   hasCursor: boolean;
   playback?: Playback;
   isRolling: boolean;
+  gap: number;
+  isNextDay: boolean;
   actionHandler: (
     action: EventItemActions,
     payload?:
@@ -77,8 +77,6 @@ export default function EventBlock(props: EventBlockProps) {
     title,
     note,
     delay,
-    previousStart,
-    previousEnd,
     colour,
     isPast,
     isNext,
@@ -87,6 +85,8 @@ export default function EventBlock(props: EventBlockProps) {
     hasCursor,
     playback,
     isRolling,
+    gap,
+    isNextDay,
     actionHandler,
   } = props;
   const { selectedEventId, setSelectedEventId, clearSelectedEventId } = useEventIdSwapping();
@@ -273,7 +273,7 @@ export default function EventBlock(props: EventBlockProps) {
       onContextMenu={onContextMenu}
       id='event-block'
     >
-      <RundownIndicators timeStart={timeStart} previousStart={previousStart} previousEnd={previousEnd} delay={delay} />
+      <RundownIndicators timeStart={timeStart} delay={delay} gap={gap} isNextDay={isNextDay} />
 
       <div className={style.binder} style={{ ...binderColours }} tabIndex={-1}>
         <span className={style.drag} ref={handleRef} {...dragAttributes} {...dragListeners}>

apps/client/src/features/rundown/event-block/EventBlock.utils.ts

@@ -1,11 +1,4 @@
-import {
+import { millisToString, removeTrailingZero } from 'ontime-utils';
-  calculateDuration,
-  checkIsNextDay,
-  dayInMs,
-  getTimeFromPrevious,
-  millisToString,
-  removeTrailingZero,
-} from 'ontime-utils';
 
 import { formatDuration } from '../../../common/utils/time';
 
@@ -17,25 +10,15 @@ export function formatDelay(timeStart: number, delay: number): string | undefine
   const timeTag = removeTrailingZero(millisToString(delayedStart));
   return `New start ${timeTag}`;
 }
-
+export function formatGap(gap: number, isNextDay: boolean) {
-export function formatOverlap(timeStart: number, previousStart?: number, previousEnd?: number): string | undefined {
+  if (gap === 0) {
-  const noPreviousElement = previousEnd === undefined || previousStart === undefined;
+    if (isNextDay) {
-  if (noPreviousElement) return;
+      // We show a next day warning even if there is no gap
-
+      return '(next day)';
-  const normalisedDuration = calculateDuration(previousStart, previousEnd);
+    }
-  const timeFromPrevious = getTimeFromPrevious(timeStart, previousStart, previousEnd, normalisedDuration);
+    return;
-  if (timeFromPrevious === 0) return;
-
-  if (checkIsNextDay(previousStart, timeStart, normalisedDuration)) {
-    const previousCrossMidnight = previousStart > previousEnd;
-    const normalisedPreviousEnd = previousCrossMidnight ? previousEnd + dayInMs : previousEnd;
-
-    const gap = dayInMs - normalisedPreviousEnd + timeStart;
-    if (gap === 0) return;
-    const gapString = formatDuration(Math.abs(gap), false);
-    return `Gap ${gapString} (next day)`;
   }
 
-  const overlapString = formatDuration(Math.abs(timeFromPrevious), false);
+  const gapString = formatDuration(Math.abs(gap), false);
-  return `${timeFromPrevious < 0 ? 'Overlap' : 'Gap'} ${overlapString}`;
+  return `${gap < 0 ? 'Overlap' : 'Gap'} ${gapString}${isNextDay ? ' (next day)' : ''}`;
 }

apps/client/src/features/rundown/event-block/RundownIndicators.tsx

@@ -1,24 +1,24 @@
-import { formatDelay, formatOverlap } from './EventBlock.utils';
+import { formatDelay, formatGap } from './EventBlock.utils';
 
 import style from './RundownIndicators.module.scss';
 
 interface RundownIndicatorProps {
   timeStart: number;
-  previousStart?: number;
+  isNextDay: boolean;
-  previousEnd?: number;
   delay: number;
+  gap: number;
 }
 
 export default function RundownIndicators(props: RundownIndicatorProps) {
-  const { timeStart, previousStart, previousEnd, delay } = props;
+  const { timeStart, delay, gap, isNextDay } = props;
 
-  const hasOverlap = formatOverlap(timeStart, previousStart, previousEnd);
+  const hasGap = formatGap(gap, isNextDay);
   const hasDelay = formatDelay(timeStart, delay);
 
   return (
     <div className={style.indicators}>
       {hasDelay && <div className={style.delay}>{hasDelay}</div>}
-      {hasOverlap && <div className={style.gap}>{hasOverlap}</div>}
+      {hasGap && <div className={style.gap}>{hasGap}</div>}
     </div>
   );
 }

apps/client/src/features/rundown/event-block/__tests__/EventBlock.utils.test.ts

@@ -1,6 +1,4 @@
-import { MILLIS_PER_HOUR } from 'ontime-utils';
+import { formatDelay } from '../EventBlock.utils';
-
-import { formatDelay, formatOverlap } from '../EventBlock.utils';
 
 describe('formatDelay()', () => {
   it('adds a given delay to the start time', () => {
@@ -10,69 +8,3 @@ describe('formatDelay()', () => {
     expect(result).toEqual('New start 00:02');
   });
 });
-
-describe('formatOverlap()', () => {
-  it('recognises an overlap between two times', () => {
-    const previousStart = 0;
-    const previousEnd = 60000; // 1 min
-    const timeStart = 30000; // 30 sec
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toEqual('Overlap 30s');
-  });
-
-  it('bug #949 recognises an overlap between two times', () => {
-    const previousStart = 46800000; // 13:00:00
-    const previousEnd = 48600000; // 13:30:00
-    const timeStart = 48300000; // 13:25:00
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toEqual('Overlap 5m');
-  });
-
-  it('handles events the day after, without overlap', () => {
-    const previousStart = 11 * MILLIS_PER_HOUR;
-    const previousEnd = 12 * MILLIS_PER_HOUR;
-    const timeStart = 6 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 18h (next day)');
-  });
-
-  it('handles events the day after, with gap', () => {
-    const previousStart = 17 * MILLIS_PER_HOUR;
-    const previousEnd = 23 * MILLIS_PER_HOUR;
-    const timeStart = 9 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 10h (next day)');
-  });
-
-  it('handles events the day after, with previous ending at midnight', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR; // 23:00:00
-    const previousEnd = 0; // 00:00:00
-    const timeStart = 1 * MILLIS_PER_HOUR; // 01:00:00
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 1h (next day)');
-  });
-
-  it('handles sequential events the day after, with previous ending over midnight', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
-    const previousEnd = 1 * MILLIS_PER_HOUR;
-    const timeStart = 1 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBeUndefined();
-  });
-
-  it('handles events the day after, with previous ending over midnight with overlap', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
-    const previousEnd = 2 * MILLIS_PER_HOUR;
-    const timeStart = 1 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Overlap 1h');
-  });
-
-  it('handles events the day after, with previous ending over midnight with gap', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
-    const previousEnd = 1 * MILLIS_PER_HOUR;
-    const timeStart = 2 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 1h');
-  });
-});

apps/client/src/features/rundown/time-input-flow/TimeInputFlow.tsx

@@ -6,6 +6,7 @@ import { IoLockClosed } from '@react-icons/all-files/io5/IoLockClosed';
 import { IoLockOpenOutline } from '@react-icons/all-files/io5/IoLockOpenOutline';
 import { IoUnlink } from '@react-icons/all-files/io5/IoUnlink';
 import { MaybeString, TimeField, TimeStrategy } from 'ontime-types';
+import { dayInMs } from 'ontime-utils';
 
 import TimeInputWithButton from '../../../common/components/input/time-input/TimeInputWithButton';
 import { useEventAction } from '../../../common/hooks/useEventAction';
@@ -45,7 +46,7 @@ function TimeInputFlow(props: EventBlockTimerProps) {
   };
 
   const warnings = [];
-  if (timeStart > timeEnd) {
+  if (timeStart + duration > dayInMs) {
     warnings.push('Over midnight');
   }
 
@@ -129,7 +130,7 @@ function TimeInputFlow(props: EventBlockTimerProps) {
       </div>
 
       {warnings.length > 0 && (
-        <div className={style.timerNote}>
+        <div className={style.timerNote} data-testid='event-warning'>
           <Tooltip label={warnings.join(' - ')} openDelay={tooltipDelayFast} variant='ontime-ondark' shouldWrapChildren>
             <IoAlertCircleOutline />
           </Tooltip>

apps/client/src/views/timeline/Timeline.tsx

@@ -1,7 +1,7 @@
 import { memo } from 'react';
 import { useViewportSize } from '@mantine/hooks';
-import { isOntimeEvent, isPlayableEvent, MaybeNumber, OntimeRundown } from 'ontime-types';
+import { isOntimeEvent, isPlayableEvent, OntimeRundown } from 'ontime-types';
-import { checkIsNextDay, dayInMs, getLastEvent, MILLIS_PER_HOUR } from 'ontime-utils';
+import { dayInMs, getLastEvent, MILLIS_PER_HOUR } from 'ontime-utils';
 
 import TimelineMarkers from './timeline-markers/TimelineMarkers';
 import { getElementPosition, getEndHour, getStartHour } from './timeline.utils';
@@ -30,10 +30,8 @@ function Timeline(props: TimelineProps) {
   const startHour = getStartHour(firstStart);
   const endHour = getEndHour(firstStart + totalDuration + (lastEvent?.delay ?? 0));
 
-  let previousEventStartTime: MaybeNumber = null;
   // we use selectedEventId as a signifier on whether the timeline is live
   let eventStatus: ProgressStatus = selectedEventId ? 'done' : 'future';
-  let elapsedDays = 0;
 
   return (
     <div className={style.timeline}>
@@ -52,14 +50,7 @@ function Timeline(props: TimelineProps) {
           eventStatus = 'live';
         }
 
-        // we only need to check for next day if we have a previous event
+        const normalisedStart = event.timeStart + event.dayOffset * dayInMs;
-        if (
-          previousEventStartTime !== null &&
-          checkIsNextDay(previousEventStartTime, event.timeStart, event.duration)
-        ) {
-          elapsedDays++;
-        }
-        const normalisedStart = event.timeStart + elapsedDays * dayInMs;
 
         const { left: elementLeftPosition, width: elementWidth } = getElementPosition(
           startHour * MILLIS_PER_HOUR,
@@ -69,9 +60,6 @@ function Timeline(props: TimelineProps) {
           screenWidth,
         );
 
-        // prepare values for next iteration
-        previousEventStartTime = normalisedStart;
-
         return (
           <TimelineEntry
             key={event.id}

apps/client/src/views/timeline/timeline.utils.ts

@@ -110,7 +110,7 @@ export function useScopedRundown(rundown: OntimeRundown, selectedEventId: MaybeS
     let selectedIndex = selectedEventId ? Infinity : -1;
     let firstStart = null;
     let totalDuration = 0;
-    let lastEntry: PlayableEvent | null = null;
+    let lastEntry: PlayableEvent | undefined;
 
     for (let i = 0; i < rundown.length; i++) {
       const currentEntry = rundown[i];
@@ -142,12 +142,7 @@ export function useScopedRundown(rundown: OntimeRundown, selectedEventId: MaybeS
           firstStart = currentEntry.timeStart;
         }
 
-        const timeFromPrevious: number = getTimeFromPrevious(
+        const timeFromPrevious: number = getTimeFromPrevious(currentEntry, lastEntry);
-          currentEntry.timeStart,
-          lastEntry?.timeStart,
-          lastEntry?.timeEnd,
-          lastEntry?.duration,
-        );
 
         if (timeFromPrevious === 0) {
           totalDuration += currentEntry.duration;
@@ -156,7 +151,7 @@ export function useScopedRundown(rundown: OntimeRundown, selectedEventId: MaybeS
         } else if (timeFromPrevious < 0) {
           totalDuration += Math.max(currentEntry.duration + timeFromPrevious, 0);
         }
-        if (isNewLatest(currentEntry.timeStart, currentEntry.timeEnd, lastEntry?.timeStart, lastEntry?.timeEnd)) {
+        if (isNewLatest(currentEntry, lastEntry)) {
           lastEntry = currentEntry;
         }
       }

apps/server/src/api-data/sheets/sheets.validation.ts

@@ -8,7 +8,7 @@ export const validateRequestConnection = [
     .exists()
     .isString()
     .isLength({
-      min: 40,
+      min: 20,
       max: 100,
     })
     .withMessage('Sheet ID is usually 44 characters long'),

apps/server/src/models/demoProject.ts

@@ -21,6 +21,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -47,6 +49,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -73,6 +77,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -99,6 +105,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -125,6 +133,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -156,6 +166,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -182,6 +194,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -208,6 +222,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -234,6 +250,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -260,6 +278,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -291,6 +311,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -317,6 +339,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -343,6 +367,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {
@@ -369,6 +395,8 @@ export const demoDb: DatabaseModel = {
       colour: '',
       revision: 0,
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 500000,
       timeDanger: 100000,
       custom: {

apps/server/src/models/eventsDefinition.ts

@@ -25,6 +25,8 @@ export const event: Omit<OntimeEvent, 'id' | 'cue'> = {
   type: SupportedEvent.Event,
   revision: 0,
   delay: 0,
+  dayOffset: 0,
+  gap: 0,
   timeWarning: 120000,
   timeDanger: 60000,
   custom: {},

apps/server/src/services/__tests__/rollUtils.test.ts

@@ -1,23 +1,7 @@
-import { OntimeEvent, SupportedEvent } from 'ontime-types';
 import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE } from 'ontime-utils';
 
 import { loadRoll } from '../rollUtils.js';
-
+import { prepareTimedEvents, makeOntimeEvent } from '../rundown-service/__mocks__/rundown.mocks.js';
-const baseEvent = {
-  type: SupportedEvent.Event,
-  skip: false,
-};
-
-function makeOntimeEvent(patch: Partial<OntimeEvent>): OntimeEvent {
-  return {
-    ...baseEvent,
-    ...patch,
-  } as OntimeEvent;
-}
-
-function prepareTimedEvents(events: Partial<OntimeEvent>[]): OntimeEvent[] {
-  return events.map(makeOntimeEvent);
-}
 
 describe('loadRoll()', () => {
   const eventlist = [

apps/server/src/services/rundown-service/__mocks__/rundown.mocks.ts

@@ -0,0 +1,30 @@
+import { SupportedEvent, OntimeEvent, OntimeDelay } from 'ontime-types';
+
+const baseEvent = {
+  type: SupportedEvent.Event,
+  skip: false,
+};
+
+/**
+ * Utility to create a Ontime event
+ */
+export function makeOntimeEvent(patch: Partial<OntimeEvent>): OntimeEvent {
+  return {
+    ...baseEvent,
+    ...patch,
+  } as OntimeEvent;
+}
+
+/**
+ * Utility to create a delay event
+ */
+export function makeOntimeDelay(duration: number): OntimeDelay {
+  return { id: 'delay', type: SupportedEvent.Delay, duration };
+}
+
+/**
+ * Utility to generate a rundown of OntimeEvents form partial objects
+ */
+export function prepareTimedEvents(events: Partial<OntimeEvent>[]): OntimeEvent[] {
+  return events.map(makeOntimeEvent);
+}

apps/server/src/services/rundown-service/__tests__/delayUtils.test.ts

@@ -1,20 +1,8 @@
-import { OntimeBlock, OntimeDelay, OntimeEvent, OntimeRundown, SupportedEvent } from 'ontime-types';
+import { OntimeBlock, OntimeEvent, OntimeRundown, SupportedEvent } from 'ontime-types';
-import { apply } from '../delayUtils.js';
 import { MILLIS_PER_HOUR } from 'ontime-utils';
 
-/**
+import { apply } from '../delayUtils.js';
- * Small utility to fill in the necessary data for the test
+import { makeOntimeDelay, makeOntimeEvent } from '../__mocks__/rundown.mocks.js';
- */
-function makeOntimeEvent(event: Partial<OntimeEvent>): OntimeEvent {
-  return { ...event, type: SupportedEvent.Event, revision: 1 } as OntimeEvent;
-}
-
-/**
- * Small utility to make a delay event
- */
-function makeOntimeDelay(duration: number): OntimeDelay {
-  return { id: 'delay', type: SupportedEvent.Delay, duration } as OntimeDelay;
-}
 
 describe('apply()', () => {
   it('applies a positive delay to the rundown', () => {
@@ -150,11 +138,11 @@ describe('apply()', () => {
       makeOntimeDelay(100),
       makeOntimeEvent({ id: '1', timeStart: 0, timeEnd: 100, duration: 100 }),
       // gap 50
-      makeOntimeEvent({ id: '2', timeStart: 150, timeEnd: 200, duration: 50 }),
+      makeOntimeEvent({ id: '2', timeStart: 150, timeEnd: 200, duration: 50, gap: 50 }),
+      // gap 0
+      makeOntimeEvent({ id: '3', timeStart: 200, timeEnd: 250, duration: 50, gap: 0 }),
       // gap 50
-      makeOntimeEvent({ id: '3', timeStart: 200, timeEnd: 250, duration: 50 }),
+      makeOntimeEvent({ id: '4', timeStart: 300, timeEnd: 350, duration: 50, gap: 50 }),
-      // gap 50
-      makeOntimeEvent({ id: '4', timeStart: 300, timeEnd: 350, duration: 50 }),
       // linked
       makeOntimeEvent({ id: '5', timeStart: 350, timeEnd: 400, duration: 50, linkStart: '4' }),
     ];
@@ -165,7 +153,7 @@ describe('apply()', () => {
       // gap 50 (100 - 50)
       { id: '2', timeStart: 150 + 50, timeEnd: 200 + 50, duration: 50, revision: 2 },
       // gap 50 (50 - 50)
-      { id: '3', timeStart: 200 + 50, timeEnd: 250 + 50, duration: 50, revision: 2 },
+      { id: '3', timeStart: 200 + 50, timeEnd: 250 + 50, duration: 50, revision: 2, gap: 0 },
       // gap (delay is 0)
       { id: '4', timeStart: 300, timeEnd: 350, duration: 50, revision: 1 },
       // linked
@@ -178,6 +166,8 @@ describe('apply()', () => {
       makeOntimeDelay(2 * MILLIS_PER_HOUR),
       makeOntimeEvent({
         id: '1',
+        gap: 0,
+        dayOffset: 0,
         timeStart: 46800000, // 13:00:00
         timeEnd: 50400000, // 14:00:00
         duration: MILLIS_PER_HOUR,
@@ -185,6 +175,8 @@ describe('apply()', () => {
       // gap 1h
       makeOntimeEvent({
         id: '2',
+        gap: 1 * MILLIS_PER_HOUR,
+        dayOffset: 0,
         timeStart: 54000000, // 15:00:00
         timeEnd: 57600000, // 16:00:00
         duration: MILLIS_PER_HOUR,

apps/server/src/services/rundown-service/__tests__/rundownCache.test.ts

@@ -577,6 +577,8 @@ describe('calculateRuntimeDelays', () => {
         type: SupportedEvent.Event,
         revision: 0,
         delay: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: '659e1',
@@ -605,6 +607,8 @@ describe('calculateRuntimeDelays', () => {
         type: SupportedEvent.Event,
         revision: 0,
         delay: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: '1c48f',
@@ -633,6 +637,8 @@ describe('calculateRuntimeDelays', () => {
         type: SupportedEvent.Event,
         revision: 0,
         delay: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: 'd48c2',
@@ -661,6 +667,8 @@ describe('calculateRuntimeDelays', () => {
         type: SupportedEvent.Event,
         revision: 0,
         delay: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: '2f185',
@@ -701,6 +709,8 @@ describe('getDelayAt()', () => {
       timeDanger: 60000,
       id: '659e1',
       delay: 0,
+      dayOffset: 0,
+      gap: 0,
       cue: '1',
       custom: {},
     },
@@ -725,6 +735,8 @@ describe('getDelayAt()', () => {
       colour: '',
       type: SupportedEvent.Event,
       revision: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 120000,
       timeDanger: 60000,
       id: '1c48f',
@@ -753,6 +765,8 @@ describe('getDelayAt()', () => {
       colour: '',
       type: SupportedEvent.Event,
       revision: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 120000,
       timeDanger: 60000,
       id: 'd48c2',
@@ -781,6 +795,8 @@ describe('getDelayAt()', () => {
       colour: '',
       type: SupportedEvent.Event,
       revision: 0,
+      dayOffset: 0,
+      gap: 0,
       timeWarning: 120000,
       timeDanger: 60000,
       id: '2f185',
@@ -835,6 +851,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         colour: '',
         type: SupportedEvent.Event,
         revision: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: '659e1',
@@ -863,6 +881,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         colour: '',
         type: SupportedEvent.Event,
         revision: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: '1c48f',
@@ -891,6 +911,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         colour: '',
         type: SupportedEvent.Event,
         revision: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: 'd48c2',
@@ -919,6 +941,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         colour: '',
         type: SupportedEvent.Event,
         revision: 0,
+        dayOffset: 0,
+        gap: 0,
         timeWarning: 120000,
         timeDanger: 60000,
         id: '2f185',

apps/server/src/services/rundown-service/__tests__/rundownCacheUtils.test.ts

@@ -9,12 +9,14 @@ import {
 } from 'ontime-types';
 import {
   addToCustomAssignment,
+  calculateDayOffset,
   getLink,
   handleCustomField,
   handleLink,
   hasChanges,
   isDataStale,
 } from '../rundownCacheUtils.js';
+import { MILLIS_PER_HOUR } from 'ontime-utils';
 
 describe('getLink()', () => {
   it('should return null if there is no link', () => {
@@ -247,3 +249,61 @@ describe('hasChanges()', () => {
     expect(hasChanges(existing, newEvent)).toBe(false);
   });
 });
+
+describe('calculateDayOffset', () => {
+  it('returns 0 if there is no previous event', () => {
+    expect(calculateDayOffset({ timeStart: 0 })).toBe(0);
+  });
+
+  it('returns 0 if the previous event duration is 0', () => {
+    expect(calculateDayOffset({ timeStart: 0 }, { timeStart: 0, duration: 0 })).toBe(0);
+  });
+
+  it('returns 0 if event starts after previous', () => {
+    expect(calculateDayOffset({ timeStart: 11 }, { timeStart: 10, duration: 2 })).toBe(0);
+  });
+
+  it('returns 1 if event starts before previous', () => {
+    expect(calculateDayOffset({ timeStart: 9 }, { timeStart: 10, duration: 2 })).toBe(1);
+  });
+
+  it('returns 1 if event starts at the same time as one before', () => {
+    expect(calculateDayOffset({ timeStart: 10 }, { timeStart: 10, duration: 2 })).toBe(1);
+  });
+
+  it('should account for an event that crossed midnight and there is a overlap', () => {
+    expect(
+      calculateDayOffset(
+        { timeStart: MILLIS_PER_HOUR }, // starts at 01:00:00
+        { timeStart: 20 * MILLIS_PER_HOUR, duration: 6 * MILLIS_PER_HOUR }, // ends at 02:00:00
+      ),
+    ).toBe(1);
+  });
+
+  it('should account for an event that crossed midnight and there is a gap', () => {
+    expect(
+      calculateDayOffset(
+        { timeStart: 2 * MILLIS_PER_HOUR }, // starts at 02:00:00
+        { timeStart: 23 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR }, // ends at 01:00:00
+      ),
+    ).toBe(1);
+  });
+
+  it('should account for an event that crossed midnight with no overlaps or gaps', () => {
+    expect(
+      calculateDayOffset(
+        { timeStart: 2 * MILLIS_PER_HOUR }, // starts at 02:00:00
+        { timeStart: 20 * MILLIS_PER_HOUR, duration: 6 * MILLIS_PER_HOUR }, // ends at 02:00:00
+      ),
+    ).toBe(1);
+  });
+
+  it('should account for an event that finishes exactly at midnight', () => {
+    expect(
+      calculateDayOffset(
+        { timeStart: 2 * MILLIS_PER_HOUR }, // starts at 02:00:00
+        { timeStart: 23 * MILLIS_PER_HOUR, duration: 6 * MILLIS_PER_HOUR }, // ends at 24:00:00
+      ),
+    ).toBe(1);
+  });
+});

apps/server/src/services/rundown-service/delayUtils.ts

@@ -1,5 +1,5 @@
 import { OntimeRundown, isOntimeDelay, isOntimeBlock, isOntimeEvent, OntimeEvent } from 'ontime-types';
-import { getTimeFromPrevious, deleteAtIndex } from 'ontime-utils';
+import { deleteAtIndex } from 'ontime-utils';
 
 /**
  * Calculates all delays in a given rundown
@@ -133,21 +133,14 @@ export function apply(eventId: string, rundown: OntimeRundown): OntimeRundown {
 
     // if the event is not linked, we try and maintain gaps
     if (lastEntry !== null) {
-      const timeFromPrevious: number = getTimeFromPrevious(
-        currentEntry.timeStart,
-        lastEntry.timeStart,
-        lastEntry.timeEnd,
-        lastEntry.duration,
-      );
-
       // when applying negative delays, we need to unlink the event
       // if the previous event was fully consumed by the delay
       if (currentEntry.linkStart && delayValue < 0 && lastEntry.timeStart + delayValue < 0) {
         shouldUnlink = true;
       }
 
-      if (timeFromPrevious > 0) {
+      if (currentEntry.gap > 0) {
-        delayValue = Math.max(delayValue - timeFromPrevious, 0);
+        delayValue = Math.max(delayValue - currentEntry.gap, 0);
       }
 
       if (delayValue === 0) {

apps/server/src/services/rundown-service/rundownCache.ts

@@ -24,7 +24,7 @@ import {
 import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
 import { createPatch } from '../../utils/parser.js';
 import { apply } from './delayUtils.js';
-import { handleCustomField, handleLink, hasChanges, isDataStale } from './rundownCacheUtils.js';
+import { calculateDayOffset, handleCustomField, handleLink, hasChanges, isDataStale } from './rundownCacheUtils.js';
 
 type EventID = string;
 type NormalisedRundown = Record<EventID, OntimeRundownEntry>;
@@ -55,6 +55,7 @@ function setIsStale() {
 
 let totalDelay = 0;
 let totalDuration = 0;
+let totalDays = 0;
 let firstStart: MaybeNumber = null;
 let lastEnd: MaybeNumber = null;
 
@@ -107,6 +108,7 @@ export function generate(
   firstStart = null;
   lastEnd = null;
   totalDuration = 0;
+  totalDays = 0;
   totalDelay = 0;
 
   let lastEntry: PlayableEvent | null = null;
@@ -117,6 +119,7 @@ export function generate(
 
     if (isOntimeEvent(currentEntry)) {
       currentEntry.delay = 0;
+      currentEntry.gap = 0;
 
       // 1. handle links - mutates updatedEvent
       handleLink(i, initialRundown, currentEntry, links);
@@ -124,6 +127,9 @@ export function generate(
       // 2. handle custom fields - mutates updatedEvent
       handleCustomField(customFields, customFieldChangelog, currentEntry, assignedCustomFields);
 
+      totalDays += calculateDayOffset(currentEntry, lastEntry);
+      currentEntry.dayOffset = totalDays;
+
       // update rundown metadata, it only concerns playable events
       if (isPlayableEvent(currentEntry)) {
         // fist start is always the first event
@@ -131,36 +137,31 @@ export function generate(
           firstStart = currentEntry.timeStart;
         }
 
-        const timeFromPrevious: number = getTimeFromPrevious(
+        currentEntry.gap = getTimeFromPrevious(currentEntry, lastEntry);
-          currentEntry.timeStart,
-          lastEntry?.timeStart,
-          lastEntry?.timeEnd,
-          lastEntry?.duration,
-        );
 
-        if (timeFromPrevious === 0) {
+        if (currentEntry.gap === 0) {
           // event starts on previous finish, we add its duration
           totalDuration += currentEntry.duration;
-        } else if (timeFromPrevious > 0) {
+        } else if (currentEntry.gap > 0) {
           // event has a gap, we add the gap and the duration
-          totalDuration += timeFromPrevious + currentEntry.duration;
+          totalDuration += currentEntry.gap + currentEntry.duration;
-        } else if (timeFromPrevious < 0) {
+        } else if (currentEntry.gap < 0) {
           // there is an overlap, we remove the overlap from the duration
           // ensuring that the sum is not negative (ie: fully overlapped events)
           // NOTE: we add the gap since it is a negative number
-          totalDuration += Math.max(currentEntry.duration + timeFromPrevious, 0);
+          totalDuration += Math.max(currentEntry.duration + currentEntry.gap, 0);
         }
 
         // remove eventual gaps from the accumulated delay
         // we only affect positive delays (time forwards)
-        if (totalDelay > 0 && timeFromPrevious > 0) {
+        if (totalDelay > 0 && currentEntry.gap > 0) {
-          totalDelay = Math.max(totalDelay - timeFromPrevious, 0);
+          totalDelay = Math.max(totalDelay - currentEntry.gap, 0);
         }
         // current event delay is the current accumulated delay
         currentEntry.delay = totalDelay;
 
         // lastEntry is the event with the latest end time
-        if (isNewLatest(currentEntry.timeStart, currentEntry.timeEnd, lastEntry?.timeStart, lastEntry?.timeEnd)) {
+        if (isNewLatest(currentEntry, lastEntry)) {
           lastEntry = currentEntry;
         }
       }

apps/server/src/services/rundown-service/rundownCacheUtils.ts

@@ -7,7 +7,7 @@ import {
   OntimeRundownEntry,
   OntimeBaseEvent,
 } from 'ontime-types';
-import { getLinkedTimes } from 'ontime-utils';
+import { dayInMs, getLinkedTimes } from 'ontime-utils';
 
 /**
  * Get linked event
@@ -147,3 +147,36 @@ export function hasChanges<T extends OntimeBaseEvent>(existingEvent: T, newEvent
     (key) => !Object.hasOwn(existingEvent, key) || existingEvent[key as keyof T] !== newEvent[key as keyof T],
   );
 }
+
+/**
+ * Utility for calculating if the current events should have a day offset
+ * @param current the current event under test
+ * @param previous the previous event
+ * @returns 0 or 1 for easy accumulation with the total days
+ */
+export function calculateDayOffset(
+  current: Pick<OntimeEvent, 'timeStart'>,
+  previous?: Pick<OntimeEvent, 'timeStart' | 'duration'>,
+) {
+  // if there is no previous there can't be a day offset
+  if (!previous) {
+    return 0;
+  }
+
+  // if the previous events duration is zero it will push the current event to next day
+  if (previous.duration === 0) {
+    return 0;
+  }
+
+  // if the previous event crossed midnight then the current event is in the next day
+  if (previous.timeStart + previous.duration >= dayInMs) {
+    return 1;
+  }
+
+  // if the current events starts at the same time or before the previous event then it is the next day
+  if (current.timeStart <= previous.timeStart) {
+    return 1;
+  }
+
+  return 0;
+}

apps/server/src/services/sheet-service/__tests__/sheetUtils.test.ts

@@ -37,6 +37,8 @@ describe('cellRequestFromEvent()', () => {
       skip: false,
       colour: 'red',
       delay: 0,
+      gap: 0,
+      dayOffset: 0,
       revision: 0,
       id: '1358',
       timeWarning: 0,
@@ -84,6 +86,8 @@ describe('cellRequestFromEvent()', () => {
       colour: 'red',
       revision: 0,
       delay: 0,
+      gap: 0,
+      dayOffset: 0,
       id: '1358',
       timeWarning: 0,
       timeDanger: 0,
@@ -132,6 +136,8 @@ describe('cellRequestFromEvent()', () => {
       colour: 'red',
       revision: 0,
       delay: 0,
+      gap: 0,
+      dayOffset: 0,
       id: '1358',
       timeWarning: 0,
       timeDanger: 0,
@@ -178,6 +184,8 @@ describe('cellRequestFromEvent()', () => {
       skip: false,
       colour: 'red',
       delay: 0,
+      gap: 0,
+      dayOffset: 0,
       revision: 0,
       id: '1358',
       timeWarning: 0,
@@ -212,6 +220,8 @@ describe('cellRequestFromEvent()', () => {
       colour: 'red',
       revision: 0,
       delay: 0,
+      gap: 0,
+      dayOffset: 0,
       id: '1358',
       timeWarning: 0,
       timeDanger: 0,
@@ -246,6 +256,8 @@ describe('cellRequestFromEvent()', () => {
       colour: 'red',
       revision: 0,
       delay: 0,
+      gap: 0,
+      dayOffset: 0,
       id: '1358',
       timeWarning: 0,
       timeDanger: 0,

apps/server/src/stores/__mocks__/runtimeState.mocks.ts

@@ -0,0 +1,46 @@
+import { TimerPhase, Playback } from 'ontime-types';
+import { deepmerge } from 'ontime-utils';
+import { RuntimeState } from '../runtimeState.js';
+
+const baseState: RuntimeState = {
+  clock: 0,
+  currentBlock: {
+    block: null,
+    startedAt: null,
+  },
+  eventNow: null,
+  publicEventNow: null,
+  eventNext: null,
+  publicEventNext: null,
+  runtime: {
+    selectedEventIndex: null,
+    numEvents: 0,
+    offset: 0,
+    plannedStart: 0,
+    plannedEnd: 0,
+    actualStart: null,
+    expectedEnd: null,
+  },
+  timer: {
+    addedTime: 0,
+    current: null,
+    duration: null,
+    elapsed: null,
+    expectedFinish: null,
+    finishedAt: null,
+    phase: TimerPhase.None,
+    playback: Playback.Stop,
+    secondaryTimer: null,
+    startedAt: null,
+  },
+  _timer: {
+    forceFinish: null,
+    totalDelay: 0,
+    pausedAt: null,
+    secondaryTarget: null,
+  },
+};
+
+export function makeRuntimeStateData(patch?: Partial<RuntimeState>) {
+  return deepmerge(baseState, patch);
+}

apps/server/src/utils/parser.ts

@@ -384,7 +384,9 @@ export function createPatch(originalEvent: OntimeEvent, patchEvent: Partial<Onti
     skip: typeof patchEvent.skip === 'boolean' ? patchEvent.skip : originalEvent.skip,
     note: makeString(patchEvent.note, originalEvent.note),
     colour: makeString(patchEvent.colour, originalEvent.colour),
-    delay: 0, //delay is always regenerated by the cache
+    delay: 0, // is always regenerated by the cache
+    dayOffset: 0, // is always regenerated by the cache
+    gap: 0, // is always regenerated by the cache
     // short circuit empty string
     cue: makeString(patchEvent.cue ?? null, originalEvent.cue),
     revision: originalEvent.revision,

apps/server/test-db/db.json

@@ -1,307 +1,420 @@
 {
   "rundown": [
-    {
+  {
-      "title": "Albania",
+    "id": "32d31",
-      "note": "SF1.01",
+    "type": "event",
-      "endAction": "none",
+    "title": "Albania",
-      "timerType": "count-down",
+    "timeStart": 36000000,
-      "timeStart": 36000000,
+    "timeEnd": 37200000,
-      "timeEnd": 37200000,
+    "duration": 1200000,
-      "duration": 1200000,
+    "timeStrategy": "lock-duration",
-      "isPublic": true,
+    "linkStart": null,
-      "skip": false,
+    "endAction": "none",
-      "colour": "",
+    "timerType": "count-down",
-      "type": "event",
+    "countToEnd": false,
-      "revision": 0,
+    "isPublic": true,
-      "id": "32d31",
+    "skip": false,
-      "cue": "SF1.01",
+    "note": "SF1.01",
-      "custom": {
+    "colour": "",
-        "song": "Sekret",
+    "delay": 0,      
-        "artist": "Ronela Hajati"
+    "dayOffset": 0,
-      }
+    "gap": 0,
-    },
+    "cue": "SF1.01",
-    {
+    "revision": 0,
-      "title": "Latvia",
+    "timeWarning": 120000,
-      "note": "SF1.02",
+    "timeDanger": 60000,
-      "endAction": "none",
+    "custom": {
-      "timerType": "count-down",
+      "song": "Sekret",
-      "timeStart": 37500000,
+      "artist": "Ronela Hajati"
-      "timeEnd": 38700000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "21cd2",
-      "cue": "SF1.02",
-      "custom": {
-        "song": "Eat Your Salad",
-        "artist": "Citi Zeni"
-      }
-    },
-    {
-      "title": "Lithuania",
-      "note": "SF1.03",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 39000000,
-      "timeEnd": 40200000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "0b371",
-      "cue": "SF1.03",
-      "custom": {
-        "song": "Sentimentai",
-        "artist": "Monika Liu"
-      }
-    },
-    {
-      "title": "Switzerland",
-      "note": "SF1.04",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 40500000,
-      "timeEnd": 41700000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "3cd28",
-      "cue": "SF1.04",
-      "custom": {
-        "song": "Boys Do Cry",
-        "artist": "Marius Bear"
-      }
-    },
-    {
-      "title": "Slovenia",
-      "note": "SF1.05",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 42000000,
-      "timeEnd": 43200000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "e457f",
-      "cue": "SF1.05",
-      "custom": {
-        "song": "Disko",
-        "artist": "LPS"
-      }
-    },
-    {
-      "title": "Lunch break",
-      "type": "block",
-      "id": "01e85"
-    },
-    {
-      "title": "Ukraine",
-      "note": "SF1.06",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 47100000,
-      "timeEnd": 48300000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "1c420",
-      "cue": "SF1.06",
-      "custom": {
-        "song": "Stefania",
-        "artist": "Kalush Orchestra"
-      }
-    },
-    {
-      "title": "Bulgaria",
-      "note": "SF1.07",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 48600000,
-      "timeEnd": 49800000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "b7737",
-      "cue": "SF1.07",
-      "custom": {
-        "song": "Intention",
-        "artist": "Intelligent Music Project"
-      }
-    },
-    {
-      "title": "Netherlands",
-      "note": "SF1.08",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 50100000,
-      "timeEnd": 51300000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "d3a80",
-      "cue": "SF1.08",
-      "custom": {
-        "song": "De Diepte",
-        "artist": "S10"
-      }
-    },
-    {
-      "title": "Moldova",
-      "note": "SF1.09",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 51600000,
-      "timeEnd": 52800000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "8276c",
-      "cue": "SF1.09",
-      "custom": {
-        "song": "Trenuletul",
-        "artist": "Zdob si Zdub"
-      }
-    },
-    {
-      "title": "Portugal",
-      "note": "SF1.10",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 53100000,
-      "timeEnd": 54300000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "2340b",
-      "cue": "SF1.10",
-      "custom": {
-        "song": "Saudade Saudade",
-        "artist": "Maro"
-      }
-    },
-    {
-      "title": "Afternoon break",
-      "type": "block",
-      "id": "cb90b"
-    },
-    {
-      "title": "Croatia",
-      "note": "SF1.11",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 56100000,
-      "timeEnd": 57300000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "503c4",
-      "cue": "SF1.11",
-      "custom": {
-        "song": "Guilty Pleasure",
-        "artist": "Mia Dimsic"
-      }
-    },
-    {
-      "title": "Denmark",
-      "note": "SF1.12",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 57600000,
-      "timeEnd": 58800000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "5e965",
-      "cue": "SF1.12",
-      "custom": {
-        "song": "The Show",
-        "artist": "Reddi"
-      }
-    },
-    {
-      "title": "Austria",
-      "note": "SF1.13",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 59100000,
-      "timeEnd": 60300000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "bab4a",
-      "cue": "SF1.13",
-      "custom": {
-        "song": "Halo",
-        "artist": "LUM!X & Pia Maria"
-      }
-    },
-    {
-      "title": "Greece",
-      "note": "SF1.14",
-      "endAction": "none",
-      "timerType": "count-down",
-      "timeStart": 60600000,
-      "timeEnd": 61800000,
-      "duration": 1200000,
-      "isPublic": true,
-      "skip": false,
-      "colour": "",
-      "type": "event",
-      "revision": 0,
-      "id": "d3eb1",
-      "cue": "SF1.14",
-      "custom": {
-        "song": "Die Together",
-        "artist": "Amanda Tenfjord"
-      }
     }
-  ],
+  },
+  {
+    "id": "21cd2",
+    "type": "event",
+    "title": "Latvia",
+    "timeStart": 37500000,
+    "timeEnd": 38700000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.02",
+    "colour": "",
+    "delay": 0,    
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.02",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Eat Your Salad",
+      "artist": "Citi Zeni"
+    }
+  },
+  {
+    "id": "0b371",
+    "type": "event",
+    "title": "Lithuania",
+    "timeStart": 39000000,
+    "timeEnd": 40200000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.03",
+    "colour": "",
+    "delay": 0,   
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.03",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Sentimentai",
+      "artist": "Monika Liu"
+    }
+  },
+  {
+    "id": "3cd28",
+    "type": "event",
+    "title": "Switzerland",
+    "timeStart": 40500000,
+    "timeEnd": 41700000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.04",
+    "colour": "",
+    "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.04",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Boys Do Cry",
+      "artist": "Marius Bear"
+    }
+  },
+  {
+    "id": "e457f",
+    "type": "event",
+    "title": "Slovenia",
+    "timeStart": 42000000,
+    "timeEnd": 43200000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.05",
+    "colour": "",
+    "delay": 0,   
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.05",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Disko",
+      "artist": "LPS"
+    }
+  },
+  {
+    "title": "Lunch break",
+    "type": "block",
+    "id": "01e85"
+  },
+  {
+    "id": "1c420",
+    "type": "event",
+    "title": "Ukraine",
+    "timeStart": 47100000,
+    "timeEnd": 48300000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.06",
+    "colour": "",
+    "delay": 0, 
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.06",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Stefania",
+      "artist": "Kalush Orchestra"
+    }
+  },
+  {
+    "id": "b7737",
+    "type": "event",
+    "title": "Bulgaria",
+    "timeStart": 48600000,
+    "timeEnd": 49800000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.07",
+    "colour": "",
+    "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.07",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Intention",
+      "artist": "Intelligent Music Project"
+    }
+  },
+  {
+    "id": "d3a80",
+    "type": "event",
+    "title": "Netherlands",
+    "timeStart": 50100000,
+    "timeEnd": 51300000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.08",
+    "colour": "",
+    "delay": 0,    
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.08",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "De Diepte",
+      "artist": "S10"
+    }
+  },
+  {
+    "id": "8276c",
+    "type": "event",
+    "title": "Moldova",
+    "timeStart": 51600000,
+    "timeEnd": 52800000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.09",
+    "colour": "",
+    "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.09",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Trenuletul",
+      "artist": "Zdob si Zdub"
+    }
+  },
+  {
+    "id": "2340b",
+    "type": "event",
+    "title": "Portugal",
+    "timeStart": 53100000,
+    "timeEnd": 54300000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.10",
+    "colour": "",
+    "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.10",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Saudade Saudade",
+      "artist": "Maro"
+    }
+  },
+  {
+    "title": "Afternoon break",
+    "type": "block",
+    "id": "cb90b"
+  },
+  {
+    "id": "503c4",
+    "type": "event",
+    "title": "Croatia",
+    "timeStart": 56100000,
+    "timeEnd": 57300000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.11",
+    "colour": "",
+    "delay": 0, 
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.11",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Guilty Pleasure",
+      "artist": "Mia Dimsic"
+    }
+  },
+  {
+    "id": "5e965",
+    "type": "event",
+    "title": "Denmark",
+    "timeStart": 57600000,
+    "timeEnd": 58800000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.12",
+    "colour": "",
+    "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.12",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "The Show",
+      "artist": "Reddi"
+    }
+  },
+  {
+    "id": "bab4a",
+    "type": "event",
+    "title": "Austria",
+    "timeStart": 59100000,
+    "timeEnd": 60300000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.13",
+    "colour": "",
+    "delay": 0,    
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.13",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Halo",
+      "artist": "LUM!X & Pia Maria"
+    }
+  },
+  {
+    "id": "d3eb1",
+    "type": "event",
+    "title": "Greece",
+    "timeStart": 60600000,
+    "timeEnd": 61800000,
+    "duration": 1200000,
+    "timeStrategy": "lock-duration",
+    "linkStart": null,
+    "endAction": "none",
+    "timerType": "count-down",
+    "countToEnd": false,
+    "isPublic": true,
+    "skip": false,
+    "note": "SF1.14",
+    "colour": "",
+    "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
+    "cue": "SF1.14",
+    "revision": 0,
+    "timeWarning": 120000,
+    "timeDanger": 60000,
+    "custom": {
+      "song": "Die Together",
+      "artist": "Amanda Tenfjord"
+    }
+  }
+],
   "project": {
     "title": "Eurovision Song Contest",
     "description": "Turin 2022",
     "publicUrl": "www.getontime.no",
     "publicInfo": "Rehearsal Schedule - Turin 2022",
     "backstageUrl": "www.github.com/cpvalente/ontime",
-    "backstageInfo": "Rehearsal Schedule - Turin 2022\nAll performers to wear full costumes for 1st rehearsal"
+    "backstageInfo": "Rehearsal Schedule - Turin 2022\nAll performers to wear full costumes for 1st rehearsal",
+    "projectLogo": null
   },
   "settings": {
     "app": "ontime",
-    "version": "2.0.0",
+    "version": "3.10.2",
     "serverPort": 4001,
     "editorKey": null,
     "operatorKey": null,
@@ -312,10 +425,9 @@
     "overrideStyles": false,
     "normalColor": "#ffffffcc",
     "warningColor": "#FFAB33",
-    "warningThreshold": 120000,
     "dangerColor": "#ED3333",
-    "dangerThreshold": 60000,
+    "endMessage": "",
-    "endMessage": ""
+    "freezeEnd": false
   },
   "urlPresets": [
     {
@@ -335,5 +447,17 @@
   "http": {
     "enabledOut": true,
     "subscriptions": []
+  },
+  "customFields": {
+    "song": {
+      "type": "string",
+      "colour": "",
+      "label": "song"
+    },
+    "artist": {
+      "type": "string",
+      "colour": "",
+      "label": "artist"
+    }
   }
 }

e2e/tests/000-upload-showfile.spec.ts

@@ -61,8 +61,13 @@ test('project file download', async ({ page }) => {
 
   // Wait for the download process to complete and save the downloaded file somewhere.
   await download.saveAs(fileToDownload);
-  await expect(download.failure()).toMatchObject({});
+  expect(download.failure()).toMatchObject({});
+
   const original = JSON.parse(await readFile(fileToUpload, { encoding: 'utf-8' }));
   const fromServer = JSON.parse(await readFile(fileToDownload, { encoding: 'utf-8' }));
-  await expect(original).toEqual(fromServer);
+
+  // when a file is parsed, the server will write the version number to the project file
+  original.settings.version = 'not-important';
+  fromServer.settings.version = 'not-important';
+  expect(original).toMatchObject(fromServer);
 });

e2e/tests/features/211-report-data.spec.ts

@@ -0,0 +1,38 @@
+import { expect, test } from '@playwright/test';
+
+test('show warning when event crosses midnight', async ({ page }) => {
+  await page.goto('http://localhost:4001/editor');
+
+  await page.getByRole('button', { name: 'Clear rundown' }).click();
+  await page.getByRole('button', { name: 'Delete all' }).click();
+
+  await page.getByRole('button', { name: 'Create Event' }).click();
+  await page.getByRole('button', { name: 'Event' }).nth(4).click();
+  await page.getByRole('button', { name: 'Event', exact: true }).nth(1).click();
+  await page.getByTestId('entry-2').getByTestId('lock__end').getByRole('img').click();
+  await page.getByTestId('entry-2').getByTestId('time-input-timeEnd').click();
+  await page.getByTestId('entry-2').getByTestId('time-input-timeEnd').fill('23h');
+  await page.getByTestId('entry-2').getByTestId('time-input-timeEnd').press('Enter');
+  await page.getByTestId('entry-3').getByTestId('time-input-duration').click();
+  await page.getByTestId('entry-3').getByTestId('time-input-duration').fill('2h');
+  await page.getByTestId('entry-3').getByTestId('time-input-duration').press('Enter');
+
+  await expect(page.getByTestId('entry-3').getByTestId('event-warning')).toBeVisible();
+});
+
+test('show warning when event starts next day midnight', async ({ page }) => {
+  await page.goto('http://localhost:4001/editor');
+
+  await page.getByRole('button', { name: 'Clear rundown' }).click();
+  await page.getByRole('button', { name: 'Delete all' }).click();
+
+  await page.getByRole('button', { name: 'Create Event' }).click();
+  await page.getByRole('button', { name: 'Event' }).nth(4).click();
+  await page.getByTestId('entry-2').getByText('E').click();
+  await page.getByTestId('entry-2').getByTestId('time-input-timeEnd').click();
+  await page.getByTestId('entry-2').getByTestId('time-input-timeEnd').fill('0');
+  await page.getByTestId('entry-2').getByTestId('time-input-timeEnd').press('Enter');
+  await page.getByRole('button', { name: 'Event', exact: true }).nth(2).click();
+
+  await expect(page.getByText('(next day)')).toBeVisible();
+});

e2e/tests/fixtures/test-db.json

@@ -17,6 +17,8 @@
     "note": "SF1.01",
     "colour": "",
     "delay": 0,      
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.01",
     "revision": 0,
     "timeWarning": 120000,
@@ -43,6 +45,8 @@
     "note": "SF1.02",
     "colour": "",
     "delay": 0,    
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.02",
     "revision": 0,
     "timeWarning": 120000,
@@ -69,6 +73,8 @@
     "note": "SF1.03",
     "colour": "",
     "delay": 0,   
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.03",
     "revision": 0,
     "timeWarning": 120000,
@@ -95,6 +101,8 @@
     "note": "SF1.04",
     "colour": "",
     "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.04",
     "revision": 0,
     "timeWarning": 120000,
@@ -121,6 +129,8 @@
     "note": "SF1.05",
     "colour": "",
     "delay": 0,   
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.05",
     "revision": 0,
     "timeWarning": 120000,
@@ -152,6 +162,8 @@
     "note": "SF1.06",
     "colour": "",
     "delay": 0, 
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.06",
     "revision": 0,
     "timeWarning": 120000,
@@ -178,6 +190,8 @@
     "note": "SF1.07",
     "colour": "",
     "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.07",
     "revision": 0,
     "timeWarning": 120000,
@@ -204,6 +218,8 @@
     "note": "SF1.08",
     "colour": "",
     "delay": 0,    
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.08",
     "revision": 0,
     "timeWarning": 120000,
@@ -230,6 +246,8 @@
     "note": "SF1.09",
     "colour": "",
     "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.09",
     "revision": 0,
     "timeWarning": 120000,
@@ -256,6 +274,8 @@
     "note": "SF1.10",
     "colour": "",
     "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.10",
     "revision": 0,
     "timeWarning": 120000,
@@ -287,6 +307,8 @@
     "note": "SF1.11",
     "colour": "",
     "delay": 0, 
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.11",
     "revision": 0,
     "timeWarning": 120000,
@@ -313,6 +335,8 @@
     "note": "SF1.12",
     "colour": "",
     "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.12",
     "revision": 0,
     "timeWarning": 120000,
@@ -339,6 +363,8 @@
     "note": "SF1.13",
     "colour": "",
     "delay": 0,    
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.13",
     "revision": 0,
     "timeWarning": 120000,
@@ -365,6 +391,8 @@
     "note": "SF1.14",
     "colour": "",
     "delay": 0,  
+    "dayOffset": 0,
+    "gap": 0,
     "cue": "SF1.14",
     "revision": 0,
     "timeWarning": 120000,

packages/types/src/definitions/core/OntimeEvent.type.ts

@@ -39,6 +39,8 @@ export type OntimeEvent = OntimeBaseEvent & {
   colour: string;
   revision: number;
   delay: number; // calculated at runtime
+  dayOffset: number; // calculated at runtime
+  gap: number; // calculated at runtime
   timeWarning: number;
   timeDanger: number;
   custom: EventCustomFields;

packages/utils/src/date-utils/checkIsNextDay.test.ts

@@ -2,66 +2,51 @@ import { checkIsNextDay } from './checkIsNextDay';
 import { MILLIS_PER_HOUR } from './conversionUtils';
 
 describe('checkIsNextDay', () => {
-  it('returns false if the previous event duration is 0', () => {
+  it('returns false if there is no previous event', () => {
-    const previousStart = 0;
+    const current = { timeStart: 0, dayOffset: 0 };
-    const previousDuration = 0;
+    const previous = undefined;
-    const timeStart = 0;
+    expect(checkIsNextDay(current, previous)).toBeFalsy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeFalsy();
   });
 
   it('returns false if event starts after one before', () => {
-    const previousStart = 10;
+    const current = { timeStart: 11, dayOffset: 0 };
-    const previousDuration = 2;
+    const previous = { timeStart: 10, duration: 2, dayOffset: 0 };
-    const timeStart = 11;
+    expect(checkIsNextDay(current, previous)).toBeFalsy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeFalsy();
   });
 
   it('returns true if event starts after one before', () => {
-    const previousStart = 10;
+    const current = { timeStart: 9, dayOffset: 1 };
-    const previousDuration = 2;
+    const previous = { timeStart: 10, duration: 2, dayOffset: 0 };
-    const timeStart = 9;
+    expect(checkIsNextDay(current, previous)).toBeTruthy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeTruthy();
   });
 
   it('returns true if event starts at the same time as one before', () => {
-    const previousStart = 10;
+    const current = { timeStart: 10, dayOffset: 1 };
-    const previousDuration = 2;
+    const previous = { timeStart: 10, duration: 2, dayOffset: 0 };
-    const timeStart = 10;
+    expect(checkIsNextDay(current, previous)).toBeTruthy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeTruthy();
   });
 
   it('should account for an event that crossed midnight', () => {
-    const previousStart = 20 * MILLIS_PER_HOUR;
+    const current = { timeStart: 1 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const previousDuration = 6 * MILLIS_PER_HOUR; // event finished at 02:00:00
+    const previous = { timeStart: 20 * MILLIS_PER_HOUR, duration: 6 * MILLIS_PER_HOUR, dayOffset: 0 }; // event finished at 02:00:00
-    const timeStart = 1 * MILLIS_PER_HOUR;
+    expect(checkIsNextDay(current, previous)).toBeFalsy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeFalsy();
   });
 
   it('should account for an event that crossed midnight and there is a gap', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
+    const current = { timeStart: 2 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const timeStart = 2 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 23 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 0 }; // event finished at 01:00:00
-    const previousDuration = 2 * MILLIS_PER_HOUR;
+    expect(checkIsNextDay(current, previous)).toBeFalsy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeFalsy();
   });
 
   it('should account for an event that crossed midnight with no overlaps', () => {
-    const previousStart = 20 * MILLIS_PER_HOUR;
+    const current = { timeStart: 19 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const previousDuration = 6 * MILLIS_PER_HOUR; // event finished at 02:00:00
+    const previous = { timeStart: 20 * MILLIS_PER_HOUR, duration: 6 * MILLIS_PER_HOUR, dayOffset: 0 }; // event finished at 02:00:00
-    const timeStart = 19 * MILLIS_PER_HOUR;
+    expect(checkIsNextDay(current, previous)).toBeFalsy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeFalsy();
   });
 
   it('should account for an event that finishes exactly at midnight', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
+    const current = { timeStart: 2 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const previousDuration = 1 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 23 * MILLIS_PER_HOUR, duration: 1 * MILLIS_PER_HOUR, dayOffset: 0 }; // event finished at 24:00:00
-    const timeStart = 2 * MILLIS_PER_HOUR;
+    expect(checkIsNextDay(current, previous)).toBeTruthy();
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeTruthy();
-  });
-
-  it('should account for normalised start over multiple days', () => {
-    const previousStart = 90000000; // 25:00:00
-    const previousDuration = 1 * MILLIS_PER_HOUR;
-    const timeStart = 0;
-    expect(checkIsNextDay(previousStart, timeStart, previousDuration)).toBeTruthy();
   });
 });

packages/utils/src/date-utils/checkIsNextDay.ts

@@ -1,41 +1,27 @@
+import type { OntimeEvent } from 'ontime-types';
+
 import { dayInMs } from './conversionUtils.js';
 
 /**
  * Utility function checks whether a given event is the day after from its predecessor
- * We consider an event to be the day after, if it begins before the start of the previous
- * @example day after
- * 09:00 - 10:00
- * 08:00 - 10:30
- * @example day after
- * 23:00 - 00:00
- * 02:00 - 03:00
- * @example same day
- * 09:00 - 10:00
- * 09:30 - 10:30
- * @example same day, but previous crosses midnight
- * 23:00 - 01:00
- * 02:00 - 03:00
- * @example same day, but previous crosses midnight (with overlap)
- * 22:00 - 02:00
- * 01:00 - 03:00
  */
-export function checkIsNextDay(previousStart: number, timeStart: number, previousDuration: number): boolean {
+export function checkIsNextDay(
-  if (previousDuration === 0) {
+  current: Pick<OntimeEvent, 'timeStart' | 'dayOffset'>,
+  previous?: Pick<OntimeEvent, 'timeStart' | 'duration' | 'dayOffset'>,
+): boolean {
+  if (!previous) {
     return false;
   }
 
-  const cappedStart = previousStart % dayInMs;
+  // if the day offsets are the same it can't be the next day
-  if (timeStart <= cappedStart) {
+  if (current.dayOffset <= previous.dayOffset) {
-    const normalisedPreviousEnd = cappedStart + previousDuration;
+    return false;
-    if (normalisedPreviousEnd === dayInMs) {
-      return true;
-    }
-    // handle exception for an event that finishes exactly at midnight
-    if (normalisedPreviousEnd > dayInMs) {
-      return false;
-    }
-    return true;
   }
 
-  return false;
+  // if the previous event crossed midnight then the current is the same day
+  if (previous.timeStart + previous.duration > dayInMs) {
+    return false;
+  }
+
+  return true;
 }

packages/utils/src/date-utils/getTimeFromPrevious.test.ts

@@ -1,64 +1,58 @@
-import { dayInMs, MILLIS_PER_HOUR } from './conversionUtils';
+import { dayInMs, MILLIS_PER_HOUR, MILLIS_PER_MINUTE } from './conversionUtils';
 import { getTimeFromPrevious } from './getTimeFromPrevious';
 
 describe('getTimeFromPrevious', () => {
   it('returns the time elapsed (gap or overlap) from the previous', () => {
-    const previousStart = 69600000; // 19:20
-    const previousEnd = 71700000; // 19:55
-    const previousDuration = 2100000; // 35 minutes
-    const currentStart = 75600000; // 21:00
     const expected = 75600000 - 71700000; // current start - previousEnd
-
+    expect(
-    expect(getTimeFromPrevious(currentStart, previousStart, previousEnd, previousDuration)).toBe(expected);
+      getTimeFromPrevious(
+        { timeStart: 21 * MILLIS_PER_HOUR, dayOffset: 0 },
+        { timeStart: 19 * MILLIS_PER_HOUR + 20 * MILLIS_PER_MINUTE, duration: 35 * MILLIS_PER_MINUTE, dayOffset: 0 },
+      ),
+    ).toBe(expected);
   });
 
   it('accounts for partially overlapping events', () => {
-    const previousStart = 10;
+    const expected = -1;
-    const previousEnd = 12;
+    expect(getTimeFromPrevious({ timeStart: 11, dayOffset: 0 }, { timeStart: 10, duration: 2, dayOffset: 0 })).toBe(
-    const previousDuration = 2;
+      expected,
-    const currentStart = 11;
+    );
-    const expected = -(previousEnd - currentStart);
-
-    expect(getTimeFromPrevious(currentStart, previousStart, previousEnd, previousDuration)).toBe(expected);
   });
 
   it('accounts for events that are fully contained', () => {
-    const previousStart = 8;
+    const expected = -6;
-    const previousEnd = 16;
+    expect(getTimeFromPrevious({ timeStart: 10, dayOffset: 0 }, { timeStart: 8, duration: 8, dayOffset: 0 })).toBe(
-    const previousDuration = 8;
+      expected,
-    const currentStart = 10;
+    );
-    const expected = -(previousEnd - currentStart);
-
-    expect(getTimeFromPrevious(currentStart, previousStart, previousEnd, previousDuration)).toBe(expected);
   });
 
   it('fully overlapping events are the next day', () => {
-    const previousStart = 10 * MILLIS_PER_HOUR;
+    const expected = dayInMs - 2 * MILLIS_PER_HOUR;
-    const previousEnd = 12 * MILLIS_PER_HOUR;
+    expect(
-    const previousDuration = previousEnd - previousStart;
+      getTimeFromPrevious(
-    const currentStart = 10 * MILLIS_PER_HOUR;
+        { timeStart: 10 * MILLIS_PER_HOUR, dayOffset: 1 },
-    const expected = dayInMs - previousDuration;
+        { timeStart: 10 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 0 },
-
+      ),
-    expect(getTimeFromPrevious(currentStart, previousStart, previousEnd, previousDuration)).toBe(expected);
+    ).toBe(expected);
   });
 
   it('accounts for events that are the day after', () => {
-    const previousStart = 20 * MILLIS_PER_HOUR;
-    const previousEnd = 23 * MILLIS_PER_HOUR;
-    const previousDuration = 3 * MILLIS_PER_HOUR;
-    const currentStart = 22 * MILLIS_PER_HOUR;
     const expected = -MILLIS_PER_HOUR; // (previousEnd - currentStart);
-
+    expect(
-    expect(getTimeFromPrevious(currentStart, previousStart, previousEnd, previousDuration)).toBe(expected);
+      getTimeFromPrevious(
+        { timeStart: 22 * MILLIS_PER_HOUR, dayOffset: 0 },
+        { timeStart: 20 * MILLIS_PER_HOUR, duration: 3 * MILLIS_PER_HOUR, dayOffset: 0 },
+      ),
+    ).toBe(expected);
   });
 
   it('accounts for events that cross midnight', () => {
-    const previousStart = 20 * MILLIS_PER_HOUR;
-    const previousEnd = 2 * MILLIS_PER_HOUR;
-    const previousDuration = 6 * MILLIS_PER_HOUR;
-    const currentStart = 1 * MILLIS_PER_HOUR;
     const expected = -MILLIS_PER_HOUR; // (previousEnd - currentStart);
-
+    expect(
-    expect(getTimeFromPrevious(currentStart, previousStart, previousEnd, previousDuration)).toBe(expected);
+      getTimeFromPrevious(
+        { timeStart: 1 * MILLIS_PER_HOUR, dayOffset: 1 },
+        { timeStart: 20 * MILLIS_PER_HOUR, duration: 6 * MILLIS_PER_HOUR, dayOffset: 0 },
+      ),
+    ).toBe(expected);
   });
 });

packages/utils/src/date-utils/getTimeFromPrevious.ts

@@ -1,45 +1,33 @@
-import { checkIsNextDay } from './checkIsNextDay.js';
+import type { OntimeEvent } from 'ontime-types';
+
 import { dayInMs } from './conversionUtils.js';
 
 /**
- * Utility returns the time elapsed (gap or overlap) from the previous
+ * Utility returns the gap from previous event
- * It uses deconstructed parameters to simplify implementation in UI
  */
 export function getTimeFromPrevious(
-  currentStart: number,
+  current: Pick<OntimeEvent, 'timeStart' | 'dayOffset'>,
-  previousStart?: number,
+  previous?: Pick<OntimeEvent, 'timeStart' | 'duration' | 'dayOffset'>,
-  previousEnd?: number,
-  previousDuration?: number,
 ): number {
   // there is no previous event
-  if (previousStart === undefined || previousEnd === undefined || previousDuration === undefined) {
+  if (!previous) {
     return 0;
   }
 
+  const normalisedCurrentStart = current.timeStart + current.dayOffset * dayInMs;
+  const normalisedPreviousEnd = previous.timeStart + previous.duration + previous.dayOffset * dayInMs;
+
   // event is linked to previous
-  if (currentStart === previousEnd) {
+  if (normalisedCurrentStart === normalisedPreviousEnd) {
     return 0;
   }
 
-  // event is the day after
-  if (checkIsNextDay(previousStart, currentStart, previousDuration)) {
-    // time from previous is difference between normalised start and previous end
-    return currentStart + dayInMs - previousEnd;
-  }
-
   // event has a gap from previous
-  if (currentStart > previousEnd) {
+  if (normalisedCurrentStart > normalisedPreviousEnd) {
     // time from previous is difference between start and previous end
-    return currentStart - previousEnd;
+    return normalisedCurrentStart - normalisedPreviousEnd;
   }
 
   // event overlaps with previous
-  const overlap = previousEnd - currentStart;
+  return normalisedCurrentStart - normalisedPreviousEnd;
-  if (overlap > 0) {
-    // time is a negative number indicating the amount of overlap
-    return -overlap;
-  }
-
-  // we need to make sure we return a number, but there are no business cases for this
-  return 0;
 }

packages/utils/src/date-utils/isNewLatest.test.ts

@@ -1,48 +1,52 @@
-import { MILLIS_PER_HOUR } from './conversionUtils';
+import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE } from './conversionUtils';
 import { isNewLatest } from './isNewLatest';
 
 describe('isNewLatest', () => {
   it('should be true if there is no previous', () => {
-    expect(isNewLatest(0, 60000)).toBeTruthy();
+    const current = { timeStart: 0, duration: MILLIS_PER_HOUR, dayOffset: 0 };
+    const previous = undefined;
+    expect(isNewLatest(current, previous)).toBe(true);
+  });
+
+  it('should be false if current is contained in the previous', () => {
+    const current = {
+      timeStart: 21 * MILLIS_PER_HOUR + 10 * MILLIS_PER_MINUTE,
+      duration: 10 * MILLIS_PER_MINUTE,
+      dayOffset: 0,
+    };
+    const previous = { timeStart: 21 * MILLIS_PER_HOUR, duration: MILLIS_PER_HOUR, dayOffset: 0 };
+
+    expect(isNewLatest(current, previous)).toBe(false);
   });
 
   it('should be true if it starts when the previous finishes', () => {
-    const nowStart = 10 * MILLIS_PER_HOUR;
+    const current = { timeStart: 10 * MILLIS_PER_HOUR, duration: MILLIS_PER_HOUR, dayOffset: 0 };
-    const nowEnd = 11 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 9 * MILLIS_PER_HOUR, duration: MILLIS_PER_HOUR, dayOffset: 0 };
-    const previousStart = 9 * MILLIS_PER_HOUR;
+    expect(isNewLatest(current, previous)).toBe(true);
-    const previousEnd = 10 * MILLIS_PER_HOUR;
-    expect(isNewLatest(nowStart, nowEnd, previousStart, previousEnd)).toBeTruthy();
   });
 
   it('should be true if it starts the same day the previous finishes', () => {
-    const nowStart = 22 * MILLIS_PER_HOUR;
+    const current = { timeStart: 22 * MILLIS_PER_HOUR, duration: MILLIS_PER_HOUR, dayOffset: 0 };
-    const nowEnd = 23 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 9 * MILLIS_PER_HOUR, duration: MILLIS_PER_HOUR, dayOffset: 0 };
-    const previousStart = 9 * MILLIS_PER_HOUR;
+    expect(isNewLatest(current, previous)).toBe(true);
-    const previousEnd = 20 * MILLIS_PER_HOUR;
-    expect(isNewLatest(nowStart, nowEnd, previousStart, previousEnd)).toBeTruthy();
   });
 
   it('should be true if it finishes after the previous, accounting for passing midnight', () => {
-    const nowStart = 1 * MILLIS_PER_HOUR;
+    const current = { timeStart: 1 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const nowEnd = 3 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 23 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 0 };
-    const previousStart = 23 * MILLIS_PER_HOUR;
+
-    const previousEnd = 2 * MILLIS_PER_HOUR;
+    expect(isNewLatest(current, previous)).toBe(true);
-    expect(isNewLatest(nowStart, nowEnd, previousStart, previousEnd)).toBeTruthy();
   });
 
   it('should be true if it the next day', () => {
-    const nowStart = 8 * MILLIS_PER_HOUR;
+    const current = { timeStart: 8 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const nowEnd = 10 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 9 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 0 };
-    const previousStart = 9 * MILLIS_PER_HOUR;
+    expect(isNewLatest(current, previous)).toBe(true);
-    const previousEnd = 11 * MILLIS_PER_HOUR;
-    expect(isNewLatest(nowStart, nowEnd, previousStart, previousEnd)).toBeTruthy();
   });
 
   it('should be true if it the next day (2)', () => {
-    const nowStart = 9 * MILLIS_PER_HOUR;
+    const current = { timeStart: 9 * MILLIS_PER_HOUR, duration: 2 * MILLIS_PER_HOUR, dayOffset: 1 };
-    const nowEnd = 11 * MILLIS_PER_HOUR;
+    const previous = { timeStart: 9 * MILLIS_PER_HOUR, duration: 11 * MILLIS_PER_HOUR, dayOffset: 0 };
-    const previousStart = 9 * MILLIS_PER_HOUR;
+    expect(isNewLatest(current, previous)).toBe(true);
-    const previousEnd = 11 * MILLIS_PER_HOUR;
-    expect(isNewLatest(nowStart, nowEnd, previousStart, previousEnd)).toBeTruthy();
   });
 });

packages/utils/src/date-utils/isNewLatest.ts

@@ -1,24 +1,21 @@
-import { checkIsNextDay } from './checkIsNextDay.js';
+import type { OntimeEvent } from 'ontime-types';
+
+import { dayInMs } from './conversionUtils.js';
 
 /**
  * Checks whether a new element is the latest in the list
  */
-export function isNewLatest(timeStart: number, timeEnd: number, previousStart?: number, previousEnd?: number): boolean {
+export function isNewLatest(
+  currentEvent: Pick<OntimeEvent, 'timeStart' | 'duration' | 'dayOffset'>,
+  previousEvent?: Pick<OntimeEvent, 'timeStart' | 'duration' | 'dayOffset'>,
+) {
   // true if there is no previous
-  if (previousStart === undefined || previousEnd === undefined) {
+  if (!previousEvent) {
     return true;
   }
 
-  // true if it starts after the previous is finished
+  const normalisedCurrentEnd = currentEvent.timeStart + currentEvent.duration + currentEvent.dayOffset * dayInMs;
-  if (timeStart >= previousEnd) {
+  const normalisedPreviousEnd = previousEvent.timeStart + previousEvent.duration + previousEvent.dayOffset * dayInMs;
-    return true;
-  }
 
-  // true if it finishes later than previous
+  return normalisedCurrentEnd >= normalisedPreviousEnd;
-  if (timeEnd > previousEnd) {
-    return true;
-  }
-
-  // true if it is the day after
-  return checkIsNextDay(previousStart, timeStart, previousEnd - previousStart);
 }