Bump ogre-tools and adapt to breaking changes (#6481)

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

src/features/helm-charts/child-features/preferences/renderer/active-helm-repositories.injectable.ts

@@ -16,26 +16,34 @@ const activeHelmRepositoriesInjectable = getInjectable({
   instantiate: (di) => {
     const requestFromChannel = di.inject(requestFromChannelInjectionToken);
     const showErrorNotification = di.inject(showErrorNotificationInjectable);
-    const helmRepositoriesErrorState = di.inject(helmRepositoriesErrorStateInjectable);
+    const helmRepositoriesErrorState = di.inject(
+      helmRepositoriesErrorStateInjectable,
+    );
 
-    return asyncComputed(async () => {
-      const result = await requestFromChannel(getActiveHelmRepositoriesChannel);
-
-      if (result.callWasSuccessful) {
-        return result.response;
-      } else {
-        showErrorNotification(result.error);
-
-        runInAction(() =>
-          helmRepositoriesErrorState.set({
-            controlsAreShown: false,
-            errorMessage: result.error,
-          }),
+    return asyncComputed({
+      getValueFromObservedPromise: async () => {
+        const result = await requestFromChannel(
+          getActiveHelmRepositoriesChannel,
         );
 
-        return [];
-      }
-    }, []);
+        if (result.callWasSuccessful) {
+          return result.response;
+        } else {
+          showErrorNotification(result.error);
+
+          runInAction(() =>
+            helmRepositoriesErrorState.set({
+              controlsAreShown: false,
+              errorMessage: result.error,
+            }),
+          );
+
+          return [];
+        }
+      },
+
+      valueWhenPending: [],
+    });
   },
 });
 

src/features/helm-charts/child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/public-helm-repositories.injectable.ts

@@ -12,9 +12,10 @@ const publicHelmRepositoriesInjectable = getInjectable({
   instantiate: (di) => {
     const callForPublicHelmRepositories = di.inject(callForPublicHelmRepositoriesInjectable);
 
-    return asyncComputed(async () => {
-      return await callForPublicHelmRepositories();
-    }, []);
+    return asyncComputed({
+      getValueFromObservedPromise: callForPublicHelmRepositories,
+      valueWhenPending: [],
+    });
   },
 });
 

src/renderer/components/+helm-charts/details/readme-of-selected-helm-chart.injectable.ts

@@ -12,22 +12,29 @@ const readmeOfSelectedHelmChartInjectable = getInjectable({
   id: "readme-of-selected-helm-chart",
 
   instantiate: (di, chart: HelmChart) => {
-    const selection = di.inject(helmChartDetailsVersionSelectionInjectable, chart);
+    const selection = di.inject(
+      helmChartDetailsVersionSelectionInjectable,
+      chart,
+    );
     const requestHelmChartReadme = di.inject(requestHelmChartReadmeInjectable);
 
-    return asyncComputed(async () => {
-      const chartVersion = selection.value.get();
+    return asyncComputed({
+      getValueFromObservedPromise: async () => {
+        const chartVersion = selection.value.get();
 
-      if (!chartVersion) {
-        return "";
-      }
+        if (!chartVersion) {
+          return "";
+        }
 
-      return await requestHelmChartReadme(
-        chartVersion.getRepository(),
-        chartVersion.getName(),
-        chartVersion.getVersion(),
-      );
-    }, "");
+        return await requestHelmChartReadme(
+          chartVersion.getRepository(),
+          chartVersion.getName(),
+          chartVersion.getVersion(),
+        );
+      },
+
+      valueWhenPending: "",
+    });
   },
 
   lifecycle: lifecycleEnum.keyedSingleton({

src/renderer/components/+helm-charts/details/versions-of-selected-helm-chart.injectable.ts

@@ -11,13 +11,16 @@ const versionsOfSelectedHelmChartInjectable = getInjectable({
   id: "versions-of-selected-helm-chart",
 
   instantiate: (di, chart: HelmChart) => {
-    const requestHelmChartVersions = di.inject(requestHelmChartVersionsInjectable);
-
-    return asyncComputed(
-      async () =>
-        await requestHelmChartVersions(chart.getRepository(), chart.getName()),
-      [],
+    const requestHelmChartVersions = di.inject(
+      requestHelmChartVersionsInjectable,
     );
+
+    return asyncComputed({
+      getValueFromObservedPromise: async () =>
+        await requestHelmChartVersions(chart.getRepository(), chart.getName()),
+
+      valueWhenPending: [],
+    });
   },
 
   lifecycle: lifecycleEnum.keyedSingleton({

src/renderer/components/+helm-charts/helm-charts/helm-charts.injectable.ts

@@ -12,7 +12,10 @@ const helmChartsInjectable = getInjectable({
   instantiate: (di) => {
     const requestHelmCharts = di.inject(requestHelmChartsInjectable);
 
-    return asyncComputed(async () => await requestHelmCharts(), []);
+    return asyncComputed({
+      getValueFromObservedPromise: requestHelmCharts,
+      valueWhenPending: [],
+    });
   },
 });
 

src/renderer/components/+helm-charts/helm-charts/versions.injectable.ts

@@ -11,16 +11,25 @@ import requestVersionsOfHelmChartInjectable from "./request-versions-of-chart-fo
 
 const helmChartVersionsInjectable = getInjectable({
   id: "helm-chart-versions-loader",
+
   instantiate: (di, release) => {
     const helmCharts = di.inject(helmChartsInjectable);
-    const requestVersionsOfHelmChart = di.inject(requestVersionsOfHelmChartInjectable);
 
-    return asyncComputed(async () => {
-      await when(() => !helmCharts.pending.get());
+    const requestVersionsOfHelmChart = di.inject(
+      requestVersionsOfHelmChartInjectable,
+    );
 
-      return requestVersionsOfHelmChart(release, helmCharts.value.get());
-    }, []);
+    return asyncComputed({
+      getValueFromObservedPromise: async () => {
+        await when(() => !helmCharts.pending.get());
+
+        return requestVersionsOfHelmChart(release, helmCharts.value.get());
+      },
+
+      valueWhenPending: [],
+    });
   },
+
   lifecycle: lifecycleEnum.keyedSingleton({
     getInstanceKey: (di, release: HelmRelease) => release.getName(),
   }),

src/renderer/components/+helm-releases/releases.injectable.ts

@@ -18,16 +18,23 @@ const releasesInjectable = getInjectable({
     const requestHelmReleases = di.inject(requestHelmReleasesInjectable);
     const toHelmRelease = di.inject(toHelmReleaseInjectable);
 
-    return asyncComputed(async () => {
-      void releaseSecrets.get();
+    return asyncComputed({
+      getValueFromObservedPromise: async () => {
+        void releaseSecrets.get();
 
-      const releaseArrays = await (clusterContext.hasSelectedAll
-        ? requestHelmReleases()
-        : Promise.all(clusterContext.contextNamespaces.map(namespace => requestHelmReleases(namespace)))
-      );
+        const releaseArrays = await (clusterContext.hasSelectedAll
+          ? requestHelmReleases()
+          : Promise.all(
+            clusterContext.contextNamespaces.map((namespace) =>
+              requestHelmReleases(namespace),
+            ),
+          ));
 
-      return releaseArrays.flat().map(toHelmRelease);
-    }, []);
+        return releaseArrays.flat().map(toHelmRelease);
+      },
+
+      valueWhenPending: [],
+    });
   },
 });
 

src/renderer/components/dock/upgrade-chart/upgrade-chart-model.injectable.ts

@@ -54,12 +54,19 @@ const upgradeChartModelInjectable = getInjectable({
           && release.getNs() === tabData.releaseNamespace
         ))
     ));
+
     const versions = di.inject(helmChartVersionsInjectable, release);
-    const storedConfiguration = asyncComputed(() => requestHelmReleaseConfiguration(
-      release.getName(),
-      release.getNs(),
-      true,
-    ), "");
+
+    const storedConfiguration = asyncComputed({
+      getValueFromObservedPromise: () =>
+        requestHelmReleaseConfiguration(
+          release.getName(),
+          release.getNs(),
+          true,
+        ),
+
+      valueWhenPending: "",
+    });
 
     await when(() => !versions.pending.get());
 

src/renderer/extension-loader/extension-should-be-enabled-for-cluster-frame.injectable.ts

@@ -22,22 +22,19 @@ const extensionShouldBeEnabledForClusterFrameInjectable = getInjectable({
     ) =>
       untracked(() => di.inject(extensionIsEnabledForClusterInjectable, { extension, cluster }));
 
-    return asyncComputed(
-      async () => {
+    return asyncComputed({
+      getValueFromObservedPromise: async () => {
         const cluster = activeKubernetesCluster.get();
 
         if (!cluster) {
           return false;
         }
 
-        return getExtensionIsEnabledForCluster(
-          extension,
-          cluster,
-        );
+        return getExtensionIsEnabledForCluster(extension, cluster);
       },
 
-      false,
-    );
+      valueWhenPending: false,
+    });
   },
 
   lifecycle: lifecycleEnum.keyedSingleton({

src/renderer/getDiForUnitTesting.tsx

@@ -118,7 +118,7 @@ export const getDiForUnitTesting = (
 
     // TODO: Remove after "LensRendererExtension.isEnabledForCluster" is removed
     di.override(extensionShouldBeEnabledForClusterFrameInjectable, () =>
-      asyncComputed(async () => true, true),
+      asyncComputed({ getValueFromObservedPromise: async () => true, valueWhenPending: true }),
     );
 
     // TODO: Remove side-effects and shared global state