@applicaster/zapp-react-native-ui-components 12.0.0-rc.14 → 12.0.0-rc.141

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

@@ -2,11 +2,17 @@ import React from "react";
 import { shallow } from "enzyme";
 import { shallowToJson } from "enzyme-to-json";
 
-import { ScreenResolver } from "@applicaster/zapp-react-native-ui-components/Components/ScreenResolver";
-
 const pathname = "/river/A1234";
 const screenData = { id: "A1234" };
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
+  useRoute: jest.fn(() => ({ pathname: pathname, screenData: screenData })),
+}));
+
+const {
+  ScreenResolver,
+} = require("@applicaster/zapp-react-native-ui-components/Components/ScreenResolver");
+
 const { RouteManager } = require("../index");
 
 describe("<RouteManager />", () => {
@@ -20,6 +26,7 @@ describe("<RouteManager />", () => {
 
   it("passes the correct props to ScreenResolver", () => {
     expect(wrapper.find(ScreenResolver).props()).toEqual({
+      pathname: "/river/A1234",
       screenType: "river",
       screenId: "A1234",
       screenData: { id: "A1234" },

package/Components/RouteManager/index.tsx

@@ -2,6 +2,7 @@ import * as React from "react";
 import * as R from "ramda";
 
 import { getPathAttributes } from "@applicaster/zapp-react-native-utils/navigationUtils";
+import { useRoute } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { ScreenResolver } from "../ScreenResolver";
 import { TestId } from "./TestId";
 
@@ -12,7 +13,8 @@ type Props = { pathname: string; screenData: Record<string, any> };
  * and reconciles data returned from hook plugins if needed
  * @param {Props}: see props above
  */
-export function RouteManager({ pathname, screenData, ...otherProps }: Props) {
+export function RouteManager(props: Props) {
+  const { pathname, screenData } = useRoute();
   const pathAttributes = getPathAttributes({ pathname });
 
   const { screenType, screenId } = R.last(pathAttributes);
@@ -22,8 +24,8 @@ export function RouteManager({ pathname, screenData, ...otherProps }: Props) {
       <ScreenResolver
         screenType={screenType}
         screenId={screenId}
+        {...props}
         screenData={screenData}
-        {...otherProps}
       />
     </TestId>
   );

package/Components/Screen/TV/hooks/index.ts

@@ -0,0 +1 @@
+export { useInitialFocus } from "./useInitialFocus";

package/Components/Screen/TV/hooks/useInitialFocus.ts

@@ -0,0 +1,70 @@
+import * as React from "react";
+import {
+  useNavigationPluginData,
+  useIsNavBarVisible,
+  useRoute,
+} from "@applicaster/zapp-react-native-utils/reactHooks";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+import {
+  setFocusOnContent,
+  setFocusOnMenu,
+} from "@applicaster/zapp-react-native-utils/appUtils/focusManagerAux";
+
+type Return =
+  | {
+      onContent: true;
+      onMenu: false;
+    }
+  | {
+      onContent: false;
+      onMenu: true;
+    };
+
+const getInitialFocus = (focusOnContent, isNavBarVisible): Return => {
+  if (focusOnContent) {
+    return {
+      onContent: true,
+      onMenu: false,
+    };
+  }
+
+  if (!focusOnContent && isNavBarVisible) {
+    // put focus on navbar
+    return {
+      onContent: false,
+      onMenu: true,
+    };
+  }
+
+  // we don't have navbar, put focus on content anyway
+  return {
+    onContent: true,
+    onMenu: false,
+  };
+};
+
+export const useInitialFocus = (): void => {
+  const navigationPluginData = useNavigationPluginData();
+
+  const focusOnContent = toBooleanWithDefaultFalse(
+    navigationPluginData?.rules?.focus_on_content
+  );
+
+  const isNavBarVisible = useIsNavBarVisible();
+
+  const { pathname: currentRoute } = useRoute();
+
+  React.useEffect(() => {
+    const initialFocus = getInitialFocus(focusOnContent, isNavBarVisible);
+
+    if (initialFocus.onContent) {
+      setFocusOnContent(currentRoute);
+
+      return;
+    }
+
+    if (initialFocus.onMenu) {
+      setFocusOnMenu(currentRoute);
+    }
+  }, []);
+};

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

@@ -0,0 +1,178 @@
+import React from "react";
+import { last } from "ramda";
+import { StyleSheet, View } from "react-native";
+import {
+  findMenuPlugin,
+  getNavigationProps,
+  getPathAttributes,
+} from "@applicaster/zapp-react-native-utils/navigationUtils";
+import {
+  useIsScreenActive,
+  useNavigation,
+} from "@applicaster/zapp-react-native-utils/reactHooks";
+import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  useNavbarState,
+  useScreenBackgroundColor,
+} from "@applicaster/zapp-react-native-utils/reactHooks/screen";
+import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+
+import { NavBarContainer } from "../../Layout/TV/NavBarContainer";
+import { ScreenResolver } from "../../ScreenResolver";
+import { useInitialFocus } from "./hooks";
+import { isPlayerPlugin } from "@applicaster/zapp-react-native-utils/pluginUtils";
+import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils";
+import { FreezeWithCallback } from "../../FreezeWithCallback";
+
+const styles = StyleSheet.create({
+  container: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+  },
+});
+
+type Components = {
+  NavBar: React.ComponentType<any>;
+  Background: React.ComponentType<any>;
+};
+
+type Props = {
+  route: string;
+  Components: Components;
+};
+
+const getActiveRiver = ({
+  screenId,
+  screenType,
+  routeState,
+  rivers,
+  fallbackActiveRiver,
+}) => {
+  if (rivers[screenId]) {
+    if (screenType === "hooks") {
+      const navigations = routeState?.state?.entry?.payload?.navigations;
+
+      if (navigations) {
+        return routeState.state.entry.payload;
+      }
+    }
+
+    return routeState?.state?.screen;
+  }
+
+  // screenId is not presented into rivers, use fallback instead
+  return fallbackActiveRiver;
+};
+
+const getNavigations = ({
+  screenId,
+  screenType,
+  routeState,
+  rivers,
+  fallbackNavigations,
+}) => {
+  if (rivers[screenId]) {
+    // river presents
+    if (screenType === "hooks") {
+      const navigations = routeState?.state?.entry?.payload?.navigations;
+
+      if (navigations) {
+        return navigations;
+      }
+    }
+
+    return routeState?.state?.screen?.navigations;
+  }
+
+  // screenId is not presented into rivers, use fallback instead
+  return fallbackNavigations;
+};
+
+export const Screen = ({ route, Components }: Props) => {
+  if (isNilOrEmpty(route)) {
+    throw Error("Required props: route is missing");
+  }
+
+  const navigator = useNavigation();
+  const { plugins = [], rivers = [] } = usePickFromState(["plugins", "rivers"]);
+
+  const pathAttributes = getPathAttributes({ pathname: route });
+  const routeState = navigator.getStackForPathname(route);
+
+  const { screenType, screenId } = last(pathAttributes);
+
+  const backgroundColor = useScreenBackgroundColor(screenId);
+
+  useInitialFocus();
+
+  const activeRiver = getActiveRiver({
+    screenId,
+    screenType,
+    routeState,
+    rivers,
+    fallbackActiveRiver: navigator.activeRiver,
+  });
+
+  const navigationProps = getNavigationProps({
+    navigator: {
+      // @ts-ignore
+      activeRiver,
+      // @ts-ignore
+      screenTitle: routeState.state.entry?.title || routeState.screen?.name,
+    },
+    category: "menu",
+  });
+
+  const navigations = getNavigations({
+    screenId,
+    screenType,
+    routeState,
+    rivers,
+    fallbackNavigations: navigator.activeRiver.navigations,
+  });
+
+  const menuPlugin = findMenuPlugin(navigations, plugins);
+
+  const NavBar = (Components.NavBar ||
+    menuPlugin.module) as React.ComponentType<any>;
+
+  const isPlayer = isPlayerPlugin(routeState);
+
+  const { visible: isNavBarVisible } = useNavbarState();
+
+  const screenData =
+    screenType === "hooks" || isPlayer
+      ? routeState?.state?.entry
+      : routeState?.state?.screen;
+
+  const isScreenActive = useIsScreenActive();
+
+  return (
+    <FreezeWithCallback
+      freeze={!isScreenActive}
+      onRelease={() => {
+        focusManager.setInitialFocus();
+      }}
+    >
+      <View style={[styles.container, { backgroundColor }]}>
+        <NavBarContainer isVisible={isNavBarVisible} onReady={noop}>
+          <NavBar
+            isVisible={isNavBarVisible}
+            menuPlugin={menuPlugin}
+            navigationProps={navigationProps}
+          />
+        </NavBarContainer>
+        <ScreenResolver
+          screenType={screenType}
+          screenId={screenId}
+          screenData={screenData}
+          groupId={route}
+        />
+      </View>
+    </FreezeWithCallback>
+  );
+};

package/Components/Screen/__tests__/Screen.test.tsx

@@ -1,11 +1,21 @@
 import * as React from "react";
 import { View } from "react-native";
-import { create, act } from "react-test-renderer";
+import { act, create } from "react-test-renderer";
 
 const Mocked_RouteManager = jest.fn((props) => (
   <View testID="routeManager" {...props} />
 ));
 
+const mock_navBarVisibleFlag = true;
+
+const mockIsNavBarVisible = jest.fn(() => mock_navBarVisibleFlag);
+
+const mockIsOrientationCompatible = jest.fn(() => true);
+
+jest.mock("react-native-safe-area-context", () => ({
+  useSafeAreaInsets: () => ({ top: 44 }),
+}));
+
 jest.mock("../../RouteManager", () => ({
   RouteManager: Mocked_RouteManager,
 }));
@@ -13,6 +23,7 @@ jest.mock("../../RouteManager", () => ({
 jest.mock(
   "@applicaster/zapp-react-native-utils/appUtils/orientationHelper",
   () => ({
+    isOrientationCompatible: mockIsOrientationCompatible,
     allowedOrientationsForScreen: jest.fn(),
     getOrientation: jest.fn(),
     getScreenOrientation: jest.fn(),
@@ -23,59 +34,54 @@ jest.mock(
   })
 );
 
-let mock_navBarVisibleFlag = true;
-
-jest.mock("../navigationHandler.ts", () => ({
-  isNavBarVisible: jest.fn(() => mock_navBarVisibleFlag),
-}));
-
 jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils", () => ({
   useAnalytics: jest.fn(() => ({
     sendScreenEvent: jest.fn(),
   })),
 }));
 
-const {
-  allowedOrientationsForScreen,
-  getOrientation,
-  useGetScreenOrientation,
-} = require("@applicaster/zapp-react-native-utils/appUtils/orientationHelper");
-
 jest.mock("@applicaster/zapp-react-native-utils/theme", () => ({
   useTheme: jest.fn(() => ({
     app_background_color: "blue",
   })),
 }));
 
+const NavBar = jest.fn((props) => <View testID="navBar" {...props} />);
+
+jest.mock(
+  "@applicaster/zapp-react-native-app/App/Layout/layoutHelpers",
+  () => ({
+    getNavigationPluginModule: () => NavBar,
+  })
+);
+
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
-  useCurrentScreenData: jest.fn(() => ({
+  ...(jest.requireActual(
+    "@applicaster/zapp-react-native-utils/reactHooks/screen"
+  ) as any),
+  useScreenData: jest.fn(() => ({
     id: "testId",
+    navigations: [{ id: "testId", category: "nav_bar" }],
   })),
-  useNavbarState: jest.fn(() => ({
-    visible: jest.fn(() => mock_navBarVisibleFlag),
+  useCurrentScreenData: jest.fn(() => ({
+    id: "testId",
   })),
 }));
 
-const {
-  useCurrentScreenData,
-} = require("@applicaster/zapp-react-native-utils/reactHooks/screen");
-
-const { isNavBarVisible } = require("../navigationHandler");
-
-const NavBar = jest.fn((props) => <View testID="navBar" {...props} />);
-const navigator = {};
-const navBarProps = { nav_items: [] };
-const screenData = {};
-
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
+  isNavBarVisible: mockIsNavBarVisible,
   useRoute: jest.fn(() => ({
     pathname: "/river/testId",
+    screenData: { id: "testId" },
   })),
   useNavigation: jest.fn(() => ({
     canGoBack: () => false,
     currentRoute: "/river/testId",
+    activeRiver: { id: "testId" },
+    screenData: { id: "testId" },
     data: { screen: { id: "testId" } },
   })),
+  useIsScreenActive: jest.fn().mockReturnValue(true),
 }));
 
 jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
@@ -93,9 +99,18 @@ jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
   }),
 }));
 
+const {
+  allowedOrientationsForScreen,
+  getOrientation,
+  useGetScreenOrientation,
+} = require("@applicaster/zapp-react-native-utils/appUtils/orientationHelper");
+
+const navigator = {};
+const navBarProps = { nav_items: [] };
+const screenData = {};
+
 const screenProps = {
   pathname: "/foo/path",
-  NavBar,
   navigator,
   navBarProps,
   screenData,
@@ -109,7 +124,6 @@ describe("<Screen Component />", () => {
   beforeEach(() => {
     allowedOrientationsForScreen.mockClear();
     getOrientation.mockClear();
-    isNavBarVisible.mockClear();
     useGetScreenOrientation.mockClear();
   });
 
@@ -125,14 +139,9 @@ describe("<Screen Component />", () => {
 
   describe("when the navbar should be hidden", () => {
     beforeEach(() => {
-      mock_navBarVisibleFlag = false;
       wrapper = create(<Screen {...screenProps} />);
     });
 
-    afterEach(() => {
-      mock_navBarVisibleFlag = true;
-    });
-
     it("renders correctly", () => {
       act(() => {
         wrapper = create(<Screen {...screenProps} />);
@@ -141,45 +150,4 @@ describe("<Screen Component />", () => {
       expect(wrapper.toJSON()).toMatchSnapshot();
     });
   });
-
-  // it("invokes the orientation hook when the route changes", () => {
-  //   act(() => {
-  //     wrapper = create(<Screen {...screenProps} />);
-  //   });
-
-  //   // @ts-ignore
-  //   useCurrentScreenData.mockReturnValue({
-  //     id: "player-testId",
-  //     general: { screen_orientation: ORIENTATIONS.landscapeSensor },
-  //     plugin_type: "player",
-  //   });
-
-  //   act(() => {
-  //     wrapper.update(
-  //       <Screen
-  //         {...screenProps}
-  //         pathname="/playable"
-  //         screenData={{
-  //           id: "player-testId",
-  //           general: { screen_orientation: ORIENTATIONS.landscapeSensor },
-  //           plugin_type: "player",
-  //         }}
-  //       />
-  //     );
-  //   });
-
-  //   useCurrentScreenData.mockReturnValue({
-  //     id: "player-testId",
-  //     general: { screen_orientation: ORIENTATIONS.landscapeSensor },
-  //   });
-
-  //   act(() => {
-  //     wrapper.update(<Screen {...screenProps} />);
-  //   });
-
-  //   expect(allowedOrientationsForScreen).toHaveBeenNthCalledWith(
-  //     1,
-  //     ORIENTATIONS.landscapeSensor
-  //   );
-  // });
 });

package/Components/Screen/__tests__/__snapshots__/Screen.test.tsx.snap

@@ -6,17 +6,26 @@ exports[`<Screen Component /> when the navbar should be hidden renders correctly
     Object {
       "backgroundColor": "blue",
       "flex": 1,
+      "paddingTop": 0,
     }
   }
 >
   <View
-    nav_items={Array []}
+    hasMenu={false}
+    id="/river/testId"
+    pathname="/river/testId"
+    selected="testId"
     testID="navBar"
+    title=""
   />
   <View>
     <View
-      pathname="/foo/path"
-      screenData={Object {}}
+      pathname="/river/testId"
+      screenData={
+        Object {
+          "id": "testId",
+        }
+      }
       testID="routeManager"
     />
   </View>
@@ -29,17 +38,26 @@ exports[`<Screen Component /> when the navbar should show renders correctly 1`]
     Object {
       "backgroundColor": "blue",
       "flex": 1,
+      "paddingTop": 0,
     }
   }
 >
   <View
-    nav_items={Array []}
+    hasMenu={false}
+    id="/river/testId"
+    pathname="/river/testId"
+    selected="testId"
     testID="navBar"
+    title=""
   />
   <View>
     <View
-      pathname="/foo/path"
-      screenData={Object {}}
+      pathname="/river/testId"
+      screenData={
+        Object {
+          "id": "testId",
+        }
+      }
       testID="routeManager"
     />
   </View>