Extract states of application update to be usable from all environments

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

src/common/application-update/checking-for-updates/checking-for-updates-state.injectable.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 createSyncBoxInjectable from "../../sync-box/create-sync-box.injectable";
+
+const checkingForUpdatesStateInjectable = getInjectable({
+  id: "checking-for-updates-state",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox("checking-for-updates");
+  },
+});
+
+export default checkingForUpdatesStateInjectable;

src/common/application-update/discovered-version/discovered-version-state.injectable.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 createSyncBoxInjectable from "../../sync-box/create-sync-box.injectable";
+
+const discoveredVersionStateInjectable = getInjectable({
+  id: "discovered-version-state",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox("discovered-version-state");
+  },
+});
+
+export default discoveredVersionStateInjectable;

src/common/application-update/downloading-update/downloading-update-state.injectable.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 createSyncBoxInjectable from "../../sync-box/create-sync-box.injectable";
+
+const downloadingUpdateStateInjectable = getInjectable({
+  id: "downloading-update-state",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox("downloading-update");
+  },
+});
+
+export default downloadingUpdateStateInjectable;

src/main/update-app/version-update.injectable.ts

@@ -3,14 +3,18 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import type { IComputedValue, IObservableValue } from "mobx";
+import type { IComputedValue } from "mobx";
-import { computed, observable, runInAction } from "mobx";
+import { computed, runInAction } from "mobx";
 import selectedUpdateChannelInjectable from "./selected-update-channel.injectable";
 import downloadPlatformUpdateInjectable from "./download-platform-update/download-platform-update.injectable";
 import type { CheckForPlatformUpdates } from "./check-for-platform-updates/check-for-platform-updates.injectable";
 import checkForPlatformUpdatesInjectable from "./check-for-platform-updates/check-for-platform-updates.injectable";
 import type { UpdateChannel } from "./update-channels";
 import showNotificationInjectable from "../show-notification/show-notification.injectable";
+import checkingForUpdatesStateInjectable from "../../common/application-update/checking-for-updates/checking-for-updates-state.injectable";
+import type { SyncBox } from "../../common/sync-box/create-sync-box.injectable";
+import downloadingUpdateStateInjectable from "../../common/application-update/downloading-update/downloading-update-state.injectable";
+import discoveredVersionStateInjectable from "../../common/application-update/discovered-version/discovered-version-state.injectable";
 
 const versionUpdateInjectable = getInjectable({
   id: "version-update",
@@ -20,30 +24,37 @@ const versionUpdateInjectable = getInjectable({
     const downloadPlatformUpdate = di.inject(downloadPlatformUpdateInjectable);
     const checkForPlatformUpdates = di.inject(checkForPlatformUpdatesInjectable);
     const showNotification = di.inject(showNotificationInjectable);
-
+    const checkingForUpdatesState = di.inject(checkingForUpdatesStateInjectable);
-    const discoveredVersionState = observable.box<string>();
+    const downloadingUpdateState = di.inject(downloadingUpdateStateInjectable);
-    const downloadingState = observable.box<boolean>(false);
+    const discoveredVersionState = di.inject(discoveredVersionStateInjectable);
-    const checkingState = observable.box<boolean>(false);
-    const discoveredFromUpdateChannelState = observable.box<UpdateChannel>();
 
     return {
-      discoveredVersion: computed(() => discoveredVersionState.get()),
+      discoveredVersion: computed(() => {
-      discoveredFromUpdateChannel: computed(() => discoveredFromUpdateChannelState.get()),
+        const discoveredVersion = discoveredVersionState.value.get();
-      downloading: computed(() => downloadingState.get()),
+
-      checking: computed(() => checkingState.get()),
+        return discoveredVersion?.version;
+      }),
+
+      discoveredFromUpdateChannel: computed(() => {
+        const discoveredVersion = discoveredVersionState.value.get();
+
+        return discoveredVersion?.updateChannel;
+      }),
+
+      downloading: computed(() => downloadingUpdateState.value.get()),
+      checking: computed(() => checkingForUpdatesState.value.get()),
 
       checkForUpdates: checkForUpdatesFor(
         checkForPlatformUpdates,
         discoveredVersionState,
-        checkingState,
         selectedUpdateChannel.value,
-        discoveredFromUpdateChannelState,
         showNotification,
+        checkingForUpdatesState,
       ),
 
       downloadUpdate: downloadUpdateFor(
         downloadPlatformUpdate,
-        downloadingState,
+        downloadingUpdateState,
       ),
     };
   },
@@ -53,33 +64,32 @@ export default versionUpdateInjectable;
 
 const downloadUpdateFor =
   (
-    downloadPlatformUpdate: () => Promise<void>,
+    downloadPlatformUpdate: () => Promise<{ downloadWasSuccessful: boolean }>,
-    downloadingState: IObservableValue<boolean>,
+    downloadingUpdateState: SyncBox<boolean>,
   ) =>
     async () => {
       runInAction(() => {
-        downloadingState.set(true);
+        downloadingUpdateState.set(true);
       });
 
       await downloadPlatformUpdate();
 
       runInAction(() => {
-        downloadingState.set(false);
+        downloadingUpdateState.set(false);
       });
     };
 
 const checkForUpdatesFor =
   (
     checkForPlatformUpdates: CheckForPlatformUpdates,
-    discoveredVersionState: IObservableValue<string>,
+    discoveredVersionState: SyncBox<{ version: string; updateChannel: UpdateChannel }>,
-    checkingState: IObservableValue<boolean>,
     selectedUpdateChannel: IComputedValue<UpdateChannel>,
-    discoveredFromUpdateChannelState: IObservableValue<UpdateChannel>,
     showNotification: (message: string) => void,
+    checkingForUpdatesState: SyncBox<boolean>,
   ) =>
     async () => {
       runInAction(() => {
-        checkingState.set(true);
+        checkingForUpdatesState.set(true);
       });
 
       const checkForUpdatesStartingFromChannel =
@@ -96,9 +106,8 @@ const checkForUpdatesFor =
       }
 
       runInAction(() => {
-        discoveredFromUpdateChannelState.set(actualUpdateChannel);
+        discoveredVersionState.set({ version, updateChannel: actualUpdateChannel });
-        discoveredVersionState.set(version);
+        checkingForUpdatesState.set(false);
-        checkingState.set(false);
       });
 
       return { updateWasDiscovered, version };