refactor: extract subsync runtime orchestration service

src/core/services/subsync-runtime-service.ts

@@ -0,0 +1,85 @@
+import {
+  SubsyncManualPayload,
+  SubsyncManualRunRequest,
+  SubsyncResult,
+} from "../../types";
+import { SubsyncResolvedConfig } from "../../subsync/utils";
+import { runSubsyncManualFromIpcService } from "./ipc-command-service";
+import {
+  TriggerSubsyncFromConfigDeps,
+  runSubsyncManualService,
+  triggerSubsyncFromConfigService,
+} from "./subsync-service";
+
+const AUTOSUBSYNC_SPINNER_FRAMES = ["|", "/", "-", "\\"];
+
+interface MpvClientLike {
+  connected: boolean;
+  currentAudioStreamIndex: number | null;
+  send: (payload: { command: (string | number)[] }) => void;
+  requestProperty: (name: string) => Promise<unknown>;
+}
+
+export interface SubsyncRuntimeDeps {
+  getMpvClient: () => MpvClientLike | null;
+  getResolvedSubsyncConfig: () => SubsyncResolvedConfig;
+  isSubsyncInProgress: () => boolean;
+  setSubsyncInProgress: (inProgress: boolean) => void;
+  showMpvOsd: (text: string) => void;
+  openManualPicker: (payload: SubsyncManualPayload) => void;
+}
+
+async function runWithSubsyncSpinnerService<T>(
+  task: () => Promise<T>,
+  showMpvOsd: (text: string) => void,
+  label = "Subsync: syncing",
+): Promise<T> {
+  let frame = 0;
+  showMpvOsd(`${label} ${AUTOSUBSYNC_SPINNER_FRAMES[0]}`);
+  const timer = setInterval(() => {
+    frame = (frame + 1) % AUTOSUBSYNC_SPINNER_FRAMES.length;
+    showMpvOsd(`${label} ${AUTOSUBSYNC_SPINNER_FRAMES[frame]}`);
+  }, 150);
+  try {
+    return await task();
+  } finally {
+    clearInterval(timer);
+  }
+}
+
+function buildTriggerSubsyncDeps(
+  deps: SubsyncRuntimeDeps,
+): TriggerSubsyncFromConfigDeps {
+  return {
+    getMpvClient: deps.getMpvClient,
+    getResolvedConfig: deps.getResolvedSubsyncConfig,
+    isSubsyncInProgress: deps.isSubsyncInProgress,
+    setSubsyncInProgress: deps.setSubsyncInProgress,
+    showMpvOsd: deps.showMpvOsd,
+    runWithSubsyncSpinner: <T>(task: () => Promise<T>) =>
+      runWithSubsyncSpinnerService(task, deps.showMpvOsd),
+    openManualPicker: deps.openManualPicker,
+  };
+}
+
+export async function triggerSubsyncFromConfigRuntimeService(
+  deps: SubsyncRuntimeDeps,
+): Promise<void> {
+  await triggerSubsyncFromConfigService(buildTriggerSubsyncDeps(deps));
+}
+
+export async function runSubsyncManualFromIpcRuntimeService(
+  request: SubsyncManualRunRequest,
+  deps: SubsyncRuntimeDeps,
+): Promise<SubsyncResult> {
+  const triggerDeps = buildTriggerSubsyncDeps(deps);
+  return runSubsyncManualFromIpcService(request, {
+    isSubsyncInProgress: triggerDeps.isSubsyncInProgress,
+    setSubsyncInProgress: triggerDeps.setSubsyncInProgress,
+    showMpvOsd: triggerDeps.showMpvOsd,
+    runWithSpinner: (task) =>
+      triggerDeps.runWithSubsyncSpinner(() => task()),
+    runSubsyncManual: (subsyncRequest) =>
+      runSubsyncManualService(subsyncRequest, triggerDeps),
+  });
+}

src/main.ts

@@ -152,13 +152,12 @@ import {
 import { updateMpvSubtitleRenderMetricsService } from "./core/services/mpv-render-metrics-service";
 import {
   handleMpvCommandFromIpcService,
-  runSubsyncManualFromIpcService,
 } from "./core/services/ipc-command-service";
 import { sendToVisibleOverlayService } from "./core/services/overlay-send-service";
 import {
-  runSubsyncManualService,
-  triggerSubsyncFromConfigService,
-} from "./core/services/subsync-service";
+  runSubsyncManualFromIpcRuntimeService,
+  triggerSubsyncFromConfigRuntimeService,
+} from "./core/services/subsync-runtime-service";
 import {
   updateInvisibleOverlayVisibilityService,
   updateVisibleOverlayVisibilityService,
@@ -377,27 +376,8 @@ function updateCurrentMediaPath(mediaPath: unknown): void {
   });
 }
 
-const AUTOSUBSYNC_SPINNER_FRAMES = ["|", "/", "-", "\\"];
 let subsyncInProgress = false;
 
-async function runWithSubsyncSpinner<T>(
-  task: () => Promise<T>,
-  label = "Subsync: syncing",
-): Promise<T> {
-  let frame = 0;
-  showMpvOsd(`${label} ${AUTOSUBSYNC_SPINNER_FRAMES[0]}`);
-  const timer = setInterval(() => {
-    frame = (frame + 1) % AUTOSUBSYNC_SPINNER_FRAMES.length;
-    showMpvOsd(`${label} ${AUTOSUBSYNC_SPINNER_FRAMES[frame]}`);
-  }, 150);
-
-  try {
-    return await task();
-  } finally {
-    clearInterval(timer);
-  }
-}
-
 const initialArgs = parseArgs(process.argv);
 if (initialArgs.logLevel) {
   process.env.SUBMINER_LOG_LEVEL = initialArgs.logLevel;
@@ -906,17 +886,15 @@ const mineSentenceSession = createNumericShortcutSessionService({
   showMpvOsd: (text) => showMpvOsd(text),
 });
 
-function getSubsyncServiceDeps() {
+function getSubsyncRuntimeDeps() {
   return {
     getMpvClient: () => mpvClient,
-    getResolvedConfig: () => getSubsyncConfig(getResolvedConfig().subsync),
+    getResolvedSubsyncConfig: () => getSubsyncConfig(getResolvedConfig().subsync),
     isSubsyncInProgress: () => subsyncInProgress,
     setSubsyncInProgress: (inProgress: boolean) => {
       subsyncInProgress = inProgress;
     },
     showMpvOsd: (text: string) => showMpvOsd(text),
-    runWithSubsyncSpinner: <T>(task: () => Promise<T>) =>
-      runWithSubsyncSpinner(task),
     openManualPicker: (payload: SubsyncManualPayload) => {
       sendToVisibleOverlay("subsync:open-manual", payload, {
         restoreOnModalClose: "subsync",
@@ -926,7 +904,7 @@ function getSubsyncServiceDeps() {
 }
 
 async function triggerSubsyncFromConfig(): Promise<void> {
-  await triggerSubsyncFromConfigService(getSubsyncServiceDeps());
+  await triggerSubsyncFromConfigRuntimeService(getSubsyncRuntimeDeps());
 }
 
 function cancelPendingMultiCopy(): void {
@@ -1239,15 +1217,7 @@ function handleMpvCommandFromIpc(command: (string | number)[]): void {
 async function runSubsyncManualFromIpc(
   request: SubsyncManualRunRequest,
 ): Promise<SubsyncResult> {
-  const deps = getSubsyncServiceDeps();
-  return runSubsyncManualFromIpcService(request, {
-    isSubsyncInProgress: deps.isSubsyncInProgress,
-    setSubsyncInProgress: deps.setSubsyncInProgress,
-    showMpvOsd: deps.showMpvOsd,
-    runWithSpinner: deps.runWithSubsyncSpinner,
-    runSubsyncManual: (subsyncRequest) =>
-      runSubsyncManualService(subsyncRequest, deps),
-  });
+  return runSubsyncManualFromIpcRuntimeService(request, getSubsyncRuntimeDeps());
 }
 
 registerIpcHandlersService({