@applicaster/zapp-react-native-ui-components 13.0.0-alpha.4700935119 → 13.0.0-alpha.4863201005

package/Components/River/ComponentsMap/hooks/useLoadingState.ts

@@ -1,50 +1,86 @@
 import * as React from "react";
-import * as R from "ramda";
-
-const allTrue = R.all(R.equals(true));
-const anyFalse = R.any(R.equals(false));
-const anyTrue = R.any(R.equals(true));
+import { isNil, set, lensIndex, T, slice } from "ramda";
+import { BehaviorSubject } from "rxjs";
+import { useRefWithInitialValue } from "@applicaster/zapp-react-native-utils/reactHooks/state/useRefWithInitialValue";
 
 const reducer = (state, { payload }) => {
-  if (!R.isNil(payload) && !state[payload]) {
-    return R.set(R.lensIndex(payload), true)(state);
+  if (!isNil(payload) && !state[payload]) {
+    return set(lensIndex(payload), true)(state);
   }
 
   return state;
 };
 
-type Return = {
-  isAnyLoading: boolean;
-  isAllLoaded: boolean;
+type LoadingState = {
+  index: number;
+  done: boolean;
   waitForAllComponents: boolean;
+};
+
+type Return = {
+  loadingState: BehaviorSubject<LoadingState>;
   onLoadFinished: (index: number) => void;
   onLoadFailed: ({ error, index }: { error: Error; index: number }) => void;
   shouldShowLoadingError: boolean;
-  isAnyLoaded: boolean;
   arePreviousComponentsLoaded: (index: number) => boolean;
 };
 
-type Action = { payload: { index: number } };
-
-type Loaded = true;
-type Loading = false;
-
-type LoadingState = Array<Loaded | Loading>;
-
 // TODO: Take this value from Zapp configuration, when feature is added to GeneralScreen
 const SHOULD_FAIL_ON_COMPONENT_LOADING = false;
 
-export const useLoadingState = (count: number): Return => {
+const createLoadingStateObservable = () =>
+  new BehaviorSubject<LoadingState>({
+    index: -1,
+    done: false,
+    waitForAllComponents: SHOULD_FAIL_ON_COMPONENT_LOADING,
+  });
+
+export const useLoadingState = (
+  count: number,
+  onLoadDone: () => void
+): Return => {
+  const componentStateRef = React.useRef(new Array(count).fill(false));
   const [loadingError, setLoadingError] = React.useState(null);
 
-  const [componentsState, dispatch] = React.useReducer<
-    React.Reducer<LoadingState, Action>
-  >(reducer, new Array(count).fill(false));
+  const loadingState = useRefWithInitialValue<BehaviorSubject<LoadingState>>(
+    createLoadingStateObservable
+  );
+
+  const arePreviousComponentsLoaded = React.useCallback((index) => {
+    if (index === 0) {
+      return true;
+    }
 
-  const handleComponentLoaded = React.useCallback((index) => {
-    dispatch({ payload: index });
+    const componentsBefore = slice(0, index, componentStateRef.current);
+
+    return componentsBefore.every(T);
   }, []);
 
+  const dispatch = React.useCallback(({ payload }) => {
+    const newState = reducer(componentStateRef.current, { payload });
+    componentStateRef.current = newState;
+    const isDone = arePreviousComponentsLoaded(count - 1);
+
+    const state = loadingState.current.getValue();
+
+    const newLoadingState = {
+      ...state,
+      index: state.index < payload ? payload : state.index,
+      done: isDone,
+    };
+
+    loadingState.current.next(newLoadingState);
+
+    if (isDone) {
+      onLoadDone();
+    }
+  }, []);
+
+  const handleComponentLoaded = React.useCallback(
+    (index) => dispatch({ payload: index }),
+    []
+  );
+
   const handleComponentLoadErrorWhenNeedToFail = React.useCallback(
     ({ error }) => {
       if (error !== loadingError) {
@@ -55,35 +91,26 @@ export const useLoadingState = (count: number): Return => {
   );
 
   const handleComponentLoadErrorWhenNoNeedToFail = React.useCallback(
-    ({ index }) => {
-      handleComponentLoaded(index);
-    },
+    ({ index }) => handleComponentLoaded(index),
     []
   );
 
-  const arePreviousComponentsLoaded = React.useCallback(
-    (index) => {
-      if (index === 0) {
-        return true;
-      }
-
-      const componentsBefore = R.slice(0, index, componentsState);
-
-      return allTrue(componentsBefore);
-    },
-    [componentsState]
+  return React.useMemo(
+    () => ({
+      loadingState: loadingState.current,
+      onLoadFinished: handleComponentLoaded,
+      onLoadFailed: SHOULD_FAIL_ON_COMPONENT_LOADING
+        ? handleComponentLoadErrorWhenNeedToFail
+        : handleComponentLoadErrorWhenNoNeedToFail,
+      shouldShowLoadingError: SHOULD_FAIL_ON_COMPONENT_LOADING && loadingError,
+      arePreviousComponentsLoaded,
+    }),
+    [
+      loadingError,
+      handleComponentLoaded,
+      handleComponentLoadErrorWhenNeedToFail,
+      handleComponentLoadErrorWhenNoNeedToFail,
+      arePreviousComponentsLoaded,
+    ]
   );
-
-  return {
-    isAnyLoading: anyFalse(componentsState),
-    isAllLoaded: allTrue(componentsState),
-    onLoadFinished: handleComponentLoaded,
-    onLoadFailed: SHOULD_FAIL_ON_COMPONENT_LOADING
-      ? handleComponentLoadErrorWhenNeedToFail
-      : handleComponentLoadErrorWhenNoNeedToFail,
-    shouldShowLoadingError: SHOULD_FAIL_ON_COMPONENT_LOADING && loadingError,
-    isAnyLoaded: anyTrue(componentsState),
-    waitForAllComponents: SHOULD_FAIL_ON_COMPONENT_LOADING,
-    arePreviousComponentsLoaded,
-  };
 };

package/Components/River/RiverFooter.tsx

@@ -1,11 +1,23 @@
-import React from "react";
+import React, { useCallback } from "react";
 import { StyleSheet, View } from "react-native";
 import { Spinner } from "@applicaster/zapp-react-native-ui-components/Components/Spinner";
+import type { Subject } from "rxjs";
+import { useStateFromSubscribe } from "@applicaster/zapp-react-native-utils/reactHooks/state/useStateFromSubscribe";
+
+type LoadingState = {
+  waitForAllComponents: boolean;
+  index: number;
+  done: boolean;
+};
+
+type State = {
+  visible: boolean;
+  isAnyLoaded: boolean;
+};
 
 type Props = {
-  visible?: boolean;
   flatListHeight?: number;
-  isAnyLoaded: boolean;
+  loadingState: Subject<LoadingState>;
 };
 
 const FOOTER_COMPONENT_HEIGHT = 200;
@@ -19,17 +31,35 @@ const footerStyles = StyleSheet.create({
 });
 
 function RiverFooterComponent(props: Props) {
-  const { visible = true, flatListHeight, isAnyLoaded } = props;
+  const { flatListHeight, loadingState } = props;
+
+  const { visible, isAnyLoaded } = useStateFromSubscribe<LoadingState, State>(
+    loadingState,
+    useCallback(
+      ({ index, done, waitForAllComponents }, setState) =>
+        setState(() => ({
+          visible: !done,
+          isAnyLoaded: index >= 0 || waitForAllComponents,
+        })),
+      []
+    ),
+    {
+      visible: true,
+      isAnyLoaded: false,
+    }
+  );
 
   if (!visible) return null;
 
   return (
     <View
-      renderToHardwareTextureAndroid={true}
-      style={{
-        ...footerStyles.container,
-        height: isAnyLoaded ? FOOTER_COMPONENT_HEIGHT : flatListHeight,
-      }}
+      renderToHardwareTextureAndroid
+      style={[
+        footerStyles.container,
+        {
+          height: isAnyLoaded ? FOOTER_COMPONENT_HEIGHT : flatListHeight,
+        },
+      ]}
     >
       <Spinner size={isAnyLoaded ? "small" : "large"} />
     </View>

package/Components/River/RiverItem.tsx

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useEffect } from "react";
 import * as R from "ramda";
 
 import { applyDecorators } from "../../Decorators";
@@ -11,6 +11,7 @@ import {
 import { riverLogger } from "./logger";
 import { tvPluginsWithCellRenderer } from "../../const";
 import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import type { BehaviorSubject } from "rxjs";
 
 export type RiverItemType = {
   item: ZappUIComponent;
@@ -24,6 +25,7 @@ export type RiverItemType = {
   getStaticComponentFeed: GeneralContentScreenProps["getStaticComponentFeed"];
   readyToBeDisplayed?: boolean;
   isLast: boolean;
+  loadingState: BehaviorSubject<{ index: number }>;
 };
 
 function getFeedUrl(feed: ZappFeed, index: number) {
@@ -36,6 +38,33 @@ function getFeedUrl(feed: ZappFeed, index: number) {
   }
 }
 
+/**
+ * useLoadingState for RiverItemComponent
+ * takes currentIndex and loadingState as arguments
+ **/
+const useLoadingState = (
+  currentIndex: number,
+  loadingState: RiverItemType["loadingState"]
+) => {
+  const [readyToBeDisplayed, setReadyToBeDisplayed] = React.useState(
+    loadingState.getValue().index + 1 === currentIndex
+  );
+
+  useEffect(() => {
+    const subscription = loadingState.subscribe(({ index }) => {
+      if (index + 1 === currentIndex) {
+        setReadyToBeDisplayed(true);
+      }
+    });
+
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [loadingState, currentIndex]);
+
+  return readyToBeDisplayed;
+};
+
 function RiverItemComponent(props: RiverItemType) {
   const {
     item,
@@ -47,10 +76,12 @@ function RiverItemComponent(props: RiverItemType) {
     onLoadFinished,
     onLoadFailed,
     getStaticComponentFeed,
-    readyToBeDisplayed,
     isLast,
+    loadingState,
   } = props;
 
+  const readyToBeDisplayed = useLoadingState(index, loadingState);
+
   const feedUrl = getFeedUrl(feed, index);
 
   const Component = useComponentResolver(
@@ -90,6 +121,10 @@ function RiverItemComponent(props: RiverItemType) {
     }
   }, []);
 
+  if (!readyToBeDisplayed) {
+    return null;
+  }
+
   if (Component === null || typeof Component === "undefined") {
     riverLogger.warning({
       message: `Component ${item.component_type} is null - skipping rendering`,

package/Components/River/__tests__/__snapshots__/componentsMap.test.js.snap

@@ -17,7 +17,90 @@ exports[`componentsMap renders renders components map correctly 1`] = `
     }
   >
     <RCTScrollView
-      ListFooterComponent={[Function]}
+      ListFooterComponent={
+        <Memo(RiverFooterComponent)
+          flatListHeight={null}
+          loadingState={
+            BehaviorSubject {
+              "_value": {
+                "done": false,
+                "index": -1,
+                "waitForAllComponents": false,
+              },
+              "closed": false,
+              "currentObservers": null,
+              "hasError": false,
+              "isStopped": false,
+              "observers": [
+                SafeSubscriber {
+                  "_finalizers": [
+                    Subscription {
+                      "_finalizers": null,
+                      "_parentage": [Circular],
+                      "closed": false,
+                      "initialTeardown": [Function],
+                    },
+                  ],
+                  "_parentage": null,
+                  "closed": false,
+                  "destination": ConsumerObserver {
+                    "partialObserver": {
+                      "complete": undefined,
+                      "error": undefined,
+                      "next": [Function],
+                    },
+                  },
+                  "initialTeardown": undefined,
+                  "isStopped": false,
+                },
+                SafeSubscriber {
+                  "_finalizers": [
+                    Subscription {
+                      "_finalizers": null,
+                      "_parentage": [Circular],
+                      "closed": false,
+                      "initialTeardown": [Function],
+                    },
+                  ],
+                  "_parentage": null,
+                  "closed": false,
+                  "destination": ConsumerObserver {
+                    "partialObserver": {
+                      "complete": undefined,
+                      "error": undefined,
+                      "next": [Function],
+                    },
+                  },
+                  "initialTeardown": undefined,
+                  "isStopped": false,
+                },
+                SafeSubscriber {
+                  "_finalizers": [
+                    Subscription {
+                      "_finalizers": null,
+                      "_parentage": [Circular],
+                      "closed": false,
+                      "initialTeardown": [Function],
+                    },
+                  ],
+                  "_parentage": null,
+                  "closed": false,
+                  "destination": ConsumerObserver {
+                    "partialObserver": {
+                      "complete": undefined,
+                      "error": undefined,
+                      "next": [Function],
+                    },
+                  },
+                  "initialTeardown": undefined,
+                  "isStopped": false,
+                },
+              ],
+              "thrownError": null,
+            }
+          }
+        />
+      }
       contentContainerStyle={
         {
           "paddingBottom": undefined,
@@ -80,22 +163,14 @@ exports[`componentsMap renders renders components map correctly 1`] = `
           style={null}
         >
           <View
+            onLayout={[Function]}
             style={
               {
-                "display": "flex",
+                "flex": 1,
               }
             }
           >
-            <View
-              onLayout={[Function]}
-              style={
-                {
-                  "flex": 1,
-                }
-              }
-            >
-              <View />
-            </View>
+            <View />
           </View>
         </View>
         <View
@@ -103,23 +178,13 @@ exports[`componentsMap renders renders components map correctly 1`] = `
           style={null}
         >
           <View
+            onLayout={[Function]}
             style={
               {
-                "display": "none",
+                "flex": 1,
               }
             }
-          >
-            <View
-              onLayout={[Function]}
-              style={
-                {
-                  "flex": 1,
-                }
-              }
-            >
-              <View />
-            </View>
-          </View>
+          />
         </View>
         <View
           onLayout={[Function]}
@@ -127,12 +192,16 @@ exports[`componentsMap renders renders components map correctly 1`] = `
           <View
             renderToHardwareTextureAndroid={true}
             style={
-              {
-                "alignItems": "center",
-                "height": null,
-                "justifyContent": "center",
-                "width": "100%",
-              }
+              [
+                {
+                  "alignItems": "center",
+                  "justifyContent": "center",
+                  "width": "100%",
+                },
+                {
+                  "height": null,
+                },
+              ]
             }
           >
             <ActivityIndicator

package/Components/River/__tests__/componentsMap.test.js

@@ -1,6 +1,5 @@
 import React from "react";
-import TestRenderer from "react-test-renderer";
-import { cleanup } from "@testing-library/react-native";
+import { cleanup, render } from "@testing-library/react-native";
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 
@@ -81,6 +80,13 @@ const mockScreenData = {
   id: "A1234",
 };
 
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: {
+    get: jest.fn((prop) => mockStore[prop]),
+    getState: jest.fn(),
+  },
+}));
+
 jest.mock("@applicaster/zapp-react-native-utils/localizationUtils", () => ({
   useIsRTL: jest.fn(() => mock_rtl_flag),
 }));
@@ -153,7 +159,13 @@ const plugins = [];
 const navigation = {};
 
 const props = { components, cellStyles, riverComponents, navigation };
-const store = mockStore({ components, cellStyles, plugins });
+
+const store = mockStore({
+  components,
+  cellStyles,
+  plugins,
+  getState: jest.fn(),
+});
 
 jest.useFakeTimers();
 
@@ -170,12 +182,12 @@ describe("componentsMap", () => {
       .spyOn(themeUtils, "useTheme")
       .mockImplementation(() => () => theme);
 
-    const wrapper = TestRenderer.create(
+    const { toJSON } = render(
       <Provider store={store}>
         <ComponentsMap {...props} />
       </Provider>
     );
 
-    expect(wrapper.toJSON()).toMatchSnapshot();
+    expect(toJSON()).toMatchSnapshot();
   });
 });

package/Components/Screen/hooks.ts

@@ -0,0 +1,56 @@
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  useGetScreenOrientation,
+  isOrientationCompatible,
+} from "@applicaster/zapp-react-native-utils/appUtils/orientationHelper";
+import {
+  useCurrentScreenData,
+  useDimensions,
+  useRoute,
+} from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useMemo, useEffect, useState } from "react";
+
+export const useWaitForValidOrientation = () => {
+  const {
+    width: screenWidth,
+    height,
+    deviceInfo,
+  } = useDimensions("screen", {
+    fullDimensions: true,
+    updateForInactiveScreens: false,
+  });
+
+  const currentScreenData = useCurrentScreenData();
+
+  const { screenData } = useRoute();
+
+  const [readyState, setReadyState] = useState(false);
+
+  const isTablet = deviceInfo?.isTablet;
+
+  const { appData } = usePickFromState(["appData"]);
+  const isTabletPortrait = appData?.isTabletPortrait;
+
+  const layoutData = useMemo(
+    () => ({ isTablet, isTabletPortrait, width: screenWidth, height }),
+    [isTablet, isTabletPortrait, screenWidth, height]
+  );
+
+  const targetScreenData =
+    currentScreenData || (screenData as any)?.targetScreen || screenData;
+
+  const orientation = useGetScreenOrientation(targetScreenData);
+
+  const isReadyForDisplay = isOrientationCompatible({
+    orientation,
+    layoutData,
+  });
+
+  useEffect(() => {
+    if (isReadyForDisplay && !readyState) {
+      setReadyState(true);
+    }
+  }, [readyState, orientation, layoutData]);
+
+  return readyState;
+};

package/Components/Screen/index.tsx

@@ -2,10 +2,6 @@
 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";
@@ -15,7 +11,6 @@ import {
   getScreenId,
 } from "@applicaster/zapp-react-native-utils/navigationUtils";
 import {
-  useDimensions,
   useRoute,
   useCurrentScreenData,
   useNavbarState,
@@ -27,6 +22,7 @@ import { getNavigationPluginModule } from "@applicaster/zapp-react-native-app/Ap
 import { RouteManager } from "../RouteManager";
 import { useScreenConfiguration } from "../River/useScreenConfiguration";
 import { isValidColor } from "./utils";
+import { useWaitForValidOrientation } from "./hooks";
 
 const screenStyles = {
   flex: 1,
@@ -50,14 +46,6 @@ export function Screen(_props: Props) {
   const currentScreenData = useCurrentScreenData();
   const { backgroundColor } = useScreenConfiguration(currentScreenData.id);
 
-  const {
-    width: screenWidth,
-    height,
-    deviceInfo,
-  } = useDimensions("screen", {
-    fullDimensions: true,
-  });
-
   const { screenData, pathname } = useRoute();
 
   const currentRiver = useScreenData(
@@ -66,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>(
@@ -108,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} />}
+
+          <OfflineFallbackScreen>
+            {/* @TODO RouteManager doesn't use props, can they be removed ?  */}
+            <RouteManager pathname={pathname} screenData={screenData} />
+          </OfflineFallbackScreen>
+        </>
+      ) : null}
     </View>
   );
 }