refactor: remove unused exports

packages/utils/src/rundown-utils/rundownUtils.test.ts

@@ -1,4 +1,4 @@
-import type { OntimeDelay, OntimeEntry, OntimeEvent, OntimeGroup } from 'ontime-types';
+import type { OntimeDelay, OntimeEntry, OntimeEvent, OntimeGroup, Rundown } from 'ontime-types';
 import { SupportedEntry } from 'ontime-types';
 
 import {
@@ -6,66 +6,15 @@ import {
   getLastEvent,
   getLastGroupNormal,
   getLastNormal,
-  getNext,
   getNextEvent,
   getNextGroupNormal,
   getNextNormal,
-  getPrevious,
-  getPreviousEvent,
-  getPreviousGroup,
   getPreviousGroupNormal,
   getPreviousNormal,
   swapEventData,
 } from './rundownUtils';
 import { demoDb } from './rundownUtils.mock';
 
-describe('getNext()', () => {
-  it('returns the next event of type event', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Event } as OntimeEvent,
-        '3': { id: '3', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3'],
-    };
-
-    const { nextEvent, nextIndex } = getNext(testRundown, '1');
-    expect(nextEvent?.id).toBe('2');
-    expect(nextIndex).toBe(1);
-  });
-
-  it('returns any type of OntimeEntry ', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
-        '3': { id: '3', type: SupportedEntry.Group } as OntimeGroup,
-        '4': { id: '4', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3', '4'],
-    };
-
-    const { nextEvent, nextIndex } = getNext(testRundown, '1');
-    expect(nextEvent?.id).toBe('2');
-    expect(nextIndex).toBe(1);
-  });
-
-  it('returns null if none found', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Event } as OntimeEvent,
-        '3': { id: '3', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3'],
-    };
-    const { nextEvent, nextIndex } = getNext(testRundown, '3');
-    expect(nextEvent).toBe(null);
-    expect(nextIndex).toBe(null);
-  });
-});
-
 describe('getNextEvent()', () => {
   it('returns the next event of type event', () => {
     const testRundown = [
@@ -105,101 +54,6 @@ describe('getNextEvent()', () => {
   });
 });
 
-describe('getPrevious()', () => {
-  it('returns the previous event of type event', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Event } as OntimeEvent,
-        '3': { id: '3', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3'],
-    };
-
-    const { entry, index } = getPrevious(testRundown, '3');
-    expect(entry?.id).toBe('2');
-    expect(index).toBe(1);
-  });
-
-  it('allow other event types', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
-        '3': { id: '3', type: SupportedEntry.Group } as OntimeGroup,
-        '4': { id: '4', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3', '4'],
-    };
-
-    const { entry, index } = getPrevious(testRundown, '3');
-    expect(entry?.id).toBe('2');
-    expect(index).toBe(1);
-  });
-
-  it('returns null if none found', () => {
-    const testRundown = {
-      entries: {
-        '2': { id: '2', type: SupportedEntry.Event } as OntimeEvent,
-        '3': { id: '3', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3'],
-    };
-
-    const { entry, index } = getPrevious(testRundown, '2');
-    expect(entry).toBe(null);
-    expect(index).toBe(null);
-  });
-});
-
-describe('getPreviousEvent()', () => {
-  it('returns the previous event of type event', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Event } as OntimeEvent,
-        '3': { id: '3', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3'],
-    };
-
-    const { previousEvent, previousIndex } = getPreviousEvent(testRundown, '3');
-    expect(previousEvent?.id).toBe('2');
-    expect(previousIndex).toBe(1);
-  });
-
-  it('ignores other event types', () => {
-    const testRundown = {
-      entries: {
-        '1': { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-        '2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
-        '3': { id: '3', type: SupportedEntry.Group } as OntimeGroup,
-        '4': { id: '4', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['1', '2', '3', '4'],
-    };
-
-    const { previousEvent, previousIndex } = getPreviousEvent(testRundown, '4');
-    expect(previousEvent?.id).toBe('1');
-    expect(previousIndex).toBe(0);
-  });
-
-  it('returns null if none found', () => {
-    const testRundown = {
-      entries: {
-        '2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
-        '3': { id: '3', type: SupportedEntry.Group } as OntimeGroup,
-        '4': { id: '4', type: SupportedEntry.Event } as OntimeEvent,
-      },
-      order: ['2', '3', '4'],
-    };
-
-    const { previousEvent, previousIndex } = getPreviousEvent(testRundown, '2');
-    expect(previousEvent).toBe(null);
-    expect(previousIndex).toBe(null);
-  });
-});
-
 describe('swapEventData', () => {
   it('swaps some data between two events', () => {
     const eventA = {
@@ -373,55 +227,11 @@ describe('getLastEvent', () => {
     });
   });
 
-  describe('getPreviousGroup()', () => {
-    const testRundown = {
       entries: {
-        a: { id: 'a', type: SupportedEntry.Event } as OntimeEvent,
-        b: { id: 'b', type: SupportedEntry.Event } as OntimeEvent,
-        c: { id: 'c', type: SupportedEntry.Event } as OntimeEvent,
-        d: { id: 'd', type: SupportedEntry.Delay } as OntimeDelay,
-        e: { id: 'e', type: SupportedEntry.Group } as OntimeGroup,
-        f: { id: 'f', type: SupportedEntry.Event } as OntimeEvent,
-        g: { id: 'g', type: SupportedEntry.Group } as OntimeGroup,
-        h: { id: 'h', type: SupportedEntry.Event } as OntimeEvent,
       },
-      order: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
-    };
 
-    test.each([
-      ['h', 'g'],
-      ['f', 'e'],
-    ])('returns the relevant group', (id, expected) => {
-      const group = getPreviousGroup(testRundown, id);
-      expect(group?.id).toBe(expected);
-    });
 
-    it('returns null if there is no parent group relevant group', () => {
-      const group = getPreviousGroup(testRundown, 'a');
-      expect(group).toBe(null);
-    });
 
-    it('also works on index 0', () => {
-      testRundown.order.unshift('0');
-      // @ts-expect-error -- we are adding an event to the rundown
-      testRundown.entries['0'] = { id: '0', type: SupportedEntry.Group } as OntimeGroup;
-      const group = getPreviousGroup(testRundown, 'a');
-      expect(group?.id).toBe('0');
-    });
 
-    it('returns the parent group if nested event', () => {
-      const testRundown = {
-        entries: {
-          1: { id: '1', type: SupportedEntry.Event } as OntimeEvent,
-          group: { id: 'group', type: SupportedEntry.Group, entries: ['21', '22', '23'] } as OntimeGroup,
-          21: { id: '21', type: SupportedEntry.Event, parent: 'group' } as OntimeEvent,
-          22: { id: '22', type: SupportedEntry.Event, parent: 'group' } as OntimeEvent,
-          23: { id: '23', type: SupportedEntry.Event, parent: 'group' } as OntimeEvent,
-        },
-        order: ['1', 'group'],
-      };
-      const group = getPreviousGroup(testRundown, '21');
-      expect(group?.id).toBe('group');
-    });
   });
 });