refactor: allow aux change direction while playing

apps/server/src/classes/simple-timer/SimpleTimer.ts

@@ -9,6 +9,13 @@ export class SimpleTimer {
   };
   private startedAt: number | null = null;
   private pausedAt: number | null = null;
+  private initialDuration = 0;
+
+  constructor(initialTime: number = 0) {
+    this.state.duration = initialTime;
+    this.initialDuration = initialTime;
+    this.state.current = initialTime;
+  }
 
   public reset() {
     this.state = {
@@ -25,14 +32,19 @@ export class SimpleTimer {
    */
   public setTime(time: number): SimpleTimerState {
     this.state.duration = time;
+    this.initialDuration = time;
     this.state.current = time;
     return this.state;
   }
 
-  public setDirection(direction: SimpleDirection): SimpleTimerState {
-    this.state.playback = SimplePlayback.Stop;
-    this.state.current = this.state.duration;
+  public setDirection(direction: SimpleDirection, timeNow: number): SimpleTimerState {
+    // if we are playing, we need to reset the targets
+    if (this.state.playback === SimplePlayback.Start) {
+      this.startedAt = timeNow;
+      this.state.duration = this.state.current;
+    }
     this.state.direction = direction;
+    this.update(timeNow);
     return this.state;
   }
 
@@ -57,7 +69,8 @@ export class SimpleTimer {
 
   public stop(): SimpleTimerState {
     this.state.playback = SimplePlayback.Stop;
-    this.state.current = this.state.duration;
+    this.state.duration = this.initialDuration;
+    this.state.current = this.initialDuration;
     this.startedAt = null;
     return this.state;
   }

apps/server/src/classes/simple-timer/__tests__/SimpleTimer.test.ts

@@ -88,7 +88,7 @@ describe('SimpleTimer count-down', () => {
     });
 
     test('count-up mode', () => {
-      const initialState = timer.setDirection(SimpleDirection.CountUp);
+      const initialState = timer.setDirection(SimpleDirection.CountUp, 0);
       expect(initialState.current).toBe(initialTime);
 
       let newState = timer.start(0);
@@ -114,16 +114,68 @@ describe('SimpleTimer count-down', () => {
       expect(newState).toStrictEqual(expected);
     });
 
-    test('changing direction stops the timer', () => {
-      const newState = timer.setDirection(SimpleDirection.CountDown);
-      const expected: SimpleTimerState = {
-        duration: initialTime,
-        current: initialTime,
-        direction: SimpleDirection.CountDown,
-        playback: SimplePlayback.Stop,
-      };
+    test('changing direction keeps the current time', () => {
+      timer.reset();
+      timer.setTime(1000);
 
-      expect(newState).toStrictEqual(expected);
+      const initialState = timer.setDirection(SimpleDirection.CountUp, 0);
+      expect(initialState.current).toBe(1000);
+
+      let newState = timer.start(0);
+      expect(newState).toStrictEqual({
+        duration: 1000,
+        current: 1000,
+        direction: SimpleDirection.CountUp,
+        playback: SimplePlayback.Start,
+      });
+
+      newState = timer.update(100);
+      expect(newState).toStrictEqual({
+        duration: 1000,
+        current: initialTime + 100,
+        direction: SimpleDirection.CountUp,
+        playback: SimplePlayback.Start,
+      });
+
+      newState = timer.update(500);
+      expect(newState).toStrictEqual({
+        duration: 1000,
+        current: 1500,
+        direction: SimpleDirection.CountUp,
+        playback: SimplePlayback.Start,
+      });
+
+      newState = timer.setDirection(SimpleDirection.CountDown, 600);
+      expect(newState).toStrictEqual({
+        duration: 1500,
+        current: 1500,
+        direction: SimpleDirection.CountDown,
+        playback: SimplePlayback.Start,
+      });
+
+      newState = timer.update(700);
+      expect(newState).toStrictEqual({
+        duration: 1500,
+        current: 1400,
+        direction: SimpleDirection.CountDown,
+        playback: SimplePlayback.Start,
+      });
+
+      newState = timer.setDirection(SimpleDirection.CountUp, 700);
+      expect(newState).toStrictEqual({
+        duration: 1400,
+        current: 1400,
+        direction: SimpleDirection.CountUp,
+        playback: SimplePlayback.Start,
+      });
+
+      newState = timer.update(800);
+      expect(newState).toStrictEqual({
+        duration: 1400,
+        current: 1500,
+        direction: SimpleDirection.CountUp,
+        playback: SimplePlayback.Start,
+      });
     });
   });
 });