@applicaster/zapp-react-native-ui-components 13.0.0-alpha.3528549047 → 13.0.0-alpha.3546196593

package/Components/Transitioner/__tests__/__snapshots__/Scene.test.js.snap

@@ -1,63 +1,23 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<Scene /> renders correctly 1`] = `
-<ForwardRef(AnimatedComponentWrapper)
-  pointerEvents="auto"
-  style={
-    [
+<View>
+  <View
+    collapsable={false}
+    pointerEvents="auto"
+    style={
       {
         "flex": 1,
-      },
-      {
-        "paddingBottom": 49,
-      },
-      {
         "fontScale": 2,
         "height": 1334,
+        "paddingBottom": 49,
         "scale": 2,
         "statusBarHeight": null,
         "width": 750,
-      },
-    ]
-  }
->
-  <ContextProvider>
-    <ContextProvider>
-      <ScreenContextProvider />
-    </ContextProvider>
-  </ContextProvider>
-</ForwardRef(AnimatedComponentWrapper)>
-`;
-
-exports[`<Scene /> renders the overlay while animating 1`] = `
-<ForwardRef(AnimatedComponentWrapper)
-  pointerEvents="auto"
-  style={
-    [
-      {
-        "flex": 1,
-      },
-      {
-        "paddingBottom": 49,
-      },
-      {
-        "height": "100%",
-        "width": "100%",
-      },
-    ]
-  }
->
-  <ContextProvider>
-    <ContextProvider>
-      <ScreenContextProvider />
-    </ContextProvider>
-  </ContextProvider>
-  <ForwardRef(AnimatedComponentWrapper)
-    style={
-      {
-        "opacity": 1,
       }
     }
   />
-</ForwardRef(AnimatedComponentWrapper)>
+</View>
 `;
+
+exports[`<Scene /> renders the overlay while animating 1`] = `[Function]`;

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

@@ -9,7 +9,7 @@ exports[`<TransitionerComponent /> renders correctly 1`] = `
     }
   }
 >
-  <Scene
+  <View
     isActive={true}
     screenUniqueId="mocked-uuid"
     style={{}}
@@ -23,6 +23,6 @@ exports[`<TransitionerComponent /> renders correctly 1`] = `
         children
       </Text>
     </View>
-  </Scene>
+  </View>
 </View>
 `;

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/Transitioner/index.js

@@ -1,5 +1,4 @@
 import * as React from "react";
-import { useWindowDimensions } from "react-native";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 import { useDimensions } from "@applicaster/zapp-react-native-utils/reactHooks/layout";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
@@ -7,10 +6,15 @@ import { TransitionerComponent } from "./Transitioner";
 
 export const Transitioner = (props) => {
   const navigator = useNavigation();
-  const { height, width } = useWindowDimensions();
 
-  const dimensions = useDimensions("window", { deviceInfo: true });
-  const isTablet = dimensions?.deviceInfo?.isTablet;
+  const {
+    width,
+    height,
+    deviceInfo: { isTablet },
+  } = useDimensions("window", {
+    updateForInactiveScreens: false,
+    deviceInfo: true,
+  });
 
   const { appData } = usePickFromState(["appData"]);
   const isTabletPortrait = appData?.isTabletPortrait;

package/Components/VideoLive/LiveImageManager.ts

@@ -8,6 +8,8 @@ import { loggerLiveImageManager } from "./loggerHelper";
 import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { Component } from "react";
 
+const TIMEOUT_FOR_DELAY_CHECK_PLAYER_POSITION = 500; // ms
+
 const { log_debug, log_info, log_error } = loggerLiveImageManager;
 
 export type LiveImageManagerEvent =
@@ -62,6 +64,9 @@ export class LiveImageManager implements PlayerLifecycleListener {
   protected currentlyPlaying: LiveImage | null = null;
   protected primaryPlayer: Player | null = null;
 
+  private checkPlayerPositionTimeout: ReturnType<typeof setTimeout> | null =
+    null;
+
   protected listeners: Record<
     string,
     Record<LiveImageManagerEvent, (event?: Record<string, any>) => void>
@@ -118,6 +123,11 @@ export class LiveImageManager implements PlayerLifecycleListener {
     });
   };
 
+  private cancelCheckPlayerPositionTimeout = () => {
+    clearTimeout(this.checkPlayerPositionTimeout);
+    this.checkPlayerPositionTimeout = null;
+  };
+
   public onViewportEnter = (item: LiveImage) => {
     log_debug(
       `onViewportEnter: live-image ${playerInfo(
@@ -125,7 +135,21 @@ export class LiveImageManager implements PlayerLifecycleListener {
       )}, primary ${playerInfo(this.primaryPlayer)}`
     );
 
-    this.checkPlayerPosition(item);
+    if (!isTV()) {
+      // mobile only
+      // we have to delay running checkPlayerPosition, because sometimes on fast scrolling we get wrong order onEnter, then onLeave.
+      // which could cause select wrong item to play
+
+      this.cancelCheckPlayerPositionTimeout();
+
+      this.checkPlayerPositionTimeout = setTimeout(() => {
+        this.cancelCheckPlayerPositionTimeout();
+
+        this.checkPlayerPosition(item);
+      }, TIMEOUT_FOR_DELAY_CHECK_PLAYER_POSITION);
+    } else {
+      this.checkPlayerPosition(item);
+    }
   };
 
   public onViewportLeave = (item: LiveImage) => {
@@ -246,6 +270,8 @@ export class LiveImageManager implements PlayerLifecycleListener {
   };
 
   public checkPlayerPosition = (item: LiveImage) => {
+    this.cancelCheckPlayerPositionTimeout();
+
     log_debug(
       `checkPlayerPosition: live-image playerId: ${playerInfo(
         item.player

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>;
@@ -44,7 +47,10 @@ type Props = {
 };
 
 const PlayerLiveImageComponent = (props: Props) => {
-  const dimensions = useDimensions("screen", { fullDimensions: true });
+  const dimensions = useDimensions("screen", {
+    fullDimensions: true,
+    updateForInactiveScreens: false,
+  });
 
   const { item, style, playerId } = props;
 
@@ -135,13 +141,16 @@ const PlayerLiveImageComponent = (props: Props) => {
     } else {
       throw new Error("Player factory item is null");
     }
-  }, [playerId, item, playerPluginId, screenConfig]);
+  }, [playerId, item.id, playerPluginId, screenConfig]);
 
   React.useEffect(() => {
     liveImageItem.setMode = setModeDebounced;
   }, [setModeDebounced, liveImageItem]);
 
-  const { start, end } = React.useMemo(() => getAutoplaySettings(item), [item]);
+  const { start, end } = React.useMemo(
+    () => getAutoplaySettings(item),
+    [item.id]
+  );
 
   const controller = liveImageItem.getPlayer();
   const player = usePlayer(playerId);
@@ -174,7 +183,7 @@ const PlayerLiveImageComponent = (props: Props) => {
 
       unregister();
     };
-  }, [item, liveImageItem]);
+  }, [item.id, liveImageItem]);
 
   React.useEffect(() => {
     if (!player) {
@@ -244,25 +253,27 @@ const PlayerLiveImageComponent = (props: Props) => {
   }, [item.id]);
 
   React.useEffect(() => {
-    if (playerManager) {
-      const isPlayerRegistered = playerManager.isPlayerRegistered(playerId);
+    if (isMeasurement(item) || !playerManager) {
+      return;
+    }
 
-      if (isPlayerRegistered) {
-        log_error(
-          `PlayerLiveImageComponent: player ${playerId} already registered`
-        );
-      } else {
-        playerManager.registerPlayer({
-          id: playerId,
-          playerController: controller,
-        });
+    const isPlayerRegistered = playerManager.isPlayerRegistered(playerId);
 
-        return () => {
-          playerManager.unregisterPlayer(playerId);
-        };
-      }
+    if (isPlayerRegistered) {
+      log_error(
+        `PlayerLiveImageComponent: player ${playerId} already registered`
+      );
+    } else {
+      playerManager.registerPlayer({
+        id: playerId,
+        playerController: controller,
+      });
+
+      return () => {
+        playerManager.unregisterPlayer(playerId);
+      };
     }
-  }, [liveImageItem, playerId, controller]);
+  }, [liveImageItem, playerId, controller, item.id]);
 
   const onPositionUpdated = React.useCallback(
     (data) => {
@@ -302,7 +313,7 @@ const PlayerLiveImageComponent = (props: Props) => {
         LiveImageManager.instance.checkPlayerPosition(liveImageItem);
       }
     },
-    [liveImageItem, dimensions]
+    [liveImageItem, dimensions.height, dimensions.width]
   );
 
   const platformSpecificProps = isApplePlatform()
@@ -320,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}
@@ -334,7 +346,7 @@ const PlayerLiveImageComponent = (props: Props) => {
             resizeMode={"cover"}
             {...platformSpecificProps}
           />
-        )}
+        ) : null}
         {
           <AnimatedInOut
             visible={isBackgroundImageVisible}

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

@@ -4,6 +4,7 @@ import { render } from "@testing-library/react-native";
 import * as PlayerFactory from "@applicaster/zapp-react-native-utils/appUtils/playerManager/playerFactory";
 import { ThemeContext } from "@applicaster/zapp-react-native-utils/theme";
 import * as navigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
 
 import { PlayerLiveImage } from "../PlayerLiveImageComponent";
 import * as useNavigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
@@ -32,7 +33,7 @@ const mockStore = configureStore();
 
 const store = mockStore({ appData: {} });
 
-const Wrapper = ({ children }: { children: React.ReactChildren }) => (
+const Wrapper = ({ children }: { children: React.ReactNode }) => (
   /* @ts-ignore */
   <Provider store={store}>
     <ThemeContext.Provider
@@ -118,4 +119,53 @@ describe("PlayerLiveImageComponent", () => {
 
     // TODO: implement this test
   });
+
+  it("should register the player for normal item", () => {
+    render(
+      <Wrapper>
+        <PlayerLiveImage {...defaultProps} />
+      </Wrapper>
+    );
+
+    const isPlayerRegistered = playerManager.isPlayerRegistered(
+      defaultProps.playerId
+    );
+
+    expect(isPlayerRegistered).toBe(true);
+  });
+
+  it("should unregister the player for normal item", () => {
+    const component = render(
+      <Wrapper>
+        <PlayerLiveImage {...defaultProps} />
+      </Wrapper>
+    );
+
+    component.unmount();
+
+    const isPlayerRegistered = playerManager.isPlayerRegistered(
+      defaultProps.playerId
+    );
+
+    expect(isPlayerRegistered).toBe(false);
+  });
+
+  it("should not register the player for 'pre-measurement' item", () => {
+    const props = {
+      ...defaultProps,
+      item: {
+        ...defaultProps.item,
+        id: "pre-measurement-1",
+      },
+    };
+
+    render(
+      <Wrapper>
+        <PlayerLiveImage {...props} />
+      </Wrapper>
+    );
+
+    const isPlayerRegistered = playerManager.isPlayerRegistered(props.playerId);
+    expect(isPlayerRegistered).toBe(false);
+  });
 });

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"
 >
@@ -31,11 +32,6 @@ exports[`PlayerLiveImageComponent should render correctly with default props 1`]
         playerId="player1"
         resizeMode="cover"
         screenConfig={{}}
-        source={
-          {
-            "uri": "",
-          }
-        }
         style={{}}
       />
     </View>

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,26 +1,26 @@
 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";
 
 const getAnimatedConfig = (toValue) => {
@@ -70,21 +70,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 +126,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;
 
@@ -137,14 +142,14 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
 
           setLastSnap(destSnapPoint);
 
-          if (destSnapPoint === modalSnapPoints[0]) {
+          if (destSnapPoint === modalSnapPoints[0] && isMinimizedModal) {
             translateYOffset.extractOffset();
             translateYOffset.setValue(preparedTranslationY);
             translateYOffset.flattenOffset();
             dragScrollY.setValue(0);
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
-          } else {
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
+          } else if (destSnapPoint !== modalSnapPoints[0] && isMaximizedModal) {
             setPlayerAnimationState(PlayerAnimationStateEnum.minimize);
           }
         } else {
@@ -158,7 +163,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
 
             dragScrollY.setValue(0);
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
           } else {
             resetPlayerAnimationState();
           }
@@ -168,7 +173,13 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
           resetPlayerAnimationState();
       }
     },
-    [lastSnap, modalSnapPoints, playerAnimationState, videoModalMode]
+    [
+      lastSnap,
+      modalSnapPoints,
+      playerAnimationState,
+      isMinimizedModal,
+      isMaximizedModal,
+    ]
   );
 
   const onScroll = React.useCallback(({ nativeEvent }) => {
@@ -219,17 +230,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 +259,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 +310,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 +360,8 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
     []
   );
 
+  const scrollEnabled = isMaximizedModal && isNotMinimizeMaximazeAnimation;
+
   return (
     <Wrapper style={generalStyles.container}>
       <TapGestureHandler
@@ -359,7 +375,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 +387,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();
           }