@applicaster/zapp-react-native-ui-components 12.0.0-alpha.4337072244 → 12.0.0-alpha.4342066143

package/Components/BaseFocusable/index.tsx

@@ -66,7 +66,7 @@ export class BaseFocusable<
     const { initialFocus } = this.props;
 
     if (initialFocus) {
-      focusManager.setFocus(this.getId());
+      focusManager.setupInitialFocus(this.getId());
     }
   }
 

package/Components/Cell/Cell.tsx

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { join, path, merge } from "ramda";
+import * as R from "ramda";
 import { View } from "react-native";
 
 import { Focusable } from "@applicaster/zapp-react-native-ui-components/Components/Focusable";
@@ -105,8 +105,8 @@ export class CellComponent extends React.Component<Props> {
       onPress(item, index);
     } else {
       const { item, navigator, component, appData } = this.props;
-      const itemTargetScreen = path(["screen_type"], item);
-      const componentTargetScreen = path(["data", "target"], component);
+      const itemTargetScreen = R.path(["screen_type"], item);
+      const componentTargetScreen = R.path(["data", "target"], component);
       const itemType = getItemType(item, appData?.layoutVersion);
 
       sendSelectCellEvent(item, component, item.title, index);
@@ -116,7 +116,7 @@ export class CellComponent extends React.Component<Props> {
         componentTargetScreen &&
         !itemTargetScreen
       ) {
-        navigator.push(merge(item, { screen_type: componentTargetScreen }));
+        navigator.push(R.merge(item, { screen_type: componentTargetScreen }));
 
         return;
       }
@@ -207,7 +207,7 @@ export class CellComponent extends React.Component<Props> {
 
     const { id } = item;
 
-    const focusableId = join("-", [component?.id, id, index]);
+    const focusableId = R.join("-", [component?.id, id, index]);
 
     const handleFocus = (focusable, mouse) => {
       const focusFn = onFocus || noop;

package/Components/Cell/CellWithFocusable.tsx

@@ -6,20 +6,12 @@ import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 import { isAppleTV } from "../../Helpers/Platform";
 import { useCellState } from "../MasterCell/utils";
 
-const useCellFocusedState = (
-  skipFocusManagerRegistration: boolean,
-  groupId: string,
-  id: string
-) => {
+const useCellFocusedState = (groupId: string, id: string) => {
   const [currentCellFocused, setCurrentCellFocused] = React.useState(false);
 
   React.useEffect(() => {
-    const isGroupItemFocused = () => {
-      if (!skipFocusManagerRegistration) {
-        const isFocused = focusManager.isGroupItemFocused(groupId, id);
-        setCurrentCellFocused(isFocused);
-      }
-    };
+    const isGroupItemFocused = () =>
+      setCurrentCellFocused(focusManager.isGroupItemFocused(groupId, id));
 
     const handler = () => {
       // tvOS hack for properly checking focus
@@ -37,7 +29,7 @@ const useCellFocusedState = (
     return () => {
       focusManager.removeHandler(FOCUS_EVENTS.FOCUS, handler);
     };
-  }, [groupId, skipFocusManagerRegistration]);
+  }, [groupId]);
 
   return currentCellFocused;
 };
@@ -73,11 +65,7 @@ export function CellWithFocusable(props: Props) {
     selected,
   } = props;
 
-  const isFocused = useCellFocusedState(
-    skipFocusManagerRegistration,
-    groupId,
-    id
-  );
+  const isFocused = useCellFocusedState(groupId, id);
 
   const state = useCellState({
     id: item.id,

package/Components/FocusableGroup/index.tsx

@@ -26,7 +26,6 @@ type Props = {
   nextFocusLeft?: any;
   nextFocusRight?: any;
   onLayout?: any;
-  excludeFromFocusSearching?: boolean;
 };
 
 export class FocusableGroup extends BaseFocusable<Props> {

package/Components/HandlePlayable/HandlePlayable.tsx

@@ -19,7 +19,6 @@ type Props = {
   modalHeight?: number;
   modalWidth?: number;
   mode: VideoModalMode;
-  groupId?: string;
 };
 
 const YOUTUBE_PLUGIN_ID = "youtube-player-qb";
@@ -94,7 +93,6 @@ export function HandlePlayable({
   modalHeight,
   modalWidth,
   mode,
-  groupId,
 }: Props): React.ReactElement | null {
   const state = usePickFromState();
 
@@ -169,7 +167,6 @@ export function HandlePlayable({
         isModal={isModal}
         mode={mode}
         disableCastAction={playerModuleProperties?.disableCastAction}
-        groupId={groupId}
       />
     );
   }

package/Components/Layout/TV/ScreenLayoutContextProvider.tsx

@@ -60,7 +60,7 @@ export function ScreenLayoutContextProvider(props: {
     initialState
   );
 
-  const screenLayoutValue = React.useMemo(
+  const screeenLayoutValue = React.useMemo(
     () => ({
       ...screenLayout,
       setScreenLayout,
@@ -69,7 +69,7 @@ export function ScreenLayoutContextProvider(props: {
   );
 
   return (
-    <ScreenLayoutContext.Provider value={screenLayoutValue}>
+    <ScreenLayoutContext.Provider value={screeenLayoutValue}>
       {props.children}
     </ScreenLayoutContext.Provider>
   );

package/Components/Layout/TV/TransitionOverlay.tsx

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { View, StyleSheet } from "react-native";
+import { useCurrentScreenData } from "@applicaster/zapp-react-native-utils/reactHooks/screen";
+import { ifEmptyUseFallback } from "@applicaster/zapp-react-native-utils/cellUtils";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { Spinner } from "@applicaster/zapp-react-native-ui-components/Components/Spinner";
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+import { useScreenConfiguration } from "../../River/useScreenConfiguration";
+
+const styles = StyleSheet.create({
+  container: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+
+    alignItems: "center",
+    justifyContent: "center",
+  },
+});
+
+export const TransitionOverlay = () => {
+  const screen = useCurrentScreenData();
+
+  const { backgroundColor: screenBackgroundColor } = useScreenConfiguration(
+    screen?.id
+  );
+
+  const theme = useTheme();
+
+  const themeBackgroundColor = React.useMemo(
+    () => theme.app_background_color,
+    [theme.app_background_color]
+  );
+
+  const backgroundColor = ifEmptyUseFallback(
+    screenBackgroundColor,
+    themeBackgroundColor
+  );
+
+  const {
+    appState: { isTransitioning },
+  } = usePickFromState(["appState"]);
+
+  if (!isWeb() || !isTransitioning) {
+    return null;
+  }
+
+  return (
+    <View
+      style={[
+        styles.container,
+        {
+          backgroundColor,
+        },
+      ]}
+    >
+      <Spinner size={"large"} />
+    </View>
+  );
+};

package/Components/Layout/TV/__tests__/__snapshots__/index.test.tsx.snap

@@ -2,18 +2,58 @@
 
 exports[`Layout TV renders 1`] = `
 <View
-  excludeFromFocusSearching={true}
-  id="/river/A1234"
-  preferredFocus={true}
+  style={
+    Object {
+      "flex": 1,
+      "height": 1080,
+      "width": 1920,
+    }
+  }
+  testID="layout-container"
 >
   <View
-    Components={
-      Object {
-        "Background": [Function],
-        "NavBar": [Function],
+    backgroundImageUrl="http://applicaster.com"
+    testID="background-component"
+  >
+    <View
+      style={
+        Array [
+          Object {
+            "position": "absolute",
+            "top": 0,
+            "width": 1920,
+            "zIndex": 10,
+          },
+          Object {
+            "maxHeight": 10,
+          },
+        ]
       }
-    }
-    route="/river/A1234"
-  />
+      testID="nav-bar-container"
+    >
+      <View
+        isVisible={true}
+        menuPlugin={
+          Object {
+            "module": [Function],
+            "name": "resolved-menu-plug",
+            "type": "menu",
+          }
+        }
+        navigationProps={
+          Object {
+            "assets": undefined,
+            "home": undefined,
+            "nav_items": undefined,
+            "rules": undefined,
+            "selected": undefined,
+            "styles": undefined,
+            "title": "",
+          }
+        }
+        testID="nav-bar-component"
+      />
+    </View>
+  </View>
 </View>
 `;

package/Components/Layout/TV/__tests__/index.test.tsx

@@ -1,48 +1,79 @@
 import * as React from "react";
-import { omit } from "ramda";
+import * as R from "ramda";
 import { View } from "react-native";
 import { render } from "@testing-library/react-native";
 import { Provider } from "react-redux";
+import { createStore } from "redux";
 import { NavigationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NavigationContext";
-import configureStore from "redux-mock-store";
 
-const withoutChildren = omit(["children"]);
+import { ThemeContext } from "@applicaster/zapp-react-native-utils/theme";
 
-jest.mock("../../../Screen/TV/index.web", () => ({
-  Screen: View,
+jest.mock("@applicaster/quick-brick-core/App/ActionSetters", () => ({
+  useRiverInitialState: () => ({}),
 }));
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen");
+
 const Layout = require("..").default;
 
-const mockStore = configureStore()({
+const ResolvedMenuPlug = () => <View testID="resolved-menu-plug" />;
+
+const plugins = [
+  {
+    module: ResolvedMenuPlug,
+    type: "menu",
+    name: "resolved-menu-plug",
+  },
+];
+
+const bgImage = "http://applicaster.com";
+const isNavBarVisible = true;
+
+const store = createStore(() => ({
   appState: { appReady: true },
-});
+  remoteConfigurations: { sdkAssets: { bgImage } },
+  plugins,
+}));
 
 describe("Layout TV", () => {
+  const themes = {
+    myTheme: { screen_margin_top: 10, screen_margin_bottom: 10 },
+  };
+
+  const selectedThemeId = "myTheme";
+
   const navigator = {
+    activeRiver: {
+      navigations: [{ category: "menu", navigation_type: "menu" }],
+    },
+    canGoBack: () => false,
     currentRoute: "/river/A1234",
-    mainStack: [
-      {
-        route: "/river/A1234",
-        state: "state",
-      },
-    ],
+    screenData: {
+      navigations: [{ category: "menu", navigation_type: "menu" }],
+    },
+    isNavBarVisible: isNavBarVisible,
   };
 
   const wrapper = ({ children }) => (
-    <Provider store={mockStore}>
+    <Provider store={store}>
       <NavigationContext.Provider value={navigator}>
-        {children}
+        <ThemeContext.Provider value={{ themes, selectedThemeId }}>
+          {children}
+        </ThemeContext.Provider>
       </NavigationContext.Provider>
     </Provider>
   );
 
+  const Screen = (props) => (
+    <View testID="screen-component" {...R.omit(["children"])(props)} />
+  );
+
   const NavBar = (props) => (
-    <View testID="nav-bar-component" {...withoutChildren(props)} />
+    <View testID="nav-bar-component" {...R.omit(["children"])(props)} />
   );
 
   const Background = (props: Record<any, any>) => (
-    <View testID="background-component" {...withoutChildren(props)}>
+    <View testID="background-component" {...R.omit(["children"])(props)}>
       {props.children}
     </View>
   );
@@ -53,8 +84,33 @@ describe("Layout TV", () => {
   };
 
   it("renders", () => {
-    const { toJSON } = render(<Layout Components={Components} />, { wrapper });
+    const { toJSON } = render(
+      <Layout Components={Components}>
+        <Screen />
+      </Layout>,
+      { wrapper }
+    );
 
     expect(toJSON()).toMatchSnapshot();
   });
+
+  describe("props passed to background component", () => {
+    it("passes correct props", () => {
+      const { getByTestId } = render(
+        <Layout
+          Components={Components}
+          ComponentsExtraProps={{
+            Background: { testProp: true },
+          }}
+        >
+          <Screen />
+        </Layout>,
+        { wrapper }
+      );
+
+      const bgComponent = getByTestId("background-component");
+      expect(bgComponent.props.backgroundImageUrl).toBe(bgImage);
+      expect(bgComponent.props.testProp).toBe(true);
+    });
+  });
 });

package/Components/Layout/TV/index.tsx

@@ -1,69 +1,131 @@
 import * as React from "react";
-import { isEmpty, pathOr } from "ramda";
+import * as R from "ramda";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
-import { getPathAttributes } from "@applicaster/zapp-react-native-utils/navigationUtils";
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+import {
+  getNavigationProps,
+  resolveNavigationPlugin,
+  routeIsPlayerScreen,
+} from "@applicaster/zapp-react-native-utils/navigationUtils";
+
+import { getBackgroundImageUrl } from "../utils";
+import { LayoutContainer } from "./LayoutContainer";
+import { NavBarContainer } from "./NavBarContainer";
+import { ScreenContainer } from "./ScreenContainer";
+import { TransitionOverlay } from "./TransitionOverlay";
 
 import { ScreenLayoutContextProvider } from "./ScreenLayoutContextProvider";
+import { isApplePlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { PathnameContext } from "../../../Contexts/PathnameContext";
-import { FocusableGroup } from "../../FocusableGroup";
-import { Screen } from "../../Screen/TV/index.web";
-
-export const ScreenDataContext = React.createContext(null);
+import { useNavbarState } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext";
+import { ScreenDataContext } from "../../../Contexts/ScreenDataContext";
 
 type Components = {
   NavBar: React.ComponentType<any>;
   Background: React.ComponentType<any>;
 };
 
+type ComponentsExtraProps = {
+  Background?: Record<string, any>;
+  NavBar?: Record<string, any>;
+};
+
 type Props = {
   Components: Components;
+  ComponentsExtraProps?: ComponentsExtraProps;
+  children: React.ReactNode;
 };
 
-const StackNavigator = ({ Components }: Props) => {
-  // @ts-ignore
-  const { mainStack, currentRoute } = useNavigation();
-
-  const renderScreen = ({ route, state }) => {
-    const pathAttributes = getPathAttributes({ pathname: route });
-
-    if (isEmpty(pathAttributes)) {
-      return null;
-    }
-
-    const id = `${route}`;
-
-    return (
-      <FocusableGroup
-        id={id}
-        preferredFocus={route === currentRoute}
-        excludeFromFocusSearching
-        key={id}
-      >
-        <ScreenDataContext.Provider value={state}>
-          <PathnameContext.Provider value={route}>
-            <Screen route={route} Components={Components} />
-          </PathnameContext.Provider>
-        </ScreenDataContext.Provider>
-      </FocusableGroup>
-    );
-  };
-
-  return mainStack.map(renderScreen);
-};
+const Layout = ({ Components, ComponentsExtraProps, children }: Props) => {
+  const navigator = useNavigation();
+  const theme = useTheme();
+  const { title, visible } = useNavbarState();
+  const { activeRiver, currentRoute } = navigator;
+
+  const {
+    appState: { appReady = false } = {},
+    remoteConfigurations,
+    plugins = [],
+  } = usePickFromState(["appState", "remoteConfigurations", "plugins"]);
+
+  const navigationProps = getNavigationProps({
+    navigator,
+    title,
+    category: "menu",
+  });
+
+  const backgroundColor = React.useMemo(() => theme.app_background_color, []);
+
+  const backgroundImageUrl = React.useMemo(
+    () => getBackgroundImageUrl(remoteConfigurations),
+    [remoteConfigurations]
+  );
+
+  const menuPlugin = React.useMemo(
+    () =>
+      resolveNavigationPlugin({
+        category: "menu",
+        navigations: activeRiver?.navigations,
+        plugins,
+      }) as QuickBrickPlugin,
+    []
+  );
+
+  const NavBar = React.useMemo(
+    () => Components.NavBar || (menuPlugin.module as React.ComponentType<any>),
+    []
+  );
+
+  const [navBarReady, setNavBarReady] = React.useState(false);
+
+  const navBarContainer = (
+    <NavBarContainer isVisible={visible} onReady={setNavBarReady}>
+      <NavBar
+        ref={ComponentsExtraProps?.NavBar?.ref}
+        isVisible={visible && !routeIsPlayerScreen(currentRoute)}
+        menuPlugin={menuPlugin}
+        navigationProps={navigationProps}
+        {...R.omit(["ref"])(ComponentsExtraProps?.NavBar)}
+      />
+    </NavBarContainer>
+  );
 
-const Layout = ({ Components }: Props) => {
-  const { appState } = usePickFromState(["appState"]);
-  const appReady = pathOr(false, ["appReady"], appState);
+  const isTVOS = isApplePlatform();
 
   if (!appReady) {
     return null;
   }
 
   return (
-    <ScreenLayoutContextProvider>
-      <StackNavigator Components={Components} />
-    </ScreenLayoutContextProvider>
+    <LayoutContainer>
+      <ScreenLayoutContextProvider>
+        <Components.Background
+          backgroundColor={backgroundColor}
+          backgroundImageUrl={backgroundImageUrl}
+          {...R.omit(["ref"])(ComponentsExtraProps?.Background)}
+        >
+          <ScreenDataContext.Provider value={navigator.data}>
+            <PathnameContext.Provider value={navigator.currentRoute}>
+              {!isTVOS ? navBarContainer : null}
+              {navBarReady ? (
+                /**
+             Need to re-mount this component on each navigation event
+             It's a hack to work around the fact that we don't support
+             correct screen rendering in our navigator (shared currentRoute state)
+             **/
+                <ScreenContainer>{children}</ScreenContainer>
+              ) : null}
+              {/** Render NavBarContainer over ScreenContainer to let tvOS native
+          focus manager works correctly to focus nav bar items first **/}
+              {isTVOS ? navBarContainer : null}
+            </PathnameContext.Provider>
+          </ScreenDataContext.Provider>
+          <TransitionOverlay />
+        </Components.Background>
+      </ScreenLayoutContextProvider>
+    </LayoutContainer>
   );
 };