@applicaster/zapp-react-native-ui-components 13.0.0-rc.11 → 13.0.0-rc.110

package/Components/VideoModal/ModalAnimation/AnimationComponent.tsx

@@ -4,28 +4,31 @@ import { Animated, View } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
 import {
-  useModalAnimationContext,
   PlayerAnimationStateEnum,
+  useModalAnimationContext,
 } from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
 
 import {
+  useDimensions,
   useGetBottomTabBarHeight,
   useNavigation,
-  useDimensions,
 } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { useIsRTL } from "@applicaster/zapp-react-native-utils/localizationUtils";
 import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useAppState } from "@applicaster/zapp-react-native-utils/reactHooks/app";
 
 import {
-  gestureListenerHelper,
-  getAnimationStyle,
+  AUDIO_PLAYER_HORIZONTAL_PADDING,
+  ComponentAnimationType,
   defaultAspectRatioWidth,
+  gestureListenerHelper,
   getAnimationDefaultValue,
-  ComponentAnimationType,
-  AUDIO_PLAYER_HORIZONTAL_PADDING,
+  getAnimationStyle,
+  getMoveUpValue,
 } from "./utils";
 
+import { DURATION_TO_MINIMIZE, DEFAULT_DURATION_FOR_ANIMATION } from "./const";
+
 type Props = {
   animationType: string;
   children: React.ReactNode;
@@ -77,7 +80,7 @@ export const AnimationView = ({
   const measureView = React.useCallback(() => {
     if (isTabletLandscape && tabletLandscapePlayerTopPosition === 0) {
       animationComponentRef.current.measure(
-        (x, y, width, height, pageX, pageY) => {
+        (_x, _y, _width, _height, _pageX, pageY) => {
           setTabletLandscapePlayerTopPosition(pageY - 20);
         }
       );
@@ -97,13 +100,16 @@ export const AnimationView = ({
 
   const inlineAudioPlayer = additionalData.inlineAudioPlayer;
 
-  const moveUpValue = additionalData.saveArea
-    ? -insets.top + (isAudioItem ? 0 : progressBarHeight)
-    : isTablet
-    ? isTabletLandscape && (!isAudioItem || (isAudioItem && inlineAudioPlayer))
-      ? -tabletLandscapePlayerTopPosition + progressBarHeight
-      : -130
-    : -50 + progressBarHeight;
+  const moveUpValue = getMoveUpValue({
+    additionalData,
+    insets,
+    isAudioItem,
+    progressBarHeight,
+    isTablet,
+    isTabletLandscape,
+    inlineAudioPlayer,
+    tabletLandscapePlayerTopPosition,
+  });
 
   const moveComponentHorizontalValue = additionalData.moveValue
     ? isRTL
@@ -118,7 +124,10 @@ export const AnimationView = ({
     (animationType, state) => {
       const defaultConfig = {
         toValue: 0,
-        duration: state === PlayerAnimationStateEnum.minimize ? 150 : 100,
+        duration:
+          state === PlayerAnimationStateEnum.minimize
+            ? DURATION_TO_MINIMIZE
+            : DEFAULT_DURATION_FOR_ANIMATION,
         useNativeDriver: true,
       };
 
@@ -227,6 +236,8 @@ export const AnimationView = ({
       isAudioItem,
       moveUpValue,
       moveComponentHorizontalValue,
+      isRTL,
+      inlineAudioPlayer,
     ]
   );
 
@@ -245,7 +256,7 @@ export const AnimationView = ({
       default:
         return getAnimationValue(
           animationType,
-          PlayerAnimationStateEnum.maximaze
+          PlayerAnimationStateEnum.maximize
         ).toValue;
     }
   }, [defaultValue, videoModalState]);
@@ -277,6 +288,11 @@ export const AnimationView = ({
       moveUpValue,
       moveComponentHorizontalValue,
       videoModalMode,
+      isAudioItem,
+      isTablet,
+      isTabletLandscape,
+      isRTL,
+      inlineAudioPlayer,
     ]
   );
 
@@ -305,7 +321,7 @@ export const AnimationView = ({
       }
 
       if (
-        videoModalMode === "MAXIMIZED" &&
+        (videoModalMode === "MAXIMIZED" || videoModalMode === "MINIMIZED") &&
         defaultValue.x !== screenWidth &&
         width &&
         height
@@ -331,7 +347,13 @@ export const AnimationView = ({
         animatedValue.setValue(value);
       }
     }
-  }, [videoModalState]);
+  }, [
+    animatedValue,
+    animationType,
+    getAnimationValue,
+    playerAnimationState,
+    videoModalState,
+  ]);
 
   React.useEffect(() => {
     if (
@@ -343,7 +365,7 @@ export const AnimationView = ({
         animatedValue,
         getAnimationValue(animationType, playerAnimationState)
       ).start();
-    } else if (playerAnimationState === PlayerAnimationStateEnum.maximaze) {
+    } else if (playerAnimationState === PlayerAnimationStateEnum.maximize) {
       animatedValue.setValue(defaultValue);
     }
   }, [playerAnimationState, startComponentsAnimation, defaultValue]);
@@ -404,7 +426,7 @@ export const AnimationView = ({
 
   return (
     <Animated.View
-      onLayout={additionalData.useLayoutMeasure && measureView}
+      onLayout={additionalData.useLayoutMeasure ? measureView : undefined}
       ref={animationComponentRef}
       style={[
         ...preparedStyles,
@@ -426,6 +448,10 @@ export const AnimationComponent = (props: Props) => {
     videoModalState: { visible },
   } = useNavigation();
 
+  if (additionalData?.disableAnimatedComponent) {
+    return <>{props.children}</>;
+  }
+
   const useAnimation =
     visible && !additionalData.disableAnimatedComponent && !isTV();
 
@@ -434,8 +460,8 @@ export const AnimationComponent = (props: Props) => {
   const Component = useAnimation
     ? AnimationView
     : style
-    ? View
-    : React.Fragment;
+      ? View
+      : React.Fragment;
 
   if (
     additionalData.extraAnimation &&

package/Components/VideoModal/ModalAnimation/ModalAnimationContext.tsx

@@ -1,14 +1,12 @@
-import React, { useContext } from "react";
+import React, { useEffect } from "react";
 import { Animated } from "react-native";
 
 import {
   useSafeAreaInsets,
   useSafeAreaFrame,
 } from "react-native-safe-area-context";
-import {
-  useGetBottomTabBarHeight,
-  useNavigation,
-} from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useGetBottomTabBarHeight } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useGetBottomTabBarHeight";
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
 import { isLive } from "@applicaster/zapp-react-native-utils/playerUtils";
 
 import { PROGRESS_BAR_HEIGHT } from "./utils";
@@ -16,12 +14,12 @@ import { useConfiguration } from "../utils";
 
 export enum PlayerAnimationStateEnum {
   minimize = "minimize",
-  maximaze = "maximaze",
+  maximize = "maximize",
   drag_player = "drag_player",
   drag_scroll = "drag_scroll",
 }
 
-type PlayerAnimationStateT = number | PlayerAnimationStateEnum | null;
+export type PlayerAnimationStateT = number | PlayerAnimationStateEnum | null;
 
 export type ModalAnimationContextT = {
   isActiveGesture: boolean;
@@ -48,7 +46,7 @@ export type ModalAnimationContextT = {
   progressBarHeight: number;
 };
 
-const ReactContext = React.createContext<ModalAnimationContextT>({
+export const ReactContext = React.createContext<ModalAnimationContextT>({
   isActiveGesture: false,
   playerAnimationState: null,
   setPlayerAnimationState: () => null,
@@ -73,10 +71,6 @@ const ReactContext = React.createContext<ModalAnimationContextT>({
   progressBarHeight: 0,
 });
 
-export function useModalAnimationContext() {
-  return useContext<ModalAnimationContextT>(ReactContext);
-}
-
 const Provider = ({ children }: { children: React.ReactNode }) => {
   const [playerAnimationState, setPlayerAnimationState] =
     React.useState<PlayerAnimationStateT>(null);
@@ -101,6 +95,13 @@ const Provider = ({ children }: { children: React.ReactNode }) => {
     setStartComponentsAnimation(false);
   }, []);
 
+  useEffect(() => {
+    // Reset player animation state when video modal is closed
+    if (!visible) {
+      resetPlayerAnimationState();
+    }
+  }, [visible, resetPlayerAnimationState]);
+
   // Animated values
   const lastScrollY = React.useRef(new Animated.Value(0)).current;
   const dragScrollY = React.useRef(new Animated.Value(0)).current;
@@ -124,11 +125,10 @@ const Provider = ({ children }: { children: React.ReactNode }) => {
     If bottomTabBarHeight is equal 0 it means an app does not use bottomTabBar.
     Because of this we need to minus bottom SafeArea offset.
   */
+
   const minValue =
     height -
-    minimisedHeight -
-    (bottomTabBarHeight || bottomSafeArea) -
-    progressBarHeight;
+    (minimisedHeight + bottomTabBarHeight + progressBarHeight + bottomSafeArea);
 
   const modalSnapPoints = React.useMemo(() => [0, minValue], [minValue]);
   // Last snap state which will helps us to make smooth responder to scrollview animation

package/Components/VideoModal/ModalAnimation/__tests__/getMoveUpValue.test.ts

@@ -0,0 +1,108 @@
+import { getMoveUpValue } from "../utils";
+
+describe("getMoveUpValue", () => {
+  it("returns correct value when additionalData.saveArea is true and isAudioItem is false", () => {
+    const result = getMoveUpValue({
+      additionalData: { saveArea: true },
+      insets: { top: 20 },
+      isAudioItem: false,
+      progressBarHeight: 10,
+      isTablet: false,
+      isTabletLandscape: false,
+      inlineAudioPlayer: false,
+      tabletLandscapePlayerTopPosition: 100,
+    });
+
+    expect(result).toBe(-20 + 10);
+  });
+
+  it("returns correct value when additionalData.saveArea is true and isAudioItem is true", () => {
+    const result = getMoveUpValue({
+      additionalData: { saveArea: true },
+      insets: { top: 15 },
+      isAudioItem: true,
+      progressBarHeight: 5,
+      isTablet: false,
+      isTabletLandscape: false,
+      inlineAudioPlayer: false,
+      tabletLandscapePlayerTopPosition: 100,
+    });
+
+    expect(result).toBe(-15 + 0);
+  });
+
+  it("returns correct value for audio item (tablet or not)", () => {
+    const result = getMoveUpValue({
+      additionalData: { marginTop: 30 },
+      insets: { top: 0 },
+      isAudioItem: true,
+      progressBarHeight: 0,
+      isTablet: false,
+      isTabletLandscape: false,
+      inlineAudioPlayer: false,
+      tabletLandscapePlayerTopPosition: 0,
+    });
+
+    expect(result).toBe(-30);
+  });
+
+  it("returns correct value for tablet landscape with inline audio player", () => {
+    const result = getMoveUpValue({
+      additionalData: {},
+      insets: { top: 0 },
+      isAudioItem: true,
+      progressBarHeight: 8,
+      isTablet: true,
+      isTabletLandscape: true,
+      inlineAudioPlayer: true,
+      tabletLandscapePlayerTopPosition: 50,
+    });
+
+    expect(result).toBe(-0);
+  });
+
+  it("returns correct value for tablet landscape without audio item", () => {
+    const result = getMoveUpValue({
+      additionalData: {},
+      insets: { top: 0 },
+      isAudioItem: false,
+      progressBarHeight: 12,
+      isTablet: true,
+      isTabletLandscape: true,
+      inlineAudioPlayer: false,
+      tabletLandscapePlayerTopPosition: 60,
+    });
+
+    expect(result).toBe(-60 + 12);
+  });
+
+  it("returns -130 for tablet portrait (not landscape)", () => {
+    const result = getMoveUpValue({
+      additionalData: {},
+      insets: { top: 0 },
+      isAudioItem: false,
+      progressBarHeight: 0,
+      isTablet: true,
+      isTabletLandscape: false,
+      inlineAudioPlayer: false,
+      tabletLandscapePlayerTopPosition: 0,
+    });
+
+    expect(result).toBe(-130);
+  });
+
+  it("returns -50 + progressBarHeight for mobile audio player in docked mode", () => {
+    const result = getMoveUpValue({
+      additionalData: {},
+      insets: { top: 0 },
+      isAudioItem: false,
+      progressBarHeight: 7,
+      isTablet: false,
+      isTabletLandscape: false,
+      inlineAudioPlayer: false,
+      tabletLandscapePlayerTopPosition: 0,
+    });
+
+    expect(result).toBe(-50 + 7);
+  });
+});

package/Components/VideoModal/ModalAnimation/const.ts

@@ -0,0 +1,5 @@
+export const DURATION_TO_MINIMIZE = 200; // old value 200
+
+export const DURATION_TO_MAXIMIZE = 0;
+
+export const DEFAULT_DURATION_FOR_ANIMATION = 200; // old value 100

package/Components/VideoModal/ModalAnimation/index.ts

@@ -6,10 +6,13 @@ export { AnimatedVideoPlayerComponent } from "./AnimatedVideoPlayerComponent";
 
 export {
   withModalAnimationProvider,
-  useModalAnimationContext,
   PlayerAnimationStateEnum,
 } from "./ModalAnimationContext";
 
+export { useModalAnimationContext } from "./useModalAnimationContext";
+
 export { AnimationComponent } from "./AnimationComponent";
 
 export { ComponentAnimationType, defaultAspectRatioWidth } from "./utils";
+
+export { DURATION_TO_MINIMIZE, DURATION_TO_MAXIMIZE } from "./const";

package/Components/VideoModal/ModalAnimation/useModalAnimationContext.ts

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { ModalAnimationContextT, ReactContext } from "./ModalAnimationContext";
+
+export function useModalAnimationContext() {
+  return useContext<ModalAnimationContextT>(ReactContext);
+}

package/Components/VideoModal/ModalAnimation/utils.ts

@@ -1,6 +1,7 @@
 /* eslint-disable padding-line-between-statements */
 
 import { PlayerAnimationStateEnum } from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
+import { toNumberWithDefaultZero } from "@applicaster/zapp-react-native-utils/numberUtils";
 
 export enum ComponentAnimationType {
   bottomBar = "bottomBar",
@@ -108,8 +109,8 @@ export const calculateAnimationValue = (animationType, dragPosition, data) => {
               : { forWidth: 3, forHeight: 3 }
             : { forWidth: 2, forHeight: 2 }
           : isTabletLandscape
-          ? { forWidth: 8, forHeight: 6.5 }
-          : { forWidth: 3.5, forHeight: 2 };
+            ? { forWidth: 8, forHeight: 6.5 }
+            : { forWidth: 3.5, forHeight: 2 };
 
       const minWidth =
         isAudioItem && !inlineAudioPlayer ? minimisedHeight : minimisedWidth;
@@ -300,3 +301,38 @@ export const resetScrollAnimatedValues = (
   dragScrollY.setValue(0);
   dragVideoPlayerY.setValue(0);
 };
+
+export const getMoveUpValue = ({
+  additionalData,
+  insets,
+  isAudioItem,
+  progressBarHeight,
+  isTablet,
+  isTabletLandscape,
+  inlineAudioPlayer,
+  tabletLandscapePlayerTopPosition,
+}) => {
+  if (additionalData.saveArea) {
+    return -insets.top + (isAudioItem ? 0 : progressBarHeight);
+  }
+
+  if (isAudioItem) {
+    // for any layouts in audioPlayer
+    return -1 * toNumberWithDefaultZero(additionalData?.marginTop);
+  }
+
+  if (isTablet) {
+    if (
+      isTabletLandscape &&
+      (!isAudioItem || (isAudioItem && inlineAudioPlayer))
+    ) {
+      return -tabletLandscapePlayerTopPosition + progressBarHeight;
+    }
+
+    // for audioPlayer(tablet/isTabletPortrait) in docked mode
+    return -130;
+  }
+
+  // for audioPlayer(mobile) in docked mode
+  return -50 + progressBarHeight;
+};

package/Components/VideoModal/OpaqueLayer.tsx

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { StyleSheet, View } from "react-native";
+
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+import { Spinner } from "../Spinner";
+
+const styles = StyleSheet.create({
+  container: {
+    ...StyleSheet.absoluteFillObject,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+});
+
+export const OpaqueLayer = () => {
+  const theme = useTheme();
+
+  return (
+    <View
+      style={[
+        styles.container,
+        {
+          // we assume that it's non-transparent and we could show spinner always until it will be covered by player
+          // this spinner hides all content under modal
+          backgroundColor: theme?.app_background_color,
+        },
+      ]}
+    >
+      <Spinner />
+    </View>
+  );
+};

package/Components/VideoModal/PlayerDetails.tsx

@@ -1,14 +1,16 @@
 import React, { useEffect, useRef } from "react";
 import {
-  StyleProp,
-  ViewStyle,
   Animated,
-  Easing,
   Dimensions,
+  Easing,
+  StyleProp,
+  ViewStyle,
+  StyleSheet,
 } from "react-native";
 import { useTargetScreenData } from "@applicaster/zapp-react-native-utils/reactHooks/screen";
 import { ComponentsMap } from "@applicaster/zapp-react-native-ui-components/Components/River/ComponentsMap";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 
 const { width: SCREEN_WIDTH } = Dimensions.get("screen");
 
@@ -21,9 +23,9 @@ type Props = {
   entry: ZappEntry;
   style: StyleProp<ViewStyle>;
   configuration: Configuration;
-  isTabletLandscape: boolean;
+  isTabletLandscape?: boolean;
   isAudioPlayer?: boolean;
-  isTablet: boolean;
+  isTablet?: boolean;
 };
 
 const containerStyle = ({
@@ -38,9 +40,9 @@ export const PlayerDetails = ({
   entry,
   style,
   configuration,
-  isTabletLandscape,
+  isTabletLandscape = false,
   isAudioPlayer,
-  isTablet,
+  isTablet = false,
 }: Props) => {
   const screenData = useTargetScreenData(entry);
   const insets = useSafeAreaInsets();
@@ -77,6 +79,10 @@ export const PlayerDetails = ({
     }
   }, [isAudioPlayer]);
 
+  if (isNilOrEmpty(screenData?.ui_components)) {
+    return null;
+  }
+
   return (
     <Animated.View
       style={[
@@ -90,17 +96,19 @@ export const PlayerDetails = ({
         {
           // workaround for avoid wrong text-height after going back to portrait rotation
           // we don't see this view in landscape mode, so we are able to use fixed width from portrait mode
-          width: isTablet ? undefined : SCREEN_WIDTH,
+          width: isTablet
+            ? undefined
+            : (StyleSheet.flatten(style)?.width ?? SCREEN_WIDTH),
         },
       ]}
     >
-      {screenData && (
+      {screenData ? (
         <ComponentsMap
           riverId={screenData.id}
           feed={screenData?.data?.source}
           riverComponents={screenData.ui_components}
         />
-      )}
+      ) : null}
     </Animated.View>
   );
 };