feat(control): таймер сессии поверх сцены

Отдельное окно countdown с «Показать игрокам»; на превью — move/resize/rotate, на презентации тот же layout.

Co-authored-by: Cursor <cursoragent@cursor.com>

app/main/sessionTimer/timerSessionStore.test.ts

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { TimerSessionStore } from './timerSessionStore';
+import {
+  clampSessionTimerLayout,
+  formatSessionTimerMs,
+  getSessionTimerRemainingMs,
+  parseSessionTimerDurationInput,
+} from '../../shared/types/sessionTimer';
+
+void test('getSessionTimerRemainingMs: paused uses remainingMs', () => {
+  const store = new TimerSessionStore();
+  const s = store.getState();
+  assert.equal(getSessionTimerRemainingMs(s, 1_000_000), s.remainingMs);
+});
+
+void test('start pause start preserves remaining', () => {
+  const store = new TimerSessionStore();
+  const t0 = 1_000_000;
+  store.dispatch({ kind: 'setDuration', durationMs: 60_000 }, t0);
+  store.dispatch({ kind: 'start' }, t0);
+  store.dispatch({ kind: 'pause' }, t0 + 10_000);
+  const afterPause = store.getState();
+  assert.equal(afterPause.running, false);
+  assert.equal(afterPause.remainingMs, 50_000);
+  store.dispatch({ kind: 'start' }, t0 + 20_000);
+  assert.equal(getSessionTimerRemainingMs(store.getState(), t0 + 25_000), 45_000);
+});
+
+void test('reset restores duration', () => {
+  const store = new TimerSessionStore();
+  store.dispatch({ kind: 'setDuration', durationMs: 90_000 });
+  store.dispatch({ kind: 'start' }, 0);
+  store.dispatch({ kind: 'pause' }, 30_000);
+  store.dispatch({ kind: 'reset' });
+  assert.equal(store.getState().remainingMs, 90_000);
+  assert.equal(store.getState().running, false);
+});
+
+void test('setVisibleToPlayers and layout.set', () => {
+  const store = new TimerSessionStore();
+  store.dispatch({ kind: 'setVisibleToPlayers', visible: true });
+  assert.equal(store.getState().visibleToPlayers, true);
+  store.dispatch({
+    kind: 'layout.set',
+    layout: { cx: 0.2, cy: 0.3, scale: 2, rotationDeg: 45 },
+  });
+  assert.equal(store.getState().layout.cx, 0.2);
+  assert.equal(store.getState().layout.scale, 2);
+  assert.equal(store.getState().layout.rotationDeg, 45);
+});
+
+void test('settleIfExpired stops at zero', () => {
+  const store = new TimerSessionStore();
+  store.dispatch({ kind: 'setDuration', durationMs: 5_000 }, 0);
+  store.dispatch({ kind: 'start' }, 0);
+  store.settleIfExpired(10_000);
+  assert.equal(store.getState().running, false);
+  assert.equal(store.getState().remainingMs, 0);
+});
+
+void test('clampSessionTimerLayout / format / parse', () => {
+  const clamped = clampSessionTimerLayout({ cx: 9, cy: -9, scale: 100, rotationDeg: 370 });
+  assert.ok(clamped.cx <= 1.2);
+  assert.ok(clamped.cy >= -0.2);
+  assert.ok(clamped.scale <= 8);
+  assert.equal(clamped.rotationDeg, 10);
+  assert.equal(formatSessionTimerMs(65_000), '01:05');
+  assert.equal(formatSessionTimerMs(3_661_000), '1:01:01');
+  assert.equal(parseSessionTimerDurationInput('5:00'), 300_000);
+  assert.equal(parseSessionTimerDurationInput('1:02:03'), 3723_000);
+  assert.equal(parseSessionTimerDurationInput('bad'), null);
+});
+
+void test('clear restores defaults', () => {
+  const store = new TimerSessionStore();
+  store.dispatch({ kind: 'setVisibleToPlayers', visible: true });
+  store.dispatch({ kind: 'start' }, 0);
+  store.clear();
+  assert.equal(store.getState().visibleToPlayers, false);
+  assert.equal(store.getState().running, false);
+});

app/main/sessionTimer/timerSessionStore.ts

@@ -0,0 +1,131 @@
+import {
+  clampSessionTimerDurationMs,
+  clampSessionTimerLayout,
+  createInitialSessionTimerState,
+  getSessionTimerRemainingMs,
+  type SessionTimerEvent,
+  type SessionTimerState,
+} from '../../shared/types/sessionTimer';
+
+export class TimerSessionStore {
+  private state: SessionTimerState = createInitialSessionTimerState();
+
+  getState(): SessionTimerState {
+    return this.state;
+  }
+
+  clear(): SessionTimerState {
+    this.state = createInitialSessionTimerState();
+    return this.state;
+  }
+
+  dispatch(event: SessionTimerEvent, now = Date.now()): SessionTimerState {
+    switch (event.kind) {
+      case 'setDuration': {
+        const durationMs = clampSessionTimerDurationMs(event.durationMs);
+        if (this.state.running) {
+          const remaining = getSessionTimerRemainingMs(this.state, now);
+          this.state = {
+            ...this.state,
+            revision: this.state.revision + 1,
+            durationMs,
+            remainingMs: Math.min(remaining, durationMs),
+            endsAt: now + Math.min(remaining, durationMs),
+          };
+        } else {
+          this.state = {
+            ...this.state,
+            revision: this.state.revision + 1,
+            durationMs,
+            remainingMs: durationMs,
+            endsAt: null,
+            running: false,
+          };
+        }
+        return this.state;
+      }
+      case 'start': {
+        const remaining = getSessionTimerRemainingMs(this.state, now);
+        if (remaining <= 0) {
+          // Restart from full duration if already at zero.
+          const durationMs = this.state.durationMs;
+          this.state = {
+            ...this.state,
+            revision: this.state.revision + 1,
+            remainingMs: durationMs,
+            running: true,
+            endsAt: now + durationMs,
+          };
+          return this.state;
+        }
+        this.state = {
+          ...this.state,
+          revision: this.state.revision + 1,
+          running: true,
+          endsAt: now + remaining,
+          remainingMs: remaining,
+        };
+        return this.state;
+      }
+      case 'pause': {
+        if (!this.state.running) return this.state;
+        const remaining = getSessionTimerRemainingMs(this.state, now);
+        this.state = {
+          ...this.state,
+          revision: this.state.revision + 1,
+          running: false,
+          endsAt: null,
+          remainingMs: remaining,
+        };
+        return this.state;
+      }
+      case 'reset': {
+        this.state = {
+          ...this.state,
+          revision: this.state.revision + 1,
+          running: false,
+          endsAt: null,
+          remainingMs: this.state.durationMs,
+        };
+        return this.state;
+      }
+      case 'setVisibleToPlayers': {
+        if (this.state.visibleToPlayers === event.visible) return this.state;
+        this.state = {
+          ...this.state,
+          revision: this.state.revision + 1,
+          visibleToPlayers: event.visible,
+        };
+        return this.state;
+      }
+      case 'layout.set': {
+        const layout = clampSessionTimerLayout(event.layout);
+        this.state = {
+          ...this.state,
+          revision: this.state.revision + 1,
+          layout,
+        };
+        return this.state;
+      }
+      default: {
+        const _exhaustive: never = event;
+        return _exhaustive;
+      }
+    }
+  }
+
+  /** Когда running и время вышло — зафиксировать 00:00 (вызывается из UI/main по желанию). */
+  settleIfExpired(now = Date.now()): SessionTimerState {
+    if (!this.state.running) return this.state;
+    const remaining = getSessionTimerRemainingMs(this.state, now);
+    if (remaining > 0) return this.state;
+    this.state = {
+      ...this.state,
+      revision: this.state.revision + 1,
+      running: false,
+      endsAt: null,
+      remainingMs: 0,
+    };
+    return this.state;
+  }
+}