@applicaster/zapp-react-native-utils 14.0.0-alpha.4111088201 → 14.0.0-alpha.4138342511

package/reactHooks/feed/__tests__/useFeedLoader.test.tsx

@@ -4,13 +4,11 @@ import * as zappPipesModule from "@applicaster/zapp-react-native-redux/ZappPipes
 import * as reactReduxModules from "react-redux";
 import { Provider } from "react-redux";
 import * as React from "react";
-import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
 import * as useRouteHook from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useRoute";
 import * as useNavigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
 import { useFeedLoader } from "../useFeedLoader";
-
-const mockStore = configureStore([thunk]);
+import { WrappedWithProviders } from "../../../testUtils";
+import { ScreenStateResolver } from "../../../appUtils/contextKeysManager/contextResolver";
 
 jest.useFakeTimers({ legacyFakeTimers: true });
 
@@ -55,13 +53,15 @@ const mockZappPipesData = {
 
 describe("useFeedLoader", () => {
   describe("with cached feed url", () => {
-    const store = mockStore({
+    const store = {
       plugins: [],
       zappPipes: { "test://testfakeurl": mockZappPipesData },
-    });
+    };
 
-    const wrapper: React.FC<any> = ({ children }) => (
-      <Provider store={store}>{children}</Provider>
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store || store}>
+        {children}
+      </WrappedWithProviders>
     );
 
     it("returns cached feed", () => {
@@ -110,8 +110,10 @@ describe("useFeedLoader", () => {
   describe("without cached feeds", () => {
     const feedUrl = "test://testfakeurl2";
 
-    const wrapper: React.FC<any> = ({ children, store }) => (
-      <Provider store={store}>{children}</Provider>
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store}>
+        {children}
+      </WrappedWithProviders>
     );
 
     it("It loads data for new url and returns it", () => {
@@ -123,10 +125,10 @@ describe("useFeedLoader", () => {
         .spyOn(zappPipesModule, "loadPipesData")
         .mockImplementation(jest.fn());
 
-      const initialStore = mockStore({
+      const initialStore = {
         plugins: [],
         zappPipes: { "test://testfakeurl": "foobar" },
-      });
+      };
 
       const { result, rerender } = renderHook(
         () => useFeedLoader({ feedUrl: "test://testfakeurl2" }),
@@ -135,15 +137,19 @@ describe("useFeedLoader", () => {
 
       expect(result.current.data).toBeNull();
 
-      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
+      expect(loadPipesDataSpy).toHaveBeenCalledWith(feedUrl, {
         clearCache: true,
         riverId: undefined,
+        callback: expect.any(Function),
+        resolvers: {
+          screen: expect.any(ScreenStateResolver),
+        },
       });
 
-      const store2 = mockStore({
+      const store2 = {
         plugins: [],
         zappPipes: { "test://testfakeurl2": mockZappPipesData },
-      });
+      };
 
       rerender({ store: store2 });
 
@@ -179,6 +185,11 @@ describe("useFeedLoader", () => {
       expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
         clearCache: true,
         riverId: undefined,
+        resolvers: {
+          screen: {
+            screenStateStore: undefined,
+          },
+        },
       });
 
       const store2 = mockStore({
@@ -228,6 +239,11 @@ describe("useFeedLoader", () => {
         expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
           clearCache: true,
           silentRefresh: true,
+          resolvers: {
+            screen: {
+              screenStateStore: undefined,
+            },
+          },
         });
 
         loadPipesDataSpy.mockRestore();
@@ -267,6 +283,11 @@ describe("useFeedLoader", () => {
         expect(loadPipesDataSpy).toBeCalledWith(nextUrl, {
           parentFeed: feedUrlWithNext,
           silentRefresh: true,
+          resolvers: {
+            screen: {
+              screenStateStore: undefined,
+            },
+          },
         });
 
         loadPipesDataSpy.mockRestore();

package/reactHooks/feed/index.ts

@@ -11,3 +11,5 @@ export { useBuildPipesUrl } from "./useBuildPipesUrl";
 export { usePipesCacheReset } from "./usePipesCacheReset";
 
 export { useBatchLoading } from "./useBatchLoading";
+
+export { useLoadPipesDataDispatch } from "./useLoadPipesDataDispatch";

package/reactHooks/feed/useBatchLoading.ts

@@ -1,16 +1,15 @@
 import { complement, compose, isNil, map, min, prop, take, uniq } from "ramda";
-import { useDispatch } from "react-redux";
 import * as React from "react";
-import { useZappPipesFeeds } from "@applicaster/zapp-react-native-redux/hooks";
-import { loadPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
+import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux";
 import { isNilOrEmpty } from "../../reactUtils/helpers";
 import { ZappPipesSearchContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import {
   getInflatedDataSourceUrl,
   getSearchContext,
+  useLoadPipesDataDispatch,
 } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { isGallery } from "@applicaster/zapp-react-native-utils/componentsUtils";
-import { useScreenContext } from "../screen/useScreenContext";
+import { useScreenContext } from "../screen";
 
 type Options = {
   initialBatchSize?: number;
@@ -63,7 +62,6 @@ export const useBatchLoading = (
   componentsToRender: { data?: ZappDataSource; component_type: string }[],
   options: Options
 ) => {
-  const dispatch = useDispatch();
   const { screen: screenContext, entry: entryContext } = useScreenContext();
   const [searchContext] = ZappPipesSearchContext.useZappPipesContext();
   const [hasEverBeenReady, setHasEverBeenReady] = React.useState(false);
@@ -118,7 +116,9 @@ export const useBatchLoading = (
     []
   );
 
-  const feeds = useZappPipesFeeds(feedUrls);
+  const feeds = useZappPipesFeed(feedUrls);
+
+  const loadPipesDataDispatcher = useLoadPipesDataDispatch();
 
   // dispatch loadPipesData for each feed that is not loaded
   const runBatchLoading = React.useCallback(() => {
@@ -138,13 +138,20 @@ export const useBatchLoading = (
 
         if (mappedFeedUrl) {
           // 4. load data
-          return dispatch(
-            loadPipesData(mappedFeedUrl, { riverId: options.riverId })
+          return loadPipesDataDispatcher(
+            mappedFeedUrl,
+            {
+              riverId: options.riverId,
+            },
+            {
+              withResolvers: true,
+              withScreenRouteMapping: true,
+            }
           );
         }
       }
     });
-  }, [feedUrls, feeds]);
+  }, [feedUrls, feeds, loadPipesDataDispatcher]);
 
   React.useEffect(() => {
     runBatchLoading();

package/reactHooks/feed/useFeedLoader.tsx

@@ -1,13 +1,11 @@
 import React, { useEffect } from "react";
-import { useDispatch } from "react-redux";
 
-import { loadPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
-import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux/hooks";
+import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux";
 
 import { reactHooksLogger } from "../logger";
 import { shouldDispatchData, useIsInitialRender } from "../utils";
 import { useInflatedUrl } from "./useInflatedUrl";
-import { useRoute } from "../navigation";
+import { useLoadPipesDataDispatch } from "./useLoadPipesDataDispatch";
 
 const logger = reactHooksLogger.addSubsystem("useFeedLoader");
 
@@ -49,29 +47,26 @@ export const useFeedLoader = ({
   }, []);
 
   const isInitialRender = useIsInitialRender();
-  const dispatch = useDispatch();
-  const { screenData } = useRoute();
 
   const callableFeedUrl = useInflatedUrl({ feedUrl, mapping });
 
   const currentFeed = useZappPipesFeed(callableFeedUrl);
 
-  const riverId =
-    (screenData as LegacyNavigationScreenData)?.targetScreen?.id ??
-    screenData?.id;
+  const loadPipesDataDispatcher = useLoadPipesDataDispatch();
 
   const reloadData = React.useCallback<ReloadDataFunction>(
     (silentRefresh = true, callback) => {
-      if (callableFeedUrl) {
-        dispatch(
-          loadPipesData(callableFeedUrl, {
-            clearCache: true,
-            silentRefresh,
-            callback,
-            riverId,
-          })
-        );
-      }
+      loadPipesDataDispatcher(
+        callableFeedUrl,
+        {
+          clearCache: true,
+          silentRefresh,
+          callback,
+        },
+        {
+          withResolvers: true,
+        }
+      );
     },
     [callableFeedUrl]
   );
@@ -80,15 +75,16 @@ export const useFeedLoader = ({
     if (callableFeedUrl) {
       const nextFeed = currentFeed?.data?.next;
 
-      if (nextFeed) {
-        dispatch(
-          loadPipesData(nextFeed, {
-            silentRefresh: true,
-            parentFeed: callableFeedUrl,
-            riverId,
-          })
-        );
-      }
+      loadPipesDataDispatcher(
+        nextFeed,
+        {
+          silentRefresh: true,
+          parentFeed: callableFeedUrl,
+        },
+        {
+          withResolvers: true,
+        }
+      );
     }
   }, [callableFeedUrl, currentFeed?.data?.next]);
 
@@ -97,12 +93,16 @@ export const useFeedLoader = ({
       shouldDispatchData(callableFeedUrl, currentFeed, pipesOptions.clearCache)
     ) {
       if (callableFeedUrl && !pipesOptions.skipLoading) {
-        dispatch(
-          loadPipesData(callableFeedUrl, {
+        loadPipesDataDispatcher(
+          callableFeedUrl,
+          {
             ...pipesOptions,
             clearCache: true,
-            riverId,
-          })
+          },
+          {
+            withResolvers: true,
+            withScreenRouteMapping: true,
+          }
         );
       } else if (!callableFeedUrl) {
         logger.info({
@@ -131,9 +131,11 @@ export const useFeedLoader = ({
   // Reload feed when feedUrl changes, unless skipLoading is true
   useEffect(() => {
     if (!isInitialRender && callableFeedUrl && !pipesOptions.skipLoading) {
-      dispatch(loadPipesData(callableFeedUrl, { ...pipesOptions, riverId }));
+      loadPipesDataDispatcher(callableFeedUrl, pipesOptions, {
+        withResolvers: true,
+      });
     }
-  }, [callableFeedUrl]);
+  }, [callableFeedUrl, isInitialRender, pipesOptions.skipLoading]);
 
   return React.useMemo(() => {
     if (!callableFeedUrl || !feedUrl) {

package/reactHooks/feed/useLoadPipesDataDispatch.ts

@@ -0,0 +1,57 @@
+import {
+  useAppDispatch,
+  ZappPipes,
+} from "@applicaster/zapp-react-native-redux";
+import { applyScreenRouteDefaults } from "@applicaster/zapp-react-native-redux/ZappPipes/feedProcessor";
+import React from "react";
+import { useScreenResolvers } from "../../actionsExecutor/screenResolver";
+import { useRoute } from "../navigation";
+import { useScreenStateStore } from "../navigation/useScreenStateStore";
+
+export const useLoadPipesDataDispatch = () => {
+  const screenStateStore = useScreenStateStore();
+  const resolvers = useScreenResolvers();
+  const dispatch = useAppDispatch();
+
+  const { pathname, screenData } = useRoute();
+
+  const riverId =
+    (screenData as LegacyNavigationScreenData)?.targetScreen?.id ??
+    screenData?.id;
+
+  const onLoadCB = (options) => (data, _err) => {
+    options?.callback?.();
+
+    if (data) {
+      applyScreenRouteDefaults(data, screenStateStore, pathname);
+    }
+  };
+
+  return React.useCallback(
+    (
+      url: string,
+      options = {},
+      {
+        withResolvers = false,
+        withScreenRouteMapping = false,
+      }: {
+        withResolvers?: boolean;
+        withScreenRouteMapping?: boolean;
+      } = {}
+    ) => {
+      if (url) {
+        dispatch(
+          ZappPipes.loadPipesData(url, {
+            riverId,
+            resolvers: withResolvers ? resolvers : undefined,
+            ...options,
+            callback: withScreenRouteMapping
+              ? onLoadCB(options)
+              : options?.callback,
+          })
+        );
+      }
+    },
+    []
+  );
+};

package/reactHooks/feed/usePipesCacheReset.ts

@@ -1,11 +1,11 @@
 import React from "react";
-import { useDispatch } from "react-redux";
 
 import { getDatasourceUrl } from "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/getDatasourceUrl";
 import { usePipesContexts } from "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/usePipesContexts";
 import { clearPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
 
-import { useRoute } from "../navigation/useRoute";
+import { useRoute } from "../navigation";
+import { useAppDispatch } from "@applicaster/zapp-react-native-redux";
 
 /**
  * reset river components cache when screen is unmounted
@@ -13,7 +13,7 @@ import { useRoute } from "../navigation/useRoute";
  * @param {Array} riverComponents list of UI components
  */
 export const usePipesCacheReset = (riverId, riverComponents) => {
-  const dispatch = useDispatch();
+  const dispatch = useAppDispatch();
   const { screenData, pathname } = useRoute();
   const pipesContexts = usePipesContexts(riverId, pathname);
 

package/reactHooks/flatList/useSequentialRenderItem.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import * as R from "ramda";
-import { View } from "react-native";
+import { View, ViewStyle } from "react-native";
 
 import { platformSelect } from "../../reactUtils";
 
@@ -49,13 +49,13 @@ export const useSequentialRenderItem = (data: Data) => {
         const readyToDisplay =
           index === 0 ? true : arePreviousComponentsReady(index);
 
-        const displayStyle = {
+        const displayStyle: ViewStyle = {
           display: readyToDisplay ? "flex" : "none",
         };
 
         const readyStyle = {
           visibility: readyToDisplay ? "visible" : "hidden",
-        };
+        } as ViewStyle;
 
         const style = platformSelect({
           tvos: readyStyle,

package/reactHooks/layout/__tests__/index.test.tsx

@@ -42,15 +42,17 @@ jest.mock("react-native-safe-area-context", () => ({
 }));
 
 jest.mock("../../../reactUtils", () => ({
+  ...jest.requireActual("../../../reactUtils"),
   platformSelect: jest.fn((specs) => specs[platform] || specs.default),
   isTV: jest.fn(() => mock_tv_flag),
 }));
 
 jest.mock("../../navigation", () => ({
-  useNavigation: () => null,
   useIsScreenActive: () => true,
 }));
 
+jest.mock("../../navigation/useNavigation");
+
 const { Dimensions } = require("react-native");
 const { useDimensions } = require("..");
 

package/reactHooks/layout/isTablet/index.ts

@@ -1,21 +1,28 @@
 import { NativeModules, Platform } from "react-native";
 
+export const isAndroidTablet = () => {
+  const { initialProps } = NativeModules.QuickBrickCommunicationModule;
+
+  return initialProps?.is_tablet;
+};
+
 /**
  * Determines wether the given device is a tablet based on dimensions, orientation, and platform
  * @param {Object} dimensions - Dimensions object passed to the function
  * @param {String} orientation - Orientation enum passed to the function
  * @returns {Boolean} isTablet - returns whether the given device is a tablet
  */
-export const isTablet = (dimensions, orientation) => {
+export const isTablet = (
+  dimensions?: { width: number; height: number },
+  orientation?: string
+) => {
   if (Platform?.OS === "ios") {
     return Platform?.isPad;
   } else if (Platform?.OS === "android") {
-    const { initialProps } = NativeModules.QuickBrickCommunicationModule;
-
-    return initialProps?.is_tablet;
+    return isAndroidTablet();
   }
 
-  const { width } = dimensions;
+  const { width } = dimensions || {};
 
   if (width < 600) return false;
   if (width >= 600 && width < 840) return orientation === "portrait";

package/reactHooks/layout/useDimensions/__tests__/useDimensions.test.ts

@@ -1,46 +1,48 @@
 import { renderHook } from "@testing-library/react-hooks";
 import { Dimensions, StatusBar } from "react-native";
+import { useDimensions } from "../useDimensions";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux";
 
-const mockUsePickFromState = jest.fn();
-const mockUseIsScreenActive = jest.fn();
-const mockGetInitialDimensions = jest.fn();
-const mockGetDeviceInfo = jest.fn();
+import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive";
 
-jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
-  ...(jest.requireActual("@applicaster/zapp-react-native-redux/hooks") as {}),
-  usePickFromState: mockUsePickFromState,
-}));
-
-jest.mock("../../../navigation", () => ({
-  useIsScreenActive: mockUseIsScreenActive,
-}));
+jest.mock("@applicaster/zapp-react-native-redux/hooks", () => {
+  return {
+    ...jest.requireActual("@applicaster/zapp-react-native-redux/hooks"),
+    usePickFromState: jest.fn(),
+  };
+});
 
-jest.mock("../helpers", () => ({
-  getInitialDimensions: mockGetInitialDimensions,
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
+  () => ({
+    useIsScreenActive: jest.fn().mockReturnValue(true),
+  })
+);
+
+jest.doMock("../helpers", () => ({
+  getInitialDimensions: jest
+    .fn()
+    .mockReturnValue({ width: 100, height: 200, scale: 1, fontScale: 1 }),
 }));
 
 jest.mock("../../getDeviceInfo", () => ({
-  getDeviceInfo: mockGetDeviceInfo,
+  getDeviceInfo: jest.fn().mockReturnValue({ deviceInfo: "testDeviceInfo" }),
 }));
 
-const { useDimensions } = require("../useDimensions");
+const mockDimensions = { width: 100, height: 200, scale: 1, fontScale: 1 };
+
+Dimensions.get = jest.fn().mockReturnValue(mockDimensions);
+
+Dimensions.addEventListener = jest.fn().mockReturnValue({
+  remove: jest.fn(),
+});
 
 describe("useDimensions", () => {
-  const mockDimensions = { width: 100, height: 200, scale: 1, fontScale: 1 };
   const mockAppData = { someData: "test" };
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    Dimensions.get = jest.fn().mockReturnValue(mockDimensions);
-
-    Dimensions.addEventListener = jest.fn().mockReturnValue({
-      remove: jest.fn(),
-    });
-
-    mockUsePickFromState.mockReturnValue({ appData: mockAppData });
-    mockUseIsScreenActive.mockReturnValue(true);
-    mockGetInitialDimensions.mockReturnValue(mockDimensions);
-    mockGetDeviceInfo.mockReturnValue({ deviceInfo: "testDeviceInfo" });
+    StatusBar.currentHeight = 20;
+    (usePickFromState as jest.Mock).mockReturnValue({ appData: mockAppData });
   });
 
   it("returns correct initial dimensions", () => {
@@ -48,12 +50,9 @@ describe("useDimensions", () => {
       useDimensions("window", { fullDimensions: false })
     );
 
-    expect(result.current).toEqual({
-      ...mockDimensions,
+    expect(result.current).toMatchObject({
       statusBarHeight: StatusBar.currentHeight,
     });
-
-    expect(mockGetInitialDimensions).toHaveBeenCalledWith("window");
   });
 
   it("calls handler on mount", () => {
@@ -70,7 +69,7 @@ describe("useDimensions", () => {
       useDimensions("window", { fullDimensions: false })
     );
 
-    mockUseIsScreenActive.mockReturnValue(false);
+    (useIsScreenActive as jest.Mock).mockReturnValue(false);
     rerender();
 
     expect(Dimensions.addEventListener).toHaveBeenCalledWith(
@@ -84,8 +83,7 @@ describe("useDimensions", () => {
       useDimensions("window", { fullDimensions: true })
     );
 
-    expect(result.current).toEqual({
-      ...mockDimensions,
+    expect(result.current).toMatchObject({
       scale: 1,
       fontScale: 1,
       statusBarHeight: StatusBar.currentHeight,
@@ -98,7 +96,7 @@ describe("useDimensions", () => {
     );
 
     expect(result.current.height).toBe(
-      mockDimensions.height - StatusBar.currentHeight ?? 0
+      mockDimensions.height - (StatusBar?.currentHeight ?? 0)
     );
   });
 

package/reactHooks/layout/useDimensions/useDimensions.ts

@@ -10,7 +10,7 @@ import { isTV } from "../../../reactUtils";
 import { Options, UseDimensions } from "../types";
 import { getDeviceInfo } from "../getDeviceInfo";
 import { getInitialDimensions } from "./helpers";
-import { useIsScreenActive } from "../../navigation";
+import { useIsScreenActive } from "../../navigation/useIsScreenActive";
 
 function compensateForScaleIfNeeded(context) {
   return function () {
@@ -24,8 +24,6 @@ const applyScaleToDimensions = R.unless(R.propEq("scale", 1), (dimensions) => ({
   scale: 1,
 }));
 
-const statusBarHeight = StatusBar?.currentHeight;
-
 /**
  * Returns React-native Dimensions object and updates it on any dimension change
  * @param {('screen'|'window')} [context=window] - Dimensions context passed to Dimensions.get method
@@ -37,6 +35,7 @@ export const useDimensions: UseDimensions = (
   context = "window",
   fullDimensions = { fullDimensions: false, updateForInactiveScreens: true }
 ) => {
+  const statusBarHeight = StatusBar?.currentHeight;
   const isActive = useIsScreenActive();
   const { appData } = usePickFromState(["appData"]);
 

package/reactHooks/layout/useLayoutVersion.ts

@@ -1,6 +1,8 @@
 /* eslint-disable no-redeclare */
-import { useSelector } from "react-redux";
-import * as R from "ramda";
+import {
+  useAppSelector,
+  selectLayoutVersion,
+} from "@applicaster/zapp-react-native-redux";
 
 export function useLayoutVersion(): ZappLayoutVersions;
 
@@ -23,9 +25,7 @@ export function useLayoutVersion({
   isV2?: boolean;
   isV1?: boolean;
 } = {}): boolean | ZappLayoutVersions {
-  const layoutVersion = useSelector<any, ZappLayoutVersions>(
-    R.path(["appData", "layoutVersion"])
-  );
+  const layoutVersion = useAppSelector(selectLayoutVersion);
 
   if (isV2) {
     return layoutVersion === "v2";

package/reactHooks/navigation/index.ts

@@ -14,7 +14,7 @@ import { HOOKS_EVENTS } from "../../appUtils/HooksManager/constants";
 import { getRiverFromRoute, getTargetRoute } from "../../navigationUtils";
 import { useConnectionInfo } from "../connection";
 
-import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavbarState } from "../screen";
 
 export { useNavigation } from "./useNavigation";
@@ -127,11 +127,13 @@ export function isNavBarVisible(
 
 export const useBackHandler = (cb: () => boolean) => {
   useEffect(() => {
-    const unsubscribe = BackHandler.addEventListener("hardwareBackPress", cb);
+    if (!isWeb()) {
+      const unsubscribe = BackHandler.addEventListener("hardwareBackPress", cb);
 
-    return () => {
-      unsubscribe.remove();
-    };
+      return () => {
+        unsubscribe.remove();
+      };
+    }
   }, [cb]);
 };