add relevantBlock function

apps/client/src/common/hooks/useSocket.ts

@@ -115,6 +115,7 @@ export const setAuxTimer = {
 export const useCuesheet = () => {
  const featureSelector = (state: RuntimeStore) => ({
  playback: state.timer.playback,
+ currentBlockId: state.blockState.block?.id ?? null,
  selectedEventId: state.eventNow?.id ?? null,
  selectedEventIndex: state.runtime.selectedEventIndex,
  numEvents: state.runtime.numEvents,

apps/client/src/common/stores/runtime.ts

@@ -38,6 +38,10 @@ export const runtimeStorePlaceholder: RuntimeStore = {
  actualStart: null,
  expectedEnd: null,
  },
+ blockState: {
+ block: null,
+ startedAt: null,
+ },
  eventNow: null,
  eventNext: null,
  publicEventNow: null,

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

@@ -150,6 +150,12 @@ export const connectSocket = () => {
  updateDevTools({ eventNow: payload });
  break;
  }
+ case 'ontime-blockState': {
+ console.log(payload)
+ patchRuntime('blockState', payload);
+ updateDevTools({ blockState: payload });
+ break;
+ }
  case 'ontime-publicEventNow': {
  patchRuntime('publicEventNow', payload);
  updateDevTools({ publicEventNow: payload });

apps/client/src/features/cuesheet/Cuesheet.tsx

@@ -21,11 +21,11 @@ interface CuesheetProps {
  columns: ColumnDef<OntimeRundownEntry>[];
  handleUpdate: (rowIndex: number, accessor: keyof OntimeRundownEntry, payload: unknown) => void;
  selectedId: string | null;
+ currentBlockId: string | null;
 }
 
-export default function Cuesheet({ data, columns, handleUpdate, selectedId }: CuesheetProps) {
+export default function Cuesheet({ data, columns, handleUpdate, selectedId, currentBlockId }: CuesheetProps) {
  const { followSelected, showSettings, showDelayBlock, showPrevious, showIndexColumn } = useCuesheetSettings();
-
  const {
  columnVisibility,
  columnOrder,
@@ -91,6 +91,7 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId }: Cu
 
  let eventIndex = 0;
  let isPast = Boolean(selectedId);
+ console.log(currentBlockId);
 
  return (
  <>
@@ -114,11 +115,16 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId }: Cu
  }
 
  if (isOntimeBlock(row.original)) {
+ if (isPast && !showPrevious && key !== currentBlockId) {
+ return null;
+ }
  return <BlockRow key={key} title={row.original.title} />;
  }
  if (isOntimeDelay(row.original)) {
+ if (isPast && !showPrevious) {
+ return null;
+ }
  const delayVal = row.original.duration;
-
  if (!showDelayBlock || delayVal === 0) {
  return null;
  }
@@ -128,9 +134,6 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId }: Cu
  if (isOntimeEvent(row.original)) {
  eventIndex++;
  const isSelected = key === selectedId;
- if (isSelected) {
- isPast = false;
- }
 
  if (isPast && !showPrevious) {
  return null;

apps/client/src/features/cuesheet/CuesheetWrapper.tsx

@@ -107,6 +107,7 @@ export default function CuesheetWrapper() {
  columns={columns}
  handleUpdate={handleUpdate}
  selectedId={featureData.selectedEventId}
+ currentBlockId={featureData.currentBlockId}
  />
  </div>
  );

apps/server/src/app.ts

@@ -179,6 +179,10 @@ export const startServer = async (
  message: messageService.getState(),
  runtime: state.runtime,
  eventNow: state.eventNow,
+ blockState: {
+ block: null,
+ startedAt: null,
+ },
  publicEventNow: state.publicEventNow,
  eventNext: state.eventNext,
  publicEventNext: state.publicEventNext,

apps/server/src/services/TimerService.ts

@@ -1,4 +1,4 @@
-import { OntimeEvent } from 'ontime-types';
+import { OntimeEvent, OntimeRundown } from 'ontime-types';
 
 import * as runtimeState from '../stores/runtimeState.js';
 import type { UpdateResult } from '../stores/runtimeState.js';
@@ -96,8 +96,8 @@ export class TimerService {
  * Loads roll information into timer service
  * @param {OntimeEvent[]} rundown -- list of events to run
  */
- roll(rundown: OntimeEvent[]) {
- runtimeState.roll(rundown);
+ roll(playableEvents: OntimeEvent[], rundown: OntimeRundown) {
+ runtimeState.roll(playableEvents, rundown);
  }
 
  shutdown() {

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

@@ -28,6 +28,7 @@ import {
  getNextEventWithCue,
  getEventWithId,
  getPlayableEvents,
+ getRundown,
 } from '../rundown-service/rundownUtils.js';
 import { integrationService } from '../integration-service/IntegrationService.js';
 import { getForceUpdate, getShouldClockUpdate, getShouldTimerUpdate } from './rundownService.utils.js';
@@ -100,8 +101,9 @@ class RuntimeService {
 
  if (shouldCallRoll) {
  // we dont call this.roll because we need to bypass the checks
- const rundown = getPlayableEvents();
- this.eventTimer.roll(rundown);
+ const playableEvents = getPlayableEvents();
+ const rundown = getRundown();
+ this.eventTimer.roll(playableEvents, rundown);
  }
 
  const timerPhaseChanged = RuntimeService.previousState.timer?.phase !== newState.timer.phase;
@@ -233,7 +235,8 @@ class RuntimeService {
  if (onlyChangedNow) {
  runtimeState.reload(eventNow);
  } else {
- runtimeState.reloadAll(eventNow, playableEvents);
+ const rundown = getRundown();
+ runtimeState.reloadAll(eventNow, playableEvents, rundown);
  }
  return;
  }
@@ -257,8 +260,9 @@ class RuntimeService {
  return false;
  }
 
- const timedEvents = getPlayableEvents();
- const success = runtimeState.load(event, timedEvents);
+ const playableEvents = getPlayableEvents();
+ const rundown = getRundown();
+ const success = runtimeState.load(event, playableEvents, rundown);
 
  if (success) {
  logger.info(LogOrigin.Playback, `Loaded event with ID ${event.id}`);
@@ -507,7 +511,9 @@ class RuntimeService {
  return;
  }
 
- this.eventTimer.roll(playableEvents);
+ const rundown = getRundown();
+
+ this.eventTimer.roll(playableEvents, rundown);
 
  const state = runtimeState.getState();
  const newState = state.timer.playback;
@@ -537,8 +543,9 @@ class RuntimeService {
  return;
  }
 
- const timedEvents = getPlayableEvents();
- runtimeState.resume(restorePoint, event, timedEvents);
+ const playableEvents = getPlayableEvents();
+ const rundown = getRundown();
+ runtimeState.resume(restorePoint, event, playableEvents, rundown);
  logger.info(LogOrigin.Playback, 'Resuming playback');
  }
 
@@ -600,6 +607,10 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
  updateEventIfChanged('eventNext', state);
  updateEventIfChanged('publicEventNext', state);
 
+ if (!deepEqual(RuntimeService?.previousState.blockState, state.blockState)) {
+ eventStore.set('blockState', state.blockState);
+ }
+
  if (shouldUpdateClock) {
  RuntimeService.previousClockUpdate = state.clock;
  eventStore.set('clock', state.clock);

apps/server/src/stores/__tests__/runtimeState.test.ts

@@ -94,11 +94,12 @@ describe('mutation on runtimeState', () => {
  });
  test('normal playback cycle', () => {
  // 1. Load event
- load(mockEvent, [mockEvent]);
+ load(mockEvent, [mockEvent], [mockEvent]);
  let newState = getState();
  expect(newState.eventNow?.id).toBe(mockEvent.id);
  expect(newState.timer.playback).toBe(Playback.Armed);
  expect(newState.clock).not.toBe(666);
+ expect(newState.blockState.block).toBeNull();
 
  // 2. Start event
  let success = start();
@@ -163,11 +164,12 @@ describe('mutation on runtimeState', () => {
  initRundown([event1, event2], {});
  test('runtime offset', () => {
  // 1. Load event
- load(event1, [event1, event2]);
+ load(event1, [event1, event2], [event1, event2]);
  let newState = getState();
  expect(newState.runtime.actualStart).toBeNull();
  expect(newState.runtime.plannedStart).toBe(0);
  expect(newState.runtime.plannedEnd).toBe(1500);
+ expect(newState.blockState.block).toBeNull();
 
  // 2. Start event
  start();
@@ -182,7 +184,7 @@ describe('mutation on runtimeState', () => {
  expect(newState.runtime.expectedEnd).toBe(event2.timeEnd - newState.runtime.offset);
 
  // 3. Next event
- load(event2, [event1, event2]);
+ load(event2, [event1, event2], [event1, event2]);
  start();
 
  newState = getState();
@@ -199,6 +201,7 @@ describe('mutation on runtimeState', () => {
  expect(newState.runtime.offset).toBe(delayBefore);
  // finish is the difference between the runtime and the schedule
  expect(newState.runtime.expectedEnd).toBe(event2.timeEnd - newState.runtime.offset);
+ expect(newState.blockState.block).toBeNull();
 
  // 4. Add time
  addTime(10);