@applicaster/zapp-react-native-ui-components 13.0.0-alpha.9946926334 → 13.0.0-rc.100

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,14 +46,6 @@ export function Screen(_props: Props) {
   const currentScreenData = useCurrentScreenData();
   const { backgroundColor } = useScreenConfiguration(currentScreenData.id);
 
-  const {
-    width: screenWidth,
-    height,
-    deviceInfo,
-  } = useDimensions("screen", {
-    fullDimensions: true,
-  });
-
   const { screenData, pathname } = useRoute();
 
   const currentRiver = useScreenData(
@@ -66,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>(
@@ -108,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>
   );
 }

package/Components/ScreenResolver/__tests__/screenResolver.test.js

@@ -1,161 +1,180 @@
 import React from "react";
 import { View } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+
 const pluginConfiguration = { foo: "bar" };
 
-const ScreenType1 = jest.fn(() => <View />);
-const ScreenType2 = jest.fn(() => <View />);
-const PlayerController = jest.fn(() => <View />);
+const MockModuleView = (testID) => {
+  // eslint-disable-next-line react/display-name
+  return function (props) {
+    return <View testID={testID} {...props} />;
+  };
+};
+
+const ScreenType1 = MockModuleView("screen_type_1");
+const ScreenType2 = MockModuleView("screen_type_2");
+const PlayerController = MockModuleView("player_controller");
 
 const mockScreenType3 = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("screen_type_3"),
   name: "ScreenType3",
   type: "screen_type_3",
   configuration: pluginConfiguration,
 };
 
 const mockScreenType4 = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("screen_type_4"),
   name: "ScreenType4",
   type: "screen_type_4",
 };
 
 const mockPlayerPlugin = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("player_plugin"),
   name: "playerPlugin",
   type: "player",
 };
 
 const mockScreenPlugin = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("screen_plugin"),
   type: "general",
   name: "Screen plugin",
   identifier: "screen-plugin",
 };
 
 const mockPluginWithConfig = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("plugin_with_config"),
   type: "general",
   name: "Plugin with config",
   identifier: "plugin-with-config",
   configuration: pluginConfiguration,
 };
 
-const components = { ScreenType1, ScreenType2, PlayerController };
-
-const mockWithAnalytics = {
-  sendOnClickEvent: jest.fn(),
-  sendMenuClickEvent: jest.fn(),
-  sendMenuToggleEvent: jest.fn(),
-  sendBackButtonClickEvent: jest.fn(),
-  sendOnNavItemClickEvent: jest.fn(),
-  sendHeaderClickEvent: jest.fn(),
-  sendHardwareBackButtonClickEvent: jest.fn(),
-  sendScreenEvent: jest.fn(),
+const mockComponents = { ScreenType1, ScreenType2, PlayerController };
+
+const mockState = {
+  components: mockComponents,
+  plugins: [
+    mockScreenType3,
+    mockScreenType4,
+    mockPlayerPlugin,
+    mockScreenPlugin,
+    mockPluginWithConfig,
+  ],
+  rivers: {
+    A1234: {},
+  },
 };
 
-const mockUsePickFromState = jest.fn(() => {
-  return {
-    components,
-    plugins: {
-      ScreenType3: mockScreenType3,
-      ScreenType4: mockScreenType4,
-      playerPlugin: mockPlayerPlugin,
-      ScreenPlugin: mockScreenPlugin,
-      PluginWithConfig: mockPluginWithConfig,
-    },
-  };
-});
-
-jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils", () => ({
-  useAnalytics: jest.fn().mockReturnValue(mockWithAnalytics),
-}));
+jest.mock(
+  "@applicaster/zapp-react-native-utils/analyticsUtils/helpers/hooks",
+  () => ({
+    useScreenAnalytics: jest.fn(),
+  })
+);
 
-jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
-  usePickFromState: mockUsePickFromState,
-}));
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation",
+  () => ({
+    useNavigation: jest.fn(() => ({
+      closeVideoModal: jest.fn(),
+      videoModalState: {
+        mode: "test",
+      },
+    })),
+  })
+);
 
-const mockUseScreenAnalytics = jest.fn();
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useRoute",
+  () => ({
+    useRoute: jest.fn(() => ({ screenId: "1234" })),
+  })
+);
 
 jest.mock(
-  "@applicaster/zapp-react-native-utils/analyticsUtils/helpers/hooks",
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
   () => ({
-    useScreenAnalytics: mockUseScreenAnalytics,
+    useIsScreenActive: () => ({
+      isScreenActive: true,
+    }),
   })
 );
 
-jest.mock("react-redux", () => ({
-  ...jest.requireActual("react-redux"),
-  useDispatch: jest.fn(() => () => {}),
-}));
+jest.mock("../../PlayerContainer", () => {
+  const { View } = jest.requireActual("react-native");
 
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
-  useNavigation: jest.fn(() => ({
-    videoModalState: {
-      mode: "test",
-    },
-  })),
-  useRoute: jest.fn(() => ({ screenId: "1234" })),
-}));
+  return {
+    PlayerContainer: (props) => (
+      <View {...props}>
+        <props.Player />
+      </View>
+    ),
+  };
+});
 
-const { ScreenResolverComponent: ScreenResolver } = require("..");
+const getWrapper = (screenId, screenType, screenData) => {
+  const ScreenResolver = require("../").ScreenResolverComponent;
 
-const getWrapper = (screenId, screenType, screenData) =>
-  shallow(
+  return renderWithProviders(
     <ScreenResolver
       {...{
         screenId,
         screenType,
         screenData,
       }}
-    />
+    />,
+    mockState
   );
+};
 
 describe("<ScreenResolver />", () => {
   it("renders correctly", () => {
     const wrapper = getWrapper("1234", "screen_type_1", {});
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.getByTestId("screen_type_1")).toBeDefined();
   });
 
   it("picks screen from plugins if it exists", () => {
     const wrapper = getWrapper("A1234", "screen_type_3", {});
 
-    expect(wrapper.find(mockScreenType3.module)).toHaveProperty("length", 1);
+    expect(wrapper.getByTestId("screen_type_3")).toBeDefined();
   });
 
   it("picks the screen from its identifier if it exists", () => {
     const wrapper = getWrapper("A1234", "screen-plugin", {});
 
-    expect(wrapper.find(mockScreenPlugin.module)).toHaveProperty("length", 1);
+    expect(wrapper.getByTestId("screen_plugin")).toBeDefined();
   });
 
   it("picks screen from components if it doesn't exist in plugins", () => {
     const wrapper = getWrapper("A1234", "screen_type_2", {});
 
-    expect(wrapper.find(ScreenType2)).toHaveProperty("length", 1);
+    expect(wrapper.getByTestId("screen_type_2")).toBeDefined();
   });
 
   it("renders the screen and passes screenId & locationState as props", () => {
     const wrapper = getWrapper("A1234", "screen_type_3", "foo");
 
-    const screenWrapper = wrapper.find(mockScreenType3.module);
+    const screenWrapper = wrapper.getByTestId("screen_type_3");
 
-    expect(screenWrapper.prop("screenId")).toEqual("A1234");
-    expect(screenWrapper.prop("screenData")).toEqual("foo");
+    expect(screenWrapper.props).toMatchObject({
+      screenId: "A1234",
+      screenData: "foo",
+    });
   });
 
   it("renders null if the screen is not found", () => {
     const wrapper = getWrapper(null, "screen_type_5", {});
 
-    expect(wrapper.getElement()).toBe(null);
+    expect(wrapper.queryAllByTestId("screen_type_5")).toBeEmpty();
   });
 
   it("injects the plugin configuration if it exists", () => {
     const wrapper = getWrapper("A1234", "plugin-with-config", {});
 
-    expect(wrapper.find(mockPluginWithConfig.module).props()).toHaveProperty(
+    const screenWrapper = wrapper.getByTestId("plugin_with_config");
+
+    expect(screenWrapper.props).toHaveProperty(
       "configuration",
       expect.objectContaining(pluginConfiguration)
     );
@@ -164,7 +183,9 @@ describe("<ScreenResolver />", () => {
   it("injects the plugin configuration if it exists, even when plugin is resolved by type", () => {
     const wrapper = getWrapper("A1234", "screen_type_3", {});
 
-    expect(wrapper.find(mockScreenType3.module).props()).toHaveProperty(
+    const screenWrapper = wrapper.getByTestId("screen_type_3");
+
+    expect(screenWrapper.props).toHaveProperty(
       "configuration",
       expect.objectContaining(pluginConfiguration)
     );
@@ -172,6 +193,6 @@ describe("<ScreenResolver />", () => {
 
   it("wraps the player with the playerController component when the screenType is playable", () => {
     const wrapper = getWrapper("A1234", "playable", {});
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.getByTestId("player_plugin")).toBeDefined();
   });
 });

package/Components/Tabs/Tab.tsx

@@ -1,11 +1,11 @@
 /* eslint-disable react-native/no-unused-styles */
 import React from "react";
 import * as R from "ramda";
-import { View, Text, StyleSheet, TouchableWithoutFeedback } from "react-native";
+import { StyleSheet, Text, TouchableWithoutFeedback, View } from "react-native";
 import { useConfiguration } from "@applicaster/zapp-react-native-utils/reactHooks/configuration";
 import {
-  getStyleForPlatform,
   applyStringTransformation,
+  getStyleForPlatform,
 } from "@applicaster/zapp-react-native-utils/configurationUtils";
 
 type Props = {
@@ -69,8 +69,8 @@ const getStyles = (configuration, selected, focused) => {
           ? tab_cell_background_color_selected_active
           : tab_cell_background_color_selected_default
         : focused
-        ? tab_cell_background_color_active
-        : tab_cell_background_color_default,
+          ? tab_cell_background_color_active
+          : tab_cell_background_color_default,
       justifyContent: "center",
       alignItems: "center",
       position: "relative",
@@ -85,8 +85,8 @@ const getStyles = (configuration, selected, focused) => {
           ? tab_cell_border_color_active_focused
           : tab_cell_border_color_active
         : focused
-        ? tab_cell_border_color_default_focused
-        : tab_cell_border_color_default,
+          ? tab_cell_border_color_default_focused
+          : tab_cell_border_color_default,
     },
     label: {
       fontFamily: text_label_font_family,
@@ -98,8 +98,8 @@ const getStyles = (configuration, selected, focused) => {
           ? text_label_selected_active_font_color
           : text_label_selected_default_font_color
         : focused
-        ? text_label_active_font_color
-        : text_label_default_font_color,
+          ? text_label_active_font_color
+          : text_label_default_font_color,
     },
     underline: {
       position: "absolute",
@@ -148,7 +148,9 @@ const Tab = ({ title, selected, handleOnPress }: Props, ref: any) => {
           <Text numberOfLines={1} style={styles.label}>
             {tabTitle}
           </Text>
-          {selected && <View testID="underline" style={styles.underline} />}
+          {selected ? (
+            <View testID="underline" style={styles.underline} />
+          ) : null}
         </View>
       </View>
     </TouchableWithoutFeedback>

package/Components/TextInputTv/index.tsx

@@ -94,8 +94,8 @@ function TextInputTV(props: Props, ref) {
             styles.textAlign === "center"
               ? styles.textAlign
               : styles.textAlign === "left"
-              ? "right"
-              : "left";
+                ? "right"
+                : "left";
 
           return { style: { ...styles, textAlign } };
         }
@@ -174,7 +174,8 @@ function TextInputTV(props: Props, ref) {
 
   return isWebPlatform ? (
     <>
-      {additional && additional()}
+      {additional ? additional() : null}
+      {/* eslint-disable-next-line react/no-unknown-property */}
       <input testID="TextInput-tv" ref={ref} {...inputProps} />
     </>
   ) : (

package/Components/TopMarginApplicator/TopMarginApplicator.tsx

@@ -2,6 +2,7 @@ import React from "react";
 import { View, ViewProps, ViewStyle } from "react-native";
 import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
 import { useCurrentScreenData } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { isFirstComponentScreenPicker } from "@applicaster/zapp-react-native-utils/componentsUtils";
 
 interface IProps {
   targetScreenId?: string;
@@ -31,11 +32,9 @@ export const useMarginTop = (targetScreenId: string): number => {
    * ScreenPicker is a component but should really be a screen.
    * We need to skip margin top for it as it's already applied to the target screen
    **/
-  const isScreenPicker =
-    screenData?.ui_components?.[0]?.component_type === "screen-picker-qb-tv";
 
   // ignore margin on screenPicker
-  if (isScreenPicker) {
+  if (isFirstComponentScreenPicker(screenData?.ui_components)) {
     return 0;
   }
 

package/Components/TrackedView/index.tsx

@@ -12,6 +12,7 @@ type TrackedViewProps = {
   onPositionUpdated: (props: { rect?: Record<string, number> }) => void;
   testId?: string | undefined;
   groupId?: string;
+  clipThreshold?: number;
 };
 
 export const TrackedView = memo(function TrackedView(props: TrackedViewProps) {

package/Components/Transitioner/AnimationManager.js

@@ -2,21 +2,21 @@ import { Animated } from "react-native";
 
 import { NAV_ACTION_PUSH, NAV_ACTION_BACK } from "./Transitioner";
 
-type TransitionConfig = {
-  duration: number,
-  easing: any,
-  from: {
-    style: any,
-  },
-  to: {
-    style: any,
-  },
-};
+// type TransitionConfig = {
+//   duration: number;
+//   easing: any;
+//   from: {
+//     style: any;
+//   };
+//   to: {
+//     style: any;
+//   };
+// };
 
-type Props = {
-  transitionConfig: TransitionConfig,
-  contentStyle: { [string]: any },
-};
+// type Props = {
+//   transitionConfig: TransitionConfig;
+//   contentStyle: { [string]: any };
+// };
 
 /**
  * Manages animation for the Transitioner,
@@ -25,7 +25,7 @@ type Props = {
  * which must have a proper structure, see types above ^.
  */
 export class AnimationManager {
-  constructor(props: Props) {
+  constructor(props) {
     this.animatedValue = new Animated.Value(0.0);
 
     this.config = props.transitionConfig(