Fix runnables to be sync if init is sync

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

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

@@ -2,9 +2,7 @@
  * 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 directoryForUserDataInjectable, { initDirectoryForUserDataOnMainInjectable, initDirectoryForUserDataOnRendererInjectable } from "./directory-for-user-data.injectable";
 import joinPathsInjectable from "../path/join-paths.injectable";
 import { createDependentInitializableState } from "../initializable-state/create-dependent";
 
@@ -22,7 +20,10 @@ const {
 
     return joinPaths(directoryForUserData.get(), "binaries");
   },
-  initAfter: [initAppPathsOnMainInjectable, initAppPathsOnRendererInjectable],
+  initAfter: [
+    initDirectoryForUserDataOnMainInjectable,
+    initDirectoryForUserDataOnRendererInjectable,
+  ],
 });
 
 export {

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

@@ -47,19 +47,31 @@ export function createDependentInitializableState<T>(args: CreateDependentInitia
   });
 
   const initializers = initAfter.map(runnableInjectable => getInjectable({
-    id: `initialize-${id}`,
+    id: `initialize-${id}-during-${runnableInjectable.injectionToken?.id}`,
     instantiate: (di) => ({
       id: `initialize-${id}`,
-      run: async () => {
+      run: (): void | Promise<void> => {
         if (initCalled) {
           throw new Error(`Cannot initialize InitializableState(${id}) more than once`);
         }
 
         initCalled = true;
+        const potentialValue = init(di);
+
+        if (potentialValue instanceof Promise) {
+          // This is done because we have to run syncronously if `init` is syncronous to prevent ordering issues
+          return (async () => {
             box = {
               set: true,
-          value: await init(di),
+              value: await potentialValue,
             };
+          })();
+        } else {
+          box = {
+            set: true,
+            value: potentialValue,
+          };
+        }
       },
       runAfter: di.inject(runnableInjectable),
     }),

src/common/initializable-state/create.ts

@@ -63,10 +63,22 @@ export function createInitializableState<T>(args: CreateInitializableStateArgs<T
         }
 
         initCalled = true;
+        const potentialValue = init(di);
+
+        if (potentialValue instanceof Promise) {
+          // This is done because we have to run syncronously if `init` is syncronous to prevent ordering issues
+          return (async () => {
             box = {
               set: true,
-          value: await init(di),
+              value: await potentialValue,
             };
+          })();
+        } else {
+          box = {
+            set: true,
+            value: potentialValue,
+          };
+        }
       },
     }),
     injectionToken: when,