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,22 +10,19 @@ import requestInitialClusterStatesInjectable from "./request-initial.injectable"
 
 const setupClusterStateSyncInjectable = getInjectable({
   id: "setup-cluster-state-sync",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
+    id: "setup-cluster-state-sync",
-    const getClusterById = di.inject(getClusterByIdInjectable);
+    run: async () => {
+      const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
+      const getClusterById = di.inject(getClusterByIdInjectable);
+      const initalStates = await requestInitialClusterStates();
 
-    return {
+      for (const { clusterId, state } of initalStates) {
-      id: "setup-cluster-state-sync",
+        getClusterById(clusterId)?.setState(state);
-      run: async () => {
+      }
-        const initalStates = await requestInitialClusterStates();
+    },
-
+    runAfter: di.inject(initClusterStoreInjectable),
-        for (const { clusterId, state } of initalStates) {
+  }),
-          getClusterById(clusterId)?.setState(state);
-        }
-      },
-      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);
+    id: "init-cluster-store",
+    run: () => {
+      const clusterStore = di.inject(clusterStoreInjectable);
 
-    return {
+      clusterStore.load();
-      id: "init-cluster-store",
+    },
-      run: () => {
+    runAfter: di.inject(initUserStoreInjectable),
-        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);
+    id: "init-hotbar-store",
+    run: () => {
+      const hotbarStore = di.inject(hotbarStoreInjectable);
 
-    return {
+      hotbarStore.load();
-      id: "init-hotbar-store",
+    },
-      run: () => {
+    runAfter: di.inject(initClusterStoreInjectable),
-        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) => ({
-    const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
+    id: "initialize-system-theme-type",
-    const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
+    run: async () => {
+      const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
+      const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
 
-    return {
+      systemThemeConfiguration.set(await requestInitialSystemThemeType());
-      id: "initialize-system-theme-type",
+    },
-      run: async () => {
+    runAfter: di.inject(initUserStoreInjectable),
-        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);
+    id: "setup-app-paths",
-    const appPathsState = di.inject(appPathsStateInjectable);
+    run: async () => {
+      const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+      const appPathsState = di.inject(appPathsStateInjectable);
+      const appPaths = await requestFromChannel(appPathsChannel);
 
-    return {
+      appPathsState.set(appPaths);
-      id: "setup-app-paths",
+    },
-      run: async () => {
+  }),
-        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) => ({
-    const customThemes = di.injectMany(customMonacoThemeInjectionToken);
+    id: "load-monaco-themes",
-    const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
+    run: () => {
+      const customThemes = di.injectMany(customMonacoThemeInjectionToken);
+      const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
 
-    return {
+      customThemes.forEach(addNewMonacoTheme);
-      id: "load-monaco-themes",
+    },
-      run: () => {
+  }),
-        customThemes.forEach(addNewMonacoTheme);
-      },
-    };
-  },
   injectionToken: evenBeforeFrameStartsInjectionToken,
 });
 

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

@@ -11,23 +11,21 @@ import { evenBeforeMainFrameStartsInjectionToken } from "../tokens";
 
 const setupCurrentClusterBroadcastInjectable = getInjectable({
   id: "setup-current-cluster-broadcast",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const matchedClusterId = di.inject(matchedClusterIdInjectable);
+    id: "setup-current-cluster-broadcast",
-    const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
+    run: () => {
+      const matchedClusterId = di.inject(matchedClusterIdInjectable);
+      const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
 
-    return {
+      reaction(
-      id: "setup-current-cluster-broadcast",
+        () => matchedClusterId.get(),
-      run: () => {
+        clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
-        reaction(
+        {
-          () => matchedClusterId.get(),
+          fireImmediately: true,
-          clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
+        },
-          {
+      );
-            fireImmediately: true,
+    },
-          },
+  }),
-        );
-      },
-    };
-  },
   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);
+    id: "setup-root-mac-classname",
+    run: () => {
+      const isMac = di.inject(isMacInjectable);
+      const rootElem = document.getElementById("app");
 
-    return {
+      rootElem?.classList.toggle("is-mac", isMac);
-      id: "setup-root-mac-classname",
+    },
-      run: () => {
+  }),
-        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,25 +11,23 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
 
 const setupWeblickContextMenuOpenInjectable = getInjectable({
   id: "setup-weblick-context-menu-open",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
+    id: "setup-weblick-context-menu-open",
-    const commandOverlay = di.inject(commandOverlayInjectable);
+    run: () => {
+      const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
+      const commandOverlay = di.inject(commandOverlayInjectable);
 
-    return {
+      catalogCategoryRegistry
-      id: "setup-weblick-context-menu-open",
+        .getForGroupKind("entity.k8slens.dev", "WebLink")
-      run: () => {
+        ?.on("catalogAddMenu", ctx => {
-        catalogCategoryRegistry
+          ctx.menuItems.push({
-          .getForGroupKind("entity.k8slens.dev", "WebLink")
+            title: "Add web link",
-          ?.on("catalogAddMenu", ctx => {
+            icon: "public",
-            ctx.menuItems.push({
+            onClick: () => commandOverlay.open(<WeblinkAddCommand />),
-              title: "Add web link",
-              icon: "public",
-              onClick: () => commandOverlay.open(<WeblinkAddCommand />),
-            });
           });
-      },
+        });
-    };
+    },
-  },
+  }),
   injectionToken: beforeFrameStartsInjectionToken,
 });
 

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

@@ -11,23 +11,21 @@ import topBarStateInjectable from "./state.injectable";
 // TODO: replace with a SyncBox
 const startTopbarStateSyncInjectable = getInjectable({
   id: "start-topbar-state-sync",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const state = di.inject(topBarStateInjectable);
+    id: "start-topbar-state-sync",
-    const ipcRenderer = di.inject(ipcRendererInjectable);
+    run: () => {
+      const state = di.inject(topBarStateInjectable);
+      const ipcRenderer = di.inject(ipcRendererInjectable);
 
-    return {
+      ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
-      id: "start-topbar-state-sync",
+        state.prevEnabled = canGoBack;
-      run: () => {
+      }));
-        ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
-          state.prevEnabled = canGoBack;
-        }));
 
-        ipcRenderer.on("history:can-go-forward", action((event, canGoForward: boolean) => {
+      ipcRenderer.on("history:can-go-forward", action((event, canGoForward: boolean) => {
-          state.nextEnabled = canGoForward;
+        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);
+    id: "start-listening-of-channels-renderer",
+    run: () => {
+      const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
 
-    return {
+      listeningOfChannels.start();
-      id: "start-listening-of-channels-renderer",
+    },
-      run: () => {
+    runAfter: di.inject(setupAppPathsInjectable),
-        listeningOfChannels.start();
+  }),
-      },
-    };
-  },
 
   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);
+    id: "provide-initial-values-for-sync-boxes",
+    run: async () => {
+      const requestFromChannel = di.inject(requestFromChannelInjectionToken);
+      const syncBoxes = di.injectMany(syncBoxInjectionToken);
+      const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
 
-    const syncBoxes = di.injectMany(syncBoxInjectionToken);
+      runInAction(() => {
+        for (const { id, value } of initialValues) {
+          const syncBox = syncBoxes.find((box) => box.id === id);
 
-    const setSyncBoxState = (syncBox: SyncBox<any>, state: any) =>
+          assert(syncBox);
-      di.inject(createSyncBoxStateInjectable, syncBox.id).set(state);
+          di.inject(createSyncBoxStateInjectable, syncBox.id).set(value);
-
+        }
-    return {
+      });
-      id: "provide-initial-values-for-sync-boxes",
+    },
-      run: async () => {
+  }),
-        const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
-
-        runInAction(() => {
-          initialValues.forEach(({ id, value }) => {
-            const syncBox = syncBoxes.find((box) => box.id === id);
-
-            assert(syncBox);
-
-            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) => ({
-    const buildVersion = di.inject(buildVersionInjectable);
+    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) => ({
-    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+    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) => ({
-    const releaseChannel = di.inject(releaseChannelInjectable);
+    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) => ({
-    const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
+    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,
 });