@applicaster/quick-brick-core 15.0.0-alpha.7622155400 → 15.0.0-alpha.7815563606

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/__tests__/usePresentSchemeHandler.test.tsx

@@ -1,14 +1,11 @@
-import * as R from "ramda";
 import axios from "axios";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook, waitFor } from "@testing-library/react-native";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
 import * as helpers from "../../../helpers";
 import * as feedLoader from "@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedLoader";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 import { usePresentSchemeHandler } from "../usePresentSchemeHandler";
 
-import configureStore from "redux-mock-store";
-
 const rivers = {
   A1234: {
     id: "A1234",
@@ -28,8 +25,6 @@ jest.mock(
   })
 );
 
-const mockStore = configureStore();
-
 const helperSpy = jest.spyOn(helpers, "handlePresentNavigation");
 const feedLoaderSpy = jest.spyOn(feedLoader, "useFeedLoader");
 
@@ -179,46 +174,88 @@ describe("usePresentSchemeHandler", () => {
   });
 
   describe("loading new river", () => {
-    it("Re-sets app ready state and calls loadAppContextData with new river and cellStyles data", async () => {
-      const store = mockStore({ test: "test" });
-
-      const wrapper = WrappedWithProviders;
+    const query = { rivers_configuration_id: "layout-uuid" };
 
-      const query = {
-        rivers_configuration_id: "test",
-      };
+    const baseSessionData = {
+      accountsAccountId: "account-123",
+      bundleIdentifier: "com.example.app",
+      app_family_id: "42",
+      version_name: "1.0.0",
+    };
 
-      const storageSpy = jest.spyOn(sessionStorage, "getAllItems");
-      const axiosGetSpy = jest.spyOn(axios, "get");
+    let storageSpy: jest.SpyInstance;
+    let axiosGetSpy: jest.SpyInstance;
 
-      const getAllItems = jest.fn().mockResolvedValue({
-        accountsAccountId: "accountsAccountId",
-        bundleIdentifier: "bundleIdentifier",
-        app_family_id: "app_family_id",
-        version_name: "version_name",
-        store: "store",
-      });
+    beforeEach(() => {
+      storageSpy = jest.spyOn(sessionStorage, "getAllItems");
+      axiosGetSpy = jest.spyOn(axios, "get");
+      axiosGetSpy.mockResolvedValue({ data: {} });
+    });
 
-      const get = jest.fn().mockResolvedValue({ data: "url" });
+    afterEach(() => {
+      storageSpy.mockRestore();
+      axiosGetSpy.mockRestore();
+    });
 
-      storageSpy.mockImplementation(getAllItems);
-      axiosGetSpy.mockImplementation(get);
+    it("fetches the rivers, cell styles and presets mapping URLs", async () => {
+      storageSpy.mockResolvedValue({ ...baseSessionData, store: "store" });
 
       renderHook(() => usePresentSchemeHandler({ query, url: "", onFinish }), {
-        wrapper,
+        wrapper: WrappedWithProviders,
       });
 
-      return () => {
-        const actions = store.getActions();
-
-        expect(
-          actions?.find(R.propEq("type", "SET_APP_NOT_READY"))
-        ).toBeDefined();
+      await waitFor(() => {
+        expect(axiosGetSpy).toHaveBeenCalledWith(
+          expect.stringContaining("/layouts/layout-uuid.json")
+        );
+      });
+    });
 
-        expect(actions?.find(R.propEq("type", "SET_APP_READY"))).toBeDefined();
+    describe("WEB_STORE_PLATFORM CDN store key mapping", () => {
+      it.each([
+        ["samsung", "samsung_app_store"],
+        ["lg", "lg_content_store"],
+        ["vizio", "vizio_app_store"],
+      ])(
+        'maps store="%s" to "%s" in the rivers URL',
+        async (store, expectedCdnKey) => {
+          storageSpy.mockResolvedValue({ ...baseSessionData, store });
+
+          renderHook(
+            () => usePresentSchemeHandler({ query, url: "", onFinish }),
+            { wrapper: WrappedWithProviders }
+          );
+
+          await waitFor(() => {
+            expect(axiosGetSpy).toHaveBeenCalledWith(
+              expect.stringContaining(`/${expectedCdnKey}/`)
+            );
+          });
+
+          // Confirm the raw store name is NOT used in the URL
+          expect(axiosGetSpy).not.toHaveBeenCalledWith(
+            expect.stringContaining(`/${store}/`)
+          );
+        }
+      );
 
-        expect(navigator.replace).toBeCalledWith({});
-      };
+      it("passes through an unmapped store value unchanged", async () => {
+        storageSpy.mockResolvedValue({
+          ...baseSessionData,
+          store: "apple_tv",
+        });
+
+        renderHook(
+          () => usePresentSchemeHandler({ query, url: "", onFinish }),
+          { wrapper: WrappedWithProviders }
+        );
+
+        await waitFor(() => {
+          expect(axiosGetSpy).toHaveBeenCalledWith(
+            expect.stringContaining("/apple_tv/")
+          );
+        });
+      });
     });
   });
 

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/__tests__/useUrlSchemeHandler.test.tsx

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { renderHook } from "@testing-library/react-hooks";
+import { renderHook } from "@testing-library/react-native";
 import * as URLHandlersMap from "..";
 
 import { Provider } from "react-redux";

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/usePresentSchemeHandler.ts

@@ -101,26 +101,28 @@ export function usePresentSchemeHandler({
 
         // @ts-ignore - to be fixed on iOS side
         // key accountsAccountID should be accountsAccountId
-        const accountId = getKeyFromStorage<string>(accountKey, sessionData);
+        const accountId = getKeyFromStorage(accountKey, sessionData);
 
-        const appBundleIdentifier = getKeyFromStorage<string>(
+        const appBundleIdentifier = getKeyFromStorage(
           "bundleIdentifier",
           sessionData
         );
 
-        const versionName = getKeyFromStorage<string>(
-          "version_name",
-          sessionData
-        );
+        const versionName = getKeyFromStorage("version_name", sessionData);
 
-        const familyId = getKeyFromStorage<string>(
-          "app_family_id",
-          sessionData
-        );
+        const familyId = getKeyFromStorage("app_family_id", sessionData);
+
+        const storeKey = getKeyFromStorage("store", sessionData);
+
+        const WEB_STORE_PLATFORM: Record<string, string> = {
+          samsung: "samsung_app_store",
+          lg: "lg_content_store",
+          vizio: "vizio_app_store",
+        };
 
-        const storeKey = getKeyFromStorage<string>("store", sessionData);
+        const cdnStoreKey = WEB_STORE_PLATFORM[storeKey] ?? storeKey;
 
-        const riversUrl = `https://assets-secure.applicaster.com/zapp/accounts/${accountId}/apps/${appBundleIdentifier}/${storeKey}/${versionName}/layouts/${rivers_configuration_id}.json`;
+        const riversUrl = `https://assets-secure.applicaster.com/zapp/accounts/${accountId}/apps/${appBundleIdentifier}/${cdnStoreKey}/${versionName}/layouts/${rivers_configuration_id}.json`;
 
         const cellStylesUrl = `https://assets-secure.applicaster.com/zapp/accounts/${accountId}/app_families/${familyId}/layouts/${rivers_configuration_id}/cell_styles.json`;
 

package/App/DeepLinking/URLSchemeListener/URLSchemeContextProvider.tsx

@@ -10,6 +10,7 @@ import * as ReactNative from "react-native";
 
 import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { log_debug, log_error, log_info } from "../logger";
+import { parseUrl } from "../helpers";
 import { getAppUrlScheme } from "@applicaster/zapp-react-native-utils/appDataUtils";
 import {
   getZappPlatform,
@@ -47,6 +48,24 @@ const getWebDeepLink = (initialURL: string) => {
   return getAppUrlScheme() + "://open" + initialURL.slice(index);
 };
 
+const getPresentDeepLink = (
+  initialURL: string | null | undefined
+): string | null => {
+  if (!initialURL) return null;
+
+  const index = initialURL.indexOf("?");
+  if (index === -1) return null;
+
+  const { query } = parseUrl(initialURL);
+  if (!query?.rivers_configuration_id) return null;
+
+  return getAppUrlScheme() + "://present" + initialURL.slice(index);
+};
+
+export const triggerUrlScheme = (url: string): void => {
+  DeviceEventEmitter.emit("handleOpenUrl", { url });
+};
+
 function URLSchemeContextProvider(props: Props) {
   const [state, setState] = useState<string | null>(initialState.url);
 
@@ -67,6 +86,16 @@ function URLSchemeContextProvider(props: Props) {
       const url = await Linking.getInitialURL();
 
       if (isWeb()) {
+        const presentDeepLink = getPresentDeepLink(url);
+
+        if (presentDeepLink) {
+          log_info(
+            `URLSchemeContextProvider: Retrieved initial deep link: ${presentDeepLink}`
+          );
+
+          return setState(presentDeepLink);
+        }
+
         if (getZappPlatform() === ZappPlatform.Vizio) {
           const deepLink = getWebDeepLink(url);
 
@@ -127,6 +156,36 @@ function URLSchemeContextProvider(props: Props) {
       };
     }
 
+    if (isWeb()) {
+      log_debug(
+        `URLSchemeContextProvider: Register DeviceEventEmitter "handleOpenUrl" listener — Platform.OS=${Platform.OS}`
+      );
+
+      const listener = DeviceEventEmitter.addListener(
+        "handleOpenUrl",
+        ({ url: eventUrl }) => {
+          if (eventUrl) {
+            log_info(
+              `URLSchemeContextProvider: DeviceEventEmitter "handleOpenUrl" received — url=${eventUrl}`
+            );
+
+            setState(eventUrl);
+          }
+        }
+      );
+
+      const linkingListener = Linking.addEventListener(
+        URL_EVENT_TYPE,
+        handleOpenURL
+      );
+
+      return () => {
+        log_debug("URLSchemeContextProvider: Remove URL event listeners");
+        listener.remove();
+        linkingListener.remove();
+      };
+    }
+
     log_debug("URLSchemeContextProvider: Register URL event listener");
 
     const listener = Linking.addEventListener(URL_EVENT_TYPE, handleOpenURL);

package/App/DeepLinking/helpers/index.ts

@@ -120,13 +120,13 @@ export function isInternalUrl(url = "") {
   return query?.isInternalLink;
 }
 
-export function getKeyFromStorage<T extends unknown>(
+export function getKeyFromStorage(
   key: keyof SessionStorageKeys,
   sessionData: Partial<SessionStorageKeys>
-): T {
+): string {
   if (!sessionData[key]) {
     throw new Error(`${key} is not available in session storage data`);
   }
 
-  return R.compose(R.replace(/"/g, ""), R.prop(key))(sessionData);
+  return String(sessionData[key]).replace(/"/g, "");
 }

package/App/ErrorBoundary/__tests__/store.test.js

@@ -1,4 +1,4 @@
-import { act, renderHook } from "@testing-library/react-hooks";
+import { act, renderHook } from "@testing-library/react-native";
 import { useErrorStore } from "../store";
 
 describe("Error Store", () => {

package/App/NavigationProvider/NavigationProvider.tsx

@@ -7,7 +7,7 @@ import {
   getTargetRoute,
   usesVideoModal,
 } from "@applicaster/zapp-react-native-utils/navigationUtils";
-import { last } from "@applicaster/zapp-react-native-utils/utils";
+import { clone, last } from "@applicaster/zapp-react-native-utils/utils";
 import {
   allowedOrientationsForScreen,
   useGetScreenOrientation,
@@ -246,22 +246,24 @@ export function NavigationProvider({ children }: Props) {
     const screen = rivers[screenId];
     const parent = findParent(context, navigator.currentRoute);
 
+    const entryClone = clone(entry);
+
     if (!screen) {
       logger.warn({
         message: `Cannot resolve type mapping for ${screenId} id`,
-        data: { entry, screenId },
+        data: { entry: entryClone, screenId },
       });
 
       return;
     }
 
     if (parent) {
-      entry.parent = parent?.data;
+      entryClone.parent = parent?.data;
 
-      entry.parentId = parent?.id;
+      entryClone.parentId = parent?.id;
     }
 
-    dispatch(setNestedContent(pathname, entry, screen));
+    dispatch(setNestedContent(pathname, entryClone, screen));
   };
 
   const pushItem = (item, options = {}) => {

package/App/NavigationProvider/__tests__/navigationProvider.test.tsx

@@ -450,4 +450,56 @@ describe("<NavigationProvider />", () => {
       });
     });
   });
+
+  describe("setNestedScreenContent", () => {
+    it("should clone the entry object before modifying it", () => {
+      const originalEntry = {
+        id: "test-entry",
+        type: {
+          value: "feed",
+        },
+        title: "Test Entry",
+      };
+
+      const entryBeforeCall = structuredClone(originalEntry);
+
+      act(() => {
+        const view = getByTestId(wrapper, "WrapperView");
+        view.props.navigator.setNestedScreenContent(originalEntry, "A1234");
+      });
+
+      // Verify that the original entry object has not been modified
+      expect(originalEntry).toEqual(entryBeforeCall);
+      expect(originalEntry.parent).toBeUndefined();
+      expect(originalEntry.parentId).toBeUndefined();
+    });
+
+    it("should not mutate the original entry when parent exists", () => {
+      // First push a route to create a parent context
+      act(() => {
+        const view = getByTestId(wrapper, "WrapperView");
+        view.props.navigator.push(rivers.A1234);
+      });
+
+      const originalEntry = {
+        id: "test-entry",
+        type: {
+          value: "feed",
+        },
+        title: "Test Entry",
+      };
+
+      const entryBeforeCall = structuredClone(originalEntry);
+
+      act(() => {
+        const view = getByTestId(wrapper, "WrapperView");
+        view.props.navigator.setNestedScreenContent(originalEntry, "B4567");
+      });
+
+      // Verify that the original entry object has not been modified
+      expect(originalEntry).toEqual(entryBeforeCall);
+      expect(originalEntry.parent).toBeUndefined();
+      expect(originalEntry.parentId).toBeUndefined();
+    });
+  });
 });

package/App/NavigationProvider/navigator/selectors.ts

@@ -60,7 +60,7 @@ export const previousStackEntriesSelector = createSelector(
 export const lastEntrySelector = createSelector(
   navigationStackSelector,
   R.compose(R.last, R.when(R.has("mainStack"), R.prop("mainStack")))
-) as (state: any) => any; // TODO: tighten type to NavigationScreenState
+) as (state: any) => NavigationScreenState | undefined;
 
 // Selector extracting identifiers of plugins requiring startup execution
 export const startUpHookPluginIdentifiersSelector = createSelector(

package/App/NetworkStatusProvider/__tests__/NetworkStatusProvider.test.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import * as R from "ramda";
-import { renderHook, act } from "@testing-library/react-hooks";
+import { renderHook, act } from "@testing-library/react-native";
 import { NetworkStatusContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NetworkStatusContext";
 import { NetworkStatusProvider } from "../NetworkStatusProvider";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
@@ -52,7 +52,7 @@ describe("NetworkStatusProvider", function () {
     expect(result.current).toStrictEqual(NetInfoMock);
   });
 
-  it("should call onConnectionLost callback when connection type changes to none", function () {
+  it("should call onConnectionLost callback when connection type changes to none", async function () {
     const onConnectionLost = jest.fn();
 
     const store = {
@@ -79,7 +79,7 @@ describe("NetworkStatusProvider", function () {
     expect(onConnectionLost).toBeCalledTimes(1);
   });
 
-  it("should call onConnectionRestored callback when connection type switches from none", function () {
+  it("should call onConnectionRestored callback when connection type switches from none", async function () {
     const onConnectionRestored = jest.fn();
 
     const store = {
@@ -116,7 +116,7 @@ describe("NetworkStatusProvider", function () {
     expect(onConnectionRestored).toBeCalledTimes(1);
   });
 
-  it("should call onConnectionTypeChanged callback when connection type changes", function () {
+  it("should call onConnectionTypeChanged callback when connection type changes", async function () {
     const onConnectionTypeChanged = jest.fn();
 
     const store = {

package/App/ThemeManager/index.tsx

@@ -9,6 +9,7 @@ import {
   partitionByKeys,
 } from "@applicaster/zapp-react-native-utils/objectUtils";
 import { getLocalizations } from "@applicaster/zapp-react-native-utils/appUtils/localizationsHelper";
+import { saveNetworkStatusLocalizations } from "./utils";
 
 type Props = {
   children: React.ReactNode;
@@ -104,6 +105,14 @@ function ThemeManagerComponent({ children, plugins }: Props) {
   const [selectedThemeId, setSelectedThemeId] =
     React.useState(DEFAULT_THEME_ID);
 
+  React.useEffect(() => {
+    const selectedTheme = themes[selectedThemeId];
+
+    if (selectedTheme) {
+      saveNetworkStatusLocalizations(selectedTheme);
+    }
+  }, [themes, selectedThemeId]);
+
   return (
     <MemoizedThemeContextProvider
       themes={themes}

package/App/ThemeManager/utils.ts

@@ -0,0 +1,54 @@
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+
+const NETWORK_STATUS_LOCALIZATIONS_KEY = "network_status_localizations";
+const THEME_STORAGE_NAMESPACE = "quick-brick-theme";
+
+const DEFAULT_NETWORK_STATUS_LOCALIZATIONS: Record<string, string> = {
+  offline_notification_title: "No internet connection",
+  offline_notification_subtitle: "Please check your connection",
+  online_notification_title: "You are back online",
+  online_notification_subtitle: "Feel free to continue where you left off",
+};
+
+const NETWORK_STATUS_KEYS = Object.keys(
+  DEFAULT_NETWORK_STATUS_LOCALIZATIONS
+) as (keyof typeof DEFAULT_NETWORK_STATUS_LOCALIZATIONS)[];
+
+export async function saveNetworkStatusLocalizations(
+  themeOrLocalizations: Record<string, unknown>
+) {
+  try {
+    const storedLocalizations = await sessionStorage.getItem(
+      NETWORK_STATUS_LOCALIZATIONS_KEY,
+      THEME_STORAGE_NAMESPACE
+    );
+
+    if (storedLocalizations) {
+      return;
+    }
+
+    const networkStatusLocalizations = NETWORK_STATUS_KEYS.reduce(
+      (acc, key) => {
+        const value = themeOrLocalizations[key];
+
+        acc[key] =
+          typeof value === "string"
+            ? value
+            : DEFAULT_NETWORK_STATUS_LOCALIZATIONS[key];
+
+        return acc;
+      },
+      {} as Record<string, string>
+    );
+
+    if (Object.keys(networkStatusLocalizations).length > 0) {
+      await sessionStorage.setItem(
+        NETWORK_STATUS_LOCALIZATIONS_KEY,
+        JSON.stringify(networkStatusLocalizations),
+        THEME_STORAGE_NAMESPACE
+      );
+    }
+  } catch (error) {
+    console.error("Error saving network status localizations", error);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "15.0.0-alpha.7622155400",
+  "version": "15.0.0-alpha.7815563606",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,13 +28,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "15.0.0-alpha.7622155400",
-    "@applicaster/quick-brick-core-plugins": "15.0.0-alpha.7622155400",
-    "@applicaster/zapp-pipes-v2-client": "15.0.0-alpha.7622155400",
-    "@applicaster/zapp-react-native-bridge": "15.0.0-alpha.7622155400",
-    "@applicaster/zapp-react-native-redux": "15.0.0-alpha.7622155400",
-    "@applicaster/zapp-react-native-ui-components": "15.0.0-alpha.7622155400",
-    "@applicaster/zapp-react-native-utils": "15.0.0-alpha.7622155400",
+    "@applicaster/applicaster-types": "15.0.0-alpha.7815563606",
+    "@applicaster/quick-brick-core-plugins": "15.0.0-alpha.7815563606",
+    "@applicaster/zapp-pipes-v2-client": "15.0.0-alpha.7815563606",
+    "@applicaster/zapp-react-native-bridge": "15.0.0-alpha.7815563606",
+    "@applicaster/zapp-react-native-redux": "15.0.0-alpha.7815563606",
+    "@applicaster/zapp-react-native-ui-components": "15.0.0-alpha.7815563606",
+    "@applicaster/zapp-react-native-utils": "15.0.0-alpha.7815563606",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",