@applicaster/zapp-react-native-ui-components 13.0.0-alpha.1124981321 → 13.0.0-alpha.1173186260

package/Components/Transitioner/__tests__/transitioner.test.js

@@ -1,9 +1,18 @@
 import React from "react";
 import { Text, View } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
 
 import { TransitionerComponent } from "../Transitioner";
+import { render } from "@testing-library/react-native";
+
+jest.mock("../Scene", () => {
+  const View = jest.requireActual("react-native").View;
+
+  return {
+    Scene(props) {
+      return <View {...props} />;
+    },
+  };
+});
 
 const children = (
   <View foo="bar">
@@ -33,12 +42,12 @@ jest.mock("uuid");
 
 describe("<TransitionerComponent />", () => {
   it("renders correctly", () => {
-    const wrapper = shallow(
+    const wrapper = render(
       <TransitionerComponent {...transitionerComponentProps}>
         {children}
       </TransitionerComponent>
     );
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.toJSON()).toMatchSnapshot();
   });
 });

package/Components/VideoLive/PlayerLiveImageComponent.tsx

@@ -1,6 +1,7 @@
 // /// <reference types="@applicaster/applicaster-types" />
 //
 import * as React from "react";
+import { useEffect } from "react";
 
 import { AppState, AppStateStatus, View } from "react-native";
 import { TrackedView } from "../TrackedView";
@@ -25,13 +26,15 @@ import { PlayerRole } from "@applicaster/zapp-react-native-utils/appUtils/player
 import { getAutoplaySettings } from "./utils";
 import { isString } from "@applicaster/zapp-react-native-utils/stringUtils";
 import { BufferAnimation } from "../PlayerContainer/BufferAnimation";
-import { useEffect } from "react";
 
 const { log_error, log_debug } = loggerLiveImageComponent;
 
 const isMeasurement = (item: ZappEntry) =>
   isString(item.id) && item.id.startsWith("pre-measurement-");
 
+// Pixels by which the view can slightly extend outside the viewport and still be considered fully visible.
+const CLIP_THRESHOLD = 10;
+
 type Props = {
   item: ZappEntry;
   style: Record<string, any>;
@@ -328,9 +331,10 @@ const PlayerLiveImageComponent = (props: Props) => {
     <TrackedView
       testId={`tracked-view-${playerId}-${item.title}`}
       onPositionUpdated={onPositionUpdated}
+      clipThreshold={CLIP_THRESHOLD}
     >
       <View ref={trackViewRef}>
-        {isVideoMode && (
+        {isVideoMode ? (
           <Player
             autoplay={false}
             ref={_assignRoot}
@@ -342,7 +346,7 @@ const PlayerLiveImageComponent = (props: Props) => {
             resizeMode={"cover"}
             {...platformSpecificProps}
           />
-        )}
+        ) : null}
         {
           <AnimatedInOut
             visible={isBackgroundImageVisible}

package/Components/VideoLive/__tests__/__snapshots__/PlayerLiveImageComponent.test.tsx.snap

@@ -2,6 +2,7 @@
 
 exports[`PlayerLiveImageComponent should render correctly with default props 1`] = `
 <TrackedView
+  clipThreshold={10}
   onPositionUpdated={[Function]}
   testId="tracked-view-player1-Test"
 >

package/Components/VideoModal/ModalAnimation/AnimatedPlayerModalWrapper.tsx

@@ -46,7 +46,7 @@ export const AnimatedPlayerModalWrapper = (props: Props) => {
 
   React.useEffect(() => {
     (playerAnimationState === PlayerAnimationStateEnum.minimize ||
-      playerAnimationState === PlayerAnimationStateEnum.maximaze) &&
+      playerAnimationState === PlayerAnimationStateEnum.maximize) &&
       setStartComponentsAnimation(true);
   }, [playerAnimationState]);
 

package/Components/VideoModal/ModalAnimation/AnimatedScrollModal.tsx

@@ -1,32 +1,34 @@
 import React from "react";
-import { Animated, StyleSheet, View, Platform } from "react-native";
+import { Animated, Platform, StyleSheet, View } from "react-native";
 
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
 import {
+  GestureHandlerRootView,
   NativeViewGestureHandler,
   PanGestureHandler,
   State,
   TapGestureHandler,
-  GestureHandlerRootView,
 } from "react-native-gesture-handler";
 
 import { PlayerContainerContext } from "@applicaster/zapp-react-native-ui-components/Components/PlayerContainer/PlayerContainerContext";
 import {
-  useModalAnimationContext,
   PlayerAnimationStateEnum,
+  useModalAnimationContext,
 } from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
 import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
 
 import {
-  setScrollModalAnimatedValue,
   resetScrollAnimatedValues,
+  setScrollModalAnimatedValue,
 } from "./utils";
 
+import { DURATION_TO_MINIMIZE } from "./const";
+
 const getAnimatedConfig = (toValue) => {
   return {
     toValue,
-    duration: 200,
+    duration: DURATION_TO_MINIMIZE,
     useNativeDriver: true,
   };
 };
@@ -70,21 +72,26 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
   const { maximiseVideoModal, minimiseVideoModal, videoModalState } =
     useNavigation();
 
-  const { mode: videoModalMode, item: videoModalItem } = videoModalState;
-  const isMaximazedModal = videoModalMode === "MAXIMIZED";
-  const isMinimizedModal = videoModalMode === "MINIMIZED";
+  const {
+    mode: videoModalMode,
+    previousMode: previousVideoModalMode,
+    item: videoModalItem,
+  } = videoModalState;
+
+  const isMaximizedModal: boolean = videoModalMode === "MAXIMIZED";
+  const isMinimizedModal: boolean = videoModalMode === "MINIMIZED";
   const previousItemId = usePrevious(videoModalItem?.id);
 
   const isNotMinimizeMaximazeAnimation =
     playerAnimationState !== PlayerAnimationStateEnum.minimize &&
-    playerAnimationState !== PlayerAnimationStateEnum.maximaze;
+    playerAnimationState !== PlayerAnimationStateEnum.maximize;
 
   const isEnablePanGesture =
     enableGesture &&
     !isLanguageOverlayVisible &&
     isNotMinimizeMaximazeAnimation &&
     !isSeekBarTouch &&
-    (isMaximazedModal || isMinimizedModal);
+    (isMaximizedModal || isMinimizedModal);
 
   const isAudioItem = React.useMemo(
     () =>
@@ -121,7 +128,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
         const preparedTranslationY =
           Math.abs(translationY) - lastScrollYValue.current;
 
-        if (videoModalMode === "MAXIMIZED") {
+        if (isMaximizedModal) {
           const endOffsetY =
             lastSnap + preparedTranslationY + dragToss * velocityY + 150;
 
@@ -143,8 +150,8 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
             translateYOffset.flattenOffset();
             dragScrollY.setValue(0);
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
-          } else {
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
+          } else if (destSnapPoint !== modalSnapPoints[0] && isMaximizedModal) {
             setPlayerAnimationState(PlayerAnimationStateEnum.minimize);
           }
         } else {
@@ -158,7 +165,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
 
             dragScrollY.setValue(0);
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
           } else {
             resetPlayerAnimationState();
           }
@@ -168,7 +175,13 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
           resetPlayerAnimationState();
       }
     },
-    [lastSnap, modalSnapPoints, playerAnimationState, videoModalMode]
+    [
+      lastSnap,
+      modalSnapPoints,
+      playerAnimationState,
+      isMinimizedModal,
+      isMaximizedModal,
+    ]
   );
 
   const onScroll = React.useCallback(({ nativeEvent }) => {
@@ -219,17 +232,18 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
   }, []);
 
   React.useEffect(() => {
-    const { mode, previousMode, item } = videoModalState;
-
     if (
-      mode === "MAXIMIZED" &&
+      videoModalMode === "MAXIMIZED" &&
       !enableGesture &&
       scrollPosition.current === 0
     ) {
       setIEnableGesture(true);
     }
 
-    if (mode === "MINIMIZED" && previousMode === "MAXIMIZED") {
+    if (
+      videoModalMode === "MINIMIZED" &&
+      previousVideoModalMode === "MAXIMIZED"
+    ) {
       // set animation to the minimize values if moving from the player to another screen
       if (playerAnimationState === null) {
         setScrollModalAnimatedValue(
@@ -247,14 +261,16 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
       }
     } else if (
       playerAnimationState === null &&
-      ((previousItemId === item?.id &&
-        mode === "MAXIMIZED" &&
-        (previousMode === "MINIMIZED" || previousMode === "MAXIMIZED")) ||
-        (previousItemId !== item?.id && mode !== "FULLSCREEN"))
+      ((previousItemId === videoModalItem?.id &&
+        videoModalMode === "MAXIMIZED" &&
+        (previousVideoModalMode === "MINIMIZED" ||
+          previousVideoModalMode === "MAXIMIZED")) ||
+        (previousItemId !== videoModalItem?.id &&
+          videoModalMode !== "FULLSCREEN"))
     ) {
-      setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+      setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
     }
-  }, [videoModalState]);
+  }, [videoModalMode, previousVideoModalMode, videoModalItem]);
 
   React.useEffect(() => {
     if (playerAnimationState === PlayerAnimationStateEnum.minimize) {
@@ -296,7 +312,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
 
         resetPlayerAnimationState();
       });
-    } else if (playerAnimationState === PlayerAnimationStateEnum.maximaze) {
+    } else if (playerAnimationState === PlayerAnimationStateEnum.maximize) {
       Animated.timing(translateYOffset, getAnimatedConfig(0)).start(() => {
         maximiseVideoModal();
         setScrollModalAnimatedValue(translateYOffset, 0, setLastSnap);
@@ -346,6 +362,8 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
     []
   );
 
+  const scrollEnabled = isMaximizedModal && isNotMinimizeMaximazeAnimation;
+
   return (
     <Wrapper style={generalStyles.container}>
       <TapGestureHandler
@@ -359,7 +377,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
             enabled={isEnablePanGesture}
             ref={panHandlerRef}
             simultaneousHandlers={[scrollRef, tapHandlerRef]}
-            shouldCancelWhenOutside={isMaximazedModal}
+            shouldCancelWhenOutside={isMaximizedModal}
             onGestureEvent={onGestureEvent}
             onHandlerStateChange={onHandlerStateChange}
             activeOffsetY={[-5, 5]}
@@ -371,9 +389,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
                 simultaneousHandlers={panHandlerRef}
               >
                 <Animated.ScrollView
-                  scrollEnabled={
-                    isMaximazedModal && isNotMinimizeMaximazeAnimation
-                  }
+                  scrollEnabled={scrollEnabled}
                   bounces={false}
                   onScrollBeginDrag={onRegisterLastScroll}
                   onScroll={onScroll}

package/Components/VideoModal/ModalAnimation/AnimatedVideoPlayerComponent.tsx

@@ -50,7 +50,7 @@ export const AnimatedVideoPlayer = ({ children }: Props) => {
 
   const isNotMinimizeMaximazeAnimation =
     playerAnimationState !== PlayerAnimationStateEnum.minimize &&
-    playerAnimationState !== PlayerAnimationStateEnum.maximaze;
+    playerAnimationState !== PlayerAnimationStateEnum.maximize;
 
   const isEnablePanGesture =
     !isLanguageOverlayVisible &&
@@ -89,7 +89,7 @@ export const AnimatedVideoPlayer = ({ children }: Props) => {
             setLastSnap(destSnapPoint);
 
             if (destSnapPoint === modalSnapPoints[0]) {
-              setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+              setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
             } else {
               lastScrollY.setValue(0);
               lastScrollYValue.current = 0;
@@ -105,7 +105,7 @@ export const AnimatedVideoPlayer = ({ children }: Props) => {
               modalSnapPoints[1] - preparedTranslationY
             );
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
           } else {
             resetPlayerAnimationState();
           }

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;
@@ -91,20 +94,21 @@ export const AnimationView = ({
   const isAudioItem = React.useMemo(
     () =>
       videoModalItem?.content?.type?.includes?.("audio") ||
-      videoModalItem?.type?.value === "audio",
+      videoModalItem?.type?.value?.includes?.("audio"),
     [videoModalItem]
   );
 
   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,
+    tabletLandscapePlayerTopPosition,
+  });
 
   const moveComponentHorizontalValue = additionalData.moveValue
     ? isRTL
@@ -119,7 +123,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,
       };
 
@@ -228,6 +235,8 @@ export const AnimationView = ({
       isAudioItem,
       moveUpValue,
       moveComponentHorizontalValue,
+      isRTL,
+      inlineAudioPlayer,
     ]
   );
 
@@ -246,7 +255,7 @@ export const AnimationView = ({
       default:
         return getAnimationValue(
           animationType,
-          PlayerAnimationStateEnum.maximaze
+          PlayerAnimationStateEnum.maximize
         ).toValue;
     }
   }, [defaultValue, videoModalState]);
@@ -278,6 +287,11 @@ export const AnimationView = ({
       moveUpValue,
       moveComponentHorizontalValue,
       videoModalMode,
+      isAudioItem,
+      isTablet,
+      isTabletLandscape,
+      isRTL,
+      inlineAudioPlayer,
     ]
   );
 
@@ -306,7 +320,7 @@ export const AnimationView = ({
       }
 
       if (
-        videoModalMode === "MAXIMIZED" &&
+        (videoModalMode === "MAXIMIZED" || videoModalMode === "MINIMIZED") &&
         defaultValue.x !== screenWidth &&
         width &&
         height
@@ -332,7 +346,13 @@ export const AnimationView = ({
         animatedValue.setValue(value);
       }
     }
-  }, [videoModalState]);
+  }, [
+    animatedValue,
+    animationType,
+    getAnimationValue,
+    playerAnimationState,
+    videoModalState,
+  ]);
 
   React.useEffect(() => {
     if (
@@ -344,7 +364,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]);
@@ -405,7 +425,7 @@ export const AnimationView = ({
 
   return (
     <Animated.View
-      onLayout={additionalData.useLayoutMeasure && measureView}
+      onLayout={additionalData.useLayoutMeasure ? measureView : undefined}
       ref={animationComponentRef}
       style={[
         ...preparedStyles,
@@ -427,6 +447,10 @@ export const AnimationComponent = (props: Props) => {
     videoModalState: { visible },
   } = useNavigation();
 
+  if (additionalData?.disableAnimatedComponent) {
+    return <>{props.children}</>;
+  }
+
   const useAnimation =
     visible && !additionalData.disableAnimatedComponent && !isTV();
 

package/Components/VideoModal/ModalAnimation/ModalAnimationContext.tsx

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useEffect } from "react";
 import { Animated } from "react-native";
 
 import {
@@ -14,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;
@@ -95,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;
@@ -118,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

@@ -14,3 +14,5 @@ export { useModalAnimationContext } from "./useModalAnimationContext";
 export { AnimationComponent } from "./AnimationComponent";
 
 export { ComponentAnimationType, defaultAspectRatioWidth } from "./utils";
+
+export { DURATION_TO_MINIMIZE, DURATION_TO_MAXIMIZE } from "./const";