@applicaster/zapp-react-native-ui-components 13.0.0-alpha.8357105823 → 13.0.0-alpha.8490438700

package/Components/BaseFocusable/index.ios.ts

@@ -25,7 +25,7 @@ type Props = {
 };
 
 export class BaseFocusable<
-  T extends Props = Props
+  T extends Props = Props,
 > extends BaseFocusableInterface<T> {
   constructor(props) {
     super(props);

package/Components/BaseFocusable/index.tsx

@@ -35,7 +35,7 @@ type Props = {
 };
 
 export class BaseFocusable<
-  T extends Props = Props
+  T extends Props = Props,
 > extends BaseFocusableInterface<T> {
   constructor(props) {
     super(props);

package/Components/Cell/Cell.tsx

@@ -273,10 +273,14 @@ export class CellComponent extends React.Component<Props, State> {
             if (isFocused) {
               const accessibilityManager = AccessibilityManager.getInstance();
 
+              const accessibilityTitle =
+                item?.extensions?.accessibility?.label || item?.title || "";
+
+              const accessibilityHint =
+                item?.extensions?.accessibility?.hint || "";
+
               accessibilityManager.readText({
-                text: String(
-                  item.extensions?.accessibility?.label || item.title
-                ),
+                text: `${accessibilityTitle} ${accessibilityHint}`,
               });
             }
 

package/Components/Focusable/Touchable.tsx

@@ -1,25 +1,24 @@
 import * as React from "react";
 
-type Props =
-  | {
-      id: string;
-      children: React.ReactNode;
-      onPress?: (ref: FocusManager.TouchableRef) => void;
-      onPressIn?: (ref: FocusManager.TouchableRef) => void;
-      onPressOut?: (ref: FocusManager.TouchableRef) => void;
-      onLongPress?: (ref: FocusManager.TouchableRef) => void;
-      onFocus?: (
-        ref: FocusManager.TouchableRef,
-        options: FocusManager.Android.CallbackOptions
-      ) => void;
-      onBlur?: (
-        ref: FocusManager.TouchableRef,
-        options: FocusManager.Android.CallbackOptions
-      ) => void;
-
-      disableFocus?: boolean;
-      blockFocus?: boolean;
-    } & Partial<ParentFocus>;
+type Props = {
+  id: string;
+  children: React.ReactNode;
+  onPress?: (ref: FocusManager.TouchableRef) => void;
+  onPressIn?: (ref: FocusManager.TouchableRef) => void;
+  onPressOut?: (ref: FocusManager.TouchableRef) => void;
+  onLongPress?: (ref: FocusManager.TouchableRef) => void;
+  onFocus?: (
+    ref: FocusManager.TouchableRef,
+    options: FocusManager.Android.CallbackOptions
+  ) => void;
+  onBlur?: (
+    ref: FocusManager.TouchableRef,
+    options: FocusManager.Android.CallbackOptions
+  ) => void;
+
+  disableFocus?: boolean;
+  blockFocus?: boolean;
+} & Partial<ParentFocus>;
 
 export class Touchable extends React.Component<Props> {
   onPress(focusableRef: FocusManager.TouchableRef): void {

package/Components/MasterCell/DefaultComponents/BorderContainerView/__tests__/index.test.tsx

@@ -0,0 +1,66 @@
+import {
+  BorderContainerView,
+  getBorderPadding, // Export for testing (using a double underscore prefix is a common convention)
+} from "../index";
+import * as React from "react";
+import { render } from "@testing-library/react-native";
+import { toNumberWithDefaultZero } from "@applicaster/zapp-react-native-utils/numberUtils";
+import { View } from "react-native";
+
+jest.mock("@applicaster/zapp-react-native-utils/numberUtils", () => ({
+  toNumberWithDefaultZero: jest.fn((value) => Number(value) || 0),
+}));
+
+describe("BorderContainerView", () => {
+  describe("getBorderPadding", () => {
+    it("returns 0 for inside", () => {
+      expect(getBorderPadding("inside", 10)).toBe(0);
+    });
+
+    it("returns borderWidth / 2 for center", () => {
+      expect(getBorderPadding("center", 10)).toBe(5);
+    });
+
+    it("returns borderWidth for outside", () => {
+      expect(getBorderPadding("outside", 10)).toBe(10);
+    });
+
+    it("returns borderWidth for invalid position", () => {
+      // @ts-ignore
+      expect(getBorderPadding("other_value", 10)).toBe(10);
+    });
+  });
+
+  it("Border component renders null if no borderPosition", () => {
+    const style = { borderWidth: 5, borderRadius: 10, borderColor: "red" };
+
+    const padding = {
+      paddingTop: 2,
+      paddingRight: 3,
+      paddingBottom: 4,
+      paddingLeft: 5,
+    };
+
+    const borderPosition = null;
+
+    const { queryByTestId } = render(
+      <BorderContainerView
+        style={style}
+        testID="border-container"
+        borderPosition={borderPosition}
+        borderPaddingTop={toNumberWithDefaultZero(padding.paddingTop)}
+        borderPaddingRight={toNumberWithDefaultZero(padding.paddingRight)}
+        borderPaddingBottom={toNumberWithDefaultZero(padding.paddingBottom)}
+        borderPaddingLeft={toNumberWithDefaultZero(padding.paddingLeft)}
+      >
+        <View testID="child" />
+      </BorderContainerView>
+    );
+
+    const children = queryByTestId("border-container").children;
+
+    expect(children[1].props.testID).toBe("child");
+
+    expect(children[0].children.length).toBe(0);
+  });
+});

package/Components/MasterCell/DefaultComponents/BorderContainerView/index.tsx

@@ -28,7 +28,10 @@ const styles = StyleSheet.create({
   },
 });
 
-const getBorderPadding = (borderPosition: BorderPosition, borderWidth) => {
+export const getBorderPadding = (
+  borderPosition: BorderPosition,
+  borderWidth: number
+) => {
   switch (borderPosition) {
     case "inside":
       return 0;

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

@@ -38,22 +38,16 @@ function Image({
 
   const shouldRenderImg = source && !error;
 
-  // Default placeholder image fallback is empty string because it won't rerender
-  // in case of undefined or {uri: undefined} source
-  // https://github.com/facebook/react-native/issues/9195
-  const defaultPlaceHolderImage = React.useMemo(
-    () => ({ uri: placeholderImage || "" }),
-    [source, error]
-  );
+  const _source = shouldRenderImg
+    ? withDimensions(source)
+    : { uri: placeholderImage };
 
   return (
-    // @ts-ignore
     <MemoizedImage
       style={style as ImageStyle}
       onError={React.useCallback(() => setErrorState(true), [])}
-      source={
-        shouldRenderImg ? withDimensions(source) : defaultPlaceHolderImage
-      }
+      // as we have defaults as "" for placeholder image, we need to pass undefined to source to not throw warnings
+      source={_source?.uri ? _source : undefined}
       {...R.omit(["source"], otherProps)}
     />
   );

package/Components/MasterCell/DefaultComponents/ImageBorderContainer/__tests__/index.test.ts

@@ -0,0 +1,93 @@
+import { ImageBorderContainer } from "../index";
+import { getImageContainerMarginStyles } from "@applicaster/zapp-react-native-utils/cellUtils";
+
+const mockValue = (key) => {
+  const values = {
+    cell_padding_top: 1,
+    cell_padding_left: 2,
+    cell_padding_right: 3,
+    cell_padding_bottom: 4,
+    image_border_size: 5,
+    image_focused_border_color: "red",
+    image_selected_border_color: "blue",
+    image_focused_selected_border_color: "green",
+    image_border_color: "black",
+    image_corner_radius: 10,
+    image_border_position: "outside",
+    image_border_padding_top: 6,
+    image_border_padding_right: 7,
+    image_border_padding_bottom: 8,
+    image_border_padding_left: 9,
+    image_margin_top: 11,
+    image_margin_left: 12,
+    image_margin_right: 13,
+    image_margin_bottom: 14,
+  };
+
+  return values[key] || 0;
+};
+
+describe("ImageBorderContainer", () => {
+  it("calculates style properties correctly", () => {
+    const marginStyles = getImageContainerMarginStyles({ value: mockValue });
+
+    expect(marginStyles.marginTop).toBe(11);
+    expect(marginStyles.marginLeft).toBe(12);
+    expect(marginStyles.marginRight).toBe(13);
+    expect(marginStyles.marginBottom).toBe(14);
+
+    const props = {
+      value: mockValue,
+      state: "default",
+      imageStyles: {},
+    };
+
+    const result = ImageBorderContainer(props);
+
+    expect(result.style.marginTop).toBe(12); // 11 + 1
+    expect(result.style.marginLeft).toBe(14); // 12 + 2
+    expect(result.style.marginRight).toBe(16); // 13 + 3
+    expect(result.style.marginBottom).toBe(18); // 14 + 4
+    expect(result.style.borderWidth).toBe(5);
+    expect(result.style.borderColor).toBe("black");
+    expect(result.style.borderRadius).toBe(10);
+    expect(result.additionalProps.borderPosition).toBe("outside");
+    expect(result.additionalProps.borderPaddingTop).toBe(6);
+    expect(result.additionalProps.borderPaddingRight).toBe(7);
+    expect(result.additionalProps.borderPaddingBottom).toBe(8);
+    expect(result.additionalProps.borderPaddingLeft).toBe(9);
+  });
+
+  it("handles focused state correctly", () => {
+    const props = {
+      value: mockValue,
+      state: "focused",
+      imageStyles: {},
+    };
+
+    const result = ImageBorderContainer(props);
+    expect(result.style.borderColor).toBe("red");
+  });
+
+  it("handles selected state correctly", () => {
+    const props = {
+      value: mockValue,
+      state: "selected",
+      imageStyles: {},
+    };
+
+    const result = ImageBorderContainer(props);
+    expect(result.style.borderColor).toBe("blue");
+  });
+
+  it("handles focused and selected state correctly", () => {
+    const props = {
+      value: mockValue,
+      state: "focused_selected",
+      imageStyles: {},
+    };
+
+    const result = ImageBorderContainer(props);
+    expect(result.style.borderColor).toBe("green");
+  });
+});

package/Components/MasterCell/DefaultComponents/SecondaryImage/utils.ts

@@ -17,7 +17,7 @@ const SECONDARY_IMAGE_PREFIX = "secondary_image";
 
 type ImageSizing = typeof IMAGE_SIZING_FIT | typeof IMAGE_SIZING_FILL;
 
-type ImagePosition = typeof IMAGE_POSITION[keyof typeof IMAGE_POSITION];
+type ImagePosition = (typeof IMAGE_POSITION)[keyof typeof IMAGE_POSITION];
 
 export type DisplayMode =
   | typeof DISPLAY_MODE_FIXED

package/Components/MasterCell/DefaultComponents/__tests__/image.test.js

@@ -39,6 +39,6 @@ describe("image with no source", () => {
     );
 
     const testInstance = testRenderer.root;
-    expect(testInstance.findByType(Image).props.source).toEqual({ uri: "" });
+    expect(testInstance.findByType(Image).props.source).toBeUndefined();
   });
 });

package/Components/MasterCell/utils/index.ts

@@ -103,7 +103,7 @@ export const useFilterChildren = <
       item: any;
       pluginIdentifier: string;
     };
-  }
+  },
 >(
   children: T[]
 ): T[] => {

package/Components/ModalComponent/Header/index.tsx

@@ -1,5 +1,5 @@
 import React, { useMemo } from "react";
-import { View, StyleSheet, LayoutChangeEvent } from "react-native";
+import { LayoutChangeEvent, StyleSheet, View } from "react-native";
 import { Title, TitleProps } from "./Title";
 import { CloseButton, CloseButtonProps } from "./CloseButton";
 import { getCloseButtonProps, getTitleProps } from "./utils";
@@ -60,8 +60,8 @@ export function ModalHeader(props: Props) {
           width: width - buttonsContainerWidth,
         }}
       >
-        {title && <Title {...titleProps} />}
-        {summary && <Title {...summaryProps} />}
+        {title ? <Title {...titleProps} /> : null}
+        {summary ? <Title {...summaryProps} /> : null}
       </View>
       <View style={{ width: buttonsContainerWidth }}>
         <CloseButton {...closeButtonProps} />

package/Components/PlayerContainer/PlayerContainerContext.tsx

@@ -9,11 +9,14 @@ type ContextProps = {
   setIsLanguageOverlayVisible: (isVisible) => void;
   setShowComponentsContainer: (isVisible) => void;
   showComponentsContainer: boolean;
+  setIsSeekBarTouch: (isTouch) => void;
+  isSeekBarTouch: boolean;
 };
 
 export const PlayerContainerContext = createContext({
   ignoreOffsetContainer: false,
   isLanguageOverlayVisible: false,
+  isSeekBarTouch: false,
 } as ContextProps);
 
 type Props = {
@@ -40,6 +43,8 @@ export const PlayerContainerContextProvider = ({
   const [showComponentsContainer, setShowComponentsContainer] =
     React.useState(true);
 
+  const [isSeekBarTouch, setIsSeekBarTouch] = React.useState(false);
+
   const value = React.useMemo(
     () => ({
       ignoreOffsetContainer,
@@ -49,6 +54,8 @@ export const PlayerContainerContextProvider = ({
       setIsLanguageOverlayVisible,
       showComponentsContainer,
       setShowComponentsContainer: inline ? setShowComponentsContainer : null,
+      isSeekBarTouch,
+      setIsSeekBarTouch,
     }),
     [
       ignoreOffsetContainer,
@@ -58,6 +65,8 @@ export const PlayerContainerContextProvider = ({
       setIsLanguageOverlayVisible,
       showComponentsContainer,
       setShowComponentsContainer,
+      isSeekBarTouch,
+      setIsSeekBarTouch,
     ]
   );
 

package/Components/River/ComponentsMap/ComponentsMap.tsx

@@ -70,21 +70,6 @@ function ComponentsMapComponent(props: Props) {
 
   const [flatListHeight, setFlatListHeight] = React.useState(null);
 
-  const {
-    isAnyLoading,
-    isAllLoaded,
-    waitForAllComponents,
-    onLoadFinished,
-    onLoadFailed,
-    shouldShowLoadingError,
-    isAnyLoaded,
-    arePreviousComponentsLoaded,
-  } = useLoadingState(feed?.entry?.length || components.length);
-
-  const theme = useTheme();
-
-  const logTimestamp = useProfilerLogging();
-
   const riverComponents = React.useMemo(() => {
     if (feed?.entry?.length < components.length) {
       return R.slice(0, feed?.entry?.length, components);
@@ -93,55 +78,42 @@ function ComponentsMapComponent(props: Props) {
     return components;
   }, [components, feed]);
 
+  const logTimestamp = useProfilerLogging();
+
+  const onLoadDone = React.useCallback(() => {
+    logTimestamp(riverId?.toString());
+  }, [logTimestamp]);
+
+  const { loadingState, onLoadFinished, onLoadFailed, shouldShowLoadingError } =
+    useLoadingState(riverComponents.length, onLoadDone);
+
+  const theme = useTheme();
+
   const renderRiverItem = React.useCallback(
     ({ item, index }) => {
-      const readyToBeDisplayed = arePreviousComponentsLoaded(index);
-
-      const styles = {
-        display: !readyToBeDisplayed ? "none" : ("flex" as "none" | "flex"),
+      const riverItemProps = {
+        riverId,
+        item,
+        index,
+        isScreenWrappedInContainer,
+        feed,
+        groupId,
+        onLoadFailed,
+        onLoadFinished,
+        getStaticComponentFeed,
+        isLast: isLast(index, riverComponents.length),
+        loadingState,
       };
 
       return (
-        <View style={styles}>
-          <ScreenLoadingMeasurementsListItemWrapper index={index}>
-            <RiverItem
-              {...{
-                readyToBeDisplayed,
-                riverId,
-                item,
-                index,
-                isScreenWrappedInContainer,
-                feed,
-                groupId,
-                onLoadFailed,
-                onLoadFinished,
-                getStaticComponentFeed,
-                isLast: isLast(index, riverComponents.length),
-              }}
-            />
-          </ScreenLoadingMeasurementsListItemWrapper>
-        </View>
+        <ScreenLoadingMeasurementsListItemWrapper index={index}>
+          <RiverItem {...riverItemProps} />
+        </ScreenLoadingMeasurementsListItemWrapper>
       );
     },
-    [
-      feed,
-      getStaticComponentFeed,
-      arePreviousComponentsLoaded,
-      onLoadFailed,
-      onLoadFinished,
-    ]
+    [feed, getStaticComponentFeed, onLoadFailed, onLoadFinished]
   );
 
-  const renderFooter = React.useCallback(() => {
-    return (
-      <RiverFooter
-        visible={isAnyLoading}
-        flatListHeight={flatListHeight}
-        isAnyLoaded={isAnyLoaded || waitForAllComponents}
-      />
-    );
-  }, [flatListHeight, isAnyLoading, isAnyLoaded]);
-
   const screenStyle = React.useMemo(
     () => ({
       paddingTop: ifEmptyUseFallback(
@@ -179,12 +151,6 @@ function ComponentsMapComponent(props: Props) {
 
   usePipesCacheReset(riverId, riverComponents);
 
-  React.useEffect(() => {
-    if (isAllLoaded) {
-      logTimestamp(riverId?.toString());
-    }
-  }, [isAllLoaded]);
-
   const refreshControl = React.useMemo(
     () =>
       pullToRefreshEnabled ? (
@@ -280,6 +246,11 @@ function ComponentsMapComponent(props: Props) {
     }
   }, []);
 
+  const contentContainerStyle = React.useMemo(
+    () => (isScreenWrappedInContainer ? {} : screenStyle),
+    [isScreenWrappedInContainer, screenStyle]
+  );
+
   if (shouldShowLoadingError) {
     return <RiverError />;
   }
@@ -291,7 +262,7 @@ function ComponentsMapComponent(props: Props) {
     <View style={styles.container}>
       <ScreenLoadingMeasurements
         riverId={riverId}
-        numberOfComponents={feed?.entry?.length || components.length}
+        numberOfComponents={riverComponents.length}
       >
         <ViewportTracker>
           <FlatList
@@ -312,10 +283,13 @@ function ComponentsMapComponent(props: Props) {
             keyExtractor={keyExtractor}
             renderItem={renderRiverItem}
             data={riverComponents}
-            contentContainerStyle={
-              isScreenWrappedInContainer ? {} : screenStyle
+            contentContainerStyle={contentContainerStyle}
+            ListFooterComponent={
+              <RiverFooter
+                flatListHeight={flatListHeight}
+                loadingState={loadingState}
+              />
             }
-            ListFooterComponent={renderFooter}
             refreshControl={refreshControl}
             onScrollBeginDrag={onScrollBeginDrag}
             onScroll={onScroll}