@applicaster/zapp-react-native-ui-components 12.0.0-rc.127 → 12.0.0-rc.128

package/Components/Focusable/__tests__/index.android.test.tsx

@@ -0,0 +1,72 @@
+import React from "react";
+import { render, act } from "@testing-library/react-native";
+import { Touchable } from "../../Touchable";
+
+const mockUseIsRTL = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/localizationUtils", () => ({
+  useIsRTL: mockUseIsRTL,
+}));
+
+const mockUseFocusManager = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/focusManager", () => ({
+  useFocusManager: mockUseFocusManager,
+}));
+
+const mockUsePrevious = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/utils", () => ({
+  usePrevious: mockUsePrevious,
+}));
+
+const { Focusable } = require("../index.android");
+
+describe("Focusable", () => {
+  const mockFocusManager = {
+    isFocused: jest.fn(),
+    onDisableFocusChange: jest.fn(),
+    registerFocusable: jest.fn(),
+    focusedId: "test-id",
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUseIsRTL.mockReturnValue(false);
+    mockUseFocusManager.mockReturnValue(mockFocusManager);
+    mockUsePrevious.mockReturnValue(false);
+  });
+
+  it("updates disableFocus state when disableFocus prop changes", () => {
+    const { rerender } = render(
+      <Focusable id="test-id" disableFocus={false}>
+        <Touchable testID="touchable" />
+      </Focusable>
+    );
+
+    rerender(
+      <Focusable id="test-id" disableFocus={true}>
+        <Touchable testID="touchable" />
+      </Focusable>
+    );
+
+    expect(mockFocusManager.onDisableFocusChange).toHaveBeenCalledWith(
+      "test-id"
+    );
+  });
+
+  it("calls focusManager.registerFocusable on mount and unregisters on unmount", () => {
+    const unregister = jest.fn();
+    mockFocusManager.registerFocusable.mockReturnValue(unregister);
+
+    const { unmount } = render(
+      <Focusable id="test-id">
+        <Touchable testID="touchable" />
+      </Focusable>
+    );
+
+    expect(mockFocusManager.registerFocusable).toHaveBeenCalled();
+    act(() => unmount());
+    expect(unregister).toHaveBeenCalled();
+  });
+});

package/Components/Focusable/index.android.tsx

@@ -128,7 +128,10 @@ function FocusableComponent(props: Props, forwardedRef) {
 
   const _onBlur = React.useCallback(
     (ref, options = {}) => {
-      setFocused(false);
+      if (ref.props.id !== focusManager.focusedId) {
+        setFocused(false);
+      }
+
       onBlur?.(ref, options);
     },
     [onBlur]
@@ -148,15 +151,14 @@ function FocusableComponent(props: Props, forwardedRef) {
     [isRTL, nextFocusDown, nextFocusUp, nextFocusLeft, nextFocusRight]
   );
 
-  const contextState = React.useMemo(
-    () => ({
+  const contextState = React.useMemo(() => {
+    return {
       focused,
       ...parentFocus,
       ref: touchableRef,
       setIsFocusable,
-    }),
-    [parentFocus, focused]
-  );
+    };
+  }, [parentFocus, focused]);
 
   return (
     <Touchable
@@ -173,9 +175,13 @@ function FocusableComponent(props: Props, forwardedRef) {
       {...parentFocus}
     >
       <FocusableContext.Provider value={contextState}>
-        {typeof children === "function"
-          ? children(focused, parentFocus, touchableRef)
-          : children}
+        {React.useMemo(
+          () =>
+            typeof children === "function"
+              ? children(focused, parentFocus, touchableRef)
+              : children,
+          [children, focused, parentFocus]
+        )}
       </FocusableContext.Provider>
     </Touchable>
   );

package/Components/FocusableList/FocusableChild.ts

@@ -1,7 +1,6 @@
 import * as React from "react";
 import { isEqual } from "@applicaster/zapp-react-native-utils/equalUtils";
 import { useFocusable } from "../Focusable/index.android";
-import { useCellState } from "./hooks/useCellState.android";
 
 /**
  * returns parent focus from prop or from context
@@ -30,15 +29,14 @@ const useParentFocus = (
   );
 
 function FocusableChildComponent(props) {
-  const { setIsFocusable, ...focusableContext } = useFocusable();
+  const { setIsFocusable, focused, ...focusableContext } = useFocusable();
+
   const parentFocus = useParentFocus(props, focusableContext);
 
   const onLoadFailed = React.useCallback(() => {
     setIsFocusable(false);
   }, []);
 
-  const focused = useCellState(props.id);
-
   return props.renderItem({
     ...props,
     focused,

package/Components/FocusableList/index.tsx

@@ -88,6 +88,7 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
     data = [],
     // eslint-disable-next-line unused-imports/no-unused-vars
     onAllComponentsLoaded, // TODO: re-implement it
+    omitPropsPropagation = [],
   } = props;
 
   useCheckItemIdsForUnique({ componentId: props.id, items: data });
@@ -252,9 +253,9 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
     ]
   );
 
-  const flatListProps = React.useMemo(
-    () =>
-      R.omit([
+  const getFlatListProps = React.useCallback(
+    R.omit(
+      [
         "onListElementFocus",
         "onListElementPress",
         "onListElementPressOut",
@@ -267,17 +268,17 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
         "focusableItemProps",
         "renderItem",
         "extraChildrenData",
-        "extraData",
-        "keyExtractor",
         "onAllComponentsLoaded",
         "focused",
         "id",
         "initialFocusDirection",
         "withStateMemory",
         "useSequentialLoading",
-        ...(props.omitPropsPropagation || []),
-      ])(props),
-    [props]
+        ...omitPropsPropagation,
+      ],
+      R.__
+    ),
+    [omitPropsPropagation]
   );
 
   const onEndReached = React.useCallback(
@@ -289,7 +290,7 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
 
   const initialNumToRender = toFiniteNumberWithDefault(
     10,
-    flatListProps.initialNumToRender
+    props.initialNumToRender
   );
 
   return (
@@ -298,12 +299,10 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
       <FlatList
         focusable={false}
         scrollEnabled={false}
-        extraData={props.extraData}
         ref={ref}
-        {...flatListProps}
+        {...getFlatListProps(props)}
         renderItem={renderItem}
         onEndReached={onEndReached}
-        keyExtractor={props.keyExtractor}
         initialNumToRender={initialNumToRender}
       />
     </ChildrenFocusDeactivatorView>

package/Components/FocusableScrollView/index.tsx

@@ -284,7 +284,7 @@ function FocusableScrollViewComponent(props: Props, ref) {
       };
 
       return (
-        <View onLayout={onItemLayout}>
+        <View key={id} onLayout={onItemLayout}>
           <Focusable
             {...nextFocus}
             onFocus={(element, direction) =>

package/Components/PlayerContainer/PlayerContainer.tsx

@@ -363,19 +363,11 @@ const PlayerContainerComponent = (props: Props) => {
     const { fullscreen = false } = event || {};
 
     if (fullscreen) {
-      // in order to avoid UI glitches with player we have to start re-render ealier and then start real rotation
       navigator.fullscreenVideoModal();
-
-      setTimeout(() => {
-        playerEvent("onFullscreenPlayerWillPresent");
-      });
+      playerEvent("onFullscreenPlayerWillPresent");
     } else {
-      // in order to avoid UI glitches with player we have to start re-render ealier and then start real rotation
       navigator.maximiseVideoModal();
-
-      setTimeout(() => {
-        playerEvent("onFullscreenPlayerWillDismiss");
-      });
+      playerEvent("onFullscreenPlayerWillDismiss");
     }
   };
 
@@ -471,6 +463,10 @@ const PlayerContainerComponent = (props: Props) => {
 
     if (mode === VideoModalMode.FULLSCREEN) {
       toggleFullscreen({ fullscreen: false });
+
+      if (!isModal) {
+        playerManager.closeNativePlayer();
+      }
     }
 
     return !!(

package/Components/VideoModal/ModalAnimation/AnimationComponent.tsx

@@ -62,6 +62,7 @@ export const AnimationView = ({
     deviceInfo: { isTablet, isTabletLandscape },
   } = useDimensions("window", {
     deviceInfo: true,
+    updateForInactiveScreens: true,
   });
 
   const { videoModalState } = useNavigation();

package/Components/ZappFrameworkComponents/BarView/BarView.tsx

@@ -45,7 +45,10 @@ const BarView = ({ screenStyles, barState = defaultState }: Props) => {
   );
 
   return (
-    <SafeAreaView style={[style.view, isRTL ? style.rtlStyle : {}]}>
+    <SafeAreaView
+      style={[style.view, isRTL ? style.rtlStyle : {}]}
+      testID="BarView-safeAreaView"
+    >
       {backButton}
       <BarTitle title={barState.title} screenStyles={screenStyles} />
       {closeButton}

package/Components/ZappFrameworkComponents/BarView/Buttons/BackButton.tsx

@@ -11,12 +11,16 @@ const renderEmptyView = () => {
   return <View style={emptyViewStyle} />;
 };
 
-type FloatingButtonProps = {
+type FloatingButtonProps = Testable & {
   onPress: () => void;
   screenStyles: any;
 };
 
-const BackButton = ({ onPress, screenStyles }: FloatingButtonProps) => {
+const BackButton = ({
+  onPress,
+  screenStyles,
+  testID = "backButton",
+}: FloatingButtonProps) => {
   const containerStyle: any = {};
 
   if (!onPress) {
@@ -25,6 +29,7 @@ const BackButton = ({ onPress, screenStyles }: FloatingButtonProps) => {
 
   return (
     <ActionButton
+      testID={`${testID}-actionButton`}
       onPress={onPress}
       buttonStyles={containerStyle}
       imageUrl={screenStyles.back_button_image}

package/Components/ZappFrameworkComponents/BarView/Buttons/CloseButton.tsx

@@ -11,12 +11,16 @@ const renderEmptyView = () => {
   return <View style={emptyViewStyle} />;
 };
 
-type CloseButtonProps = {
+type CloseButtonProps = Testable & {
   onPress: () => void;
   screenStyles?: any;
 };
 
-const CloseButton = ({ onPress, screenStyles }: CloseButtonProps) => {
+const CloseButton = ({
+  onPress,
+  screenStyles,
+  testID = "closeButton",
+}: CloseButtonProps) => {
   const containerStyle: any = {};
 
   if (!onPress) {
@@ -25,6 +29,7 @@ const CloseButton = ({ onPress, screenStyles }: CloseButtonProps) => {
 
   return (
     <ActionButton
+      testID={`${testID}-actionButton`}
       onPress={onPress}
       buttonStyles={containerStyle}
       imageUrl={screenStyles.close_button_image}

package/Components/ZappFrameworkComponents/BarView/__tests__/BarView.test.tsx

@@ -0,0 +1,87 @@
+import React from "react";
+import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+import { fireEvent } from "@testing-library/react-native";
+
+const mockUseIsRTL = jest.fn(() => true);
+
+jest.mock("@applicaster/zapp-react-native-utils/localizationUtils", () => ({
+  useIsRTL: mockUseIsRTL,
+}));
+
+const BarView = require("../BarView").default;
+
+describe("BarView", () => {
+  const screenStyles = {
+    title_font_color: "#000",
+    title_font_android: "Roboto",
+    title_font_ios: "San Francisco",
+    title_font_size: "16",
+    background_color: "#fff",
+  };
+
+  const barState = {
+    backHandler: jest.fn(),
+    closeHandler: jest.fn(),
+    title: "Test Title",
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("renders without crashing", () => {
+    mockUseIsRTL.mockReturnValue(false);
+
+    const { getByText } = renderWithProviders(
+      <BarView screenStyles={screenStyles} barState={barState} />
+    );
+
+    expect(getByText("Test Title")).toBeTruthy();
+  });
+
+  it("applies RTL styles when isRTL is true", () => {
+    mockUseIsRTL.mockReturnValue(true);
+
+    const { getByTestId } = renderWithProviders(
+      <BarView screenStyles={screenStyles} barState={barState} />
+    );
+
+    expect(getByTestId("BarView-safeAreaView").props.style).toContainEqual({
+      transform: [{ scaleX: -1 }],
+    });
+  });
+
+  it("does not apply RTL styles when isRTL is false", () => {
+    mockUseIsRTL.mockReturnValue(false);
+
+    const { getByTestId } = renderWithProviders(
+      <BarView screenStyles={screenStyles} barState={barState} />
+    );
+
+    expect(getByTestId("BarView-safeAreaView").props.style).not.toContainEqual({
+      transform: [{ scaleX: -1 }],
+    });
+  });
+
+  it("calls closeHandler when CloseButton is pressed", () => {
+    mockUseIsRTL.mockReturnValue(false);
+
+    const { getByTestId } = renderWithProviders(
+      <BarView screenStyles={screenStyles} barState={barState} />
+    );
+
+    fireEvent.press(getByTestId("closeButton-actionButton-touchable"));
+    expect(barState.closeHandler).toHaveBeenCalled();
+  });
+
+  it("calls backHandler when BackButton is pressed", () => {
+    mockUseIsRTL.mockReturnValue(false);
+
+    const { getByTestId } = renderWithProviders(
+      <BarView screenStyles={screenStyles} barState={barState} />
+    );
+
+    fireEvent.press(getByTestId("backButton-actionButton-touchable"));
+    expect(barState.backHandler).toHaveBeenCalled();
+  });
+});

package/Components/ZappFrameworkComponents/Buttons/ActionButton.tsx

@@ -28,7 +28,7 @@ styles: {
 }
 */
 
-type ActionButtonProps = {
+type ActionButtonProps = Testable & {
   onPress: () => void;
   buttonStyles: any;
   imageUrl: string;
@@ -46,11 +46,16 @@ const ActionButton = ({
   buttonStyles,
   imageUrl,
   imageStyle = closeButtonStyle,
+  testID,
 }: ActionButtonProps) => {
   return (
-    <View style={buttonStyles}>
-      <TouchableOpacity onPress={onPress}>
-        <Image source={{ uri: imageUrl }} style={imageStyle} />
+    <View style={buttonStyles} testID={testID}>
+      <TouchableOpacity onPress={onPress} testID={`${testID}-touchable`}>
+        <Image
+          source={{ uri: imageUrl }}
+          style={imageStyle}
+          testID={`${testID}-image`}
+        />
       </TouchableOpacity>
     </View>
   );

package/Contexts/CachedDimensionsContext/index.ts

@@ -1,5 +1,6 @@
 import { create, useStore } from "zustand";
 import { produce } from "immer";
+import { useCallback, useMemo } from "react";
 
 type Dimensions = {
   width: Option<number>;
@@ -31,16 +32,19 @@ export const useCachedDimensions = (id: string) => {
     dimensionsStore
   ) as DimensionsState;
 
-  const getCachedDimensions = () => {
+  const getCachedDimensions = useCallback(() => {
     return dimensions[id] || initialDimensions();
-  };
+  }, [dimensions?.[id], id]);
 
-  const handleSetCachedDimensions = (newDimensions) => {
+  const handleSetCachedDimensions = useCallback((newDimensions) => {
     setCachedDimensions(id, newDimensions);
-  };
-
-  return {
-    getCachedDimensions,
-    setCachedDimensions: handleSetCachedDimensions,
-  };
+  }, []);
+
+  return useMemo(
+    () => ({
+      getCachedDimensions,
+      setCachedDimensions: handleSetCachedDimensions,
+    }),
+    [getCachedDimensions, handleSetCachedDimensions]
+  );
 };

package/Contexts/ScreenContext/index.tsx

@@ -177,7 +177,12 @@ export function withScreenContext(Component: React.ComponentType<any>) {
   return function WithScreenContextWrapper(props) {
     return (
       <ScreenContext.Consumer>
-        {(value) => <Component {...props} screenContext={value} />}
+        {useCallback(
+          (value) => (
+            <Component {...props} screenContext={value} />
+          ),
+          [Component, props]
+        )}
       </ScreenContext.Consumer>
     );
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-ui-components",
-  "version": "12.0.0-rc.127",
+  "version": "12.0.0-rc.128",
   "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": "12.0.0-rc.127",
-    "@applicaster/zapp-react-native-bridge": "12.0.0-rc.127",
-    "@applicaster/zapp-react-native-redux": "12.0.0-rc.127",
-    "@applicaster/zapp-react-native-utils": "12.0.0-rc.127",
+    "@applicaster/applicaster-types": "12.0.0-rc.128",
+    "@applicaster/zapp-react-native-bridge": "12.0.0-rc.128",
+    "@applicaster/zapp-react-native-redux": "12.0.0-rc.128",
+    "@applicaster/zapp-react-native-utils": "12.0.0-rc.128",
     "promise": "^8.3.0",
     "react-router-native": "^5.1.2",
     "url": "^0.11.0",