refactor: extract overlay visibility facade runtime

src/core/services/overlay-visibility-facade-service.test.ts

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  OverlayVisibilityFacadeDeps,
+  setVisibleOverlayVisibleRuntimeFacadeService,
+  toggleInvisibleOverlayRuntimeFacadeService,
+  toggleVisibleOverlayRuntimeFacadeService,
+} from "./overlay-visibility-facade-service";
+
+function makeDeps(initialVisible = false, initialInvisible = false): {
+  deps: OverlayVisibilityFacadeDeps;
+  getState: () => { visible: boolean; invisible: boolean; mpvSubVisible: boolean | null };
+} {
+  let visible = initialVisible;
+  let invisible = initialInvisible;
+  let mpvSubVisible: boolean | null = null;
+
+  const deps: OverlayVisibilityFacadeDeps = {
+    getVisibleOverlayVisible: () => visible,
+    getInvisibleOverlayVisible: () => invisible,
+    setVisibleOverlayVisibleState: (value) => {
+      visible = value;
+    },
+    setInvisibleOverlayVisibleState: (value) => {
+      invisible = value;
+    },
+    updateVisibleOverlayVisibility: () => {},
+    updateInvisibleOverlayVisibility: () => {},
+    syncInvisibleOverlayMousePassthrough: () => {},
+    shouldBindVisibleOverlayToMpvSubVisibility: () => true,
+    isMpvConnected: () => true,
+    setMpvSubVisibility: (value) => {
+      mpvSubVisible = value;
+    },
+  };
+
+  return {
+    deps,
+    getState: () => ({ visible, invisible, mpvSubVisible }),
+  };
+}
+
+test("setVisibleOverlayVisibleRuntimeFacadeService updates visible state and mpv subtitle visibility", () => {
+  const { deps, getState } = makeDeps(false, true);
+  setVisibleOverlayVisibleRuntimeFacadeService(true, deps);
+  assert.deepEqual(getState(), {
+    visible: true,
+    invisible: true,
+    mpvSubVisible: false,
+  });
+});
+
+test("toggleVisibleOverlayRuntimeFacadeService flips visible overlay state", () => {
+  const { deps, getState } = makeDeps(false, false);
+  toggleVisibleOverlayRuntimeFacadeService(deps);
+  assert.equal(getState().visible, true);
+});
+
+test("toggleInvisibleOverlayRuntimeFacadeService flips invisible overlay state", () => {
+  const { deps, getState } = makeDeps(false, false);
+  toggleInvisibleOverlayRuntimeFacadeService(deps);
+  assert.equal(getState().invisible, true);
+});

src/core/services/overlay-visibility-facade-service.ts

@@ -0,0 +1,64 @@
+import {
+  setInvisibleOverlayVisibleService,
+  setVisibleOverlayVisibleService,
+} from "./overlay-visibility-runtime-service";
+
+export interface OverlayVisibilityFacadeDeps {
+  getVisibleOverlayVisible: () => boolean;
+  getInvisibleOverlayVisible: () => boolean;
+  setVisibleOverlayVisibleState: (visible: boolean) => void;
+  setInvisibleOverlayVisibleState: (visible: boolean) => void;
+  updateVisibleOverlayVisibility: () => void;
+  updateInvisibleOverlayVisibility: () => void;
+  syncInvisibleOverlayMousePassthrough: () => void;
+  shouldBindVisibleOverlayToMpvSubVisibility: () => boolean;
+  isMpvConnected: () => boolean;
+  setMpvSubVisibility: (visible: boolean) => void;
+}
+
+export function setVisibleOverlayVisibleRuntimeFacadeService(
+  visible: boolean,
+  deps: OverlayVisibilityFacadeDeps,
+): void {
+  setVisibleOverlayVisibleService({
+    visible,
+    setVisibleOverlayVisibleState: deps.setVisibleOverlayVisibleState,
+    updateVisibleOverlayVisibility: deps.updateVisibleOverlayVisibility,
+    updateInvisibleOverlayVisibility: deps.updateInvisibleOverlayVisibility,
+    syncInvisibleOverlayMousePassthrough: deps.syncInvisibleOverlayMousePassthrough,
+    shouldBindVisibleOverlayToMpvSubVisibility:
+      deps.shouldBindVisibleOverlayToMpvSubVisibility,
+    isMpvConnected: deps.isMpvConnected,
+    setMpvSubVisibility: deps.setMpvSubVisibility,
+  });
+}
+
+export function setInvisibleOverlayVisibleRuntimeFacadeService(
+  visible: boolean,
+  deps: OverlayVisibilityFacadeDeps,
+): void {
+  setInvisibleOverlayVisibleService({
+    visible,
+    setInvisibleOverlayVisibleState: deps.setInvisibleOverlayVisibleState,
+    updateInvisibleOverlayVisibility: deps.updateInvisibleOverlayVisibility,
+    syncInvisibleOverlayMousePassthrough: deps.syncInvisibleOverlayMousePassthrough,
+  });
+}
+
+export function toggleVisibleOverlayRuntimeFacadeService(
+  deps: OverlayVisibilityFacadeDeps,
+): void {
+  setVisibleOverlayVisibleRuntimeFacadeService(
+    !deps.getVisibleOverlayVisible(),
+    deps,
+  );
+}
+
+export function toggleInvisibleOverlayRuntimeFacadeService(
+  deps: OverlayVisibilityFacadeDeps,
+): void {
+  setInvisibleOverlayVisibleRuntimeFacadeService(
+    !deps.getInvisibleOverlayVisible(),
+    deps,
+  );
+}

src/main.ts

@@ -172,10 +172,14 @@ import {
 } from "./core/services/overlay-window-service";
 import { initializeOverlayRuntimeService } from "./core/services/overlay-runtime-init-service";
 import {
-  setInvisibleOverlayVisibleService,
-  setVisibleOverlayVisibleService,
   syncInvisibleOverlayMousePassthroughService,
 } from "./core/services/overlay-visibility-runtime-service";
+import {
+  setInvisibleOverlayVisibleRuntimeFacadeService,
+  setVisibleOverlayVisibleRuntimeFacadeService,
+  toggleInvisibleOverlayRuntimeFacadeService,
+  toggleVisibleOverlayRuntimeFacadeService,
+} from "./core/services/overlay-visibility-facade-service";
 import {
   MpvIpcClient,
   MPV_REQUEST_ID_SECONDARY_SUB_VISIBILITY,
@@ -1102,11 +1106,23 @@ function syncInvisibleOverlayMousePassthrough(): void {
 }
 
 function setVisibleOverlayVisible(visible: boolean): void {
-  setVisibleOverlayVisibleService({
-    visible,
-    setVisibleOverlayVisibleState: (nextVisible) => {
+  setVisibleOverlayVisibleRuntimeFacadeService(visible, getOverlayVisibilityFacadeDeps());
+}
+
+function setInvisibleOverlayVisible(visible: boolean): void {
+  setInvisibleOverlayVisibleRuntimeFacadeService(visible, getOverlayVisibilityFacadeDeps());
+}
+
+function getOverlayVisibilityFacadeDeps() {
+  return {
+    getVisibleOverlayVisible: () => visibleOverlayVisible,
+    getInvisibleOverlayVisible: () => invisibleOverlayVisible,
+    setVisibleOverlayVisibleState: (nextVisible: boolean) => {
       visibleOverlayVisible = nextVisible;
     },
+    setInvisibleOverlayVisibleState: (nextVisible: boolean) => {
+      invisibleOverlayVisible = nextVisible;
+    },
     updateVisibleOverlayVisibility: () => updateVisibleOverlayVisibility(),
     updateInvisibleOverlayVisibility: () => updateInvisibleOverlayVisibility(),
     syncInvisibleOverlayMousePassthrough: () =>
@@ -1114,26 +1130,18 @@ function setVisibleOverlayVisible(visible: boolean): void {
     shouldBindVisibleOverlayToMpvSubVisibility: () =>
       shouldBindVisibleOverlayToMpvSubVisibility(),
     isMpvConnected: () => Boolean(mpvClient && mpvClient.connected),
-    setMpvSubVisibility: (mpvSubVisible) => {
+    setMpvSubVisibility: (mpvSubVisible: boolean) => {
       setMpvSubVisibilityRuntimeService(mpvClient, mpvSubVisible);
     },
-  });
+  };
 }
 
-function setInvisibleOverlayVisible(visible: boolean): void {
-  setInvisibleOverlayVisibleService({
-    visible,
-    setInvisibleOverlayVisibleState: (nextVisible) => {
-      invisibleOverlayVisible = nextVisible;
-    },
-    updateInvisibleOverlayVisibility: () => updateInvisibleOverlayVisibility(),
-    syncInvisibleOverlayMousePassthrough: () =>
-      syncInvisibleOverlayMousePassthrough(),
-  });
+function toggleVisibleOverlay(): void {
+  toggleVisibleOverlayRuntimeFacadeService(getOverlayVisibilityFacadeDeps());
+}
+function toggleInvisibleOverlay(): void {
+  toggleInvisibleOverlayRuntimeFacadeService(getOverlayVisibilityFacadeDeps());
 }
-
-function toggleVisibleOverlay(): void { setVisibleOverlayVisible(!visibleOverlayVisible); }
-function toggleInvisibleOverlay(): void { setInvisibleOverlayVisible(!invisibleOverlayVisible); }
 function setOverlayVisible(visible: boolean): void { setVisibleOverlayVisible(visible); }
 function toggleOverlay(): void { toggleVisibleOverlay(); }
 function handleOverlayModalClosed(modal: OverlayHostedModal): void {