@applicaster/zapp-react-native-utils 15.0.0-rc.99 → 15.1.0-alpha.2915689988

package/reactHooks/casting/useIsCasting.tsx

@@ -0,0 +1,57 @@
+import React from "react";
+import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
+import { useAppState } from "@applicaster/zapp-react-native-utils/reactHooks/app";
+import { isApplePlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
+
+const CHROMECAST_IDENTIFIER = "quick-brick-chromecast-action";
+
+const fakeEntry: any = {
+  title: "Chromecast use is casting fake entry",
+  id: "quick-brick-use-is-casting-fake-entry",
+};
+
+/**
+ * Returns the cast action state connection status, does not update when app is in background on Apple platforms
+ * On other platforms, it continues to check the cast action state even when the app is in background
+ */
+export const useIsCasting = () => {
+  const actionContext = useActions(CHROMECAST_IDENTIFIER);
+  const appState = useAppState();
+  const isAppInForeground = appState === "active";
+  const shouldOnlyUpdateInForeground = isApplePlatform();
+
+  const [castActionState, setCastActionState] = React.useState(
+    !actionContext ? null : actionContext.initialEntryState(fakeEntry)
+  );
+
+  React.useEffect(() => {
+    if (!shouldOnlyUpdateInForeground || isAppInForeground) {
+      if (actionContext && castActionState === null) {
+        setCastActionState(actionContext.initialEntryState(fakeEntry));
+      }
+    }
+  }, [
+    actionContext,
+    setCastActionState,
+    isAppInForeground,
+    shouldOnlyUpdateInForeground,
+  ]);
+
+  React.useEffect(() => {
+    if (typeof actionContext?.addListener === "function") {
+      return actionContext?.addListener(String(fakeEntry.id), (state) => {
+        // Only check foreground state on Apple platforms
+        if (!shouldOnlyUpdateInForeground || isAppInForeground) {
+          setCastActionState(state);
+        }
+      });
+    }
+  }, [
+    setCastActionState,
+    actionContext,
+    isAppInForeground,
+    shouldOnlyUpdateInForeground,
+  ]);
+
+  return !!castActionState?.connected;
+};

package/reactHooks/cell-click/__tests__/index.test.js

@@ -1,8 +1,10 @@
 import * as React from "react";
-import { cleanup, renderHook, waitFor } from "@testing-library/react-native";
+import { cleanup, renderHook } from "@testing-library/react-hooks";
 import { CellTapContext } from "@applicaster/zapp-react-native-ui-components/Contexts/CellTapContext";
 import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutorContext";
 
+import { waitFor } from "@testing-library/react-native";
+
 const mockNavigator = {
   getPathname: () => "pathnameMock",
   push: jest.fn(),

package/reactHooks/componentsMap/index.ts

@@ -0,0 +1,55 @@
+import * as React from "react";
+
+const layoutReducer = (state, { payload }) => {
+  return state.map((item, index, _state) => ({
+    height: index === payload.index ? payload.height : item.height,
+    y:
+      index > 0
+        ? _state.slice(0, index).reduce((acc, value) => acc + value.height, 0)
+        : 0,
+  }));
+};
+
+export const useComponentsLayout = (count, onFinishLoadingVisible) => {
+  const [itemsLayout, dispatchItemLayout] = React.useReducer(
+    layoutReducer,
+    Array.from({ length: count }, () => ({ height: 0, y: 0 }))
+  );
+
+  const notified = React.useRef(false);
+  const [listHeight, setListHeight] = React.useState<number>(0);
+
+  const onItemLayout = React.useCallback(
+    (index) => (event) => {
+      const { height } = event.nativeEvent.layout;
+      dispatchItemLayout({ payload: { index, height } });
+    },
+    []
+  );
+
+  const onListLayout = React.useCallback((event) => {
+    const { height } = event.nativeEvent.layout;
+    setListHeight(height);
+  }, []);
+
+  React.useEffect(() => {
+    if (!notified.current) {
+      const finishLoadingVisible = !!itemsLayout.find(
+        (item) => item.y > listHeight
+      );
+
+      if (finishLoadingVisible) {
+        notified.current = true;
+        onFinishLoadingVisible?.();
+      }
+    }
+  }, [itemsLayout, listHeight]);
+
+  return React.useMemo(
+    () => ({
+      onItemLayout,
+      onListLayout,
+    }),
+    []
+  );
+};

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

@@ -1,6 +1,6 @@
 /* eslint-disable react/prop-types */
 import React from "react";
-import { renderHook, cleanup } from "@testing-library/react-native";
+import { renderHook, cleanup } from "@testing-library/react-hooks";
 import { ConfigurationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ConfigutaionContext";
 import { useConfiguration } from "@applicaster/zapp-react-native-utils/reactHooks/configuration";
 

package/reactHooks/connection/__tests__/index.test.js

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { renderHook, cleanup } from "@testing-library/react-native";
+import { renderHook, cleanup } from "@testing-library/react-hooks";
 import { NetworkStatusContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NetworkStatusContext";
 
 const MockNetInfo = {

package/reactHooks/debugging/__tests__/index.test.js

@@ -27,20 +27,20 @@ describe("Debug utils", () => {
     it("should create new timer if timer with a label does not exist", () => {
       performanceNowMock.mockReturnValue(1000);
       time("timer1");
-      expect(timers.timer1).toBeDefined();
-      expect(timers.timer1.startTime).toBe(1000);
+      expect(timers["timer1"]).toBeDefined();
+      expect(timers["timer1"].startTime).toBe(1000);
     });
 
     it("should update start time of timer if timer with a label exists", () => {
       // First call to time()
       performanceNowMock.mockReturnValue(1000);
       time("timer1");
-      const previousStartTime = timers.timer1.startTime;
+      const previousStartTime = timers["timer1"].startTime;
 
       // Second call to time()
       performanceNowMock.mockReturnValue(2000);
       time("timer1");
-      const currentStartTime = timers.timer1.startTime;
+      const currentStartTime = timers["timer1"].startTime;
 
       expect(previousStartTime).toBe(1000);
       expect(currentStartTime).toBe(2000);

package/reactHooks/device/useIsTablet.tsx

@@ -1,23 +1,28 @@
 /* eslint react-native/split-platform-components: off */
 
 import { Platform, PlatformIOSStatic, NativeModules } from "react-native";
+import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { F as alwaysFalse } from "ramda";
 import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
 
-export const useIsTablet = (): boolean => {
-  const platform = Platform.OS;
+const useIsTabletIos = (): boolean => {
+  const { isPad } = Platform as PlatformIOSStatic;
 
-  if (platform === "ios") {
-    const { isPad } = Platform as PlatformIOSStatic;
-
-    return Boolean(isPad);
-  }
-
-  if (platform === "android") {
-    const initialProps =
-      NativeModules.QuickBrickCommunicationModule?.initialProps;
+  return isPad;
+};
 
-    return toBooleanWithDefaultFalse(initialProps?.is_tablet);
-  }
+const useIsTabletAndroid = (): boolean => {
+  const { initialProps } = NativeModules.QuickBrickCommunicationModule;
 
-  return false;
+  return toBooleanWithDefaultFalse(initialProps?.is_tablet);
 };
+
+export const useIsTablet = platformSelect({
+  ios: useIsTabletIos,
+  android: useIsTabletAndroid,
+  lg_tv: alwaysFalse,
+  samsung_tv: alwaysFalse,
+  android_tv: alwaysFalse,
+  tvos: alwaysFalse,
+  default: alwaysFalse,
+});

package/reactHooks/device/useMemoizedIsTablet.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import { useIsTablet } from "./useIsTablet";
-import { useAppData } from "@applicaster/zapp-react-native-redux";
 
 export const useMemoizedIsTablet = () => {
   const isTablet = useIsTablet();
@@ -14,9 +14,9 @@ export const useMemoizedIsTablet = () => {
 };
 
 export const useIsTabletLandscape = (): boolean => {
-  const { isTabletPortrait } = useAppData();
+  const { appData } = usePickFromState(["appData"]);
 
   const isTablet = useIsTablet();
 
-  return isTablet && !isTabletPortrait;
+  return isTablet && !appData.isTabletPortrait;
 };

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

@@ -1,7 +1,8 @@
-import { renderHook, waitFor } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import { allFeedsIsReady, useBatchLoading } from "../useBatchLoading";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { waitFor } from "@testing-library/react-native";
 
 jest.mock("../../navigation");
 
@@ -15,11 +16,7 @@ jest.mock(
   })
 );
 
-const getWrapper =
-  (store) =>
-  ({ children }) => (
-    <WrappedWithProviders store={store}>{children}</WrappedWithProviders>
-  );
+const wrapper = WrappedWithProviders;
 
 describe("useBatchLoading", () => {
   const data = [
@@ -66,7 +63,8 @@ describe("useBatchLoading", () => {
     const riverId = "123";
 
     renderHook(() => useBatchLoading(data, { initialBatchSize, riverId }), {
-      wrapper: getWrapper(store),
+      wrapper,
+      initialProps: { store },
     });
 
     const actions = (appStore.getStore() as any).getActions();
@@ -86,7 +84,7 @@ describe("useBatchLoading", () => {
     });
   });
 
-  it("loadPipesData start loading new feed when 1 feed is done loading and 1 is in loading state", async () => {
+  it("loadPipesData start loading new feed when 1 feed is done loading and 1 is in loading state", () => {
     const store = {
       zappPipes: {
         url1: {
@@ -112,14 +110,13 @@ describe("useBatchLoading", () => {
     const riverId = "123";
 
     renderHook(() => useBatchLoading(data, { initialBatchSize, riverId }), {
-      wrapper: getWrapper(store),
+      wrapper,
+      initialProps: { store },
     });
 
     const actions = (appStore.getStore() as any).getActions();
 
-    await waitFor(() => {
-      expect(actions).toHaveLength(1);
-    });
+    expect(actions).toHaveLength(1);
 
     expect(actions[0]).toMatchObject({
       type: "ZAPP_PIPES_REQUEST_START",
@@ -127,7 +124,7 @@ describe("useBatchLoading", () => {
     });
   });
 
-  it("loadPipesData has been called when no data cached", async () => {
+  it("loadPipesData has been called when no data cached", () => {
     const store = {
       zappPipes: {},
       test: "true",
@@ -137,17 +134,16 @@ describe("useBatchLoading", () => {
     const riverId = "123";
 
     renderHook(() => useBatchLoading(data, { initialBatchSize, riverId }), {
-      wrapper: getWrapper(store),
+      wrapper,
+      initialProps: { store },
     });
 
     const actions = (appStore.getStore() as any).getActions();
 
-    await waitFor(() => {
-      expect(actions).toHaveLength(3);
-    });
+    expect(actions).toHaveLength(3);
   });
 
-  it("initial batch ready when all initial items loaded", async () => {
+  it("initial batch ready when all initial items loaded", () => {
     const store = {
       zappPipes: {
         url1: {
@@ -173,15 +169,13 @@ describe("useBatchLoading", () => {
 
     const { result } = renderHook(
       () => useBatchLoading(data, { initialBatchSize, riverId }),
-      { wrapper: getWrapper(store) }
+      { wrapper, initialProps: { store } }
     );
 
-    await waitFor(() => {
-      expect(result.current).toBe(true);
-    });
+    expect(result.current).toBe(true);
   });
 
-  it("gallery-qb: loadPipesData should be called only once for first component in the gallery", async () => {
+  it("gallery-qb: loadPipesData should be called only once for first component in the gallery", () => {
     const store = {
       zappPipes: {},
       test: "true",
@@ -204,17 +198,16 @@ describe("useBatchLoading", () => {
     ];
 
     renderHook(() => useBatchLoading(data, { initialBatchSize, riverId }), {
-      wrapper: getWrapper(store),
+      wrapper,
+      initialProps: { store },
     });
 
     const actions = (appStore.getStore() as any).getActions();
 
-    await waitFor(() => {
-      expect(actions).toHaveLength(1);
-    });
+    expect(actions).toHaveLength(1);
   });
 
-  it("gallery-qb: initial batch ready when all initial items loaded", async () => {
+  it("gallery-qb: initial batch ready when all initial items loaded", () => {
     const store = {
       zappPipes: {
         url1: {
@@ -240,12 +233,10 @@ describe("useBatchLoading", () => {
 
     const { result } = renderHook(
       () => useBatchLoading(data, { initialBatchSize, riverId }),
-      { wrapper: getWrapper(store) }
+      { wrapper, initialProps: { store } }
     );
 
-    await waitFor(() => {
-      expect(result.current).toBe(true);
-    });
+    expect(result.current).toBe(true);
   });
 });
 

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

@@ -1,4 +1,4 @@
-import { renderHook, waitFor } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import { encodeParams } from "@applicaster/zapp-pipes-v2-client/src/utils";
 
 const appData = {
@@ -42,26 +42,26 @@ describe("useBuildPipesUrl", () => {
       build: jest.fn(() => Promise.resolve(buildResult)),
     };
 
-    const { result } = renderHook(() =>
+    const { result, waitForNextUpdate } = renderHook(() =>
       useBuildPipesUrl({ url, mapping, requestBuilder: mockedRequestBuilder })
     );
 
     expect(result.current.url).toBe("http://foo.com/show/show-1");
     expect(result.current.requestParams).toBeNull();
 
-    await waitFor(() => {
-      expect(result.current.requestParams).toEqual(
-        expect.objectContaining({
-          params: {
-            version: appData.version_name,
-            ctx: encodeParams({ platform: appData.platform }),
-          },
-          headers: {
-            SDK: appData.sdk_version,
-          },
-        })
-      );
-    });
+    await waitForNextUpdate();
+
+    expect(result.current.requestParams).toEqual(
+      expect.objectContaining({
+        params: {
+          version: appData.version_name,
+          ctx: encodeParams({ platform: appData.platform }),
+        },
+        headers: {
+          SDK: appData.sdk_version,
+        },
+      })
+    );
   });
 
   it("returns empty object if url is not in endpoints", async () => {
@@ -81,15 +81,15 @@ describe("useBuildPipesUrl", () => {
       build: jest.fn(() => Promise.resolve(buildResult)),
     };
 
-    const { result } = renderHook(() =>
+    const { result, waitForNextUpdate } = renderHook(() =>
       useBuildPipesUrl({ url, mapping, requestBuilder: mockedRequestBuilder })
     );
 
     expect(result.current.url).toBe("http://foobar.com/show-1");
     expect(result.current.requestParams).toBeNull();
 
-    await waitFor(() => {
-      expect(result.current.requestParams).toEqual({});
-    });
+    await waitForNextUpdate();
+
+    expect(result.current.requestParams).toEqual({});
   });
 });

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

@@ -1,6 +1,6 @@
 import * as R from "ramda";
 import React from "react";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import { Provider } from "react-redux";
 import { createStore } from "redux";
 
@@ -10,9 +10,6 @@ describe("useEntryScreenId", () => {
   const mappedScreenId = "mapped-id";
 
   const initialState = {
-    rivers: {
-      [mappedScreenId]: { id: mappedScreenId, type: "any" },
-    },
     contentTypes: { mappedEntry: { screen_id: mappedScreenId } },
   };
 

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

@@ -1,4 +1,4 @@
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import * as R from "ramda";
 import * as zappPipesModule from "@applicaster/zapp-react-native-redux/ZappPipes";
 import * as reactReduxModules from "react-redux";
@@ -50,16 +50,6 @@ const mockZappPipesData = {
   url: "test://testfakeurl",
 };
 
-const createWrapper = (
-  getStore: () => any
-): React.FC<{ children: React.ReactNode }> => {
-  const Wrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
-    <WrappedWithProviders store={getStore()}>{children}</WrappedWithProviders>
-  );
-
-  return Wrapper;
-};
-
 describe("useFeedLoader", () => {
   describe("with cached feed url", () => {
     const store = {
@@ -67,7 +57,11 @@ describe("useFeedLoader", () => {
       zappPipes: { "test://testfakeurl": mockZappPipesData },
     };
 
-    const wrapper = createWrapper(() => store);
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store || store}>
+        {children}
+      </WrappedWithProviders>
+    );
 
     it("returns cached feed", () => {
       const { result } = renderHook(
@@ -115,6 +109,12 @@ describe("useFeedLoader", () => {
   describe("without cached feeds", () => {
     const feedUrl = "test://testfakeurl2";
 
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store}>
+        {children}
+      </WrappedWithProviders>
+    );
+
     it("It loads data for new url and returns it", () => {
       const useDispatchSpy = jest
         .spyOn(reactReduxModules, "useDispatch")
@@ -129,12 +129,9 @@ describe("useFeedLoader", () => {
         zappPipes: { "test://testfakeurl": "foobar" },
       };
 
-      let store = initialStore;
-      const wrapper = createWrapper(() => store);
-
       const { result, rerender } = renderHook(
-        ({ feedUrl: url }) => useFeedLoader({ feedUrl: url }),
-        { wrapper, initialProps: { feedUrl } }
+        () => useFeedLoader({ feedUrl: "test://testfakeurl2" }),
+        { wrapper, initialProps: { store: initialStore } }
       );
 
       expect(result.current.data).toBeNull();
@@ -153,8 +150,7 @@ describe("useFeedLoader", () => {
         zappPipes: { "test://testfakeurl2": mockZappPipesData },
       };
 
-      store = store2;
-      rerender({ feedUrl });
+      rerender({ store: store2 });
 
       expect(R.omit(["reloadData", "loadNext"], result.current)).toEqual(
         mockZappPipesData
@@ -178,12 +174,9 @@ describe("useFeedLoader", () => {
         zappPipes: { "test://testfakeurl": "foobar" },
       };
 
-      let store = initialStore;
-      const wrapper = createWrapper(() => store);
-
       const { result, rerender } = renderHook(
-        ({ feedUrl: url }) => useFeedLoader({ feedUrl: url }),
-        { wrapper, initialProps: { feedUrl } }
+        () => useFeedLoader({ feedUrl: "test://testfakeurl2" }),
+        { wrapper, initialProps: { store: initialStore } }
       );
 
       expect(result.current.data).toBeNull();
@@ -205,8 +198,7 @@ describe("useFeedLoader", () => {
         zappPipes: { "test://testfakeurl2": mockZappPipesData },
       };
 
-      store = store2;
-      rerender({ feedUrl });
+      rerender({ store: store2 });
 
       loadPipesDataSpy.mockRestore();
       useDispatchSpy.mockRestore();
@@ -217,6 +209,12 @@ describe("useFeedLoader", () => {
     const feedUrl = "test://testfakeurl";
     const feedUrlWithNext = "test://withnexttestfakeurl";
 
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store || {}}>
+        {children}
+      </WrappedWithProviders>
+    );
+
     describe("reloadData", () => {
       it("Tries to reload data in the redux store", () => {
         const loadPipesDataSpy = jest
@@ -232,17 +230,10 @@ describe("useFeedLoader", () => {
           zappPipes: { [feedUrl]: "foobar" },
         };
 
-        const store = initialStore;
-
-        const wrapper = createWrapper(() => store);
-
-        const { result } = renderHook(
-          ({ feedUrl: url }) => useFeedLoader({ feedUrl: url }),
-          {
-            wrapper,
-            initialProps: { feedUrl },
-          }
-        );
+        const { result } = renderHook(() => useFeedLoader({ feedUrl }), {
+          wrapper,
+          initialProps: { store: initialStore },
+        });
 
         const { reloadData } = result.current;
 
@@ -288,14 +279,11 @@ describe("useFeedLoader", () => {
           zappPipes: { [feedUrlWithNext]: { data: { next: nextUrl } } },
         };
 
-        const store = initialStore;
-        const wrapper = createWrapper(() => store);
-
         const { result } = renderHook(
-          ({ feedUrl: url }) => useFeedLoader({ feedUrl: url }),
+          () => useFeedLoader({ feedUrl: feedUrlWithNext }),
           {
             wrapper,
-            initialProps: { feedUrl: feedUrlWithNext },
+            initialProps: { store: initialStore },
           }
         );
 

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

@@ -1,4 +1,4 @@
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 
 jest.useFakeTimers();
 

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

@@ -214,7 +214,7 @@ describe("getSearchContext", () => {
 });
 
 describe("useGetUrlInflater", () => {
-  const { renderHook } = require("@testing-library/react-native");
+  const { renderHook } = require("@testing-library/react-hooks");
 
   it("returns original url when mapping is not provided", () => {
     const { result } = renderHook(() => useGetUrlInflater(), {

package/reactHooks/feed/useBatchLoading.ts

@@ -151,13 +151,7 @@ export const useBatchLoading = (
         }
       }
     });
-  }, [
-    batchComponents,
-    feeds,
-    getUrl,
-    loadPipesDataDispatcher,
-    options.riverId,
-  ]);
+  }, [feedUrls, feeds, loadPipesDataDispatcher]);
 
   React.useEffect(() => {
     runBatchLoading();

package/reactHooks/feed/useEntryScreenId.ts

@@ -1,7 +1,7 @@
-import { useContentTypes } from "@applicaster/zapp-react-native-redux";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 export const useEntryScreenId = (entry?: ZappEntry): string | undefined => {
-  const contentTypes = useContentTypes();
+  const { contentTypes } = usePickFromState("contentTypes");
 
   if (!entry) {
     return;

package/reactHooks/feed/useInflatedUrl.ts

@@ -45,7 +45,7 @@ interface GetInflatedDataSourceUrl {
   (properties: {
     source?: string;
     contexts: {
-      entry?: ZappEntry;
+      entry?: ZappEntry & { parent?: ZappEntry };
       screen?: ZappRiver;
       search?: object | string;
     };