Complete local transition to InitializableState

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

src/common/application-update/selected-update-channel/default-update-channel.injectable.ts

@@ -2,13 +2,13 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
+import { createInitializableState } from "../../initializable-state/create";
 import releaseChannelInjectable from "../../vars/release-channel.injectable";
 import { updateChannels } from "../update-channels";
 
-const defaultUpdateChannelInjectable = getInjectable({
+const defaultUpdateChannelInjectable = createInitializableState({
   id: "default-update-channel",
-  instantiate: (di) => updateChannels[di.inject(releaseChannelInjectable)],
+  init: (di) => updateChannels[di.inject(releaseChannelInjectable)],
 });
 
 export default defaultUpdateChannelInjectable;

src/common/application-update/selected-update-channel/selected-update-channel.injectable.ts

@@ -19,16 +19,16 @@ const selectedUpdateChannelInjectable = getInjectable({
 
   instantiate: (di): SelectedUpdateChannel => {
     const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
-    const state = observable.box(defaultUpdateChannel);
+    const state = observable.box<UpdateChannel>();
 
     return {
-      value: computed(() => state.get()),
+      value: computed(() => state.get() ?? defaultUpdateChannel.get()),
 
       setValue: action((channelId) => {
         const targetUpdateChannel =
           channelId && updateChannels[channelId]
             ? updateChannels[channelId]
-            : defaultUpdateChannel;
+            : defaultUpdateChannel.get();
 
         state.set(targetUpdateChannel);
       }),

src/common/initializable-state/create.ts

@@ -3,18 +3,24 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import type { DiContainerForInjection } from "@ogre-tools/injectable";
+import type { DiContainerForInjection, Injectable, InjectionToken } from "@ogre-tools/injectable";
 import { getInjectable } from "@ogre-tools/injectable";
 
 export interface CreateInitializableStateArgs<T> {
   id: string;
-  init: (di: DiContainerForInjection) => Promise<T>;
+  init: (di: DiContainerForInjection) => Promise<T> | T;
+  injectionToken?: InjectionToken<InitializableState<T>, void>;
+}
+
+export interface InitializableState<T> {
+  get: () => T;
+  init: () => Promise<void>;
 }
 
 type InitializableStateValue<T> = { set: false } | { set: true; value: T };
 
-export function createInitializableState<T>(args: CreateInitializableStateArgs<T>) {
-  const { id, init } = args;
+export function createInitializableState<T>(args: CreateInitializableStateArgs<T>): Injectable<InitializableState<T>, unknown, void> {
+  const { id, init, injectionToken } = args;
 
   return getInjectable({
     id,
@@ -49,5 +55,6 @@ export function createInitializableState<T>(args: CreateInitializableStateArgs<T
         },
       };
     },
+    injectionToken,
   });
 }

src/common/vars/build-semantic-version.injectable.ts

@@ -3,11 +3,13 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { getInjectionToken, getInjectable } from "@ogre-tools/injectable";
+import { getInjectionToken } from "@ogre-tools/injectable";
 import { SemVer } from "semver";
+import type { InitializableState } from "../initializable-state/create";
+import { createInitializableState } from "../initializable-state/create";
 import type { RequestChannel } from "../utils/channel/request-channel-injection-token";
 
-export const buildVersionInjectionToken = getInjectionToken<string>({
+export const buildVersionInjectionToken = getInjectionToken<InitializableState<string>>({
   id: "build-version-token",
 });
 
@@ -15,9 +17,13 @@ export const buildVersionChannel: RequestChannel<void, string> = {
   id: "build-version",
 };
 
-const buildSemanticVersionInjectable = getInjectable({
+const buildSemanticVersionInjectable = createInitializableState({
   id: "build-semantic-version",
-  instantiate: (di) => new SemVer(di.inject(buildVersionInjectionToken)),
+  init: (di) => {
+    const buildVersion = di.inject(buildVersionInjectionToken);
+
+    return new SemVer(buildVersion.get());
+  },
 });
 
 export default buildSemanticVersionInjectable;

src/extensions/common-api/index.ts

@@ -7,7 +7,7 @@
 import { App } from "./app";
 import * as EventBus from "./event-bus";
 import * as Store from "./stores";
-import * as Util from "./utils";
+import { Util } from "./utils";
 import * as Catalog from "./catalog";
 import * as Types from "./types";
 import * as Proxy from "./proxy";

src/extensions/common-api/utils.ts

@@ -4,25 +4,34 @@
  */
 
 import openLinkInBrowserInjectable from "../../common/utils/open-link-in-browser.injectable";
-import buildVersionInjectable from "../../main/vars/build-version.injectable";
+import buildVersionInjectable from "../../main/vars/build-version/build-version.injectable";
 import { asLegacyGlobalFunctionForExtensionApi } from "../as-legacy-globals-for-extension-api/as-legacy-global-function-for-extension-api";
 import { getLegacyGlobalDiForExtensionApi } from "../as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
+import { Singleton } from "../../common/utils";
+import { prevDefault, stopPropagation } from "../../renderer/utils/prevDefault";
+import type { IClassName } from "../../renderer/utils/cssNames";
+import { cssNames } from "../../renderer/utils/cssNames";
 
-export { Singleton } from "../../common/utils";
-export { prevDefault, stopPropagation } from "../../renderer/utils/prevDefault";
-export { cssNames } from "../../renderer/utils/cssNames";
-
-/**
- * @deprecated Use {@link openBrowser} instead
- */
-export const openExternal = asLegacyGlobalFunctionForExtensionApi(openLinkInBrowserInjectable);
-export const openBrowser = asLegacyGlobalFunctionForExtensionApi(openLinkInBrowserInjectable);
-
-/**
- * @deprecated use `Common.App.version` instead
- */
-export function getAppVersion() {
-  const di = getLegacyGlobalDiForExtensionApi();
-
-  return di.inject(buildVersionInjectable);
+export interface UtilsExtensionItems {
+  Singleton: Singleton;
+  prevDefault: <E extends React.SyntheticEvent | Event, R>(callback: (evt: E) => R) => (evt: E) => R;
+  stopPropagation: (evt: Event | React.SyntheticEvent) => void;
+  cssNames: (...classNames: IClassName[]) => string;
+  openExternal: (url: string) => Promise<void>;
+  openBrowser: (url: string) => Promise<void>;
+  getAppVersion: () => string;
 }
+
+export const Util: UtilsExtensionItems = {
+  Singleton,
+  prevDefault,
+  stopPropagation,
+  cssNames,
+  openExternal: asLegacyGlobalFunctionForExtensionApi(openLinkInBrowserInjectable),
+  openBrowser: asLegacyGlobalFunctionForExtensionApi(openLinkInBrowserInjectable),
+  getAppVersion: () => {
+    const di = getLegacyGlobalDiForExtensionApi();
+
+    return di.inject(buildVersionInjectable).get();
+  },
+};

src/features/application-update/analytics-for-installing-update.test.ts

@@ -19,7 +19,7 @@ import quitAndInstallUpdateInjectable from "../../main/application-update/quit-a
 import periodicalCheckForUpdatesInjectable from "../../main/application-update/periodical-check-for-updates/periodical-check-for-updates.injectable";
 import { advanceFakeTime, useFakeTime } from "../../common/test-utils/use-fake-time";
 import emitEventInjectable from "../../common/app-event-bus/emit-event.injectable";
-import buildVersionInjectable from "../../main/vars/build-version.injectable";
+import buildVersionInjectable from "../../main/vars/build-version/build-version.injectable";
 
 describe("analytics for installing update", () => {
   let builder: ApplicationBuilder;
@@ -36,7 +36,9 @@ describe("analytics for installing update", () => {
     analyticsListenerMock = jest.fn();
 
     builder.beforeApplicationStart(mainDi => {
-      mainDi.override(buildVersionInjectable, () => "42.0.0");
+      mainDi.override(buildVersionInjectable, () => ({
+        get: () => "42.0.0",
+      }));
 
       checkForPlatformUpdatesMock = asyncFn();
 

src/features/application-update/downgrading-version-update.test.ts

@@ -14,7 +14,7 @@ import processCheckingForUpdatesInjectable from "../../main/application-update/c
 import selectedUpdateChannelInjectable from "../../common/application-update/selected-update-channel/selected-update-channel.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
 import { updateChannels } from "../../common/application-update/update-channels";
-import buildVersionInjectable from "../../main/vars/build-version.injectable";
+import buildVersionInjectable from "../../main/vars/build-version/build-version.injectable";
 
 describe("downgrading version update", () => {
   let applicationBuilder: ApplicationBuilder;
@@ -102,7 +102,9 @@ describe("downgrading version update", () => {
     },
   ].forEach(({ appVersion, updateChannel, downgradeIsAllowed }) => {
     it(`given application version "${appVersion}" and update channel "${updateChannel.id}", when checking for updates, can${downgradeIsAllowed ? "": "not"} downgrade`, async () => {
-      mainDi.override(buildVersionInjectable, () => appVersion);
+      mainDi.override(buildVersionInjectable, () => ({
+        get: () => appVersion,
+      }));
 
       await applicationBuilder.render();
 

src/features/application-update/selection-of-update-stability.test.ts

@@ -22,7 +22,7 @@ import setUpdateOnQuitInjectable from "../../main/electron-app/features/set-upda
 import showInfoNotificationInjectable from "../../renderer/components/notifications/show-info-notification.injectable";
 import processCheckingForUpdatesInjectable from "../../main/application-update/check-for-updates/process-checking-for-updates.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
-import buildVersionInjectable from "../../main/vars/build-version.injectable";
+import buildVersionInjectable from "../../main/vars/build-version/build-version.injectable";
 
 describe("selection of update stability", () => {
   let builder: ApplicationBuilder;
@@ -268,7 +268,9 @@ describe("selection of update stability", () => {
 
   it('given no update channel selection is stored and currently using stable release, when user checks for updates, checks for updates from "latest" update channel by default', async () => {
     builder.beforeApplicationStart((mainDi) => {
-      mainDi.override(buildVersionInjectable, () => "1.0.0");
+      mainDi.override(buildVersionInjectable, () => ({
+        get: () => "1.0.0",
+      }));
     });
 
     await builder.render();
@@ -285,7 +287,9 @@ describe("selection of update stability", () => {
 
   it('given no update channel selection is stored and currently using alpha release, when checking for updates, checks for updates from "alpha" channel', async () => {
     builder.beforeApplicationStart((mainDi) => {
-      mainDi.override(buildVersionInjectable, () => "1.0.0-alpha");
+      mainDi.override(buildVersionInjectable, () => ({
+        get: () => "1.0.0-alpha",
+      }));
     });
 
     await builder.render();
@@ -299,7 +303,9 @@ describe("selection of update stability", () => {
 
   it('given no update channel selection is stored and currently using beta release, when checking for updates, checks for updates from "beta" channel', async () => {
     builder.beforeApplicationStart((mainDi) => {
-      mainDi.override(buildVersionInjectable, () => "1.0.0-beta");
+      mainDi.override(buildVersionInjectable, () => ({
+        get: () => "1.0.0-beta",
+      }));
     });
 
     await builder.render();
@@ -313,7 +319,9 @@ describe("selection of update stability", () => {
 
   it("given update channel selection is stored and currently using prerelease, when checking for updates, checks for updates from stored channel", async () => {
     builder.beforeApplicationStart((mainDi) => {
-      mainDi.override(buildVersionInjectable, () => "1.0.0-alpha");
+      mainDi.override(buildVersionInjectable, () => ({
+        get: () => "1.0.0-alpha",
+      }));
 
       // TODO: Switch to more natural way of setting initial value
       // TODO: UserStore is currently responsible for getting and setting initial value

src/main/application-update/emit-current-version-to-analytics.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { afterApplicationIsLoadedInjectionToken } from "../start-main-application/runnable-tokens/after-application-is-loaded-injection-token";
 import emitEventInjectable from "../../common/app-event-bus/emit-event.injectable";
 import { getCurrentDateTime } from "../../common/utils/date/get-current-date-time";
-import buildVersionInjectable from "../vars/build-version.injectable";
+import buildVersionInjectable from "../vars/build-version/build-version.injectable";
 
 const emitCurrentVersionToAnalyticsInjectable = getInjectable({
   id: "emit-current-version-to-analytics",
@@ -22,7 +22,7 @@ const emitCurrentVersionToAnalyticsInjectable = getInjectable({
           action: "current-version",
 
           params: {
-            version: buildVersion,
+            version: buildVersion.get(),
             currentDateTime: getCurrentDateTime(),
           },
         });

src/main/build-version/setup-channel.injectable.ts

@@ -5,14 +5,16 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { requestChannelListenerInjectionToken } from "../../common/utils/channel/request-channel-listener-injection-token";
 import { buildVersionChannel } from "../../common/vars/build-semantic-version.injectable";
-import buildVersionInjectable from "../vars/build-version.injectable";
+import buildVersionInjectable from "../vars/build-version/build-version.injectable";
 
 const setupBuildVersionRequestChannelInjectable = getInjectable({
   id: "setup-build-version-request-channel",
   instantiate: (di) => {
+    const buildVersion = di.inject(buildVersionInjectable);
+
     return {
       channel: buildVersionChannel,
-      handler: () => di.inject(buildVersionInjectable),
+      handler: () => buildVersion.get(),
     };
   },
   injectionToken: requestChannelListenerInjectionToken,

src/main/electron-app/electron-app.global-override-for-injectable.ts

@@ -4,6 +4,8 @@
  */
 
 import { getGlobalOverride } from "../../common/test-utils/get-global-override";
-import buildVersionInjectable from "./build-version.injectable";
+import electronAppInjectable from "./electron-app.injectable";
 
-export default getGlobalOverride(buildVersionInjectable, () => "6.0.0");
+export default getGlobalOverride(electronAppInjectable, () => ({
+  getVersion: () => "6.0.0",
+} as Electron.App));

src/main/menu/show-about.injectable.ts

@@ -7,7 +7,7 @@ import showMessagePopupInjectable from "../electron-app/features/show-message-po
 import isWindowsInjectable from "../../common/vars/is-windows.injectable";
 import appNameInjectable from "../../common/vars/app-name.injectable";
 import productNameInjectable from "../../common/vars/product-name.injectable";
-import buildVersionInjectable from "../vars/build-version.injectable";
+import buildVersionInjectable from "../vars/build-version/build-version.injectable";
 import extensionApiVersionInjectable from "../../common/vars/extension-api-version.injectable";
 import applicationCopyrightInjectable from "../../common/vars/application-copyright.injectable";
 
@@ -15,7 +15,7 @@ const showAboutInjectable = getInjectable({
   id: "show-about",
 
   instantiate: (di) => {
-    const appVersion = di.inject(buildVersionInjectable);
+    const buildVersion = di.inject(buildVersionInjectable);
     const extensionApiVersion = di.inject(extensionApiVersionInjectable);
     const showMessagePopup = di.inject(showMessagePopupInjectable);
     const isWindows = di.inject(isWindowsInjectable);
@@ -25,7 +25,7 @@ const showAboutInjectable = getInjectable({
 
     return () => {
       const appInfo = [
-        `${appName}: ${appVersion}`,
+        `${appName}: ${buildVersion.get()}`,
         `Extension API: ${extensionApiVersion}`,
         `Electron: ${process.versions.electron}`,
         `Chrome: ${process.versions.chrome}`,

src/main/routes/versions/get-version-route.injectable.ts

@@ -4,19 +4,23 @@
  */
 import { getRouteInjectable } from "../../router/router.injectable";
 import { route } from "../../router/route";
-import buildVersionInjectable from "../../vars/build-version.injectable";
+import buildVersionInjectable from "../../vars/build-version/build-version.injectable";
 
 const getVersionRouteInjectable = getRouteInjectable({
   id: "get-version-route",
 
-  instantiate: (di) => route({
-    method: "get",
-    path: `/version`,
-  })(() => ({
-    response: {
-      version: di.inject(buildVersionInjectable),
-    },
-  })),
+  instantiate: (di) => {
+    const buildVersion = di.inject(buildVersionInjectable);
+
+    return route({
+      method: "get",
+      path: `/version`,
+    })(() => ({
+      response: {
+        version: buildVersion.get(),
+      },
+    }));
+  },
 });
 
 export default getVersionRouteInjectable;

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

@@ -11,7 +11,7 @@ import lensProxyPortInjectable from "../../lens-proxy/lens-proxy-port.injectable
 import isWindowsInjectable from "../../../common/vars/is-windows.injectable";
 import showErrorPopupInjectable from "../../electron-app/features/show-error-popup.injectable";
 import { beforeApplicationIsLoadingInjectionToken } from "../runnable-tokens/before-application-is-loading-injection-token";
-import buildVersionInjectable from "../../vars/build-version.injectable";
+import buildVersionInjectable from "../../vars/build-version/build-version.injectable";
 
 const setupLensProxyInjectable = getInjectable({
   id: "setup-lens-proxy",
@@ -43,7 +43,7 @@ const setupLensProxyInjectable = getInjectable({
             lensProxyPort.get(),
           );
 
-          if (buildVersion !== versionFromProxy) {
+          if (buildVersion.get() !== versionFromProxy) {
             logger.error("Proxy server responded with invalid response");
 
             return exitApp();

src/main/vars/build-version.injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { buildVersionInjectionToken } from "../../common/vars/build-semantic-version.injectable";
-import electronAppInjectable from "../electron-app/electron-app.injectable";
-
-const buildVersionInjectable = getInjectable({
-  id: "build-version",
-  instantiate: (di) => di.inject(electronAppInjectable).getVersion(),
-  injectionToken: buildVersionInjectionToken,
-});
-
-export default buildVersionInjectable;

src/main/vars/build-version/build-version.injectable.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { createInitializableState } from "../../../common/initializable-state/create";
+import { buildVersionInjectionToken } from "../../../common/vars/build-semantic-version.injectable";
+import electronAppInjectable from "../../electron-app/electron-app.injectable";
+
+const buildVersionInjectable = createInitializableState({
+  id: "build-version",
+  init: (di) => di.inject(electronAppInjectable).getVersion(),
+  injectionToken: buildVersionInjectionToken,
+});
+
+export default buildVersionInjectable;

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

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import buildVersionInjectable from "./build-version.injectable";
+
+const initializeBuildVersionAsyncSyncBoxInjectable = getInjectable({
+  id: "initialize-build-version-async-sync-box",
+  instantiate: (di) => {
+    const buildVersion = di.inject(buildVersionInjectable);
+
+    return {
+      run: () => buildVersion.init(),
+    };
+  },
+  injectionToken: beforeApplicationIsLoadingInjectionToken,
+});
+
+export default initializeBuildVersionAsyncSyncBoxInjectable;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import defaultUpdateChannelInjectable from "../../../common/application-update/selected-update-channel/default-update-channel.injectable";
+import initSemanticBuildVersionInjectable from "../../../renderer/vars/semantic-build-version/init.injectable";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+
+const initDefaultUpdateChannelInjectableInjectable = getInjectable({
+  id: "init-default-update-channel-injectable",
+  instantiate: (di) => {
+    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+
+    return {
+      run: () => defaultUpdateChannel.init(),
+      runAfter: di.inject(initSemanticBuildVersionInjectable),
+    };
+  },
+  injectionToken: beforeApplicationIsLoadingInjectionToken,
+});
+
+export default initDefaultUpdateChannelInjectableInjectable;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import buildSemanticVersionInjectable from "../../../common/vars/build-semantic-version.injectable";
+import { beforeApplicationIsLoadingInjectionToken } from "../../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import initializeBuildVersionInjectable from "../build-version/init.injectable";
+
+const initSemanticBuildVersionInjectable = getInjectable({
+  id: "init-semantic-build-version",
+  instantiate: (di) => {
+    const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
+
+    return {
+      run: () => buildSemanticVersion.init(),
+      runAfter: di.inject(initializeBuildVersionInjectable),
+    };
+  },
+  injectionToken: beforeApplicationIsLoadingInjectionToken,
+});
+
+export default initSemanticBuildVersionInjectable;

src/renderer/utils/prevDefault.ts

@@ -17,7 +17,7 @@ import type React from "react";
 //  <Icon onClick={prevDefault(() => console.log('stay on the page and open dialog'))}/>
 // </a>
 
-export function prevDefault<E extends React.SyntheticEvent | Event>(callback: (evt: E) => any) {
+export function prevDefault<E extends React.SyntheticEvent | Event, R>(callback: (evt: E) => R): (event: E) => R {
   return function (evt: E) {
     evt.preventDefault();
     evt.stopPropagation();

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

@@ -2,16 +2,16 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { getInjectable } from "@ogre-tools/injectable";
-import { buildVersionInjectionToken } from "../../../common/vars/build-semantic-version.injectable";
-import buildVersionAsyncSyncBoxInjectable from "./state.injectable";
+import { createInitializableState } from "../../../common/initializable-state/create";
+import { requestFromChannelInjectionToken } from "../../../common/utils/channel/request-from-channel-injection-token";
+import { buildVersionChannel, buildVersionInjectionToken } from "../../../common/vars/build-semantic-version.injectable";
 
-const buildVersionInjectable = getInjectable({
+const buildVersionInjectable = createInitializableState({
   id: "build-version",
-  instantiate: (di) => {
-    const buildVersionAsyncSyncBox = di.inject(buildVersionAsyncSyncBoxInjectable);
+  init: (di) => {
+    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
 
-    return buildVersionAsyncSyncBox.get();
+    return requestFromChannel(buildVersionChannel);
   },
   injectionToken: buildVersionInjectionToken,
 });

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

@@ -4,18 +4,18 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { beforeFrameStartsInjectionToken } from "../../before-frame-starts/before-frame-starts-injection-token";
-import buildVersionAsyncSyncBoxInjectable from "./state.injectable";
+import buildVersionInjectable from "./build-version.injectable";
 
-const initializeBuildVersionAsyncSyncBoxInjectable = getInjectable({
-  id: "initialize-build-version-async-sync-box",
+const initializeBuildVersionInjectable = getInjectable({
+  id: "initialize-build-version",
   instantiate: (di) => {
-    const buildVersionAsyncSyncBox = di.inject(buildVersionAsyncSyncBoxInjectable);
+    const buildVersion = di.inject(buildVersionInjectable);
 
     return {
-      run: () => buildVersionAsyncSyncBox.init(),
+      run: () => buildVersion.init(),
     };
   },
   injectionToken: beforeFrameStartsInjectionToken,
 });
 
-export default initializeBuildVersionAsyncSyncBoxInjectable;
+export default initializeBuildVersionInjectable;

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

@@ -1,19 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { createInitializableState } from "../../../common/initializable-state/create";
-import { requestFromChannelInjectionToken } from "../../../common/utils/channel/request-from-channel-injection-token";
-import { buildVersionChannel } from "../../../common/vars/build-semantic-version.injectable";
-
-const buildVersionAsyncSyncBoxInjectable = createInitializableState({
-  id: "build-version",
-  init: (di) => {
-    const requestFromChannel = di.inject(requestFromChannelInjectionToken);
-
-    return requestFromChannel(buildVersionChannel);
-  },
-});
-
-export default buildVersionAsyncSyncBoxInjectable;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import defaultUpdateChannelInjectable from "../../../common/application-update/selected-update-channel/default-update-channel.injectable";
+import initSemanticBuildVersionInjectable from "../../../renderer/vars/semantic-build-version/init.injectable";
+import { beforeFrameStartsInjectionToken } from "../../before-frame-starts/before-frame-starts-injection-token";
+
+const initDefaultUpdateChannelInjectableInjectable = getInjectable({
+  id: "init-default-update-channel-injectable",
+  instantiate: (di) => {
+    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+
+    return {
+      run: () => defaultUpdateChannel.init(),
+      runAfter: di.inject(initSemanticBuildVersionInjectable),
+    };
+  },
+  injectionToken: beforeFrameStartsInjectionToken,
+});
+
+export default initDefaultUpdateChannelInjectableInjectable;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import buildSemanticVersionInjectable from "../../../common/vars/build-semantic-version.injectable";
+import { beforeFrameStartsInjectionToken } from "../../before-frame-starts/before-frame-starts-injection-token";
+import initializeBuildVersionInjectable from "../build-version/init.injectable";
+
+const initSemanticBuildVersionInjectable = getInjectable({
+  id: "init-semantic-build-version",
+  instantiate: (di) => {
+    const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
+
+    return {
+      run: () => buildSemanticVersion.init(),
+      runAfter: di.inject(initializeBuildVersionInjectable),
+    };
+  },
+  injectionToken: beforeFrameStartsInjectionToken,
+});
+
+export default initSemanticBuildVersionInjectable;