Introduce and use createDependantInitializableState

- Replaces uses of createLazyInitializableState as it has an explicit
  initialization order

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

src/common/app-paths/directory-for-binaries.injectable.ts

@@ -2,11 +2,19 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
+import { initAppPathsOnMainInjectable } from "../../main/app-paths/impl.injectable";
+import { initAppPathsOnRendererInjectable } from "../../renderer/app-paths/impl.injectable";
 import directoryForUserDataInjectable from "./directory-for-user-data.injectable";
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
 import joinPathsInjectable from "../path/join-paths.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 
-const directoryForBinariesInjectable = createLazyInitializableState({
+const {
+  value: directoryForBinariesInjectable,
+  initializers: [
+    initDirectoryForBinariesOnMainInjectable,
+    initDirectoryForBinariesOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-binaries",
   init: (di) => {
     const joinPaths = di.inject(joinPathsInjectable);
@@ -14,6 +22,12 @@ const directoryForBinariesInjectable = createLazyInitializableState({
 
     return joinPaths(directoryForUserData.get(), "binaries");
   },
+  initAfter: [initAppPathsOnMainInjectable, initAppPathsOnRendererInjectable],
 });
 
+export {
+  initDirectoryForBinariesOnMainInjectable,
+  initDirectoryForBinariesOnRendererInjectable,
+};
+
 export default directoryForBinariesInjectable;

src/common/app-paths/directory-for-downloads.injectable.ts

@@ -2,12 +2,26 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import { initAppPathsOnMainInjectable } from "../../main/app-paths/impl.injectable";
+import { initAppPathsOnRendererInjectable } from "../../renderer/app-paths/impl.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 import { appPathsInjectionToken } from "./token";
 
-const directoryForDownloadsInjectable = createLazyInitializableState({
+const {
+  value: directoryForDownloadsInjectable,
+  initializers: [
+    initDirectoryForDownloadsOnMainInjectable,
+    initDirectoryForDownloadsOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-downloads",
   init: (di) => di.inject(appPathsInjectionToken).get().downloads,
+  initAfter: [initAppPathsOnMainInjectable, initAppPathsOnRendererInjectable],
 });
 
+export {
+  initDirectoryForDownloadsOnMainInjectable,
+  initDirectoryForDownloadsOnRendererInjectable,
+};
+
 export default directoryForDownloadsInjectable;

src/common/app-paths/directory-for-exes.injectable.ts

@@ -2,12 +2,26 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import { initAppPathsOnMainInjectable } from "../../main/app-paths/impl.injectable";
+import { initAppPathsOnRendererInjectable } from "../../renderer/app-paths/impl.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 import { appPathsInjectionToken } from "./token";
 
-const directoryForExesInjectable = createLazyInitializableState({
+const {
+  value: directoryForExesInjectable,
+  initializers: [
+    initDirectoryForExesOnMainInjectable,
+    initDirectoryForExesOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-exes",
   init: (di) => di.inject(appPathsInjectionToken).get().exe,
+  initAfter: [initAppPathsOnMainInjectable, initAppPathsOnRendererInjectable],
 });
 
+export {
+  initDirectoryForExesOnMainInjectable,
+  initDirectoryForExesOnRendererInjectable,
+};
+
 export default directoryForExesInjectable;

src/common/app-paths/directory-for-kube-configs.injectable.ts

@@ -2,19 +2,33 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import directoryForUserDataInjectable from "./directory-for-user-data.injectable";
+import directoryForUserDataInjectable, { initDirectoryForUserDataOnMainInjectable, initDirectoryForUserDataOnRendererInjectable } from "./directory-for-user-data.injectable";
 import joinPathsInjectable from "../path/join-paths.injectable";
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 
-const directoryForKubeConfigsInjectable = createLazyInitializableState({
+const {
+  value: directoryForKubeConfigsInjectable,
+  initializers: [
+    initDirectoryForKubeConfigsOnMainInjectable,
+    initDirectoryForKubeConfigsOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-kube-configs",
-
   init: (di) => {
     const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
     return joinPaths(directoryForUserData.get(), "kubeconfigs");
   },
+  initAfter: [
+    initDirectoryForUserDataOnMainInjectable,
+    initDirectoryForUserDataOnRendererInjectable,
+  ],
 });
 
+export {
+  initDirectoryForKubeConfigsOnMainInjectable,
+  initDirectoryForKubeConfigsOnRendererInjectable,
+};
+
 export default directoryForKubeConfigsInjectable;

src/common/app-paths/directory-for-kubectl-binaries.injectable.ts

@@ -2,11 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import directoryForBinariesInjectable from "./directory-for-binaries.injectable";
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import directoryForBinariesInjectable, { initDirectoryForBinariesOnMainInjectable, initDirectoryForBinariesOnRendererInjectable } from "./directory-for-binaries.injectable";
 import joinPathsInjectable from "../path/join-paths.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 
-const directoryForKubectlBinariesInjectable = createLazyInitializableState({
+const {
+  value: directoryForKubectlBinariesInjectable,
+  initializers: [
+    initDirectoryForKubectlBinariesOnMainInjectable,
+    initDirectoryForKubectlBinariesOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-kubectl-binaries",
   init: (di) => {
     const joinPaths = di.inject(joinPathsInjectable);
@@ -14,6 +20,15 @@ const directoryForKubectlBinariesInjectable = createLazyInitializableState({
 
     return joinPaths(directoryForBinaries.get(), "kubectl");
   },
+  initAfter: [
+    initDirectoryForBinariesOnMainInjectable,
+    initDirectoryForBinariesOnRendererInjectable,
+  ],
 });
 
+export {
+  initDirectoryForKubectlBinariesOnMainInjectable,
+  initDirectoryForKubectlBinariesOnRendererInjectable,
+};
+
 export default directoryForKubectlBinariesInjectable;

src/common/app-paths/directory-for-temp.injectable.ts

@@ -2,12 +2,26 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import { initAppPathsOnMainInjectable } from "../../main/app-paths/impl.injectable";
+import { initAppPathsOnRendererInjectable } from "../../renderer/app-paths/impl.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 import { appPathsInjectionToken } from "./token";
 
-const directoryForTempInjectable = createLazyInitializableState({
+const {
+  value: directoryForTempInjectable,
+  initializers: [
+    initDirectoryForTempOnMainInjectable,
+    initDirectoryForTempOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-temp",
   init: (di) => di.inject(appPathsInjectionToken).get().temp,
+  initAfter: [initAppPathsOnMainInjectable, initAppPathsOnRendererInjectable],
 });
 
+export {
+  initDirectoryForTempOnMainInjectable,
+  initDirectoryForTempOnRendererInjectable,
+};
+
 export default directoryForTempInjectable;

src/common/app-paths/directory-for-user-data.injectable.ts

@@ -2,12 +2,26 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import { initAppPathsOnMainInjectable } from "../../main/app-paths/impl.injectable";
+import { initAppPathsOnRendererInjectable } from "../../renderer/app-paths/impl.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 import { appPathsInjectionToken } from "./token";
 
-const directoryForUserDataInjectable = createLazyInitializableState({
+const {
+  value: directoryForUserDataInjectable,
+  initializers: [
+    initDirectoryForUserDataOnMainInjectable,
+    initDirectoryForUserDataOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-user-data",
   init: (di) => di.inject(appPathsInjectionToken).get().userData,
+  initAfter: [initAppPathsOnMainInjectable, initAppPathsOnRendererInjectable],
 });
 
+export {
+  initDirectoryForUserDataOnMainInjectable,
+  initDirectoryForUserDataOnRendererInjectable,
+};
+
 export default directoryForUserDataInjectable;

src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts

@@ -2,19 +2,33 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data.injectable";
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import directoryForUserDataInjectable, { initDirectoryForUserDataOnMainInjectable, initDirectoryForUserDataOnRendererInjectable } from "../app-paths/directory-for-user-data.injectable";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 import joinPathsInjectable from "../path/join-paths.injectable";
 
-const directoryForLensLocalStorageInjectable = createLazyInitializableState({
+const {
+  value: directoryForLensLocalStorageInjectable,
+  initializers: [
+    initDirectoryForLensLocalStorageOnMainInjectable,
+    initDirectoryForLensLocalStorageOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-lens-local-storage",
-
   init: (di) => {
     const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
     return joinPaths(directoryForUserData.get(), "lens-local-storage");
   },
+  initAfter: [
+    initDirectoryForUserDataOnMainInjectable,
+    initDirectoryForUserDataOnRendererInjectable,
+  ],
 });
 
+export {
+  initDirectoryForLensLocalStorageOnMainInjectable,
+  initDirectoryForLensLocalStorageOnRendererInjectable,
+};
+
 export default directoryForLensLocalStorageInjectable;

src/common/initializable-state/create-dependent.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import type { DiContainerForInjection, Injectable, InjectionToken } from "@ogre-tools/injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+import type { Runnable } from "../runnable/run-many-for";
+import type { InitializableState, InitializableStateValue } from "./create";
+
+export interface CreateDependentInitializableStateArgs<T> {
+  id: string;
+  init: (di: DiContainerForInjection) => Promise<T> | T;
+  injectionToken?: InjectionToken<InitializableState<T>, void>;
+  initAfter: Injectable<Runnable<void>, Runnable<void>, void>[];
+}
+
+export interface CreateDependentInitializableStateResult<T> {
+  value: Injectable<InitializableState<T>, unknown, void>;
+  initializers: Injectable<Runnable<void>, Runnable<void>, void>[];
+}
+
+export function createDependentInitializableState<T>(args: CreateDependentInitializableStateArgs<T>): CreateDependentInitializableStateResult<T> {
+  const { id, init, injectionToken, initAfter } = args;
+
+  const valueInjectable = getInjectable({
+    id,
+    instantiate: (di) => {
+      let box: InitializableStateValue<T> = {
+        set: false,
+      };
+      let initCalled = false;
+
+      return {
+        init: async () => {
+          if (initCalled) {
+            throw new Error(`Cannot initialize InitializableState(${id}) more than once`);
+          }
+
+          initCalled = true;
+          box = {
+            set: true,
+            value: await init(di),
+          };
+        },
+        get: () => {
+          if (!initCalled) {
+            throw new Error(`InitializableState(${id}) has not been initialized yet`);
+          }
+
+          if (box.set === false) {
+            throw new Error(`InitializableState(${id}) has not finished initializing`);
+          }
+
+          return box.value;
+        },
+      };
+    },
+    injectionToken,
+  });
+
+  const initializers = initAfter.map(runnableInjectable => getInjectable({
+    id: `initialize-${id}`,
+    instantiate: (di) => {
+      const value = di.inject(valueInjectable);
+
+      return {
+        id: `initialize-${id}`,
+        run: () => value.init(),
+        runAfter: di.inject(runnableInjectable),
+      };
+    },
+    injectionToken: runnableInjectable.injectionToken,
+  }));
+
+  return {
+    value: valueInjectable,
+    initializers,
+  };
+}

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

@@ -5,8 +5,10 @@
 
 import { getInjectionToken } from "@ogre-tools/injectable";
 import { SemVer } from "semver";
+import { initializeBuildVersionOnMainInjectable } from "../../main/vars/build-version/build-version.injectable";
+import { initializeBuildVersionOnRendererInjectable } from "../../renderer/vars/build-version.injectable";
 import type { InitializableState } from "../initializable-state/create";
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
 
 export const buildVersionInjectionToken = getInjectionToken<InitializableState<string>>({
@@ -17,14 +19,29 @@ export const buildVersionChannel: RequestChannel<void, string> = {
   id: "build-version",
 };
 
-const buildSemanticVersionInjectable = createLazyInitializableState({
+const {
+  value: buildSemanticVersionInjectable,
+  initializers: [
+    initBuildSemanticVersionOnMainInjectable,
+    initBuildSemanticVersionOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "build-semantic-version",
   init: (di) => {
     const buildVersion = di.inject(buildVersionInjectionToken);
 
     return new SemVer(buildVersion.get());
   },
+  initAfter: [
+    initializeBuildVersionOnMainInjectable,
+    initializeBuildVersionOnRendererInjectable,
+  ],
 });
 
+export {
+  initBuildSemanticVersionOnMainInjectable,
+  initBuildSemanticVersionOnRendererInjectable,
+};
+
 export default buildSemanticVersionInjectable;
 

src/common/vars/release-channel.injectable.ts

@@ -2,11 +2,17 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { createLazyInitializableState } from "../initializable-state/create-lazy";
-import buildSemanticVersionInjectable from "./build-semantic-version.injectable";
+import buildSemanticVersionInjectable, { initBuildSemanticVersionOnMainInjectable, initBuildSemanticVersionOnRendererInjectable } from "./build-semantic-version.injectable";
 import type { ReleaseChannel } from "../../features/application-update/common/update-channels";
+import { createDependentInitializableState } from "../initializable-state/create-dependent";
 
-const releaseChannelInjectable = createLazyInitializableState({
+const {
+  value: releaseChannelInjectable,
+  initializers: [
+    initReleaseChannelOnMainInjectable,
+    initReleaseChannelOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "release-channel",
   init: (di): ReleaseChannel => {
     const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
@@ -21,6 +27,15 @@ const releaseChannelInjectable = createLazyInitializableState({
         return "latest";
     }
   },
+  initAfter: [
+    initBuildSemanticVersionOnMainInjectable,
+    initBuildSemanticVersionOnRendererInjectable,
+  ],
 });
 
+export {
+  initReleaseChannelOnMainInjectable,
+  initReleaseChannelOnRendererInjectable,
+};
+
 export default releaseChannelInjectable;

src/extensions/extension-installer/extension-package-root-directory.injectable.ts

@@ -2,12 +2,27 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import directoryForUserDataInjectable from "../../common/app-paths/directory-for-user-data.injectable";
-import { createLazyInitializableState } from "../../common/initializable-state/create-lazy";
+import directoryForUserDataInjectable, { initDirectoryForUserDataOnMainInjectable, initDirectoryForUserDataOnRendererInjectable } from "../../common/app-paths/directory-for-user-data.injectable";
+import { createDependentInitializableState } from "../../common/initializable-state/create-dependent";
 
-const extensionPackageRootDirectoryInjectable = createLazyInitializableState({
+const {
+  value: extensionPackageRootDirectoryInjectable,
+  initializers: [
+    initExtensionPackageRootDirectoryOnMainInjectable,
+    initExtensionPackageRootDirectoryOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "extension-package-root-directory",
   init: (di) => di.inject(directoryForUserDataInjectable).get(),
+  initAfter: [
+    initDirectoryForUserDataOnMainInjectable,
+    initDirectoryForUserDataOnRendererInjectable,
+  ],
 });
 
+export {
+  initExtensionPackageRootDirectoryOnMainInjectable,
+  initExtensionPackageRootDirectoryOnRendererInjectable,
+};
+
 export default extensionPackageRootDirectoryInjectable;

src/extensions/extension-loader/file-system-provisioner-store/directory-for-extension-data.injectable.ts

@@ -2,19 +2,33 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data.injectable";
-import { createLazyInitializableState } from "../../../common/initializable-state/create-lazy";
+import directoryForUserDataInjectable, { initDirectoryForUserDataOnMainInjectable, initDirectoryForUserDataOnRendererInjectable } from "../../../common/app-paths/directory-for-user-data.injectable";
+import { createDependentInitializableState } from "../../../common/initializable-state/create-dependent";
 import joinPathsInjectable from "../../../common/path/join-paths.injectable";
 
-const directoryForExtensionDataInjectable = createLazyInitializableState({
+const {
+  value: directoryForExtensionDataInjectable,
+  initializers: [
+    initDirectoryForExtensionDataOnMainInjectable,
+    initDirectoryForExtensionDataOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "directory-for-extension-data",
-
   init: (di) => {
     const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
     return joinPaths(directoryForUserData.get(), "extension_data");
   },
+  initAfter: [
+    initDirectoryForUserDataOnMainInjectable,
+    initDirectoryForUserDataOnRendererInjectable,
+  ],
 });
 
+export {
+  initDirectoryForExtensionDataOnMainInjectable,
+  initDirectoryForExtensionDataOnRendererInjectable,
+};
+
 export default directoryForExtensionDataInjectable;

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

@@ -2,13 +2,28 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { createLazyInitializableState } from "../../../../common/initializable-state/create-lazy";
-import releaseChannelInjectable from "../../../../common/vars/release-channel.injectable";
+import { createDependentInitializableState } from "../../../../common/initializable-state/create-dependent";
+import releaseChannelInjectable, { initReleaseChannelOnMainInjectable, initReleaseChannelOnRendererInjectable } from "../../../../common/vars/release-channel.injectable";
 import { updateChannels } from "../update-channels";
 
-const defaultUpdateChannelInjectable = createLazyInitializableState({
+const {
+  value: defaultUpdateChannelInjectable,
+  initializers: [
+    initDefaultUpdateChannelOnMainInjectable,
+    initDefaultUpdateChannelOnRendererInjectable,
+  ],
+} = createDependentInitializableState({
   id: "default-update-channel",
   init: (di) => updateChannels[di.inject(releaseChannelInjectable).get()],
+  initAfter: [
+    initReleaseChannelOnMainInjectable,
+    initReleaseChannelOnRendererInjectable,
+  ],
 });
 
+export {
+  initDefaultUpdateChannelOnMainInjectable,
+  initDefaultUpdateChannelOnRendererInjectable,
+};
+
 export default defaultUpdateChannelInjectable;

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

@@ -15,7 +15,7 @@ import setElectronAppPathInjectable from "./set-electron-app-path/set-electron-a
 
 const {
   value: appPathsInjectable,
-  initializer: initAppPathsInjectable,
+  initializer: initAppPathsOnMainInjectable,
 } = createInitializableState({
   id: "app-paths",
   init: (di) => {
@@ -41,6 +41,6 @@ const {
   when: beforeElectronIsReadyInjectionToken,
 });
 
-export { initAppPathsInjectable };
+export { initAppPathsOnMainInjectable };
 
 export default appPathsInjectable;

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

@@ -9,7 +9,7 @@ import getBuildVersionInjectable from "./get-build-version.injectable";
 
 const {
   value: buildVersionInjectable,
-  initializer: initializeBuildVersionInjectable,
+  initializer: initializeBuildVersionOnMainInjectable,
 } = createInitializableState({
   id: "build-version",
   init: (di) => {
@@ -21,6 +21,6 @@ const {
   when: beforeApplicationIsLoadingInjectionToken,
 });
 
-export { initializeBuildVersionInjectable };
+export { initializeBuildVersionOnMainInjectable };
 
 export default buildVersionInjectable;

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

@@ -11,7 +11,7 @@ import { beforeFrameStartsInjectionToken } from "../before-frame-starts/before-f
 
 const {
   value: appPathsInjectable,
-  initializer: initAppPathsInjectable,
+  initializer: initAppPathsOnRendererInjectable,
 } = createInitializableState({
   id: "app-paths",
   init: (di) => {
@@ -23,6 +23,6 @@ const {
   when: beforeFrameStartsInjectionToken,
 });
 
-export { initAppPathsInjectable };
+export { initAppPathsOnRendererInjectable };
 
 export default appPathsInjectable;

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

@@ -9,7 +9,7 @@ import { beforeFrameStartsInjectionToken } from "../before-frame-starts/before-f
 
 const {
   value: buildVersionInjectable,
-  initializer: initializeBuildVersionInjectable,
+  initializer: initializeBuildVersionOnRendererInjectable,
 } = createInitializableState({
   id: "build-version",
   init: (di) => {
@@ -21,6 +21,6 @@ const {
   when: beforeFrameStartsInjectionToken,
 });
 
-export { initializeBuildVersionInjectable };
+export { initializeBuildVersionOnRendererInjectable };
 
 export default buildVersionInjectable;