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

package/Components/Cell/CellWithFocusable.ios.tsx

@@ -0,0 +1,126 @@
+/** TODO: Remove this file when tvos FocusableGroup
+ * behaviour is aligned to the web one
+ * FocusableGroup should only send onFocus and onBlur events when
+ * Focus enters and leaves the Focusables inside the branch
+ */
+import * as React from "react";
+
+import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
+import * as FOCUS_EVENTS from "@applicaster/zapp-react-native-utils/appUtils/focusManager/events";
+import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+import { isAppleTV } from "../../Helpers/Platform";
+import { useCellState } from "../MasterCell/utils";
+
+const useCellFocusedState = (
+  skipFocusManagerRegistration: boolean,
+  groupId: string,
+  id: string
+) => {
+  const [currentCellFocused, setCurrentCellFocused] = React.useState(false);
+
+  React.useEffect(() => {
+    const isGroupItemFocused = () => {
+      if (!skipFocusManagerRegistration) {
+        const isFocused = focusManager.isGroupItemFocused(groupId, id);
+        setCurrentCellFocused(isFocused);
+      }
+    };
+
+    const handler = () => {
+      // tvOS hack for properly checking focus
+      if (isAppleTV()) {
+        setTimeout(() => {
+          isGroupItemFocused();
+        }, 0);
+      } else {
+        isGroupItemFocused();
+      }
+    };
+
+    focusManager.on(FOCUS_EVENTS.FOCUS, handler);
+
+    return () => {
+      focusManager.removeHandler(FOCUS_EVENTS.FOCUS, handler);
+    };
+  }, [groupId, skipFocusManagerRegistration]);
+
+  return currentCellFocused;
+};
+
+type Props = {
+  item: ZappEntry;
+  CellRenderer: React.FunctionComponent<any>;
+  id: string;
+  groupId: string;
+  onFocus: Function;
+  index: number;
+  scrollTo: Function;
+  preferredFocus?: boolean;
+  skipFocusManagerRegistration?: boolean;
+  isFocusable?: boolean;
+  behavior: Behavior;
+  focused?: boolean;
+};
+
+export function CellWithFocusable(props: Props) {
+  const {
+    index,
+    item,
+    CellRenderer,
+    id,
+    groupId,
+    onFocus,
+    scrollTo = noop,
+    preferredFocus,
+    skipFocusManagerRegistration,
+    isFocusable,
+    behavior,
+    focused,
+  } = props;
+
+  const isFocused = useCellFocusedState(
+    skipFocusManagerRegistration,
+    groupId,
+    id
+  );
+
+  const state = useCellState({
+    id: item.id,
+    behavior,
+    focused: isFocused || toBooleanWithDefaultFalse(focused),
+  });
+
+  const [focusedButtonId, setFocusedButtonId] = React.useState(undefined);
+
+  // for horizontal scrolling
+  React.useEffect(() => {
+    if (focusedButtonId) {
+      scrollTo(index);
+    }
+  }, [focusedButtonId]);
+
+  const handleToggleFocus = (value) => {
+    setFocusedButtonId(value.focusedButtonId);
+
+    if (value.focusable) {
+      onFocus(value.focusable, value.mouse);
+    }
+  };
+
+  return (
+    <CellRenderer
+      item={item}
+      groupId={groupId}
+      onToggleFocus={handleToggleFocus}
+      state={state}
+      prefixId={id}
+      focusedButtonId={focusedButtonId}
+      preferredFocus={preferredFocus}
+      skipFocusManagerRegistration={skipFocusManagerRegistration}
+      isFocusable={isFocusable}
+      focused={focused}
+    />
+  );
+}

package/Components/Cell/CellWithFocusable.tsx

@@ -1,48 +1,10 @@
 import * as React from "react";
 
-import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
-import * as FOCUS_EVENTS from "@applicaster/zapp-react-native-utils/appUtils/focusManager/events";
 import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
 
-import { isAppleTV } from "../../Helpers/Platform";
 import { useCellState } from "../MasterCell/utils";
-
-const useCellFocusedState = (
-  skipFocusManagerRegistration: boolean,
-  groupId: string,
-  id: string
-) => {
-  const [currentCellFocused, setCurrentCellFocused] = React.useState(false);
-
-  React.useEffect(() => {
-    const isGroupItemFocused = () => {
-      if (!skipFocusManagerRegistration) {
-        const isFocused = focusManager.isGroupItemFocused(groupId, id);
-        setCurrentCellFocused(isFocused);
-      }
-    };
-
-    const handler = () => {
-      // tvOS hack for properly checking focus
-      if (isAppleTV()) {
-        setTimeout(() => {
-          isGroupItemFocused();
-        }, 0);
-      } else {
-        isGroupItemFocused();
-      }
-    };
-
-    focusManager.on(FOCUS_EVENTS.FOCUS, handler);
-
-    return () => {
-      focusManager.removeHandler(FOCUS_EVENTS.FOCUS, handler);
-    };
-  }, [groupId, skipFocusManagerRegistration]);
-
-  return currentCellFocused;
-};
+import { FocusableGroup } from "../FocusableGroup";
 
 type Props = {
   item: ZappEntry;
@@ -75,11 +37,7 @@ export function CellWithFocusable(props: Props) {
     focused,
   } = props;
 
-  const isFocused = useCellFocusedState(
-    skipFocusManagerRegistration,
-    groupId,
-    id
-  );
+  const [isFocused, setIsFocused] = React.useState(false);
 
   const state = useCellState({
     id: item.id,
@@ -96,26 +54,52 @@ export function CellWithFocusable(props: Props) {
     }
   }, [focusedButtonId]);
 
-  const handleToggleFocus = (value) => {
-    setFocusedButtonId(value.focusedButtonId);
+  const handleToggleFocus = React.useCallback(
+    (value) => {
+      setFocusedButtonId(value.focusedButtonId);
+
+      if (value.focusable) {
+        onFocus(value.focusable, value.mouse);
+      }
+    },
+    [onFocus]
+  );
+
+  const onGroupFocus = React.useCallback(() => {
+    if (!skipFocusManagerRegistration) {
+      setIsFocused(true);
+    }
+  }, [skipFocusManagerRegistration]);
 
-    if (value.focusable) {
-      onFocus(value.focusable, value.mouse);
+  const onGroupBlur = React.useCallback(() => {
+    if (!skipFocusManagerRegistration) {
+      setIsFocused(false);
     }
-  };
+  }, [skipFocusManagerRegistration]);
 
   return (
-    <CellRenderer
-      item={item}
+    <FocusableGroup
+      id={`focusable-cell-wrapper-${id}`}
+      testID={"cell-with-focusable-cell-renderer-focusable-group"}
       groupId={groupId}
-      onToggleFocus={handleToggleFocus}
-      state={state}
-      prefixId={id}
-      focusedButtonId={focusedButtonId}
       preferredFocus={preferredFocus}
-      skipFocusManagerRegistration={skipFocusManagerRegistration}
-      isFocusable={isFocusable}
-      focused={focused}
-    />
+      shouldUsePreferredFocus
+      onFocus={onGroupFocus}
+      onBlur={onGroupBlur}
+    >
+      <CellRenderer
+        testID={"cell-with-focusable-cell-renderer"}
+        item={item}
+        groupId={`focusable-cell-wrapper-${id}`}
+        onToggleFocus={handleToggleFocus}
+        state={state}
+        prefixId={id}
+        focusedButtonId={focusedButtonId}
+        preferredFocus={true}
+        skipFocusManagerRegistration={skipFocusManagerRegistration}
+        isFocusable={isFocusable}
+        focused={focused}
+      />
+    </FocusableGroup>
   );
 }

package/Components/Cell/__tests__/CellWIthFocusable.test.js

@@ -1,7 +1,7 @@
 import { View } from "react-native";
 import React from "react";
 import { act, render } from "@testing-library/react-native";
-import { CellWithFocusable } from "../CellWithFocusable";
+import { CellWithFocusable } from "../CellWithFocusable.tsx";
 
 import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
 
@@ -23,7 +23,9 @@ describe("CellWithFocusable", () => {
 
     const wrapper = renderWith(props);
 
-    expect(wrapper.UNSAFE_getByType("View").props.state).toBe("default");
+    const element = wrapper.getByTestId("cell-with-focusable-cell-renderer");
+
+    expect(element.props.state).toBe("default");
   });
 
   it("should render in default state", () => {
@@ -40,8 +42,9 @@ describe("CellWithFocusable", () => {
     focusManager.isGroupItemFocused = jest.fn(() => true);
 
     const wrapper = renderWith(props);
+    const element = wrapper.getByTestId("cell-with-focusable-cell-renderer");
 
-    expect(wrapper.UNSAFE_getByType("View").props.state).toBe("default");
+    expect(element.props.state).toBe("default");
   });
 
   it("should render in focused state", () => {
@@ -55,13 +58,17 @@ describe("CellWithFocusable", () => {
       scrollTo: jest.fn(),
     };
 
-    focusManager.isGroupItemFocused = jest.fn(() => true);
     const wrapper = renderWith(props);
 
+    const focusableGroupComponent = wrapper.getByTestId(
+      "cell-with-focusable-cell-renderer-focusable-group"
+    );
+
     act(() => {
-      focusManager.on.mock.calls[focusManager.on.mock.calls.length - 1][1]();
+      focusableGroupComponent.props.onFocus();
     });
 
-    expect(wrapper.UNSAFE_getByType("View").props.state).toBe("focused");
+    const element = wrapper.getByTestId("cell-with-focusable-cell-renderer");
+    expect(element.props.state).toBe("focused");
   });
 });

package/Components/MasterCell/DefaultComponents/Image/Image.web.tsx

@@ -1,21 +1,15 @@
 import * as React from "react";
-import { ImageStyle } from "react-native";
+import { Image as RnImage, ImageStyle } from "react-native";
+import * as R from "ramda";
 
 import { useImageSource } from "./hooks";
 
-type ResizeMode = "cover" | "contain" | "stretch" | "center" | "repeat";
-type ObjectFit = "cover" | "contain" | "fill" | "none";
-
 type Source = {
   uri: string;
 };
 
 type Props = Record<string, unknown> & {
-  style: Omit<ImageStyle, "backgroundColor" | "borderColor" | "transform"> & {
-    borderColor?: string;
-    backgroundColor?: string;
-    transform?: string;
-  };
+  style: ImageStyle;
   uri?: string;
 
   placeholderImage?: string;
@@ -23,21 +17,6 @@ type Props = Record<string, unknown> & {
   withDimensions: (source: Source) => Source;
 };
 
-const mapResizeModeToObjectFit = (resizeMode?: ResizeMode): ObjectFit => {
-  switch (resizeMode) {
-    case "cover":
-      return "cover";
-    case "contain":
-      return "contain";
-    case "stretch":
-      return "fill";
-    case "center":
-      return "none";
-    default:
-      return "cover";
-  }
-};
-
 function Image({
   style,
   uri,
@@ -51,13 +30,11 @@ function Image({
   const updatedSource = source ? withDimensions(source) : { uri: "" };
 
   return (
-    <img
-      defaultValue={placeholderImage}
-      src={updatedSource.uri}
-      style={{
-        ...style,
-        objectFit: mapResizeModeToObjectFit(style.resizeMode),
-      }}
+    <RnImage
+      defaultSource={placeholderImage || null}
+      style={style}
+      source={updatedSource}
+      {...R.omit(["source", "placeholderImage"], otherProps)}
     />
   );
 }

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("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";

package/Components/ScreenRevealManager/withScreenRevealManager.tsx

@@ -0,0 +1,79 @@
+import * as React from "react";
+import { Animated } from "react-native";
+import { isFirstComponentScreenPicker } from "@applicaster/zapp-react-native-utils/componentsUtils";
+import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { useRefWithInitialValue } from "@applicaster/zapp-react-native-utils/reactHooks/state/useRefWithInitialValue";
+
+import { ScreenRevealManager } from "./ScreenRevealManager";
+
+const flex = platformSelect({
+  tvos: 1,
+  android_tv: 1,
+  web: undefined,
+  samsung_tv: undefined,
+  lg_tv: undefined,
+  default: undefined,
+});
+
+export const TIMEOUT = 500; // 500 ms
+
+const HIDDEN = 0;
+
+export const SHOWN = 1;
+
+type Props = {
+  componentsToRender: ZappUIComponent[];
+};
+
+export const withScreenRevealManager = (Component) => {
+  return function WithScreenRevealManager(props: Props) {
+    const { componentsToRender } = props;
+
+    const [isReadyToShow, setIsReadyToShow] = React.useState(false);
+
+    const handleSetIsReadyToShow = React.useCallback(() => {
+      setIsReadyToShow(true);
+    }, []);
+
+    const managerRef = useRefWithInitialValue<ScreenRevealManager>(
+      () => new ScreenRevealManager(componentsToRender, handleSetIsReadyToShow)
+    );
+
+    const opacityRef = useRefWithInitialValue<Animated.Value>(
+      () => new Animated.Value(HIDDEN)
+    );
+
+    React.useEffect(() => {
+      if (isReadyToShow) {
+        Animated.timing(opacityRef.current, {
+          toValue: SHOWN,
+          duration: TIMEOUT,
+          useNativeDriver: true,
+        }).start();
+      }
+    }, [isReadyToShow]);
+
+    if (isFirstComponentScreenPicker(componentsToRender)) {
+      // for screen-picker with have additional internal ComponentsMap, no need to add this wrapper
+      return <Component {...props} />;
+    }
+
+    return (
+      <Animated.View
+        style={{ opacity: opacityRef.current, flex }}
+        testID="animated-component"
+      >
+        <Component
+          {...props}
+          initialNumberToLoad={
+            managerRef.current.numberOfComponentsWaitToLoadBeforePresent
+          }
+          onLoadFinishedFromScreenRevealManager={
+            managerRef.current.onLoadFinished
+          }
+          onLoadFailedFromScreenRevealManager={managerRef.current.onLoadFailed}
+        />
+      </Animated.View>
+    );
+  };
+};

package/Components/TopMarginApplicator/TopMarginApplicator.tsx

@@ -2,6 +2,7 @@ import React from "react";
 import { View, ViewProps, ViewStyle } from "react-native";
 import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
 import { useCurrentScreenData } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { isFirstComponentScreenPicker } from "@applicaster/zapp-react-native-utils/componentsUtils";
 
 interface IProps {
   targetScreenId?: string;
@@ -31,11 +32,9 @@ export const useMarginTop = (targetScreenId: string): number => {
    * ScreenPicker is a component but should really be a screen.
    * We need to skip margin top for it as it's already applied to the target screen
    **/
-  const isScreenPicker =
-    screenData?.ui_components?.[0]?.component_type === "screen-picker-qb-tv";
 
   // ignore margin on screenPicker
-  if (isScreenPicker) {
+  if (isFirstComponentScreenPicker(screenData?.ui_components)) {
     return 0;
   }
 

package/Components/VideoModal/ModalAnimation/ModalAnimationContext.tsx

@@ -118,11 +118,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-ui-components",
-  "version": "13.0.0-alpha.4863201005",
+  "version": "13.0.0-alpha.4958485095",
   "description": "Applicaster Zapp React Native ui components for the Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -34,10 +34,10 @@
     "redux-mock-store": "^1.5.3"
   },
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.4863201005",
+    "@applicaster/applicaster-types": "13.0.0-alpha.4958485095",
+    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.4958485095",
+    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.4958485095",
+    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.4958485095",
     "promise": "^8.3.0",
     "react-router-native": "^5.1.2",
     "url": "^0.11.0",