diff --git a/src/common/app-paths/directory-for-binaries.injectable.ts b/src/common/app-paths/directory-for-binaries.injectable.ts index 13c22322e2..21b8c1250d 100644 --- a/src/common/app-paths/directory-for-binaries.injectable.ts +++ b/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; diff --git a/src/common/app-paths/directory-for-downloads.injectable.ts b/src/common/app-paths/directory-for-downloads.injectable.ts index 503b77061e..0d2b21dd52 100644 --- a/src/common/app-paths/directory-for-downloads.injectable.ts +++ b/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; diff --git a/src/common/app-paths/directory-for-exes.injectable.ts b/src/common/app-paths/directory-for-exes.injectable.ts index 4db3cf258c..a52b95208c 100644 --- a/src/common/app-paths/directory-for-exes.injectable.ts +++ b/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; diff --git a/src/common/app-paths/directory-for-kube-configs.injectable.ts b/src/common/app-paths/directory-for-kube-configs.injectable.ts index e7884e54cb..f3d74c99d7 100644 --- a/src/common/app-paths/directory-for-kube-configs.injectable.ts +++ b/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; diff --git a/src/common/app-paths/directory-for-kubectl-binaries.injectable.ts b/src/common/app-paths/directory-for-kubectl-binaries.injectable.ts index 178a79ad98..378689f18c 100644 --- a/src/common/app-paths/directory-for-kubectl-binaries.injectable.ts +++ b/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; diff --git a/src/common/app-paths/directory-for-temp.injectable.ts b/src/common/app-paths/directory-for-temp.injectable.ts index 4099de2749..d4bae4392d 100644 --- a/src/common/app-paths/directory-for-temp.injectable.ts +++ b/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; diff --git a/src/common/app-paths/directory-for-user-data.injectable.ts b/src/common/app-paths/directory-for-user-data.injectable.ts index 8890a5b635..349bb68fc4 100644 --- a/src/common/app-paths/directory-for-user-data.injectable.ts +++ b/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; diff --git a/src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts b/src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts index 3c7d55bbfc..4661c5aa29 100644 --- a/src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts +++ b/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; diff --git a/src/common/initializable-state/create-dependent.ts b/src/common/initializable-state/create-dependent.ts new file mode 100644 index 0000000000..3010fdeca1 --- /dev/null +++ b/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 { + id: string; + init: (di: DiContainerForInjection) => Promise | T; + injectionToken?: InjectionToken, void>; + initAfter: Injectable, Runnable, void>[]; +} + +export interface CreateDependentInitializableStateResult { + value: Injectable, unknown, void>; + initializers: Injectable, Runnable, void>[]; +} + +export function createDependentInitializableState(args: CreateDependentInitializableStateArgs): CreateDependentInitializableStateResult { + const { id, init, injectionToken, initAfter } = args; + + const valueInjectable = getInjectable({ + id, + instantiate: (di) => { + let box: InitializableStateValue = { + 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, + }; +} diff --git a/src/common/vars/build-semantic-version.injectable.ts b/src/common/vars/build-semantic-version.injectable.ts index 7af7e05e0a..161820cf33 100644 --- a/src/common/vars/build-semantic-version.injectable.ts +++ b/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>({ @@ -17,14 +19,29 @@ export const buildVersionChannel: RequestChannel = { 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; diff --git a/src/common/vars/release-channel.injectable.ts b/src/common/vars/release-channel.injectable.ts index a486585a06..e72d0f3586 100644 --- a/src/common/vars/release-channel.injectable.ts +++ b/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; diff --git a/src/extensions/extension-installer/extension-package-root-directory.injectable.ts b/src/extensions/extension-installer/extension-package-root-directory.injectable.ts index e578506f61..2a7177cf0d 100644 --- a/src/extensions/extension-installer/extension-package-root-directory.injectable.ts +++ b/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; diff --git a/src/extensions/extension-loader/file-system-provisioner-store/directory-for-extension-data.injectable.ts b/src/extensions/extension-loader/file-system-provisioner-store/directory-for-extension-data.injectable.ts index a5d6cffe1d..3c55c0b28e 100644 --- a/src/extensions/extension-loader/file-system-provisioner-store/directory-for-extension-data.injectable.ts +++ b/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; diff --git a/src/features/application-update/common/selected-update-channel/default-update-channel.injectable.ts b/src/features/application-update/common/selected-update-channel/default-update-channel.injectable.ts index 0898d8efaa..1027bbdd13 100644 --- a/src/features/application-update/common/selected-update-channel/default-update-channel.injectable.ts +++ b/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; diff --git a/src/main/app-paths/impl.injectable.ts b/src/main/app-paths/impl.injectable.ts index a16c334be2..3f6c61c46f 100644 --- a/src/main/app-paths/impl.injectable.ts +++ b/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; diff --git a/src/main/vars/build-version/build-version.injectable.ts b/src/main/vars/build-version/build-version.injectable.ts index 47a71a6f8c..45a46c0fce 100644 --- a/src/main/vars/build-version/build-version.injectable.ts +++ b/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; diff --git a/src/renderer/app-paths/impl.injectable.ts b/src/renderer/app-paths/impl.injectable.ts index bef082b847..705b3b6f48 100644 --- a/src/renderer/app-paths/impl.injectable.ts +++ b/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; diff --git a/src/renderer/vars/build-version.injectable.ts b/src/renderer/vars/build-version.injectable.ts index cc45587f52..a862e6a420 100644 --- a/src/renderer/vars/build-version.injectable.ts +++ b/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;