@ledgerhq/live-common 34.39.0-nightly.0 → 34.39.0-nightly.1

package/src/hooks/useAppVersionBlockCheck.test.ts

@@ -0,0 +1,134 @@
+import { useAppVersionBlockCheck } from "./useAppVersionBlockCheck";
+
+describe("useAppVersionBlockCheck", () => {
+  describe("LLM", () => {
+    it("should update if current version is not compatible on android", () => {
+      // given
+      const getConfigValue = () => ({
+        llm: {
+          android: [
+            {
+              minOsVersion: "32",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "android",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(true);
+    });
+    it("should update if current version is not compatible on ios", () => {
+      const getConfigValue = () => ({
+        llm: {
+          ios: [
+            {
+              minOsVersion: "32",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "ios",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(true);
+    });
+    it("should not update the app if current version is not compatible on android with another os version", () => {
+      // given
+      const getConfigValue = () => ({
+        llm: {
+          android: [
+            {
+              minOsVersion: "33",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "android",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(false);
+    });
+    it("should not update the app if current version is not compatible on ios with another os version", () => {
+      // given
+      const getConfigValue = () => ({
+        llm: {
+          ios: [
+            {
+              minOsVersion: "33",
+              version: "2.0.3",
+            },
+          ],
+        },
+      });
+      // when
+      const { shouldUpdate } = useAppVersionBlockCheck({
+        appVersion: "2.0.1",
+        osVersion: "32",
+        platform: "ios",
+        appKey: "llm",
+        getConfigValue,
+      });
+      //then
+      expect(shouldUpdate).toBe(false);
+    });
+    it.each([
+      ["android", "2.1.3"],
+      ["ios", "2.1.3"],
+      ["android", "2.1.3-rc.2"],
+      ["ios", "2.1.3-rc.2"],
+      ["android", "2.2.3-next.0"],
+      ["ios", "2.2.3-next.0"],
+      ["android", "2.0.3-rc2"],
+      ["ios", "2.0.3-rc2"],
+      ["android", "2.0.3-next.3"],
+      ["ios", "2.0.3-next.3"],
+    ])(
+      "should not update the app on %s for version %s compatible with 2.0.3",
+      (platform, appVersion) => {
+        // given
+        const getConfigValue = () => ({
+          llm: {
+            [platform]: [
+              {
+                minOsVersion: "32",
+                version: "2.0.3",
+              },
+            ],
+          },
+        });
+        // when
+        const { shouldUpdate } = useAppVersionBlockCheck({
+          appVersion,
+          osVersion: "32",
+          platform: platform as "ios" | "android",
+          appKey: "llm",
+          getConfigValue,
+        });
+        // then
+        expect(shouldUpdate).toBe(false);
+      },
+    );
+  });
+});

package/src/hooks/useAppVersionBlockCheck.ts

@@ -0,0 +1,65 @@
+import semver from "semver";
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
+
+type LLMMinVersionConfig = {
+  minOsVersion: string;
+  version: string;
+};
+
+type LLMinVersionConfig = {
+  lld: {
+    windows: string;
+    macOS: string;
+    linux: string;
+  };
+  llm: {
+    android: LLMMinVersionConfig[];
+    ios: LLMMinVersionConfig[];
+  };
+};
+
+const checkLLmVersion = (
+  appVersion: string,
+  osVersion: string,
+  platform: "ios" | "android",
+  llmMinVersionConfig: LLMinVersionConfig["llm"],
+) => {
+  if (!llmMinVersionConfig[platform]) {
+    return false;
+  }
+
+  return llmMinVersionConfig[platform]
+    .filter(minVersionConfig =>
+      semver.satisfies(semver.coerce(osVersion), `>=${minVersionConfig.minOsVersion}`),
+    )
+    .reduce((acc, curr) => {
+      return acc || semver.satisfies(appVersion, `<${curr.version}`);
+    }, false);
+};
+
+export const useAppVersionBlockCheck = ({
+  appVersion: uncoercedAppVersion,
+  appKey,
+  platform,
+  osVersion,
+  getConfigValue = LiveConfig.getValueByKey,
+}: {
+  appVersion: string;
+  osVersion?: string;
+  appKey: "llm" | "lld";
+  platform: "ios" | "android" | "macOS" | "windows" | "linux";
+  getConfigValue?: typeof LiveConfig.getValueByKey;
+}) => {
+  const llMinVersionConfig = getConfigValue("config_ll_min_version");
+  const appVersion = semver.coerce(uncoercedAppVersion)?.version || "";
+  let shouldUpdate = false;
+
+  if (!llMinVersionConfig) {
+    return { shouldUpdate };
+  }
+
+  if (appKey === "llm" && (platform === "android" || platform === "ios") && osVersion) {
+    shouldUpdate = checkLLmVersion(appVersion, osVersion, platform, llMinVersionConfig[appKey]);
+  }
+  return { shouldUpdate };
+};

package/src/hw/connectAppEventMapper.ts

@@ -203,7 +203,9 @@ export class ConnectAppEventMapper {
         type: "install",
         name: installPlan.installPlan[installPlan.currentIndex]!.versionName,
       },
-      installQueue: installPlan.installPlan.map(app => app.versionName),
+      installQueue: installPlan.installPlan
+        .map(app => app.versionName)
+        .slice(installPlan.currentIndex),
     });
     this.installPlan = installPlan;
   }

package/src/modularDrawer/__test__/useModularDrawerVisibility.test.ts

@@ -0,0 +1,149 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useModularDrawerVisibility } from "../useModularDrawerVisibility";
+import { ModularDrawerLocation } from "../enums";
+import {
+  makeMockedFeatureFlagsProviderWrapper,
+  makeMockedContextValue,
+} from "../../featureFlags/mock";
+
+describe("useModularDrawerVisibility", () => {
+  describe("lldModularDrawer", () => {
+    it("should return false if the feature flag is not enabled", () => {
+      const mockedFeatures = {
+        lldModularDrawer: {
+          enabled: false,
+          params: { [ModularDrawerLocation.ADD_ACCOUNT]: true },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return false if the location param is not set", () => {
+      const mockedFeatures = {
+        lldModularDrawer: { enabled: true, params: {} },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return the correct visibility for each location", () => {
+      const mockedFeatures = {
+        lldModularDrawer: {
+          enabled: true,
+          params: {
+            [ModularDrawerLocation.ADD_ACCOUNT]: true,
+            [ModularDrawerLocation.EARN_FLOW]: false,
+          },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.EARN_FLOW)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.LIVE_APP)).toBe(false);
+    });
+  });
+
+  describe("llmModularDrawer", () => {
+    it("should return false if the feature flag is not enabled", () => {
+      const mockedFeatures = {
+        llmModularDrawer: {
+          enabled: false,
+          params: { [ModularDrawerLocation.ADD_ACCOUNT]: true },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return false if the location param is not set", () => {
+      const mockedFeatures = {
+        llmModularDrawer: { enabled: true, params: {} },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return the correct visibility for each location", () => {
+      const mockedFeatures = {
+        llmModularDrawer: {
+          enabled: true,
+          params: {
+            [ModularDrawerLocation.ADD_ACCOUNT]: false,
+            [ModularDrawerLocation.EARN_FLOW]: true,
+            [ModularDrawerLocation.RECEIVE_FLOW]: true,
+          },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.EARN_FLOW)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.RECEIVE_FLOW)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.LIVE_APP)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.SEND_FLOW)).toBe(false);
+    });
+  });
+});

package/src/modularDrawer/enums.ts

@@ -0,0 +1,7 @@
+export enum ModularDrawerLocation {
+  ADD_ACCOUNT = "add_account",
+  EARN_FLOW = "earn_flow",
+  LIVE_APP = "live_app",
+  RECEIVE_FLOW = "receive_flow",
+  SEND_FLOW = "send_flow",
+}

package/src/modularDrawer/useModularDrawerVisibility.ts

@@ -0,0 +1,25 @@
+import { useCallback } from "react";
+import { useFeature } from "../featureFlags";
+import { ModularDrawerLocation } from "./enums";
+
+type ModularDrawerFeatureFlagKey = "lldModularDrawer" | "llmModularDrawer";
+
+export function useModularDrawerVisibility({
+  modularDrawerFeatureFlagKey,
+}: {
+  modularDrawerFeatureFlagKey: ModularDrawerFeatureFlagKey;
+}) {
+  const featureModularDrawer = useFeature(modularDrawerFeatureFlagKey);
+
+  const isModularDrawerVisible = useCallback(
+    (location: ModularDrawerLocation) => {
+      if (!featureModularDrawer?.enabled) return false;
+      return featureModularDrawer.params?.[location] ?? false;
+    },
+    [featureModularDrawer],
+  );
+
+  return {
+    isModularDrawerVisible,
+  };
+}