@applicaster/zapp-react-native-ui-components 12.0.0-alpha.4201443043 → 12.0.0-alpha.4223432180

package/Components/FreezeWithCallback/__tests__/index.test.tsx

@@ -0,0 +1,170 @@
+import React, { Dispatch, useEffect, useState } from "react";
+import {
+  act,
+  create,
+  ReactTestRenderer,
+  ReactTestRendererJSON,
+} from "react-test-renderer";
+import { FreezeWithCallback } from "../index";
+
+const SimpleContent = () => <div />;
+
+interface InnerProps {
+  value: number;
+}
+// eslint-disable-next-line unused-imports/no-unused-vars
+const Inner = ({ value }: InnerProps) => <div />;
+
+interface TestSubscriber {
+  renderCount: number;
+  subscription: Dispatch<number>;
+}
+
+function createSubscriberComponent(): [React.FC, TestSubscriber] {
+  const testState: TestSubscriber = {
+    renderCount: 0,
+    subscription: () => {},
+  };
+
+  const Subscriber: React.FC = () => {
+    const [value, setValue] = useState(0);
+
+    useEffect(() => {
+      testState.subscription = setValue;
+    }, []);
+
+    testState.renderCount += 1;
+
+    return <Inner value={value} />;
+  };
+
+  return [Subscriber, testState];
+}
+
+interface ContainerProps {
+  freeze: boolean;
+  children: React.ReactNode;
+}
+
+const Container = ({ freeze, children }: ContainerProps) => (
+  <FreezeWithCallback freeze={freeze}>{children}</FreezeWithCallback>
+);
+
+function setupTest(initialFreeze: boolean = false) {
+  let testRenderer: ReactTestRenderer | undefined;
+  const [Subscriber, subscriberState] = createSubscriberComponent();
+
+  act(() => {
+    testRenderer = create(
+      <Container freeze={initialFreeze}>
+        <Subscriber />
+      </Container>
+    );
+  });
+
+  return {
+    testRenderer,
+    testInstance: testRenderer?.root,
+    subscriberState,
+    updateFreeze: (freeze: boolean) => {
+      act(() =>
+        testRenderer?.update(
+          <Container freeze={freeze}>
+            <Subscriber />
+          </Container>
+        )
+      );
+    },
+  };
+}
+
+describe("FreezeWithCallback", () => {
+  test("Renders stuff not frozen", () => {
+    const testRenderer = create(
+      <Container freeze={false}>
+        <SimpleContent />
+      </Container>
+    );
+
+    expect(testRenderer.root.findByType(SimpleContent)).toBeTruthy();
+  });
+
+  test("Does not render stuff when frozen", () => {
+    const testRenderer = create(
+      <Container freeze>
+        <SimpleContent />
+      </Container>
+    );
+
+    expect(testRenderer.root.findAllByType(SimpleContent)).toHaveLength(0);
+  });
+
+  test("Stuff is gone after freeze", () => {
+    const testRenderer = create(
+      <Container freeze={false}>
+        <SimpleContent />
+      </Container>
+    );
+
+    expect(testRenderer.root.findByType(SimpleContent)).toBeTruthy();
+
+    act(() =>
+      testRenderer.update(
+        <Container freeze>
+          <SimpleContent />
+        </Container>
+      )
+    );
+
+    expect(testRenderer.toJSON()).toBe(null);
+  });
+
+  test("Updates work when not frozen", () => {
+    const { testInstance, subscriberState } = setupTest();
+
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    act(() => subscriberState.subscription(1));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(1);
+    expect(subscriberState.renderCount).toBe(2);
+  });
+
+  test("Updates does not propagate when frozen", () => {
+    const { testInstance, subscriberState, updateFreeze } = setupTest();
+
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    updateFreeze(true);
+    act(() => subscriberState.subscription(1));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    expect(subscriberState.renderCount).toBe(1);
+  });
+
+  test("State persists after defrost", () => {
+    const { testInstance, subscriberState, updateFreeze, testRenderer } =
+      setupTest();
+
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    act(() => subscriberState.subscription(1));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(1);
+
+    updateFreeze(true);
+    expect(testRenderer?.toJSON()).toBe(null);
+
+    updateFreeze(false);
+    expect((testRenderer?.toJSON() as ReactTestRendererJSON).type).toBe("div");
+    expect(testInstance?.findByType(Inner).props.value).toEqual(1);
+  });
+
+  test("Update propagate after defrost", () => {
+    const { testInstance, subscriberState, updateFreeze } = setupTest();
+
+    updateFreeze(true);
+    act(() => subscriberState.subscription(1));
+    act(() => subscriberState.subscription(2));
+    act(() => subscriberState.subscription(3));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+
+    updateFreeze(false);
+    expect(testInstance?.findByType(Inner).props.value).toEqual(3);
+    expect(subscriberState.renderCount).toBe(2);
+  });
+});

package/Components/FreezeWithCallback/index.tsx

@@ -0,0 +1,3 @@
+import { Freeze } from "./Freeze";
+
+export const FreezeWithCallback = Freeze;

package/Components/Layout/TV/ScreenContainer.tsx

@@ -5,13 +5,30 @@ import * as R from "ramda";
 import { ScreenLayoutContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenLayoutContext";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 import { ifEmptyUseFallback } from "@applicaster/zapp-react-native-utils/cellUtils";
-import { useCurrentScreenData } from "@applicaster/zapp-react-native-utils/reactHooks/screen";
+import {
+  useCurrentScreenData,
+  useNavbarState,
+} from "@applicaster/zapp-react-native-utils/reactHooks/screen";
 import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
 
 import { useScreenConfiguration } from "../../River/useScreenConfiguration";
-import { routeIsPlayerScreen } from "@applicaster/zapp-react-native-utils/navigationUtils";
+import {
+  findMenuPlugin,
+  getNavigationProps,
+  routeIsPlayerScreen,
+} from "@applicaster/zapp-react-native-utils/navigationUtils";
+import { isApplePlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { NavBarContainer } from "./NavBarContainer";
+
+type ComponentsExtraProps = {
+  Background?: Record<string, any>;
+  NavBar?: Record<string, any>;
+};
 
 type Props = {
+  ComponentsExtraProps?: ComponentsExtraProps;
+  NavBar: React.ComponentType<any>;
   children: React.ReactNode;
 };
 
@@ -30,9 +47,13 @@ const styles = StyleSheet.create({
   container: { flex: 1, height: "100%", width: "100%" },
 });
 
+const isTVOS = isApplePlatform();
+
 // eslint-disable-next-line react/display-name
 export const ScreenContainer = React.memo(function ScreenContainer({
   children,
+  ComponentsExtraProps,
+  NavBar,
 }: Props) {
   const { screenMarginBottom } = React.useContext(ScreenLayoutContext);
   const { currentRoute, screenData } = useNavigation();
@@ -80,9 +101,62 @@ export const ScreenContainer = React.memo(function ScreenContainer({
     [themeStyles]
   );
 
+  const navigator = useNavigation();
+  const { activeRiver } = navigator;
+  const { title, visible } = useNavbarState();
+
+  const { plugins = [] } = usePickFromState([
+    "appState",
+    "remoteConfigurations",
+    "plugins",
+  ]);
+
+  const navigationProps = getNavigationProps({
+    navigator,
+    title,
+    category: "menu",
+  });
+
+  const menuPlugin = React.useMemo(
+    () => findMenuPlugin(activeRiver?.navigations, plugins),
+    [activeRiver?.navigations]
+  );
+
+  const NavBarComponent = React.useMemo(
+    () => NavBar || (menuPlugin.module as React.ComponentType<any>),
+    []
+  );
+
+  const [navBarReady, setNavBarReady] = React.useState(false);
+
+  const navBarContainer = (
+    <NavBarContainer isVisible={visible} onReady={setNavBarReady}>
+      <NavBarComponent
+        ref={ComponentsExtraProps?.NavBar?.ref}
+        isVisible={visible}
+        menuPlugin={menuPlugin}
+        navigationProps={navigationProps}
+        {...R.omit(["ref"])(ComponentsExtraProps?.NavBar)}
+      />
+    </NavBarContainer>
+  );
+
   return (
-    <View testID="screen-container" style={viewStyles}>
-      {children}
-    </View>
+    <>
+      {!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)
+        **/
+        <View testID="screen-container" style={viewStyles}>
+          {children}
+        </View>
+      ) : null}
+      {/** Render NavBarContainer over ScreenContainer to let tvOS native
+              focus manager works correctly to focus nav bar items first **/}
+      {isTVOS ? navBarContainer : null}
+    </>
   );
 });

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

@@ -1,14 +1,27 @@
 import * as React from "react";
 import { View } from "react-native";
-import { render } from "@testing-library/react-native";
+import { render, waitFor } from "@testing-library/react-native";
+import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 
 import { ScreenLayoutContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenLayoutContext";
 
 const navigator_mock = {
   currentRoute: "/river/A1234",
   screenData: {},
+  activeRiver: {
+    navigations: {},
+    id: "A1234",
+    home: false,
+  },
 };
 
+jest.mock("@applicaster/zapp-react-native-utils/navigationUtils", () => ({
+  ...jest.requireActual<any>(
+    "@applicaster/zapp-react-native-utils/navigationUtils"
+  ),
+  findMenuPlugin: () => ({}),
+}));
+
 jest.mock("@applicaster/quick-brick-core/App/ActionSetters", () => ({
   useRiverInitialState: () => ({}),
 }));
@@ -17,13 +30,13 @@ jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
   useNavigation: () => navigator_mock,
 }));
 
-jest.mock("../../../River/useScreenConfiguration.ts", () => ({
+jest.mock("../../../River/useScreenConfiguration", () => ({
   useScreenConfiguration: () => ({}),
 }));
 
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
-  useCurrentScreenData: jest.fn(() => ({})),
-}));
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/screen/useCurrentScreenData"
+);
 
 jest.mock("@applicaster/zapp-react-native-utils/theme", () => ({
   useTheme: () => ({}),
@@ -44,42 +57,39 @@ describe("ScreenContainer", () => {
   const setScreenLayout = () => {};
 
   const wrapper = ({ children }) => (
-    <ScreenLayoutContext.Provider value={{ ...screenLayout, setScreenLayout }}>
-      {children}
-    </ScreenLayoutContext.Provider>
+    <WrappedWithProviders>
+      <ScreenLayoutContext.Provider
+        value={{ ...screenLayout, setScreenLayout }}
+      >
+        <ScreenContainer NavBar={View}>{children}</ScreenContainer>
+      </ScreenLayoutContext.Provider>
+    </WrappedWithProviders>
   );
 
   const TestComp = () => <View testID="test-component" />;
 
   it("renders", () => {
-    const { toJSON } = render(
-      <ScreenContainer>
-        <TestComp />
-      </ScreenContainer>,
-      { wrapper }
-    );
+    const { toJSON } = render(<TestComp />, { wrapper });
 
     expect(toJSON()).toMatchSnapshot();
   });
 
-  it("renders passed component", () => {
-    const { getByTestId } = render(
-      <ScreenContainer>
-        <TestComp />
-      </ScreenContainer>,
-      { wrapper }
-    );
+  it("renders passed component", async () => {
+    const { getByTestId } = render(<TestComp />, { wrapper });
+
+    await waitFor(() => {
+      return expect(getByTestId("screen-container")).toBeDefined();
+    });
 
     expect(getByTestId("test-component")).toBeDefined();
   });
 
-  it("sets margins provided by the theme", () => {
-    const { getByTestId } = render(
-      <ScreenContainer>
-        <TestComp />
-      </ScreenContainer>,
-      { wrapper }
-    );
+  it("sets margins provided by the theme", async () => {
+    const { getByTestId } = render(<TestComp />, { wrapper });
+
+    await waitFor(() => {
+      return expect(getByTestId("screen-container")).toBeDefined();
+    });
 
     const screen = getByTestId("screen-container");
     expect(screen.props.style).toMatchSnapshot();

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

@@ -1,28 +1,40 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`ScreenContainer renders 1`] = `
-<View
+<RNCSafeAreaProvider
+  onInsetsChange={[Function]}
   style={
     Array [
       Object {
         "flex": 1,
-        "height": "100%",
-        "width": "100%",
-      },
-      Object {
-        "backgroundColor": "transparent",
-        "marginBottom": 10,
-        "paddingBottom": 0,
-        "paddingTop": 0,
       },
+      undefined,
     ]
   }
-  testID="screen-container"
 >
   <View
-    testID="test-component"
-  />
-</View>
+    style={
+      Array [
+        Object {
+          "position": "absolute",
+          "top": 0,
+          "width": 1920,
+          "zIndex": 10,
+        },
+        Object {
+          "maxHeight": 10,
+        },
+      ]
+    }
+    testID="nav-bar-container"
+  >
+    <View
+      isVisible={true}
+      menuPlugin={Object {}}
+      navigationProps={null}
+    />
+  </View>
+</RNCSafeAreaProvider>
 `;
 
 exports[`ScreenContainer sets margins provided by the theme 1`] = `

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

@@ -12,7 +12,7 @@ jest.mock("../../../Screen/TV/index.web", () => ({
   Screen: View,
 }));
 
-const Layout = require("..").default;
+const Layout = require("../index.web").default;
 
 const mockStore = configureStore()({
   appState: { appReady: true },
@@ -21,10 +21,11 @@ const mockStore = configureStore()({
 describe("Layout TV", () => {
   const navigator = {
     currentRoute: "/river/A1234",
+    canGoBack: jest.fn(),
     mainStack: [
       {
         route: "/river/A1234",
-        state: "state",
+        state: { screen: {} },
       },
     ],
   };

package/Components/Layout/TV/index.tsx

@@ -1,32 +1,75 @@
 import * as React from "react";
-import { 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 { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+import { getBackgroundImageUrl } from "../utils";
+import { LayoutContainer } from "./LayoutContainer";
+import { ScreenContainer } from "./ScreenContainer";
 
 import { ScreenLayoutContextProvider } from "./ScreenLayoutContextProvider";
-import { StackNavigator } from "../../Navigator";
+import { PathnameContext } from "../../../Contexts/PathnameContext";
+import { ScreenDataContext } from "../../../Contexts/ScreenDataContext";
+import { ScreenContextProvider } from "../../../Contexts/ScreenContext";
 
 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 Layout = ({ Components }: Props) => {
-  const { appState } = usePickFromState(["appState"]);
-  const appReady = pathOr(false, ["appReady"], appState);
+const Layout = ({ Components, ComponentsExtraProps, children }: Props) => {
+  const navigator = useNavigation();
+  const theme = useTheme();
+
+  const { appState: { appReady = false } = {}, remoteConfigurations } =
+    usePickFromState(["appState", "remoteConfigurations", "plugins"]);
+
+  const backgroundColor = React.useMemo(() => theme.app_background_color, []);
+
+  const backgroundImageUrl = React.useMemo(
+    () => getBackgroundImageUrl(remoteConfigurations),
+    [remoteConfigurations]
+  );
 
   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}>
+              <ScreenContextProvider pathname={navigator.currentRoute}>
+                <ScreenContainer
+                  ComponentsExtraProps={ComponentsExtraProps}
+                  NavBar={Components.NavBar}
+                >
+                  {children}
+                </ScreenContainer>
+              </ScreenContextProvider>
+            </PathnameContext.Provider>
+          </ScreenDataContext.Provider>
+        </Components.Background>
+      </ScreenLayoutContextProvider>
+    </LayoutContainer>
   );
 };
 

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

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { pathOr } from "ramda";
+
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+
+import { ScreenLayoutContextProvider } from "./ScreenLayoutContextProvider";
+import { StackNavigator } from "../../Navigator";
+
+type Components = {
+  NavBar: React.ComponentType<any>;
+  Background: React.ComponentType<any>;
+};
+
+type Props = {
+  Components: Components;
+};
+
+const Layout = ({ Components }: Props) => {
+  const { appState } = usePickFromState(["appState"]);
+  const appReady = pathOr(false, ["appReady"], appState);
+
+  if (!appReady) {
+    return null;
+  }
+
+  return (
+    <ScreenLayoutContextProvider>
+      <StackNavigator Components={Components} />
+    </ScreenLayoutContextProvider>
+  );
+};
+
+export default Layout;

package/Components/Layout/index.tsx

@@ -1,20 +1,24 @@
 import * as React from "react";
-import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
-import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
-import { ScreenContextProvider } from "../../Contexts/ScreenContext";
+import {
+  isTV,
+  platformSelect,
+} from "@applicaster/zapp-react-native-utils/reactUtils";
 
 import Mobile from "./Mobile";
-import TV from "./TV";
 
-export default function Layout(props) {
-  const { currentRoute: pathname } = useNavigation();
+import TVWeb from "./TV/index.web";
+import TVDefault from "./TV/index";
+
+const TV = platformSelect({
+  samsung_tv: TVWeb,
+  lg_tv: TVWeb,
+  web: TVWeb,
+  default: TVDefault,
+});
 
+export default function Layout(props) {
   if (isTV()) {
-    return (
-      <ScreenContextProvider pathname={pathname}>
-        <TV {...props} />
-      </ScreenContextProvider>
-    );
+    return <TV {...props} />;
   } else {
     return <Mobile {...props} />;
   }

package/Components/MasterCell/DefaultComponents/ActionButton.tsx

@@ -53,6 +53,7 @@ export function ActionButton(props: Props) {
   const { item, action, asset, flavour = "flavour_1", cellUUID } = props;
   const actionContext = useActions(action?.identifier);
 
+  // TODO: add subscription API for action availability
   const actionDisabled =
     typeof actionContext?.isActionAvailable === "function" &&
     !actionContext.isActionAvailable(item);
@@ -68,7 +69,7 @@ export function ActionButton(props: Props) {
     if (actionDisabled || !actionContext) return;
 
     setActionState(actionContext.initialEntryState(item));
-  }, [actionDisabled, item?.id]);
+  }, [actionDisabled, item?.id, actionContext]);
 
   const onPress = useCallback(() => {
     actionContext.invokeAction(item, {