@applicaster/zapp-react-native-ui-components 13.0.0-alpha.2245033574 → 13.0.0-alpha.2308533304

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>
   );
 }

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 = {
@@ -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

@@ -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(

package/Components/Transitioner/Scene.tsx

@@ -105,7 +105,7 @@ function SceneComponent({
       style={[style, contentStyle, dimensions]}
     >
       {children}
-      {isAnimating && <Animated.View style={overlayStyle} />}
+      {isAnimating ? <Animated.View style={overlayStyle} /> : null}
     </Animated.View>
   );
 }

package/Components/Transitioner/Transitioner.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { View } from "react-native";
-import { update, compose, tail, append, take, identity, isNil } from "ramda";
+import { append, compose, identity, isNil, tail, take, update } from "ramda";
 
 import { AnimationManager } from "./AnimationManager";
 import { Scene } from "./Scene";
@@ -289,7 +289,7 @@ export class TransitionerComponent extends React.PureComponent<Props, State> {
 
     return (
       <View style={styles.container}>
-        {scenes[to.index] && (
+        {scenes[to.index] ? (
           <Scene
             {...{ style: to?.style || {} }}
             pathname={pathname}
@@ -301,7 +301,7 @@ export class TransitionerComponent extends React.PureComponent<Props, State> {
           >
             {scenes[to.index].children}
           </Scene>
-        )}
+        ) : null}
       </View>
     );
   }

package/Components/Transitioner/__tests__/Scene.test.js

@@ -1,6 +1,7 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render } from "@testing-library/react-native";
+
+import { Scene } from "../Scene";
 
 const overlayStyle = { opacity: 1 };
 const contentStyle = { paddingBottom: 49 };
@@ -23,28 +24,38 @@ jest.mock(
   })
 );
 
-const { Scene } = require("../Scene");
+jest.mock("../../../Contexts/PathnameContext", () => ({
+  PathnameContext: jest.requireActual("react").createContext({ pathname: "" }),
+}));
 
-const wrapper = shallow(
-  <Scene
-    style={style}
-    overlayStyle={overlayStyle}
-    contentStyle={contentStyle}
-  />
-);
+jest.mock("../../../Contexts/ScreenDataContext", () => ({
+  ScreenDataContext: jest.requireActual("react").createContext({}),
+}));
+
+jest.mock("../../../Contexts/ScreenContext", () => ({
+  ScreenContextProvider: jest.requireActual("react-native").View,
+}));
 
 describe("<Scene />", () => {
+  const wrapper = render(
+    <Scene
+      style={style}
+      overlayStyle={overlayStyle}
+      contentStyle={contentStyle}
+    />
+  );
+
   it("renders correctly", () => {
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.toJSON()).toMatchSnapshot();
   });
 
   // skipped - this isn't a very useful test, and it doesn't work as it used to on the new version of RN
   it.skip("renders children surrounded by AnimatedComponent", () => {
-    expect(shallowToJson(wrapper).type).toEqual("AnimatedComponent");
+    expect(wrapper.toJSON()).toEqual("AnimatedComponent");
   });
 
   it("renders the overlay while animating", () => {
-    const wrapperWithOverlay = shallow(
+    const wrapperWithOverlay = render(
       <Scene
         style={style}
         overlayStyle={overlayStyle}
@@ -53,6 +64,6 @@ describe("<Scene />", () => {
       />
     );
 
-    expect(shallowToJson(wrapperWithOverlay)).toMatchSnapshot();
+    expect(wrapperWithOverlay.toJSON).toMatchSnapshot();
   });
 });