cpvalente/ontime
1
0
Fork 0
mirror of https://github.com/cpvalente/ontime.git synced 2026-08-16 12:53:32 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

feat: auto cue re-numbering (#2016)

Browse Source 
* feat: update auto cue numbering

* feat: renumber from ui

* refactor: patchEntries is not used

* chore: format

* fix: correct cue at top of group

* fix: handle precision

* refactor dialog

* bump limit for performance time test

* extract type

* add class name to lable

* fix rebase

* refator: extract renumering logic

* chore: comments for getIntegerAndFraction function

* chore: add the for renumber mutation

* fix: fraction match precision

* refactor: small cleanup

* refactor: use more narrow validator

---------

Co-authored-by: alex-Arc <omnivox@LAPTOP-RC5SNBVV.localdomain>
This commit is contained in:
Alex Christoffer Rasmussen
2026-05-03 18:39:00 +02:00
committed by GitHub
parent ba1c3235b3
commit 1a08b39b8b
20 changed files with 554 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/utils/src/cue-utils/cueUtils.test.ts
+45 -49
View File
@@ -1,7 +1,7 @@
import type { OntimeDelay, OntimeEntry, OntimeEvent, RundownEntries } from 'ontime-types';
import type { OntimeDelay, OntimeEntry, OntimeEvent, OntimeGroup, OntimeMilestone, RundownEntries } from 'ontime-types';
import { SupportedEntry } from 'ontime-types';
import { getCueCandidate, getIncrement, sanitiseCue } from './cueUtils.js';
import { getCueCandidate, getIncrement } from './cueUtils.js';
describe('getIncrement()', () => {
it('increments number', () => {
@@ -12,24 +12,30 @@ describe('getIncrement()', () => {
});
it('increments decimal number', () => {
expect(getIncrement('1.1')).toBe('1.2');
expect(getIncrement('1.9')).toBe('1.10');
expect(getIncrement('10.10')).toBe('10.11');
expect(getIncrement('99.99')).toBe('99.100');
expect(getIncrement('101.101')).toBe('101.102');
// NOTE: we know the below would fail, handling this amount of decimals is outside of scope
// expect(getIncrement('101.999')).toBe('101.1000');
expect(getIncrement('101.999')).toBe('101.1000');
});
// NOTE: we also know the following fails since we only handle one decimal
//it('handles multiple decimals', () => {
// expect(getIncrement('2.1.1')).toBe('2.1.2');
//});
it('finds last digit in string', () => {
it.fails('handles multiple decimals', () => {
expect(getIncrement('2.1.1')).toBe('2.1.2');
});
it('finds last digit in string without separator', () => {
expect(getIncrement('Presenter1')).toBe('Presenter2');
expect(getIncrement('Presenter10')).toBe('Presenter11');
expect(getIncrement('Presenter99')).toBe('Presenter100');
expect(getIncrement('Presenter101')).toBe('Presenter102');
});
it('finds last digit in string with space separator', () => {
expect(getIncrement('Presenter 1')).toBe('Presenter 2');
expect(getIncrement('Presenter 10')).toBe('Presenter 11');
expect(getIncrement('Presenter 99')).toBe('Presenter 100');
expect(getIncrement('Presenter 101')).toBe('Presenter 102');
});
it('adds a 2 if none is found', () => {
expect(getIncrement('Presenter')).toBe('Presenter2');
expect(getIncrement('Presenter')).toBe('Presenter-2');
});
});
@@ -43,15 +49,6 @@ describe('getCueCandidate()', () => {
const cue = getCueCandidate(entries, ['1', '2'], null);
expect(cue).toBe('1');
});
it('creates decimal stem if next cue is 1', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: '1', type: SupportedEntry.Event } as OntimeEvent,
'2': { id: '2', cue: '10', type: SupportedEntry.Event } as OntimeEvent,
};
const cue = getCueCandidate(entries, ['1', '2'], null);
expect(cue).toBe('0.1');
});
});
describe('in the middle of the rundown', () => {
@@ -74,10 +71,10 @@ describe('getCueCandidate()', () => {
} as OntimeEntry,
};
const cue = getCueCandidate(entries, ['1', '2'], '1');
expect(cue).toBe('Presenter2');
expect(cue).toBe('Presenter-2');
});
it('creates decimal stem if next cue has same stem (case of numbers)', () => {
it.fails('creates decimal stem if next cue has same stem (case of numbers)', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: '1', type: SupportedEntry.Event } as OntimeEvent,
'2': { id: '2', cue: '2', type: SupportedEntry.Event } as OntimeEvent,
@@ -86,7 +83,7 @@ describe('getCueCandidate()', () => {
expect(cue).toBe('1.1');
});
it('creates decimal stem if next cue has same stem (case of letters)', () => {
it.fails('creates decimal stem if next cue has same stem (case of letters)', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: 'Presenter1', type: SupportedEntry.Event } as OntimeEvent,
'2': { id: '2', cue: 'Presenter2', type: SupportedEntry.Event } as OntimeEvent,
@@ -99,22 +96,33 @@ describe('getCueCandidate()', () => {
describe('considers edge cases', () => {
it('previousEvent might not be a cue', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: '10', type: SupportedEntry.Event } as OntimeEvent,
'0': { id: '0', cue: '10', type: SupportedEntry.Event } as OntimeEvent,
'1': { id: '1', type: SupportedEntry.Milestone } as OntimeMilestone,
'2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
};
const cue = getCueCandidate(entries, ['0', '1', '2'], '2');
expect(cue).toBe('11');
});
it('previousEvent might not be a group', () => {
const entries: RundownEntries = {
'0': { id: '0', cue: '10', type: SupportedEntry.Event } as OntimeEvent,
'1': { id: '1', type: SupportedEntry.Milestone } as OntimeMilestone,
'2': { id: '2', type: SupportedEntry.Group } as OntimeGroup,
};
const cue = getCueCandidate(entries, ['0', '1', '2'], null, '2');
expect(cue).toBe('11');
});
it('there might not be events before', () => {
const entries: RundownEntries = {
'1': { id: '1', type: SupportedEntry.Delay } as OntimeDelay,
'2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
};
const cue = getCueCandidate(entries, ['1', '2'], '2');
expect(cue).toBe('11');
expect(cue).toBe('1');
});
});
it('there might not be events before', () => {
const entries: RundownEntries = {
'1': { id: '1', type: SupportedEntry.Delay } as OntimeDelay,
'2': { id: '2', type: SupportedEntry.Delay } as OntimeDelay,
};
const cue = getCueCandidate(entries, ['1', '2'], '2');
expect(cue).toBe('1');
});
});
describe('findCueName() with mixed events', () => {
@@ -128,7 +136,8 @@ describe('findCueName() with mixed events', () => {
expect(cue).toBe('1');
});
it('creates decimal stem if next cue is 1', () => {
// we let this fail to reduced complexity
it.fails('creates decimal stem if next cue is 1', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: '1', type: SupportedEntry.Event } as OntimeEvent,
'2': { id: '2', cue: '10', type: SupportedEntry.Event } as OntimeEvent,
@@ -154,10 +163,10 @@ describe('findCueName() with mixed events', () => {
'2': { id: '2', cue: 'Interval', type: SupportedEntry.Event } as OntimeEvent,
};
const cue = getCueCandidate(entries, ['1', '2'], '1');
expect(cue).toBe('Presenter2');
expect(cue).toBe('Presenter-2');
});
it('creates decimal stem if next cue has same stem (case of numbers)', () => {
it.fails('creates decimal stem if next cue has same stem (case of numbers)', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: '1', type: SupportedEntry.Event } as OntimeEvent,
'2': { id: '2', cue: '2', type: SupportedEntry.Event } as OntimeEvent,
@@ -166,7 +175,7 @@ describe('findCueName() with mixed events', () => {
expect(cue).toBe('1.1');
});
it('creates decimal stem if next cue has same stem (case of letters)', () => {
it.fails('creates decimal stem if next cue has same stem (case of letters)', () => {
const entries: RundownEntries = {
'1': { id: '1', cue: 'Presenter1', type: SupportedEntry.Event } as OntimeEvent,
'2': { id: '2', cue: 'Presenter2', type: SupportedEntry.Event } as OntimeEvent,
@@ -176,16 +185,3 @@ describe('findCueName() with mixed events', () => {
});
});
});
describe('sanitiseCue()', () => {
it('removes spaces', () => {
expect(sanitiseCue(' test')).toBe('test');
expect(sanitiseCue(' test ')).toBe('test');
expect(sanitiseCue('test')).toBe('test');
expect(sanitiseCue('t e s t ')).toBe('test');
});
it('enforces . as decimals', () => {
expect(sanitiseCue('1,2')).toBe('1.2');
expect(sanitiseCue('1,2,3')).toBe('1.2.3');
});
});
packages/utils/src/cue-utils/cueUtils.ts
+34 -76
View File
@@ -1,13 +1,10 @@
import type { EntryId, OntimeEntry, RundownEntries } from 'ontime-types';
import { isOntimeEvent } from 'ontime-types';
import { getFirstEventNormal, getNextEventNormal, getPreviousEventNormal } from '../rundown-utils/rundownUtils.js';
import { isNumeric } from '../types/types.js';
import { getPreviousEventNormal } from '../rundown-utils/rundownUtils.js';
// Zero or more non-digit characters at the beginning ((\D*)).
// One or more digits ((\d+)).
// Optionally, a decimal part starting with a dot ((\.\d+)?).
const regex = /^(\D*)(\d+)(\.\d+)?$/;
// Groups: 1=prefix, 2=separator(optional dash or space), 3=integer, 4='.', 5=fraction
const regex = /^(\D*?)(?:([ -]))?(\d+)(?:(\.)(\d+))?$/;
/**
* Finds if last characters in input are a number and increments
@@ -15,84 +12,45 @@ const regex = /^(\D*)(\d+)(\.\d+)?$/;
export function getIncrement(input: string): string {
// Check if the input string contains a number at the end
const match = regex.exec(input);
if (match) {
// If a number is found, extract the non-numeric prefix, integer part, and decimal part
// eslint-disable-next-line prefer-const -- some items in the destructuring are modified
let [, prefix, integerPart, decimalPart] = match;
if (decimalPart) {
if (decimalPart === '.99') {
decimalPart = '.100';
} else {
const addDecimal = `${'0'.repeat(decimalPart.length - 2)}1`;
const incrementedDecimal = (Number(decimalPart) + Number(`0.${addDecimal}`)).toFixed(decimalPart.length - 1);
decimalPart = incrementedDecimal.toString().replace('0.', '.');
}
return `${prefix}${integerPart}${decimalPart}`;
}
const incrementedInteger = Number(integerPart) + 1;
integerPart = incrementedInteger.toString();
return `${prefix}${integerPart}`;
}
// If no number is found, append "2" to the string and return the updated string
return `${input}2`;
if (match === null) return `${input}-2`;
const [, prefix, separator, integerPart, _decimalSeparator, decimalPart] = match;
if (decimalPart === undefined) return incrementInteger(prefix, integerPart, separator);
return incrementDecimal(prefix, integerPart, decimalPart, separator);
}
const incrementDecimal = (prefix: string, integerPart: string, decimalPart: string, separator = '') => {
const decimalInteger = parseInt(decimalPart);
const incrementedDecimal = (decimalInteger + 1).toString();
const newDecimalPart = incrementedDecimal.padStart(decimalPart.length, '0');
return `${prefix}${separator ?? ''}${integerPart}.${newDecimalPart}`;
};
const incrementInteger = (prefix: string, integerPart: string, separator = '') => {
const incrementedInteger = parseInt(integerPart) + 1;
const newIntegerPart = incrementedInteger.toString();
return `${prefix}${separator}${newIntegerPart}`;
};
/**
* Gets suitable name for a new event cue
*/
export function getCueCandidate(entries: RundownEntries, order: EntryId[], insertAfterId: EntryId | null): string {
// we did not provide a element to go after, we attempt to go first so only need to check for a cue with value 1
if (insertAfterId === null || order.length === 0) {
return addAtTop();
}
export function getCueCandidate(
entries: RundownEntries,
flatOrder: EntryId[],
insertAfterId: EntryId | null,
parent?: EntryId,
): string {
// we might not get a insertAfterId if we are inserting at the top of a group
// in that case we need to get the id of the group so we can find the proceeding event
const prevId = insertAfterId ? insertAfterId : (parent ?? null);
if (flatOrder.length === 0 || prevId === null) return '1';
// get the given event, or any before that
let previousEvent: OntimeEntry | null | undefined = entries[insertAfterId];
let previousEvent: OntimeEntry | null | undefined = entries[prevId];
if (!isOntimeEvent(previousEvent)) {
previousEvent = getPreviousEventNormal(entries, order, insertAfterId).previousEvent;
if (!isOntimeEvent(previousEvent)) {
return addAtTop();
}
previousEvent = getPreviousEventNormal(entries, flatOrder, prevId).previousEvent;
if (!isOntimeEvent(previousEvent)) return '1';
}
// the cue is based on the previous event cue
const cue = getIncrement(previousEvent.cue);
const { nextEvent } = getNextEventNormal(entries, order, insertAfterId);
// if increment is clashing with next, we add a decimal instead
if (cue !== nextEvent?.cue) {
return cue;
}
// there is a clash, bt the cue is a pure number
if (isNumeric(cue)) {
return incrementDecimal(previousEvent.cue);
}
/**
* at this point, we know the cue is not numeric
* but the increment failed, so we have a numeric ending
* eg. Presenter 1 .... Presenter 2 -> Presenter1.1
* eg. Presenter 1.1 .... Presenter 1.2 -> Presenter1.1.1
*/
return `${previousEvent.cue}.1`;
function incrementDecimal(cue: string) {
const n = Number(cue);
return (n + 0.1).toString();
}
function addAtTop() {
const firstEventCue = getFirstEventNormal(entries, order).firstEvent?.cue;
if (firstEventCue === '1') {
return '0.1';
}
return '1';
}
}
export function sanitiseCue(cue: string) {
return cue.replaceAll(' ', '').replaceAll(',', '.');
return getIncrement(previousEvent.cue);
}