Skip fixes (#805)

* refactor: resolve current in time-to-end

* refactor: recalculate on skip

* Alpha tweaks (#806)

* style: small tweaks to interface

* refactor: simplify quick add

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

@@ -68,7 +68,7 @@ export async function addEvent(
 
   notifyChanges({ timer: [newEvent.id], external: true });
 
-  // notify runtime that rundown size has changed
+  // notify runtime that rundown has changed
   updateRuntimeOnChange();
 
   return newEvent;
@@ -84,7 +84,7 @@ export async function deleteEvent(eventId: string) {
 
   notifyChanges({ timer: [eventId], external: true });
 
-  // notify event loader that rundown size has changed
+  // notify event loader that rundown has changed
   updateRuntimeOnChange();
 }
 
@@ -114,6 +114,9 @@ export async function editEvent(patch: Partial<OntimeEvent> | Partial<OntimeBloc
 
   notifyChanges({ timer: [patch.id], external: true });
 
+  // notify event loader that rundown has changed
+  updateRuntimeOnChange();
+
   return newEvent;
 }
 
@@ -127,6 +130,9 @@ export async function batchEditEvents(ids: string[], data: Partial<OntimeEvent>)
   await scopedMutation({ patch: data, eventIds: ids });
 
   notifyChanges({ timer: ids, external: true });
+
+  // notify event loader that rundown has changed
+  updateRuntimeOnChange();
 }
 
 /**
@@ -141,6 +147,9 @@ export async function reorderEvent(eventId: string, from: number, to: number) {
 
   notifyChanges({ timer: true, external: true });
 
+  // notify event loader that rundown has changed
+  updateRuntimeOnChange();
+
   return reorderedItem;
 }
 
@@ -162,6 +171,9 @@ export async function swapEvents(from: string, to: string) {
   await scopedMutation({ fromId: from, toId: to });
 
   notifyChanges({ timer: true, external: true });
+
+  // notify event loader that rundown has changed
+  updateRuntimeOnChange();
 }
 
 /**
@@ -169,7 +181,8 @@ export async function swapEvents(from: string, to: string) {
  * Called when we make changes to the rundown object
  */
 function updateRuntimeOnChange() {
-  updateRundownData(getPlayableEvents());
+  // schedule an update for the end of the event loop
+  setImmediate(() => updateRundownData(getPlayableEvents()));
 }
 
 /**
@@ -180,10 +193,8 @@ export function notifyChanges(options: { timer?: boolean | string[]; external?:
     const playableEvents = getPlayableEvents();
     // notify timer service of changed events
     // timer can be true or an array of changed IDs
-    if (Array.isArray(options.timer)) {
-      runtimeService.maybeUpdate(playableEvents, options.timer);
-    }
-    runtimeService.maybeUpdate(playableEvents);
+    const affected = Array.isArray(options.timer) ? options.timer : undefined;
+    runtimeService.maybeUpdate(playableEvents, affected);
   }
 
   if (options.external) {

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

@@ -8,7 +8,7 @@ export function getLink(currentIndex: number, rundown: OntimeRundown): OntimeEve
   // currently the link is the previous event
   for (let i = currentIndex - 1; i >= 0; i--) {
     const event = rundown[i];
-    if (isOntimeEvent(event)) {
+    if (isOntimeEvent(event) && !event.skip) {
       return event;
     }
   }

apps/server/src/services/runtime-service/RuntimeService.ts

@@ -147,13 +147,13 @@ class RuntimeService {
    */
   maybeUpdate(playableEvents: OntimeEvent[], affectedIds?: string[]) {
     const state = runtimeState.getState();
-    const hasLoadedElements = state.eventNow || state.eventNext;
+    const hasLoadedElements = state.eventNow !== null || state.eventNext !== null;
     if (!hasLoadedElements) {
       return;
     }
 
     // we need to reload in a few scenarios:
-    // 1. we are not confident that changes do not affect running event
+    // 1. we are not confident that changes do not affect running event (eg. all events where changed)
     const safeOption = typeof affectedIds === 'undefined';
     // 2. the edited event is in memory (now or next) running
     const eventInMemory = safeOption ? false : this.affectsLoaded(affectedIds);
@@ -166,15 +166,18 @@ class RuntimeService {
       }
       // load stuff again, but keep running if our events still exist
       const eventNow = getEventWithId(state.eventNow.id);
-      if (eventNow) {
+      const onlyChangedNow = affectedIds?.length === 1 && affectedIds.at(0) === eventNow.id;
+      if (onlyChangedNow) {
         runtimeState.reload(eventNow);
+      } else {
+        runtimeState.reloadAll(eventNow, playableEvents);
       }
       return;
     }
 
+    // Maybe the event will become the next
     isNext = this.isNewNext();
     if (isNext) {
-      // TODO: do i need to load here?
       runtimeState.loadNext(playableEvents);
     }
   }