V2 beta1 (#326)

* style: labels on added time

* style: remove mentions of PiP

* refactor: unify usage of ms for timers

* refactor: create events with 0 duration

* style: several small tweaks

* refactor: keep block when applying delays

* feat: blocks have titles

* style: improvements in time entry warnings

* style: override progress bar styles

* style: prevent overflow

* feat: show character count in editor

* refactor: provide initial payload

* refactor: lower test boundary

* refactor: get colour from swatches

* style: rename title block

* chore: version bump

apps/server/src/adapters/WebsocketAdapter.ts

@@ -112,7 +112,7 @@ export class SocketServer implements IAdapter {
   }
 
   // message is any serializable value
-  send(message: unknown) {
+  sendAsJson(message: unknown) {
     this.wss?.clients.forEach((client) => {
       if (client !== this.wss && client.readyState === WebSocket.OPEN) {
         client.send(JSON.stringify(message));

apps/server/src/adapters/websocketAux.ts

@@ -5,7 +5,7 @@ import { socket } from './WebsocketAdapter.js';
  * @param payload -- possible patch payload
  */
 export function sendRefetch(payload: any | null = null) {
-  socket.send({
+  socket.sendAsJson({
     type: 'ontime-refetch',
     payload,
   });

apps/server/src/app.ts

@@ -30,6 +30,7 @@ import { integrationService } from './services/integration-service/IntegrationSe
 import { logger } from './classes/Logger.js';
 import { oscIntegration } from './services/integration-service/OscIntegration.js';
 import { populateStyles } from './modules/loadStyles.js';
+import { eventStore, getInitialPayload } from './stores/EventStore.js';
 
 console.log(`Starting Ontime version ${ONTIME_VERSION}`);
 
@@ -132,7 +133,10 @@ export const startServer = async () => {
   expressServer = http.createServer(app);
 
   socket.init(expressServer);
+
+  // provide initial payload to event store
   eventLoader.init();
+  eventStore.init(getInitialPayload());
 
   expressServer.listen(serverPort, '0.0.0.0');
 

apps/server/src/classes/Logger.ts

@@ -39,7 +39,7 @@ class Logger {
     }
 
     try {
-      socket.send({
+      socket.sendAsJson({
         type: 'ontime-log',
         payload: log,
       });

apps/server/src/classes/data-provider/DataProvider.ts

@@ -2,7 +2,7 @@
  * Class Event Provider is a mediator for handling the local db
  * and adds logic specific to ontime data
  */
-import { EventData, ViewSettings } from 'ontime-types';
+import { EventData, SupportedEvent, ViewSettings } from 'ontime-types';
 
 import { data, db } from '../../modules/loadDb.js';
 import { safeMerge } from './DataProvider.utils.js';
@@ -35,7 +35,9 @@ export class DataProvider {
     const eventIndex = data.rundown.findIndex((e) => e.id === eventId);
     const persistedEvent = data.rundown[eventIndex];
     const newEvent = { ...persistedEvent, ...newData };
-    newEvent.revision++;
+    if (newEvent.type === SupportedEvent.Event) {
+      newEvent.revision++;
+    }
     data.rundown[eventIndex] = newEvent;
     await this.persist();
     return data.rundown[eventIndex];

apps/server/src/classes/event-loader/EventLoader.ts

@@ -24,9 +24,9 @@ export class EventLoader {
     instance = this;
   }
 
+  // we need to delay init until the store is ready
   init() {
-    this.reset();
-    this.loadedEvent = null;
+    this.reset(false);
   }
 
   /**

apps/server/src/external/styles/override.css

@@ -2,12 +2,14 @@
   --background-color-override: #ececec;
   --color-override: #101010;
   --secondary-color-override: #404040;
-  --accent-color-override: #FA5656;
+  --accent-color-override: #fa5656;
   --label-color-override: #6c6c6c;
   --timer-color-override: #202020;
-  --card-background-color-override: #FFF;
+  --card-background-color-override: #fff;
   --font-family-override: "Open Sans";
   --font-family-bold-override: "Arial Black";
+  --timer-progress-bg-override: #fff;
+  --timer-progress-override: #202020;
 }
 
 .timer {

apps/server/src/models/eventsDefinition.ts

@@ -34,5 +34,6 @@ export const delay: Omit<OntimeDelay, 'id'> = {
 };
 
 export const block: Omit<OntimeBlock, 'id'> = {
+  title: '',
   type: SupportedEvent.Block,
 };

apps/server/src/services/PlaybackService.ts

@@ -219,7 +219,9 @@ export class PlaybackService {
     if (eventTimer.loadedTimerId) {
       const delayInMs = delayTime * 1000 * 60;
       eventTimer.delay(delayInMs);
-      logger.info('PLAYBACK', `Added ${delayTime} min delay`);
+      delayInMs > 0
+        ? logger.info('PLAYBACK', `Added ${delayTime} min delay`)
+        : logger.info('PLAYBACK', `Removed ${delayTime} min delay`);
     }
   }
 }

apps/server/src/services/RundownService.ts

@@ -1,4 +1,4 @@
-import { OntimeBaseEvent, OntimeBlock, OntimeDelay, OntimeEvent } from 'ontime-types';
+import { OntimeBaseEvent, OntimeBlock, OntimeDelay, OntimeEvent, SupportedEvent } from 'ontime-types';
 import { generateId } from 'ontime-utils';
 import { DataProvider } from '../classes/data-provider/DataProvider.js';
 import { block as blockDef, delay as delayDef, event as eventDef } from '../models/eventsDefinition.js';
@@ -218,15 +218,13 @@ export async function reorderEvent(eventId, from, to) {
  */
 export async function applyDelay(eventId) {
   const rundown = DataProvider.getRundown();
-  // AUX
   let delayIndex = null;
-  let blockIndex = null;
   let delayValue = 0;
 
   for (const [index, e] of rundown.entries()) {
     // look for delay
     if (delayIndex === null) {
-      if (e.id === eventId && e.type === 'delay') {
+      if (e.id === eventId && e.type === SupportedEvent.Delay) {
         delayValue = e.duration;
         delayIndex = index;
       }
@@ -234,16 +232,14 @@ export async function applyDelay(eventId) {
 
     // apply delay value to all items until block or end
     else {
-      if (e.type === 'event') {
+      if (e.type === SupportedEvent.Event) {
         // update times
         e.timeStart += delayValue;
         e.timeEnd += delayValue;
 
         // increment revision
         e.revision += 1;
-      } else if (e.type === 'block') {
-        // save id and stop
-        blockIndex = index;
+      } else if (e.type === SupportedEvent.Block) {
         break;
       }
     }
@@ -256,10 +252,6 @@ export async function applyDelay(eventId) {
   // delete delay
   rundown.splice(delayIndex, 1);
 
-  // delete block
-  // index would have moved down since we deleted delay
-  if (blockIndex) rundown.splice(blockIndex - 1, 1);
-
   // update rundown
   await DataProvider.setRundown(rundown);
   updateTimer();

apps/server/src/stores/EventStore.ts

@@ -1,12 +1,18 @@
 import { RuntimeStore } from 'ontime-types';
 import { socket } from '../adapters/WebsocketAdapter.js';
+import { eventTimer } from '../services/TimerService.js';
+import { messageService } from '../services/message-service/MessageService.js';
+import { eventLoader } from '../classes/event-loader/EventLoader.js';
 
-const store: Partial<RuntimeStore> = {};
+let store: Partial<RuntimeStore> = {};
 
 /**
  * A runtime store that broadcasts its payload
  */
 export const eventStore = {
+  init(payload: RuntimeStore) {
+    store = payload;
+  },
   get<T extends keyof RuntimeStore>(key: T) {
     return store[key];
   },
@@ -23,9 +29,35 @@ export const eventStore = {
     return store;
   },
   broadcast() {
-    socket.send({
+    socket.sendAsJson({
       type: 'ontime',
       payload: store,
     });
   },
 };
+
+/**
+ * Module initialises the services and provides initial payload for the store
+ * Currently registered objects in store
+ * - Timer Service      timer
+ * - Timer Service      playback
+ * - Message Service    timerMessage
+ * - Message Service    publicMessage
+ * - Message Service    lowerMessage
+ * - Message Service    onAir
+ * - Event Loader       loaded
+ * - Event Loader       titles
+ * - Event Loader       titlesPublic
+ */
+
+export const getInitialPayload = () => ({
+  timer: eventTimer.timer,
+  playback: eventTimer.playback,
+  timerMessage: messageService.timerMessage,
+  publicMessage: messageService.publicMessage,
+  lowerMessage: messageService.lowerMessage,
+  onAir: messageService.onAir,
+  loaded: eventLoader.loaded,
+  titles: eventLoader.titles,
+  titlesPublic: eventLoader.titlesPublic,
+});

apps/server/src/utils/__tests__/getRandomName.test.js

@@ -1,11 +1,11 @@
 import getRandomName from '../getRandomName.js';
 
-test('generates 100 unique names', () => {
+test('generates unique names', () => {
   const names = new Set();
   let attempts = 1;
-  while (names.size < 100) {
+  while (names.size < 10) {
     names.add(getRandomName());
     attempts++;
   }
-  expect(attempts).toBeLessThan(105);
+  expect(attempts).toBeLessThan(50);
 });

apps/server/src/utils/parserFunctions.ts

@@ -54,7 +54,7 @@ export const parseRundown = (data): OntimeRundown => {
             id: e.id || generateId(),
           });
         } else if (e.type === 'block') {
-          rundown.push({ ...blockDef, id: e.id || generateId() });
+          rundown.push({ ...blockDef, title: e.title, id: e.id || generateId() });
         } else {
           console.log('ERROR: undefined event type, skipping');
         }