@applicaster/zapp-react-native-ui-components 14.0.0-alpha.4517121861 → 14.0.0-alpha.4520122433

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

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { View } from "react-native";
-import { act, create } from "react-test-renderer";
+import { render } from "@testing-library/react-native";
 
 const Mocked_RouteManager = jest.fn((props) => (
   <View testID="routeManager" {...props} />
@@ -68,12 +68,33 @@ jest.mock(
   })
 );
 
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/state/useRivers",
+  () => ({
+    useRivers: jest.fn(() => ({
+      rivers: [{ id: "testId", name: "Test River" }],
+    })),
+  })
+);
+
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
   isNavBarVisible: mockIsNavBarVisible,
   useIsScreenActive: jest.fn().mockReturnValue(true),
+  useNavigation: jest.fn(() => ({
+    canGoBack: () => false,
+    currentRoute: "/river/testId",
+    activeRiver: { id: "testId" },
+    screenData: { id: "testId" },
+    data: { screen: { id: "testId" } },
+  })),
+  useRoute: jest.fn(() => ({
+    pathname: "/river/testId",
+    screenData: { id: "testId" },
+  })),
 }));
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
+  ...jest.requireActual("@applicaster/zapp-react-native-utils/reactHooks"),
   useCurrentScreenData: jest.fn(() => ({
     id: "testId",
   })),
@@ -84,17 +105,6 @@ jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
     id: "testId",
     navigations: [{ id: "testId", category: "nav_bar" }],
   })),
-  useNavigation: jest.fn(() => ({
-    canGoBack: () => false,
-    currentRoute: "/river/testId",
-    activeRiver: { id: "testId" },
-    screenData: { id: "testId" },
-    data: { screen: { id: "testId" } },
-  })),
-  useRoute: jest.fn(() => ({
-    pathname: "/river/testId",
-    screenData: { id: "testId" },
-  })),
   useDimensions: jest.fn(() => ({
     width: 1920,
     height: 1080,
@@ -102,10 +112,11 @@ jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
   useIsTablet: jest.fn(() => false),
 }));
 
-jest.mock("@applicaster/zapp-react-native-redux/hooks/usePickFromState", () => {
+jest.mock("@applicaster/zapp-react-native-redux/hooks", () => {
   const View = jest.requireActual("react-native").View;
 
   return {
+    ...jest.requireActual("@applicaster/zapp-react-native-redux/hooks"),
     usePickFromState: () => ({
       plugins: [
         {
@@ -141,8 +152,6 @@ const screenProps = {
 const { Screen } = require("..");
 
 describe("<Screen Component />", () => {
-  let wrapper;
-
   beforeEach(() => {
     allowedOrientationsForScreen.mockClear();
     getOrientation.mockClear();
@@ -150,26 +159,16 @@ describe("<Screen Component />", () => {
   });
 
   describe("when the navbar should show", () => {
-    act(() => {
-      wrapper = create(<Screen {...screenProps} />);
-    });
-
     it("renders correctly", () => {
-      expect(wrapper.toJSON()).toMatchSnapshot();
+      const { toJSON } = render(<Screen {...screenProps} />);
+      expect(toJSON()).toMatchSnapshot();
     });
   });
 
   describe("when the navbar should be hidden", () => {
-    beforeEach(() => {
-      wrapper = create(<Screen {...screenProps} />);
-    });
-
     it("renders correctly", () => {
-      act(() => {
-        wrapper = create(<Screen {...screenProps} />);
-      });
-
-      expect(wrapper.toJSON()).toMatchSnapshot();
+      const { toJSON } = render(<Screen {...screenProps} />);
+      expect(toJSON()).toMatchSnapshot();
     });
   });
 });

package/Components/Screen/__tests__/navigationHandler.test.ts

@@ -3,61 +3,172 @@ import { isMenuVisible } from "../navigationHandler";
 describe("NavigationHandler", () => {
   describe("isMenuVisible", () => {
     it("returns false when the route is a player route", () => {
-      const menuVisible = isMenuVisible("/playable/some_vod_item", {});
+      const menuVisible = isMenuVisible("/playable/some_vod_item", {}, [
+        {
+          identifier: "quick-brick-bottom-tabs",
+          category: "menu",
+          name: "Bottom Tabs",
+        },
+      ]);
+
       expect(menuVisible).toBe(false);
     });
 
     describe("when screen is a hook", () => {
       it("returns true if the `showNavBar` flag is set to true", () => {
-        const menuVisible = isMenuVisible("", {
-          hookPlugin: {
-            module: {
-              showNavBar: true,
+        const menuVisible = isMenuVisible(
+          "",
+          {
+            hookPlugin: {
+              module: {
+                showNavBar: true,
+              },
             },
+            navigations: [
+              {
+                navigation_type: "quick-brick-bottom-tabs",
+                identifier: "quick-brick-bottom-tabs",
+                category: "menu",
+                name: "Bottom Tabs",
+              },
+            ],
           },
-        });
+          [
+            {
+              identifier: "quick-brick-bottom-tabs",
+              category: "menu",
+              name: "Bottom Tabs",
+            },
+          ]
+        );
 
         expect(menuVisible).toBe(true);
       });
 
       it("returns true if presentFullScreen flag is set to false", () => {
-        const menuVisible = isMenuVisible("", {
-          hookPlugin: {
-            module: {
-              presentFullScreen: false,
+        const menuVisible = isMenuVisible(
+          "",
+          {
+            hookPlugin: {
+              module: {
+                presentFullScreen: false,
+              },
             },
+            navigations: [
+              {
+                navigation_type: "quick-brick-bottom-tabs",
+                identifier: "quick-brick-bottom-tabs",
+                category: "menu",
+                name: "Bottom Tabs",
+              },
+            ],
           },
-        });
+          [
+            {
+              identifier: "quick-brick-bottom-tabs",
+              category: "menu",
+              name: "Bottom Tabs",
+            },
+          ]
+        );
 
         expect(menuVisible).toBe(true);
       });
 
       it("returns false if presentFullScreen flag is set to true", () => {
-        const menuVisible = isMenuVisible("", {
-          hookPlugin: {
-            module: {
-              presentFullScreen: true,
+        const menuVisible = isMenuVisible(
+          "",
+          {
+            hookPlugin: {
+              module: {
+                presentFullScreen: true,
+              },
             },
+            navigations: [
+              {
+                navigation_type: "quick-brick-bottom-tabs",
+                identifier: "quick-brick-bottom-tabs",
+                category: "menu",
+                name: "Bottom Tabs",
+              },
+            ],
           },
-        });
+          [
+            {
+              identifier: "quick-brick-bottom-tabs",
+              category: "menu",
+              name: "Bottom Tabs",
+            },
+          ]
+        );
 
         expect(menuVisible).toBe(false);
       });
     });
 
     it("returns false if the screen's general settings allow screen presentation", () => {
-      const menuVisible = isMenuVisible("", {
-        general: {
-          allow_screen_plugin_presentation: true,
+      const menuVisible = isMenuVisible(
+        "",
+        {
+          general: {
+            allow_screen_plugin_presentation: true,
+          },
+          navigations: [
+            {
+              navigation_type: "quick-brick-bottom-tabs",
+              identifier: "quick-brick-bottom-tabs",
+              category: "menu",
+              name: "Bottom Tabs",
+            },
+          ],
         },
-      });
+        [
+          {
+            identifier: "quick-brick-bottom-tabs",
+            category: "menu",
+            name: "Bottom Tabs",
+          },
+        ]
+      );
 
       expect(menuVisible).toBe(false);
     });
 
-    it("returns true otherwise", () => {
-      const menuVisible = isMenuVisible("", {});
+    it("returns false otherwise", () => {
+      const menuVisible = isMenuVisible(
+        "any",
+        {
+          navigations: [
+            {
+              navigation_type: "quick-brick-bottom-tabs",
+              identifier: "quick-brick-bottom-tabs",
+              category: "menu",
+              name: "Bottom Tabs",
+            },
+          ],
+        },
+        [
+          {
+            identifier: "quick-brick-bottom-tabs",
+            category: "menu",
+            name: "Bottom Tabs",
+          },
+        ]
+      );
+
       expect(menuVisible).toBe(true);
     });
+
+    it("returns false otherwise", () => {
+      const menuVisible = isMenuVisible("", {}, [
+        {
+          identifier: "quick-brick-bottom-tabs",
+          category: "menu",
+          name: "Bottom Tabs",
+        },
+      ]);
+
+      expect(menuVisible).toBe(false);
+    });
   });
 });

package/Components/Screen/navigationHandler.ts

@@ -1,3 +1,5 @@
+import { resolveNavigationPlugin } from "@applicaster/zapp-react-native-utils/navigationUtils";
+
 /**
  * This function helps to decide wether the menu should be presented on the screen
  * based on route and / or screen Data
@@ -14,12 +16,28 @@
  * @param {Object} screenData payload associated with the currently presented screen
  * @returns {Boolean}
  */
-export function isMenuVisible(route, screenData) {
+export function isMenuVisible(route, screenData, plugins) {
+  const plugin = resolveNavigationPlugin({
+    category: "menu",
+    navigations:
+      screenData?.navigations || screenData?.targetScreen?.navigations,
+    plugins,
+  });
+
+  const isBottomTabsPlugin = plugin?.identifier === "quick-brick-bottom-tabs";
+
+  if (!isBottomTabsPlugin) {
+    return false;
+  }
+
   if (route.includes("playable")) {
     return false;
   }
 
-  if (screenData.type === "qb_search_screen") {
+  if (
+    screenData.type === "qb_search_screen" ||
+    screenData?.targetScreen?.type === "qb_search_screen"
+  ) {
     return false;
   }
 

package/Components/ScreenRevealManager/ScreenRevealManager.ts

@@ -0,0 +1,76 @@
+import { makeListOf } from "@applicaster/zapp-react-native-utils/arrayUtils";
+import { isFirstComponentGallery } from "@applicaster/zapp-react-native-utils/componentsUtils";
+import { once } from "ramda";
+
+const INITIAL_NUMBER_TO_LOAD = 3;
+
+// Infer the values of COMPONENT_LOADING_STATE as a type
+type ComponentLoadingState =
+  (typeof COMPONENT_LOADING_STATE)[keyof typeof COMPONENT_LOADING_STATE];
+
+export const COMPONENT_LOADING_STATE = {
+  UNKNOWN: "UNKNOWN",
+  LOADED_WITH_SUCCESS: "LOADED_WITH_SUCCESS",
+  LOADED_WITH_FAILURE: "LOADED_WITH_FAILURE",
+} as const;
+
+// Function to get the number of loaded components
+const getNumberOfLoaded = (states: ComponentLoadingState[]): number => {
+  return states.filter((value) => value !== COMPONENT_LOADING_STATE.UNKNOWN)
+    .length;
+};
+
+const getNumberOfComponentsWaitToLoadBeforePresent = (
+  componentsToRender: ZappUIComponent[]
+): number => {
+  // when Gallery is the first component, no need to wait the others
+  if (isFirstComponentGallery(componentsToRender)) {
+    return 1;
+  }
+
+  return Math.min(INITIAL_NUMBER_TO_LOAD, componentsToRender.length);
+};
+
+export class ScreenRevealManager {
+  public numberOfComponentsWaitToLoadBeforePresent: number;
+  private renderingState: Array<ComponentLoadingState>;
+  private callback: Callback;
+
+  constructor(componentsToRender: ZappUIComponent[], callback: Callback) {
+    this.numberOfComponentsWaitToLoadBeforePresent =
+      getNumberOfComponentsWaitToLoadBeforePresent(componentsToRender);
+
+    this.renderingState = makeListOf<ComponentLoadingState>(
+      COMPONENT_LOADING_STATE.UNKNOWN,
+      this.numberOfComponentsWaitToLoadBeforePresent
+    );
+
+    this.callback = once(callback);
+  }
+
+  onLoadFinished = (index: number): void => {
+    this.renderingState[index] = COMPONENT_LOADING_STATE.LOADED_WITH_SUCCESS;
+
+    if (
+      getNumberOfLoaded(this.renderingState) >=
+      this.numberOfComponentsWaitToLoadBeforePresent
+    ) {
+      this.setIsReadyToShow();
+    }
+  };
+
+  onLoadFailed = (index: number): void => {
+    this.renderingState[index] = COMPONENT_LOADING_STATE.LOADED_WITH_FAILURE;
+
+    if (
+      getNumberOfLoaded(this.renderingState) >=
+      this.numberOfComponentsWaitToLoadBeforePresent
+    ) {
+      this.setIsReadyToShow();
+    }
+  };
+
+  setIsReadyToShow = (): void => {
+    this.callback();
+  };
+}

package/Components/ScreenRevealManager/__tests__/ScreenRevealManager.test.ts

@@ -0,0 +1,107 @@
+import {
+  ScreenRevealManager,
+  COMPONENT_LOADING_STATE,
+} from "../ScreenRevealManager";
+
+describe("ScreenRevealManager", () => {
+  const mockCallback = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should initialize with the correct number of components to wait for", () => {
+    const componentsToRender: ZappUIComponent[] = [
+      { component_type: "component1" },
+      { component_type: "component2" },
+      { component_type: "component3" },
+    ];
+
+    const manager = new ScreenRevealManager(componentsToRender, mockCallback);
+
+    expect(manager.numberOfComponentsWaitToLoadBeforePresent).toBe(3);
+
+    expect(manager.renderingState).toEqual([
+      COMPONENT_LOADING_STATE.UNKNOWN,
+      COMPONENT_LOADING_STATE.UNKNOWN,
+      COMPONENT_LOADING_STATE.UNKNOWN,
+    ]);
+  });
+
+  it("should call the callback when the required number of components are loaded successfully", () => {
+    const componentsToRender: ZappUIComponent[] = [
+      { component_type: "component1" },
+      { component_type: "component2" },
+      { component_type: "component3" },
+    ];
+
+    const manager = new ScreenRevealManager(componentsToRender, mockCallback);
+
+    manager.onLoadFinished(0);
+    manager.onLoadFinished(1);
+    manager.onLoadFinished(2);
+
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call the callback when the required number of components fail to load", () => {
+    const componentsToRender: ZappUIComponent[] = [
+      { component_type: "component1" },
+      { component_type: "component2" },
+      { component_type: "component3" },
+    ];
+
+    const manager = new ScreenRevealManager(componentsToRender, mockCallback);
+
+    manager.onLoadFailed(0);
+    manager.onLoadFailed(1);
+    manager.onLoadFailed(2);
+
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call the callback when a mix of successful and failed loads meet the required number", () => {
+    const componentsToRender: ZappUIComponent[] = [
+      { component_type: "component1" },
+      { component_type: "component2" },
+      { component_type: "component3" },
+    ];
+
+    const manager = new ScreenRevealManager(componentsToRender, mockCallback);
+
+    manager.onLoadFinished(0);
+    manager.onLoadFailed(1);
+    manager.onLoadFinished(2);
+
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not call the callback if the required number of components are not loaded", () => {
+    const componentsToRender: ZappUIComponent[] = [
+      { component_type: "component1" },
+      { component_type: "component2" },
+      { component_type: "component3" },
+    ];
+
+    const manager = new ScreenRevealManager(componentsToRender, mockCallback);
+
+    manager.onLoadFinished(0);
+    manager.onLoadFailed(1);
+
+    expect(mockCallback).not.toHaveBeenCalled();
+  });
+
+  it("should call the callback when the when first component is gallery and it was loaded successfully", () => {
+    const componentsToRender: ZappUIComponent[] = [
+      { component_type: "gallery-qb" },
+      { component_type: "component2" },
+      { component_type: "component3" },
+    ];
+
+    const manager = new ScreenRevealManager(componentsToRender, mockCallback);
+
+    manager.onLoadFinished(0);
+
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+});

package/Components/ScreenRevealManager/__tests__/withScreenRevealManager.test.tsx

@@ -0,0 +1,96 @@
+/* eslint-disable react/prop-types */
+
+import * as React from "react";
+import { render, screen, act } from "@testing-library/react-native";
+import { View } from "react-native";
+import {
+  withScreenRevealManager,
+  SHOWN,
+  TIMEOUT,
+} from "../withScreenRevealManager";
+
+// jest.mock("react-native/Libraries/Animated/NativeAnimatedHelper");
+
+const MockComponent = ({
+  initialNumberToLoad,
+  onLoadFinishedFromScreenRevealManager,
+  onLoadFailedFromScreenRevealManager,
+}) => {
+  React.useEffect(() => {
+    // Simulate loading components
+    for (let i = 0; i < initialNumberToLoad; i++) {
+      onLoadFinishedFromScreenRevealManager(i);
+    }
+  }, [initialNumberToLoad, onLoadFinishedFromScreenRevealManager]);
+
+  return (
+    <View
+      testID="mock-component"
+      initialNumberToLoad={initialNumberToLoad}
+      onLoadFinishedFromScreenRevealManager={
+        onLoadFinishedFromScreenRevealManager
+      }
+      onLoadFailedFromScreenRevealManager={onLoadFailedFromScreenRevealManager}
+    />
+  );
+};
+
+const WrappedComponent = withScreenRevealManager(MockComponent);
+
+describe.skip("withScreenRevealManager", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+
+  it("should render the wrapped component", () => {
+    render(
+      <WrappedComponent
+        componentsToRender={[{ id: "1" }, { id: "2" }, { id: "3" }]}
+      />
+    );
+
+    expect(screen.getByTestId("mock-component")).toBeTruthy();
+  });
+
+  it("should animate opacity when ready to show", () => {
+    render(
+      <WrappedComponent
+        componentsToRender={[{ id: "1" }, { id: "2" }, { id: "3" }]}
+      />
+    );
+
+    const animatedView = screen.getByTestId("animated-component");
+
+    act(() => {
+      jest.advanceTimersByTime(TIMEOUT + 100);
+    });
+
+    expect(animatedView.props.style.opacity).toBe(SHOWN);
+  });
+
+  it("should pass initialNumberToLoad, onLoadFinishedFromScreenRevealManager, and onLoadFailedFromScreenRevealManager to the wrapped component", () => {
+    render(
+      <WrappedComponent
+        componentsToRender={[{ id: "1" }, { id: "2" }, { id: "3" }]}
+      />
+    );
+
+    const mockComponent = screen.getByTestId("mock-component");
+
+    expect(mockComponent.props.initialNumberToLoad).toBe(3);
+
+    expect(
+      mockComponent.props.onLoadFinishedFromScreenRevealManager
+    ).toBeInstanceOf(Function);
+
+    expect(
+      mockComponent.props.onLoadFailedFromScreenRevealManager
+    ).toBeInstanceOf(Function);
+  });
+});

package/Components/ScreenRevealManager/index.ts

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