@applicaster/zapp-react-native-ui-components 13.0.0-alpha.6523249552 → 13.0.0-alpha.6651373134

package/Components/River/__tests__/__snapshots__/river.test.js.snap

@@ -1,89 +1,27 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`When River has a general_content type <River /> renders correctly 1`] = `
-<ContextProvider
-  value={null}
->
-  <RiverWithData
-    appData={
-      {
-        "layoutVersion": "v1",
-      }
-    }
-    dispatch={[Function]}
-    rivers={
-      {
-        "A1234": {
-          "home": true,
-          "id": "A1234",
-          "name": "foo",
-          "type": "general_content",
-          "ui_components": [
-            {
-              "component_type": "hero",
-            },
-            {
-              "component_type": "grid",
-            },
-          ],
-        },
-        "B4567": {
-          "id": "B4567",
-        },
-        "C0987": {
-          "home": false,
-          "id": "C0987",
-          "name": "Some-Screen-Plugin",
-          "type": "some-screen-plugin",
-          "ui_components": [],
-        },
-      }
-    }
-    screenId="A1234"
-    store={
-      {
-        "clearActions": [Function],
-        "dispatch": [Function],
-        "getActions": [Function],
-        "getState": [Function],
-        "replaceReducer": [Function],
-        "subscribe": [Function],
-      }
-    }
-  />
-</ContextProvider>
-`;
-
-exports[`When River has a general_content type <RiverComponent /> renders correctly 1`] = `
-<GeneralContentScreen
-  groupId="ZF-C4"
-  screenId="A1234"
-/>
-`;
-
-exports[`When River has any other type other than general_content <RiverComponent /> renders correctly 1`] = `
-<WithProvider
-  screenData={
+exports[`When River has a general_content type renders River component correctly 1`] = `
+<View
+  onLayout={[Function]}
+  style={
     {
-      "groupId": undefined,
-      "home": false,
-      "id": "C0987",
-      "name": "Some-Screen-Plugin",
-      "type": "some-screen-plugin",
-      "ui_components": [],
+      "flex": 1,
     }
   }
-  screenId="C0987"
-  screenType="some-screen-plugin"
-/>
-`;
-
-exports[`When River has feed url <RiverComponent /> renders correctly 1`] = `
-<Connect(FeedLoaderComponent)
-  feedUrl="https://some-feed-url.net"
-  refreshCallback={[Function]}
-  refreshing={false}
+  testID="on-layout-view"
 >
-  <Component />
-</Connect(FeedLoaderComponent)>
+  <View
+    style={
+      {
+        "display": "none",
+        "flex": 1,
+      }
+    }
+  >
+    <View
+      screenId="A1234"
+      testID="general-content-screen"
+    />
+  </View>
+</View>
 `;

package/Components/River/__tests__/componentsMap.test.js

@@ -1,6 +1,5 @@
 import React from "react";
-import TestRenderer from "react-test-renderer";
-import { cleanup } from "@testing-library/react-native";
+import { cleanup, render } from "@testing-library/react-native";
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 
@@ -183,12 +182,12 @@ describe("componentsMap", () => {
       .spyOn(themeUtils, "useTheme")
       .mockImplementation(() => () => theme);
 
-    const wrapper = TestRenderer.create(
+    const { toJSON } = render(
       <Provider store={store}>
         <ComponentsMap {...props} />
       </Provider>
     );
 
-    expect(wrapper.toJSON()).toMatchSnapshot();
+    expect(toJSON()).toMatchSnapshot();
   });
 });

package/Components/River/__tests__/river.test.js

@@ -1,13 +1,50 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render, screen } from "@testing-library/react-native";
 import configureStore from "redux-mock-store";
+import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+import { Provider } from "react-redux";
 
-import { GeneralContentScreen } from "../../GeneralContentScreen";
-import { FeedLoader } from "../../FeedLoader";
-import { River } from "../index";
-import { RiverComponent } from "../River";
+import { River } from "../";
 import { ScreenResolver } from "../../ScreenResolver";
+import { RiverComponent } from "../River";
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
+  () => ({
+    useIsScreenActive: jest.fn(() => true),
+  })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/GeneralContentScreen",
+  () => {
+    const { View } = jest.requireActual("react-native");
+
+    return {
+      GeneralContentScreen: (props) => (
+        <View testID="general-content-screen" {...props} />
+      ),
+    };
+  }
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/analyticsUtils/helpers/hooks",
+  () => ({
+    useScreenAnalytics: jest.fn(),
+  })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation",
+  () => ({
+    useNavigation: jest.fn(() => ({
+      videoModalState: {
+        mode: "test",
+      },
+    })),
+  })
+);
 
 const river = {
   home: true,
@@ -55,24 +92,24 @@ const appData = { layoutVersion: "v1" };
 const store = configureStore()({ rivers, appData });
 
 describe("When River has a general_content type", () => {
-  const wrapper = shallow(<RiverComponent {...riverProps} />);
-
-  describe("<RiverComponent />", () => {
-    it("renders correctly", () => {
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-    });
-
-    it("it returns a GeneralContentScreen", () => {
-      expect(wrapper.find(GeneralContentScreen).length).toBe(1);
-    });
+  it("renders GeneralContentScreen correctly", () => {
+    const { getByTestId } = render(
+      <Provider store={store}>
+        <RiverComponent {...riverProps} />
+      </Provider>
+    );
+
+    expect(getByTestId("general-content-screen")).toBeTruthy();
   });
 
-  describe("<River />", () => {
-    const wrapper = shallow(<River screenId="A1234" store={store} />);
+  it("renders River component correctly", () => {
+    const wrapper = render(
+      <Provider store={store}>
+        <River screenId="A1234" />
+      </Provider>
+    );
 
-    it("renders correctly", () => {
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-    });
+    expect(wrapper.toJSON()).toMatchSnapshot();
   });
 });
 
@@ -83,16 +120,10 @@ describe("When River has any other type other than general_content", () => {
     appData,
   };
 
-  const wrapper = shallow(<RiverComponent {...riverPropsWithScreenPlugin} />);
-
-  describe("<RiverComponent />", () => {
-    it("renders correctly", () => {
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-    });
+  it("renders ScreenResolver correctly", () => {
+    renderWithProviders(<RiverComponent {...riverPropsWithScreenPlugin} />);
 
-    it("it returns a ScreenResolver", () => {
-      expect(wrapper.find(ScreenResolver).length).toBe(1);
-    });
+    expect(screen.UNSAFE_getByType(ScreenResolver)).toBeDefined();
   });
 });
 
@@ -104,15 +135,19 @@ describe("When River has feed url", () => {
     appData: { layoutVersion: "v1" },
   };
 
-  const wrapper = shallow(<RiverComponent {...riverPropsWithFeedUrl} />);
-
-  describe("<RiverComponent />", () => {
-    it("renders correctly", () => {
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-    });
-
-    it("it returns a FeedLoader if it's a v1 layout", () => {
-      expect(wrapper.find(FeedLoader).length).toBe(1);
-    });
+  it("renders FeedLoader when layout is v1", () => {
+    const wrapper = renderWithProviders(
+      <RiverComponent {...riverPropsWithFeedUrl} />,
+      {
+        zappPipes: {
+          "https://some-feed-url.net": {
+            loading: false,
+            data: { entry: [] },
+          },
+        },
+      }
+    );
+
+    expect(wrapper.getByTestId("general-content-screen")).toBeDefined();
   });
 });

package/Components/RouteManager/__tests__/__snapshots__/routeManager.test.js.snap

@@ -1,10 +1,16 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<RouteManager /> renders correctly 1`] = `
-<TestId
-  screenId="A1234"
+<View
+  accessibilityLabel="A1234"
+  style={
+    {
+      "flex": 1,
+    }
+  }
+  testID="A1234"
 >
-  <WithProvider
+  <View
     pathname="/river/A1234"
     screenData={
       {
@@ -13,6 +19,7 @@ exports[`<RouteManager /> renders correctly 1`] = `
     }
     screenId="A1234"
     screenType="river"
+    testID="screen-resolver"
   />
-</TestId>
+</View>
 `;

package/Components/RouteManager/__tests__/routeManager.test.js

@@ -1,31 +1,46 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render } from "@testing-library/react-native";
 
-const pathname = "/river/A1234";
-const screenData = { id: "A1234" };
+import { RouteManager } from "../";
+
+const mockPathname = "/river/A1234";
+const mockScreenData = { id: "A1234" };
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
-  useRoute: jest.fn(() => ({ pathname: pathname, screenData: screenData })),
+  useRoute: jest.fn(() => ({
+    pathname: mockPathname,
+    screenData: mockScreenData,
+  })),
 }));
 
-const {
-  ScreenResolver,
-} = require("@applicaster/zapp-react-native-ui-components/Components/ScreenResolver");
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/ScreenResolver",
+  () => {
+    const { View } = jest.requireActual("react-native");
 
-const { RouteManager } = require("../index");
+    return {
+      ScreenResolver: (props) => <View testID="screen-resolver" {...props} />,
+    };
+  }
+);
 
 describe("<RouteManager />", () => {
-  const wrapper = shallow(
-    <RouteManager pathname={pathname} screenData={screenData} />
-  );
+  let wrapper;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    wrapper = render(
+      <RouteManager pathname={mockPathname} screenData={mockScreenData} />
+    );
+  });
 
   it("renders correctly", () => {
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.toJSON()).toMatchSnapshot();
   });
 
   it("passes the correct props to ScreenResolver", () => {
-    expect(wrapper.find(ScreenResolver).props()).toEqual({
+    expect(wrapper.getByTestId("screen-resolver").props).toMatchObject({
       pathname: "/river/A1234",
       screenType: "river",
       screenId: "A1234",

package/Components/RouteManager/__tests__/testId.test.js

@@ -2,8 +2,8 @@
 /* eslint-disable react/prop-types */
 import React from "react";
 import { View, Text } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+
+import { render } from "@testing-library/react-native";
 
 import { TestId } from "../TestId";
 
@@ -17,14 +17,16 @@ const screenId = "A1234";
 
 describe("TestId", () => {
   it("renders correctly and assigns the testID to a wrapping view", () => {
-    const wrapper = shallow(
+    const wrapper = render(
       <TestId screenId={screenId}>
         <TestComponent name="dev test" />
       </TestId>
     );
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-    expect(wrapper.find(View).prop("testID")).toEqual(screenId);
-    expect(wrapper.find(View).prop("accessibilityLabel")).toEqual(screenId);
+    expect(wrapper.getByTestId(screenId)).toBeTruthy();
+
+    expect(wrapper.getByTestId(screenId).props.accessibilityLabel).toEqual(
+      screenId
+    );
   });
 });

package/Components/Screen/TV/index.web.tsx

@@ -92,6 +92,10 @@ const getNavigations = ({
   return fallbackNavigations;
 };
 
+const onRelease = () => {
+  focusManager.setInitialFocus();
+};
+
 export const Screen = ({ route, Components }: Props) => {
   if (isNilOrEmpty(route)) {
     throw Error("Required props: route is missing");
@@ -152,12 +156,7 @@ export const Screen = ({ route, Components }: Props) => {
   const isScreenActive = useIsScreenActive();
 
   return (
-    <FreezeWithCallback
-      freeze={!isScreenActive}
-      onRelease={() => {
-        focusManager.setInitialFocus();
-      }}
-    >
+    <FreezeWithCallback freeze={!isScreenActive} onRelease={onRelease}>
       <View style={[styles.container, { backgroundColor }]}>
         <NavBarContainer isVisible={isNavBarVisible} onReady={noop}>
           <NavBar

package/Components/Screen/hooks.ts

@@ -0,0 +1,53 @@
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  useGetScreenOrientation,
+  isOrientationCompatible,
+} from "@applicaster/zapp-react-native-utils/appUtils/orientationHelper";
+import {
+  useCurrentScreenData,
+  useDimensions,
+  useRoute,
+  useIsTablet,
+} from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useMemo, useEffect, useState } from "react";
+
+export const useWaitForValidOrientation = () => {
+  const { width: screenWidth, height } = useDimensions("screen", {
+    fullDimensions: true,
+    updateForInactiveScreens: false,
+  });
+
+  const currentScreenData = useCurrentScreenData();
+
+  const { screenData } = useRoute();
+
+  const [readyState, setReadyState] = useState(false);
+
+  const isTablet = useIsTablet();
+
+  const { appData } = usePickFromState(["appData"]);
+  const isTabletPortrait = appData?.isTabletPortrait;
+
+  const layoutData = useMemo(
+    () => ({ isTablet, isTabletPortrait, width: screenWidth, height }),
+    [isTablet, isTabletPortrait, screenWidth, height]
+  );
+
+  const targetScreenData =
+    currentScreenData || (screenData as any)?.targetScreen || screenData;
+
+  const orientation = useGetScreenOrientation(targetScreenData);
+
+  const isReadyForDisplay = isOrientationCompatible({
+    orientation,
+    layoutData,
+  });
+
+  useEffect(() => {
+    if (isReadyForDisplay && !readyState) {
+      setReadyState(true);
+    }
+  }, [readyState, orientation, layoutData]);
+
+  return readyState;
+};

package/Components/Screen/index.tsx

@@ -2,31 +2,27 @@
 import React from "react";
 import { View } from "react-native";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
-import {
-  isOrientationCompatible,
-  useGetScreenOrientation,
-} from "@applicaster/zapp-react-native-utils/appUtils/orientationHelper";
 
 import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
 import { getComponentModule } from "@applicaster/zapp-react-native-utils/pluginUtils";
 import {
-  shouldNavBarDisplayMenu,
   getNavBarProps,
   getScreenId,
+  shouldNavBarDisplayMenu,
 } from "@applicaster/zapp-react-native-utils/navigationUtils";
 import {
-  useDimensions,
-  useRoute,
   useCurrentScreenData,
   useNavbarState,
-  useScreenData,
   useNavigation,
+  useRoute,
+  useScreenData,
 } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { getNavigationPluginModule } from "@applicaster/zapp-react-native-app/App/Layout/layoutHelpers";
 
 import { RouteManager } from "../RouteManager";
 import { useScreenConfiguration } from "../River/useScreenConfiguration";
 import { isValidColor } from "./utils";
+import { useWaitForValidOrientation } from "./hooks";
 
 const screenStyles = {
   flex: 1,
@@ -50,15 +46,6 @@ export function Screen(_props: Props) {
   const currentScreenData = useCurrentScreenData();
   const { backgroundColor } = useScreenConfiguration(currentScreenData.id);
 
-  const {
-    width: screenWidth,
-    height,
-    deviceInfo,
-  } = useDimensions("screen", {
-    updateForInactiveScreens: false,
-    fullDimensions: true,
-  });
-
   const { screenData, pathname } = useRoute();
 
   const currentRiver = useScreenData(
@@ -67,13 +54,6 @@ export function Screen(_props: Props) {
 
   const { title } = useNavbarState();
 
-  const isTablet = deviceInfo?.isTablet;
-
-  const { appData } = usePickFromState(["appData"]);
-  const isTabletPortrait = appData?.isTabletPortrait;
-
-  const layoutData = { isTablet, isTabletPortrait, width: screenWidth, height };
-
   const hasMenu = shouldNavBarDisplayMenu(currentRiver, plugins);
 
   const navBarProps = React.useMemo<MobileNavBarPluginProps | null>(
@@ -109,30 +89,23 @@ export function Screen(_props: Props) {
     [theme.app_background_color, backgroundColor]
   );
 
-  const targetScreenData =
-    currentScreenData || (screenData as any)?.targetScreen || screenData;
-
-  const orientation = useGetScreenOrientation(targetScreenData);
+  // Set ready state when screen is rotated to desired orientation
+  const isReady = useWaitForValidOrientation();
 
   // We prevent rendering of the screen until UI is actually rotated to screen desired orientation.
   // This saves unnecessary re-renders and user will not see distorted aspect screen.
-  if (
-    !isOrientationCompatible({
-      orientation,
-      layoutData,
-    })
-  ) {
-    return <View style={style} />;
-  }
-
   return (
     <View style={style}>
-      {navBarProps && <NavBar {...navBarProps} hasMenu={hasMenu} />}
-
-      <OfflineFallbackScreen>
-        {/* @TODO RouteManager doesn't use props, can they be removed ?  */}
-        <RouteManager pathname={pathname} screenData={screenData} />
-      </OfflineFallbackScreen>
+      {isReady ? (
+        <>
+          {navBarProps ? <NavBar {...navBarProps} hasMenu={hasMenu} /> : null}
+
+          <OfflineFallbackScreen>
+            {/* @TODO RouteManager doesn't use props, can they be removed ?  */}
+            <RouteManager pathname={pathname} screenData={screenData} />
+          </OfflineFallbackScreen>
+        </>
+      ) : null}
     </View>
   );
 }