Convert all renderer runnables to late-inject style

- To help fix issues around injection time

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

src/features/cluster/state-sync/renderer/setup-sync.injectable.ts

@@ -10,13 +10,11 @@ import requestInitialClusterStatesInjectable from "./request-initial.injectable"
 
 const setupClusterStateSyncInjectable = getInjectable({
   id: "setup-cluster-state-sync",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
-    const getClusterById = di.inject(getClusterByIdInjectable);
-
-    return {
     id: "setup-cluster-state-sync",
     run: async () => {
+      const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
+      const getClusterById = di.inject(getClusterByIdInjectable);
       const initalStates = await requestInitialClusterStates();
 
       for (const { clusterId, state } of initalStates) {
@@ -24,8 +22,7 @@ const setupClusterStateSyncInjectable = getInjectable({
       }
     },
     runAfter: di.inject(initClusterStoreInjectable),
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/features/cluster/store/renderer/init.injectable.ts

@@ -9,17 +9,15 @@ import initUserStoreInjectable from "../../../../renderer/stores/init-user-store
 
 const initClusterStoreInjectable = getInjectable({
   id: "init-cluster-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const clusterStore = di.inject(clusterStoreInjectable);
-
-    return {
     id: "init-cluster-store",
     run: () => {
+      const clusterStore = di.inject(clusterStoreInjectable);
+
       clusterStore.load();
     },
     runAfter: di.inject(initUserStoreInjectable),
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/features/hotbar/store/renderer/init.injectable.ts

@@ -9,17 +9,15 @@ import initClusterStoreInjectable from "../../../cluster/store/renderer/init.inj
 
 const initHotbarStoreInjectable = getInjectable({
   id: "init-hotbar-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const hotbarStore = di.inject(hotbarStoreInjectable);
-
-    return {
     id: "init-hotbar-store",
     run: () => {
+      const hotbarStore = di.inject(hotbarStoreInjectable);
+
       hotbarStore.load();
     },
     runAfter: di.inject(initClusterStoreInjectable),
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/features/theme/system-type/renderer/initialize.injectable.ts

@@ -10,18 +10,16 @@ import requestInitialSystemThemeTypeInjectable from "./request-initial.injectabl
 
 const initializeSystemThemeTypeInjectable = getInjectable({
   id: "initialize-system-theme-type",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "initialize-system-theme-type",
+    run: async () => {
       const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
       const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
 
-    return {
-      id: "initialize-system-theme-type",
-      run: async () => {
       systemThemeConfiguration.set(await requestInitialSystemThemeType());
     },
     runAfter: di.inject(initUserStoreInjectable),
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

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

@@ -11,19 +11,16 @@ import { requestFromChannelInjectionToken } from "../../common/utils/channel/req
 const setupAppPathsInjectable = getInjectable({
   id: "setup-app-paths",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
-    const appPathsState = di.inject(appPathsStateInjectable);
-
-    return {
     id: "setup-app-paths",
     run: async () => {
+      const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+      const appPathsState = di.inject(appPathsStateInjectable);
       const appPaths = await requestFromChannel(appPathsChannel);
 
       appPathsState.set(appPaths);
     },
-    };
+  }),
-  },
 
   injectionToken: beforeFrameStartsInjectionToken,
 });

src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts

@@ -9,17 +9,15 @@ import { evenBeforeFrameStartsInjectionToken } from "../tokens";
 
 const loadMonacoThemesInjectable = getInjectable({
   id: "load-monaco-themes",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "load-monaco-themes",
+    run: () => {
       const customThemes = di.injectMany(customMonacoThemeInjectionToken);
       const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
 
-    return {
-      id: "load-monaco-themes",
-      run: () => {
       customThemes.forEach(addNewMonacoTheme);
     },
-    };
+  }),
-  },
   injectionToken: evenBeforeFrameStartsInjectionToken,
 });
 

src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts

@@ -11,13 +11,12 @@ import { evenBeforeMainFrameStartsInjectionToken } from "../tokens";
 
 const setupCurrentClusterBroadcastInjectable = getInjectable({
   id: "setup-current-cluster-broadcast",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "setup-current-cluster-broadcast",
+    run: () => {
       const matchedClusterId = di.inject(matchedClusterIdInjectable);
       const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
 
-    return {
-      id: "setup-current-cluster-broadcast",
-      run: () => {
       reaction(
         () => matchedClusterId.get(),
         clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
@@ -26,8 +25,7 @@ const setupCurrentClusterBroadcastInjectable = getInjectable({
         },
       );
     },
-    };
+  }),
-  },
   injectionToken: evenBeforeMainFrameStartsInjectionToken,
 });
 

src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts

@@ -8,18 +8,15 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
 
 const setupRootMacClassnameInjectable = getInjectable({
   id: "setup-root-mac-classname",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const isMac = di.inject(isMacInjectable);
-
-    return {
     id: "setup-root-mac-classname",
     run: () => {
+      const isMac = di.inject(isMacInjectable);
       const rootElem = document.getElementById("app");
 
       rootElem?.classList.toggle("is-mac", isMac);
     },
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx

@@ -11,13 +11,12 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
 
 const setupWeblickContextMenuOpenInjectable = getInjectable({
   id: "setup-weblick-context-menu-open",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "setup-weblick-context-menu-open",
+    run: () => {
       const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
       const commandOverlay = di.inject(commandOverlayInjectable);
 
-    return {
-      id: "setup-weblick-context-menu-open",
-      run: () => {
       catalogCategoryRegistry
         .getForGroupKind("entity.k8slens.dev", "WebLink")
         ?.on("catalogAddMenu", ctx => {
@@ -28,8 +27,7 @@ const setupWeblickContextMenuOpenInjectable = getInjectable({
           });
         });
     },
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/renderer/components/layout/top-bar/start-state-sync.injectable.ts

@@ -11,13 +11,12 @@ import topBarStateInjectable from "./state.injectable";
 // TODO: replace with a SyncBox
 const startTopbarStateSyncInjectable = getInjectable({
   id: "start-topbar-state-sync",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "start-topbar-state-sync",
+    run: () => {
       const state = di.inject(topBarStateInjectable);
       const ipcRenderer = di.inject(ipcRendererInjectable);
 
-    return {
-      id: "start-topbar-state-sync",
-      run: () => {
       ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
         state.prevEnabled = canGoBack;
       }));
@@ -26,8 +25,7 @@ const startTopbarStateSyncInjectable = getInjectable({
         state.nextEnabled = canGoForward;
       }));
     },
-    };
+  }),
-  },
   injectionToken: beforeFrameStartsInjectionToken,
   causesSideEffects: true,
 });

src/renderer/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts

@@ -5,20 +5,20 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { beforeFrameStartsInjectionToken } from "../../../before-frame-starts/tokens";
 import listeningOnMessageChannelsInjectable from "../../../../common/utils/channel/listening-on-message-channels.injectable";
+import setupAppPathsInjectable from "../../../app-paths/setup-app-paths.injectable";
 
 const startListeningOfChannelsInjectable = getInjectable({
   id: "start-listening-of-channels-renderer",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
-
-    return {
     id: "start-listening-of-channels-renderer",
     run: () => {
+      const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
+
       listeningOfChannels.start();
     },
-    };
+    runAfter: di.inject(setupAppPathsInjectable),
-  },
+  }),
 
   injectionToken: beforeFrameStartsInjectionToken,
 });

src/renderer/utils/sync-box/provide-initial-values-for-sync-boxes.injectable.ts

@@ -8,38 +8,29 @@ import { syncBoxInitialValueChannel } from "../../../common/utils/sync-box/chann
 import createSyncBoxStateInjectable from "../../../common/utils/sync-box/sync-box-state.injectable";
 import { requestFromChannelInjectionToken } from "../../../common/utils/channel/request-from-channel-injection-token";
 import { runInAction } from "mobx";
-import type { SyncBox } from "../../../common/utils/sync-box/sync-box-injection-token";
 import { syncBoxInjectionToken } from "../../../common/utils/sync-box/sync-box-injection-token";
 import assert from "assert";
 
 const provideInitialValuesForSyncBoxesInjectable = getInjectable({
   id: "provide-initial-values-for-sync-boxes",
 
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
-
-    const syncBoxes = di.injectMany(syncBoxInjectionToken);
-
-    const setSyncBoxState = (syncBox: SyncBox<any>, state: any) =>
-      di.inject(createSyncBoxStateInjectable, syncBox.id).set(state);
-
-    return {
     id: "provide-initial-values-for-sync-boxes",
     run: async () => {
+      const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+      const syncBoxes = di.injectMany(syncBoxInjectionToken);
       const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
 
       runInAction(() => {
-          initialValues.forEach(({ id, value }) => {
+        for (const { id, value } of initialValues) {
           const syncBox = syncBoxes.find((box) => box.id === id);
 
           assert(syncBox);
-
+          di.inject(createSyncBoxStateInjectable, syncBox.id).set(value);
-            setSyncBoxState(syncBox, value);
+        }
-          });
       });
     },
-    };
+  }),
-  },
 
   injectionToken: beforeFrameStartsInjectionToken,
 });

src/renderer/vars/build-version/init.injectable.ts

@@ -8,14 +8,14 @@ import buildVersionInjectable from "./build-version.injectable";
 
 const initializeBuildVersionInjectable = getInjectable({
   id: "initialize-build-version",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "initialize-build-version",
+    run: async () => {
       const buildVersion = di.inject(buildVersionInjectable);
 
-    return {
+      await buildVersion.init();
-      id: "initialize-build-version",
-      run: () => buildVersion.init(),
-    };
     },
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/renderer/vars/default-update-channel/init.injectable.ts

@@ -9,15 +9,15 @@ import defaultUpdateChannelInjectable from "../../../features/application-update
 
 const initDefaultUpdateChannelInjectable = getInjectable({
   id: "init-default-update-channel",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "init-default-update-channel",
+    run: async () => {
       const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
 
-    return {
+      await defaultUpdateChannel.init();
-      id: "init-default-update-channel",
-      run: () => defaultUpdateChannel.init(),
-      runAfter: di.inject(initReleaseChannelInjectable),
-    };
     },
+    runAfter: di.inject(initReleaseChannelInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/renderer/vars/release-channel/init.injectable.ts

@@ -9,15 +9,15 @@ import initSemanticBuildVersionInjectable from "../semantic-build-version/init.i
 
 const initReleaseChannelInjectable = getInjectable({
   id: "init-release-channel",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "init-release-channel",
+    run: async () => {
       const releaseChannel = di.inject(releaseChannelInjectable);
 
-    return {
+      await releaseChannel.init();
-      id: "init-release-channel",
-      run: () => releaseChannel.init(),
-      runAfter: di.inject(initSemanticBuildVersionInjectable),
-    };
     },
+    runAfter: di.inject(initSemanticBuildVersionInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

src/renderer/vars/semantic-build-version/init.injectable.ts

@@ -9,15 +9,15 @@ import initializeBuildVersionInjectable from "../build-version/init.injectable";
 
 const initSemanticBuildVersionInjectable = getInjectable({
   id: "init-semantic-build-version",
-  instantiate: (di) => {
+  instantiate: (di) => ({
+    id: "init-semantic-build-version",
+    run: async () => {
       const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
 
-    return {
+      await buildSemanticVersion.init();
-      id: "init-semantic-build-version",
-      run: () => buildSemanticVersion.init(),
-      runAfter: di.inject(initializeBuildVersionInjectable),
-    };
     },
+    runAfter: di.inject(initializeBuildVersionInjectable),
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });