refactor: clone events fully copies data

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

@@ -1,10 +1,10 @@
-import { EndAction, EventCustomFields, OntimeEvent, SupportedEvent, TimerType } from 'ontime-types';
+import { EndAction, EventCustomFields, OntimeEvent, SupportedEvent, TimerType, TimeStrategy } from 'ontime-types';
 
 import { cloneEvent } from '../eventsManager';
 
 describe('cloneEvent()', () => {
   it('creates a stem from a given event', () => {
-    const original = {
+    const original: OntimeEvent = {
       id: 'unique',
       type: SupportedEvent.Event,
       title: 'title',
@@ -14,6 +14,9 @@ describe('cloneEvent()', () => {
       duration: 10,
       timeEnd: 10,
       timerType: TimerType.CountDown,
+      timeStrategy: TimeStrategy.LockEnd,
+      linkStart: null,
+      countToEnd: false,
       endAction: EndAction.None,
       isPublic: false,
       skip: false,
@@ -21,29 +24,39 @@ describe('cloneEvent()', () => {
       revision: 10,
       timeWarning: 120000,
       timeDanger: 60000,
+      delay: 0,
+      dayOffset: 0,
+      gap: 0,
       custom: {
         lighting: '3',
       } as EventCustomFields,
-    } as OntimeEvent;
+    };
 
     const cloned = cloneEvent(original);
     expect(cloned).not.toBe(original);
-    // @ts-expect-error -- safeguarding this
+    expect(cloned.custom).not.toBe(original.custom);
-    expect(cloned?.id).toBe(undefined);
+
-    expect(cloned.title).toBe(original.title);
+    expect(cloned).toMatchObject({
-    expect(cloned.note).toBe(original.note);
+      type: SupportedEvent.Event,
-    expect(cloned.endAction).toBe(original.endAction);
+      title: original.title,
-    expect(cloned.timerType).toBe(original.timerType);
+      note: original.note,
-    expect(cloned.timeStart).toBe(original.timeStart);
+      timeStart: original.timeStart,
-    expect(cloned.timeEnd).toBe(original.timeEnd);
+      duration: original.duration,
-    expect(cloned.duration).toBe(original.duration);
+      timeEnd: original.timeEnd,
-    expect(cloned.isPublic).toBe(original.isPublic);
+      timerType: original.timerType,
-    expect(cloned.skip).toBe(original.skip);
+      timeStrategy: original.timeStrategy,
-    expect(cloned.colour).toBe(original.colour);
+      countToEnd: original.countToEnd,
-    expect(cloned.type).toBe(SupportedEvent.Event);
+      linkStart: original.linkStart,
-    expect(cloned.revision).toBe(0);
+      endAction: original.endAction,
-    expect(cloned.timeWarning).toBe(original.timeWarning);
+      isPublic: original.isPublic,
-    expect(cloned.timeDanger).toBe(original.timeDanger);
+      skip: original.skip,
-    expect(cloned.custom).toStrictEqual({});
+      colour: original.colour,
+      revision: 0,
+      delay: original.delay,
+      dayOffset: original.dayOffset,
+      gap: 0,
+      timeWarning: original.timeWarning,
+      timeDanger: original.timeDanger,
+    });
   });
 });

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

@@ -24,11 +24,11 @@ export const cloneEvent = (event: OntimeEvent): ClonedEvent => {
     skip: event.skip,
     colour: event.colour,
     revision: 0,
-    delay: 0,
+    delay: event.delay, // the events will be collocated, so having the same metadata is a good start
-    dayOffset: 0,
+    dayOffset: event.dayOffset,
     gap: 0,
     timeWarning: event.timeWarning,
     timeDanger: event.timeDanger,
-    custom: {},
+    custom: { ...event.custom },
   };
 };