Convert all sync runnables to comply with new checks for sync-ness

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/features/application-menu/main/application-menu-reactivity.injectable.ts

@@ -15,8 +15,9 @@ const applicationMenuReactivityInjectable = getInjectable({
     const applicationMenuItemComposite = di.inject(applicationMenuItemCompositeInjectable);
     const populateApplicationMenu = di.inject(populateApplicationMenuInjectable);
 
-    return getStartableStoppable("application-menu-reactivity", () =>
-      autorun(() => populateApplicationMenu(applicationMenuItemComposite.get()), {
+    return getStartableStoppable(
+      "application-menu-reactivity",
+      () => autorun(() => populateApplicationMenu(applicationMenuItemComposite.get()), {
         delay: 100,
       }),
     );

src/features/application-menu/main/stop-application-menu.injectable.ts

@@ -10,15 +10,11 @@ const stopApplicationMenuInjectable = getInjectable({
   id: "stop-application-menu",
 
   instantiate: (di) => {
-    const applicationMenu = di.inject(
-      applicationMenuReactivityInjectable,
-    );
+    const applicationMenu = di.inject(applicationMenuReactivityInjectable);
 
     return {
       id: "stop-application-menu",
-      run: async () => {
-        await applicationMenu.stop();
-      },
+      run: () => void applicationMenu.stop(),
     };
   },
 

src/features/application-update/child-features/periodical-checking-of-updates/main/periodical-check-for-updates.injectable.ts

@@ -7,6 +7,8 @@ import { getStartableStoppable } from "../../../../../common/utils/get-startable
 import processCheckingForUpdatesInjectable from "../../../main/process-checking-for-updates.injectable";
 import withOrphanPromiseInjectable from "../../../../../common/utils/with-orphan-promise/with-orphan-promise.injectable";
 
+const TWO_HOURS = 1000 * 60 * 60 * 2;
+
 const periodicalCheckForUpdatesInjectable = getInjectable({
   id: "periodical-check-for-updates",
 
@@ -15,12 +17,9 @@ const periodicalCheckForUpdatesInjectable = getInjectable({
     const processCheckingForUpdates = withOrphanPromise(di.inject(processCheckingForUpdatesInjectable));
 
     return getStartableStoppable("periodical-check-for-updates", () => {
-      const TWO_HOURS = 1000 * 60 * 60 * 2;
-
       processCheckingForUpdates("periodic");
 
       const intervalId = setInterval(() => {
-
         processCheckingForUpdates("periodic");
       }, TWO_HOURS);
 

src/features/application-update/child-features/periodical-checking-of-updates/main/stop-checking-for-updates.injectable.ts

@@ -14,10 +14,12 @@ const stopCheckingForUpdatesInjectable = getInjectable({
 
     return {
       id: "stop-checking-for-updates",
-      run: async () => {
+      run: () => {
         if (periodicalCheckForUpdates.started) {
-          await periodicalCheckForUpdates.stop();
+          periodicalCheckForUpdates.stop();
         }
+
+        return undefined;
       },
     };
   },

src/features/application-update/main/watch-if-update-should-happen-on-quit/stop-watching-if-update-should-happen-on-quit.injectable.ts

@@ -14,9 +14,7 @@ const stopWatchingIfUpdateShouldHappenOnQuitInjectable = getInjectable({
 
     return {
       id: "stop-watching-if-update-should-happen-on-quit",
-      run: () => {
-        watchIfUpdateShouldHappenOnQuit.stop();
-      },
+      run: () => void watchIfUpdateShouldHappenOnQuit.stop(),
     };
   },
 

src/main/app-paths/setup-app-paths.injectable.ts

@@ -44,6 +44,9 @@ const setupAppPathsInjectable = getInjectable({
         ) as AppPaths;
 
         appPathsState.set(appPaths);
+
+        // NOTE: this is the worse of two evils. This makes sure that `RunnableSync` always is sync
+        return undefined;
       },
     };
   },

src/main/catalog-sync-to-renderer/catalog-sync-to-renderer.injectable.ts

@@ -13,8 +13,9 @@ const catalogSyncToRendererInjectable = getInjectable({
   instantiate: (di) => {
     const catalogEntityRegistry = di.inject(catalogEntityRegistryInjectable);
 
-    return getStartableStoppable("catalog-sync", () =>
-      startCatalogSyncToRenderer(catalogEntityRegistry),
+    return getStartableStoppable(
+      "catalog-sync",
+      () => startCatalogSyncToRenderer(catalogEntityRegistry),
     );
   },
 

src/main/catalog-sync-to-renderer/stop-catalog-sync.injectable.ts

@@ -14,10 +14,12 @@ const stopCatalogSyncInjectable = getInjectable({
 
     return {
       id: "stop-catalog-sync",
-      run: async () => {
+      run: () => {
         if (catalogSyncToRenderer.started) {
-          await catalogSyncToRenderer.stop();
+          catalogSyncToRenderer.stop();
         }
+
+        return undefined;
       },
     };
   },

src/main/electron-app/features/sync-theme-from-operating-system.injectable.ts

@@ -18,9 +18,7 @@ const syncThemeFromOperatingSystemInjectable = getInjectable({
 
     return getStartableStoppable("sync-theme-from-operating-system", () => {
       const updateThemeState = () => {
-        const newTheme = getElectronTheme();
-
-        currentThemeState.set(newTheme);
+        currentThemeState.set(getElectronTheme());
       };
 
       nativeTheme.on("updated", updateThemeState);

src/main/electron-app/runnables/clean-up-deep-linking.injectable.ts

@@ -14,9 +14,7 @@ const cleanUpDeepLinkingInjectable = getInjectable({
 
     return {
       id: "clean-up-deep-linking",
-      run: () => {
-        lensProtocolRouterMain.cleanup();
-      },
+      run: () => void lensProtocolRouterMain.cleanup(),
     };
   },
 

src/main/electron-app/runnables/dock-visibility/hide-dock-for-last-closed-window.injectable.ts

@@ -23,6 +23,8 @@ const hideDockForLastClosedWindowInjectable = getInjectable({
         if (isEmpty(visibleWindows)) {
           app.dock?.hide();
         }
+
+        return undefined;
       },
     };
   },

src/main/electron-app/runnables/enforce-single-application-instance.injectable.ts

@@ -20,6 +20,8 @@ const enforceSingleApplicationInstanceInjectable = getInjectable({
         if (!requestSingleInstanceLock()) {
           exitApp();
         }
+
+        return undefined;
       },
     };
   },

src/main/electron-app/runnables/setup-application-name.injectable.ts

@@ -18,6 +18,8 @@ const setupApplicationNameInjectable = getInjectable({
       id: "setup-application-name",
       run: () => {
         app.setName(appName);
+
+        return undefined;
       },
     };
   },

src/main/electron-app/runnables/setup-runnables-after-window-is-opened.injectable.ts

@@ -13,15 +13,14 @@ const setupRunnablesAfterWindowIsOpenedInjectable = getInjectable({
 
   instantiate: (di) => {
     const afterWindowIsOpened = runManyFor(di)(afterWindowIsOpenedInjectionToken);
+    const app = di.inject(electronAppInjectable);
 
     return {
       id: "setup-runnables-after-window-is-opened",
       run: () => {
-        const app = di.inject(electronAppInjectable);
+        app.on("browser-window-created", () => afterWindowIsOpened);
 
-        app.on("browser-window-created", async () => {
-          await afterWindowIsOpened();
-        });
+        return undefined;
       },
     };
   },

src/main/electron-app/runnables/setup-runnables-before-closing-of-application.injectable.ts

@@ -15,24 +15,16 @@ const setupRunnablesBeforeClosingOfApplicationInjectable = getInjectable({
   id: "setup-closing-of-application",
 
   instantiate: (di) => {
-    const runMany = runManySyncFor(di);
-
-    const runRunnablesBeforeQuitOfFrontEnd = runMany(
-      beforeQuitOfFrontEndInjectionToken,
-    );
-
-    const runRunnablesBeforeQuitOfBackEnd = runMany(
-      beforeQuitOfBackEndInjectionToken,
-    );
+    const runManySync = runManySyncFor(di);
+    const runRunnablesBeforeQuitOfFrontEnd = runManySync(beforeQuitOfFrontEndInjectionToken);
+    const runRunnablesBeforeQuitOfBackEnd = runManySync(beforeQuitOfBackEndInjectionToken);
+    const app = di.inject(electronAppInjectable);
+    const isIntegrationTesting = di.inject(isIntegrationTestingInjectable);
+    const autoUpdater = di.inject(autoUpdaterInjectable);
 
     return {
       id: "setup-closing-of-application",
       run: () => {
-        const app = di.inject(electronAppInjectable);
-
-        const isIntegrationTesting = di.inject(isIntegrationTestingInjectable);
-        const autoUpdater = di.inject(autoUpdaterInjectable);
-
         let isAutoUpdating = false;
 
         autoUpdater.on("before-quit-for-update", () => {
@@ -51,6 +43,8 @@ const setupRunnablesBeforeClosingOfApplicationInjectable = getInjectable({
             event.preventDefault();
           }
         });
+
+        return undefined;
       },
     };
   },

src/main/start-main-application/runnable-tokens/before-electron-is-ready-injection-token.ts

@@ -5,7 +5,6 @@
 import { getInjectionToken } from "@ogre-tools/injectable";
 import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
 
-export const beforeElectronIsReadyInjectionToken =
-  getInjectionToken<RunnableSync>({
-    id: "before-electron-is-ready",
-  });
+export const beforeElectronIsReadyInjectionToken = getInjectionToken<RunnableSync>({
+  id: "before-electron-is-ready",
+});

src/main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token.ts

@@ -5,7 +5,6 @@
 import { getInjectionToken } from "@ogre-tools/injectable";
 import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
 
-export const beforeQuitOfBackEndInjectionToken =
-  getInjectionToken<RunnableSync>({
-    id: "before-quit-of-back-end",
-  });
+export const beforeQuitOfBackEndInjectionToken = getInjectionToken<RunnableSync>({
+  id: "before-quit-of-back-end",
+});

src/main/start-main-application/runnable-tokens/before-quit-of-front-end-injection-token.ts

@@ -5,7 +5,6 @@
 import { getInjectionToken } from "@ogre-tools/injectable";
 import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
 
-export const beforeQuitOfFrontEndInjectionToken =
-  getInjectionToken<RunnableSync>({
-    id: "before-quit-of-front-end",
-  });
+export const beforeQuitOfFrontEndInjectionToken = getInjectionToken<RunnableSync>({
+  id: "before-quit-of-front-end",
+});

src/main/start-main-application/runnables/clean-up-shell-sessions.injectable.ts

@@ -11,9 +11,7 @@ const cleanUpShellSessionsInjectable = getInjectable({
 
   instantiate: () => ({
     id: "clean-up-shell-sessions",
-    run: () => {
-      ShellSession.cleanup();
-    },
+    run: () => void ShellSession.cleanup(),
   }),
 
   injectionToken: beforeQuitOfBackEndInjectionToken,

src/main/start-main-application/runnables/emit-close-to-event-bus.injectable.ts

@@ -16,6 +16,8 @@ const emitCloseToEventBusInjectable = getInjectable({
       id: "emit-close-to-event-bus",
       run: () => {
         emitAppEvent({ name: "app", action: "close" });
+
+        return undefined;
       },
     };
   },

src/main/start-main-application/runnables/flag-renderer/flag-renderer-as-not-loaded.injectable.ts

@@ -20,6 +20,8 @@ const flagRendererAsNotLoadedInjectable = getInjectable({
           // Todo: remove this kludge which enables out-of-place temporal dependency.
           lensProtocolRouterMain.rendererLoaded = false;
         });
+
+        return undefined;
       },
     };
   },

src/main/start-main-application/runnables/kube-config-sync/stop-kube-config-sync.injectable.ts

@@ -14,9 +14,7 @@ const stopKubeConfigSyncInjectable = getInjectable({
 
     return {
       id: "stop-kube-config-sync",
-      run: () => {
-        kubeConfigSyncManager.stopSync();
-      },
+      run: () => void kubeConfigSyncManager.stopSync(),
     };
   },
 

src/main/start-main-application/runnables/sentry/setup.injectable.ts

@@ -15,7 +15,7 @@ const setupSentryInjectable = getInjectable({
 
     return {
       id: "setup-sentry",
-      run: () => initializeSentryReportingWith(initializeSentryOnMain),
+      run: () => void initializeSentryReportingWith(initializeSentryOnMain),
     };
   },
   injectionToken: beforeElectronIsReadyInjectionToken,

src/main/start-main-application/runnables/setup-hardware-acceleration.injectable.ts

@@ -20,6 +20,8 @@ const setupHardwareAccelerationInjectable = getInjectable({
         if (hardwareAccelerationShouldBeDisabled) {
           disableHardwareAcceleration();
         }
+
+        return undefined;
       },
     };
   },

src/main/start-main-application/runnables/setup-immer.injectable.ts

@@ -16,6 +16,8 @@ const setupImmerInjectable = getInjectable({
       // Required in `utils/storage-helper.ts`
       Immer.setAutoFreeze(false); // allow to merge mobx observables
       Immer.enableMapSet(); // allow to merge maps and sets
+
+      return undefined;
     },
   }),
 

src/main/start-main-application/runnables/setup-mobx.injectable.ts

@@ -21,6 +21,8 @@ const setupMobxInjectable = getInjectable({
         // reactionRequiresObservable: true,
         // observableRequiresReaction: true,
       });
+
+      return undefined;
     },
   }),
 

src/main/start-main-application/runnables/setup-proxy-env.injectable.ts

@@ -34,6 +34,8 @@ const setupProxyEnvInjectable = getInjectable({
         if (getCommandLineSwitch("proxy-server") !== "") {
           process.env.HTTPS_PROXY = getCommandLineSwitch("proxy-server");
         }
+
+        return undefined;
       },
     };
   },

src/main/start-main-application/runnables/stop-cluster-manager.injectable.ts

@@ -16,13 +16,13 @@ const stopClusterManagerInjectable = getInjectable({
       id: "stop-cluster-manager",
       run: () => {
         clusterManager.stop();
+
+        return undefined;
       },
     };
   },
 
   injectionToken: beforeQuitOfFrontEndInjectionToken,
-
-  causesSideEffects: true,
 });
 
 export default stopClusterManagerInjectable;

src/main/theme/broadcast-theme-change/stop-broadcasting-theme-change.injectable.ts

@@ -14,9 +14,7 @@ const stopBroadcastingThemeChangeInjectable = getInjectable({
 
     return {
       id: "stop-broadcasting-theme-change",
-      run: async () => {
-        await broadcastThemeChange.stop();
-      },
+      run: () => void broadcastThemeChange.stop(),
     };
   },
 

src/main/theme/sync-theme-from-os/stop-syncing-theme-from-operating-system.injectable.ts

@@ -14,9 +14,7 @@ const stopSyncingThemeFromOperatingSystemInjectable = getInjectable({
 
     return {
       id: "stop-syncing-theme-from-operating-system",
-      run: async () => {
-        await syncTheme.stop();
-      },
+      run: () => void syncTheme.stop(),
     };
   },
 

src/main/tray/electron-tray/stop-tray.injectable.ts

@@ -15,10 +15,7 @@ const stopTrayInjectable = getInjectable({
 
     return {
       id: "stop-tray",
-      run: () => {
-        electronTray.stop();
-      },
-
+      run: () => void electronTray.stop(),
       runAfter: di.inject(stopReactiveTrayMenuItemsInjectable),
     };
   },

src/main/tray/menu-icon/stop-reactivity.injectable.ts

@@ -14,9 +14,7 @@ const stopReactiveTrayMenuIconInjectable = getInjectable({
 
     return {
       id: "stop-reactive-tray-menu-icon",
-      run: async () => {
-        await reactiveTrayMenuIcon.stop();
-      },
+      run: () => void reactiveTrayMenuIcon.stop(),
     };
   },
 

src/main/tray/reactive-tray-menu-items/reactive-tray-menu-items.injectable.ts

@@ -19,10 +19,8 @@ const reactiveTrayMenuItemsInjectable = getInjectable({
 
     return getStartableStoppable("reactive-tray-menu-items", () =>
       reaction(
-        (): MinimalTrayMenuItem[] => reactiveItems.get().map(toNonReactiveItem),
-
+        () => reactiveItems.get().map(toNonReactiveItem),
         (nonReactiveItems) => electronTray.setMenuItems(nonReactiveItems),
-
         {
           fireImmediately: true,
         },

src/main/tray/reactive-tray-menu-items/stop-reactive-tray-menu-items.injectable.ts

@@ -14,9 +14,7 @@ const stopReactiveTrayMenuItemsInjectable = getInjectable({
 
     return {
       id: "stop-reactive-tray-menu-items",
-      run: async () => {
-        await reactiveTrayMenuItems.stop();
-      },
+      run: () => void reactiveTrayMenuItems.stop(),
     };
   },
 

src/main/utils/channel/channel-listeners/start-listening-on-channels.injectable.ts

@@ -16,9 +16,9 @@ const startListeningOnChannelsInjectable = getInjectable({
 
     return {
       id: "start-listening-on-channels-main",
-      run: async () => {
-        await listeningOnMessageChannels.start();
-        await listeningOnRequestChannels.start();
+      run: () => {
+        listeningOnMessageChannels.start();
+        listeningOnRequestChannels.start();
       },
     };
   },