@applicaster/zapp-react-native-ui-components 14.0.7 → 14.0.8

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

@@ -3,8 +3,8 @@ import { isNil } from "ramda";
 import { ImageStyle, View } from "react-native";
 import {
   FIT_POSITION,
-  IMAGE_SIZING_FIT,
   IMAGE_SIZING_FILL,
+  IMAGE_SIZING_FIT,
 } from "@applicaster/zapp-react-native-utils/manifestUtils/secondaryImage";
 import { QBImage as Image } from "@applicaster/zapp-react-native-ui-components/Components/Image";
 
@@ -25,49 +25,51 @@ interface Props {
   fitPosition: typeof FIT_POSITION;
   fixedWidth: number;
   fixedHeight: number;
-  onAsyncRender: () => void;
+  onAsyncRender?: () => void;
 }
 
 /** Secondary Image Dynamic does not render until the image is loaded */
-const SecondaryImageDynamic = (props: Props) => {
-  const { uri, style, displayMode, imageSizing, fitPosition, onAsyncRender } =
-    props;
+const SecondaryImageDynamic = withAsyncRenderHOC(
+  (props: Props & { onAsyncRender: () => void }) => {
+    const { uri, style, displayMode, imageSizing, fitPosition, onAsyncRender } =
+      props;
 
-  const imageDimension = useGetImageDimensions(
-    uri,
-    style.width as number,
-    isImageSizingFit(imageSizing) ? undefined : (style.height as number)
-  );
+    const imageDimension = useGetImageDimensions(
+      uri,
+      style.width as number,
+      isImageSizingFit(imageSizing) ? undefined : (style.height as number)
+    );
 
-  const containerHeight = imageDimension?.height;
+    const containerHeight = imageDimension?.height;
 
-  const containerWidth = style?.width;
+    const containerWidth = style?.width;
 
-  if (isNil(imageDimension?.aspectRatio)) {
-    return null;
-  }
+    if (isNil(imageDimension?.aspectRatio)) {
+      return null;
+    }
 
-  return (
-    <View style={style} onLayout={onAsyncRender}>
-      <Image
-        {...props}
-        source={{ uri }}
-        style={{
-          ...getStyle({
-            imageSizing,
-            fitPosition,
-            displayMode,
-            imageDimension,
-            containerHeight,
-            containerWidth,
-          }),
-          borderRadius: style.borderRadius,
-          aspectRatio: imageDimension.aspectRatio,
-        }}
-      />
-    </View>
-  );
-};
+    return (
+      <View style={style} onLayout={onAsyncRender}>
+        <Image
+          {...props}
+          source={{ uri }}
+          style={{
+            ...getStyle({
+              imageSizing,
+              fitPosition,
+              displayMode,
+              imageDimension,
+              containerHeight,
+              containerWidth,
+            }),
+            borderRadius: style.borderRadius,
+            aspectRatio: imageDimension.aspectRatio,
+          }}
+        />
+      </View>
+    );
+  }
+);
 
 /** Secondary Image Fixed does not render  the image until the image is loaded, but keep container rendered */
 const SecondaryImageFixed = (props: Props) => {
@@ -79,7 +81,6 @@ const SecondaryImageFixed = (props: Props) => {
     fitPosition,
     fixedHeight,
     fixedWidth,
-    onAsyncRender,
   } = props;
 
   const imageDimension = useGetImageDimensions(
@@ -89,7 +90,7 @@ const SecondaryImageFixed = (props: Props) => {
   );
 
   return (
-    <View style={style} onLayout={onAsyncRender}>
+    <View style={style}>
       {isNil(imageDimension?.aspectRatio) ? null : (
         <Image
           {...props}
@@ -128,4 +129,4 @@ const SecondaryImageComponent = (props: Props) => {
   );
 };
 
-export const SecondaryImage = withAsyncRenderHOC(SecondaryImageComponent);
+export const SecondaryImage = SecondaryImageComponent;

package/Components/MasterCell/DefaultComponents/SecondaryImage/__tests__/Image.test.tsx

@@ -10,6 +10,10 @@ describe("SecondaryImage - Image", () => {
         displayMode="dynamic"
         uri={undefined}
         style={{ width: 100 }}
+        imageSizing="fit"
+        fitPosition="center"
+        fixedWidth={0}
+        fixedHeight={0}
       />
     );
 
@@ -23,6 +27,10 @@ describe("SecondaryImage - Image", () => {
         displayMode="dynamic"
         uri="someurl"
         style={{ width: 100 }}
+        imageSizing="fit"
+        fitPosition="center"
+        fixedWidth={0}
+        fixedHeight={0}
       />
     );
 
@@ -36,6 +44,93 @@ describe("SecondaryImage - Image", () => {
         uri="someUrl"
         displayMode="dynamic"
         style={{ width: 100, height: 100, borderRadius: 10 }}
+        imageSizing="fill"
+        fitPosition="center"
+        fixedWidth={0}
+        fixedHeight={0}
+      />
+    );
+
+    expect(wrapper.toJSON()).not.toEqual(null);
+    expect(wrapper.toJSON()).toMatchSnapshot();
+  });
+
+  it("SecondaryImage should render in fixed mode without image until loaded", async () => {
+    const wrapper = await render(
+      <SecondaryImage
+        displayMode="fixed"
+        uri="someurl"
+        style={{ width: 100, height: 100, borderRadius: 5 }}
+        imageSizing="fit"
+        fitPosition="center"
+        fixedWidth={100}
+        fixedHeight={100}
+      />
+    );
+
+    expect(wrapper.toJSON()).toMatchSnapshot();
+  });
+
+  it("SecondaryImage should not render in dynamic mode without image", async () => {
+    const wrapper = await render(
+      <SecondaryImage
+        displayMode="dynamic"
+        uri={null}
+        style={{ width: 100, height: 100 }}
+        imageSizing="fit"
+        fitPosition="center"
+        fixedWidth={0}
+        fixedHeight={0}
+      />
+    );
+
+    expect(wrapper.toJSON()).toEqual(null);
+    expect(wrapper.toJSON()).toMatchSnapshot();
+  });
+
+  it("SecondaryImage should render in fixed mode with known dimensions", async () => {
+    const wrapper = await render(
+      <SecondaryImage
+        uri="someUrl"
+        displayMode="fixed"
+        style={{ width: 100, height: 100, borderRadius: 10 }}
+        imageSizing="fill"
+        fitPosition="center"
+        fixedWidth={100}
+        fixedHeight={100}
+      />
+    );
+
+    expect(wrapper.toJSON()).not.toEqual(null);
+    expect(wrapper.toJSON()).toMatchSnapshot();
+  });
+
+  it("SecondaryImage dynamic mode should call onAsyncRender when provided", async () => {
+    const wrapper = await render(
+      <SecondaryImage
+        uri="someUrl"
+        displayMode="dynamic"
+        style={{ width: 100, height: 100, borderRadius: 10 }}
+        imageSizing="fill"
+        fitPosition="center"
+        fixedWidth={0}
+        fixedHeight={0}
+      />
+    );
+
+    expect(wrapper.toJSON()).not.toEqual(null);
+  });
+
+  it("SecondaryImage fixed mode should not use async render props", async () => {
+    const wrapper = await render(
+      <SecondaryImage
+        uri="someUrl"
+        displayMode="fixed"
+        style={{ width: 100, height: 100, borderRadius: 10 }}
+        imageSizing="fill"
+        fitPosition="center"
+        fixedWidth={100}
+        fixedHeight={100}
       />
     );
 

package/Components/MasterCell/DefaultComponents/SecondaryImage/__tests__/__snapshots__/Image.test.tsx.snap

@@ -1,9 +1,45 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`SecondaryImage - Image SecondaryImage fixed mode should not use async render props 1`] = `
+<View
+  style={
+    {
+      "borderRadius": 10,
+      "height": 100,
+      "width": 100,
+    }
+  }
+>
+  <Image
+    displayMode="fixed"
+    fitPosition="center"
+    fixedHeight={100}
+    fixedWidth={100}
+    imageSizing="fill"
+    source={
+      {
+        "uri": "someUrl",
+      }
+    }
+    style={
+      {
+        "aspectRatio": 1,
+        "borderRadius": 10,
+        "height": 100,
+        "width": 100,
+      }
+    }
+    uri="someUrl"
+  />
+</View>
+`;
+
 exports[`SecondaryImage - Image SecondaryImage should not render if no aspect ratio (dynamic) 1`] = `null`;
 
 exports[`SecondaryImage - Image SecondaryImage should not render if no uri 1`] = `null`;
 
+exports[`SecondaryImage - Image SecondaryImage should not render in dynamic mode without image 1`] = `null`;
+
 exports[`SecondaryImage - Image SecondaryImage should render if known dimensions 1`] = `
 <View
   onLayout={[Function]}
@@ -17,6 +53,10 @@ exports[`SecondaryImage - Image SecondaryImage should render if known dimensions
 >
   <Image
     displayMode="dynamic"
+    fitPosition="center"
+    fixedHeight={0}
+    fixedWidth={0}
+    imageSizing="fill"
     onAsyncRender={[Function]}
     source={
       {
@@ -35,3 +75,49 @@ exports[`SecondaryImage - Image SecondaryImage should render if known dimensions
   />
 </View>
 `;
+
+exports[`SecondaryImage - Image SecondaryImage should render in fixed mode with known dimensions 1`] = `
+<View
+  style={
+    {
+      "borderRadius": 10,
+      "height": 100,
+      "width": 100,
+    }
+  }
+>
+  <Image
+    displayMode="fixed"
+    fitPosition="center"
+    fixedHeight={100}
+    fixedWidth={100}
+    imageSizing="fill"
+    source={
+      {
+        "uri": "someUrl",
+      }
+    }
+    style={
+      {
+        "aspectRatio": 1,
+        "borderRadius": 10,
+        "height": 100,
+        "width": 100,
+      }
+    }
+    uri="someUrl"
+  />
+</View>
+`;
+
+exports[`SecondaryImage - Image SecondaryImage should render in fixed mode without image until loaded 1`] = `
+<View
+  style={
+    {
+      "borderRadius": 5,
+      "height": 100,
+      "width": 100,
+    }
+  }
+/>
+`;

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

@@ -0,0 +1,141 @@
+import { SecondaryImage } from "../index";
+
+describe("SecondaryImage - Configuration Builder", () => {
+  const mockValue = (config: any) => (key: string, transformer?: Function) => {
+    const value = config[key];
+
+    return transformer ? transformer(value) : value;
+  };
+
+  it("should pass false as second argument to image_src_from_media_item", () => {
+    const config = {
+      secondary_image_switch: true,
+      secondary_image_position: "over_image",
+      secondary_image_visibility: "always",
+      secondary_image_image_key: "custom_image",
+      secondary_image_display_mode: "dynamic",
+      secondary_image_dynamic_width: 100,
+    };
+
+    const result = SecondaryImage({
+      value: mockValue(config),
+      currentPosition: "over_image",
+      state: "default",
+    });
+
+    expect(result).not.toBeNull();
+    expect(result?.elements).toBeDefined();
+    expect(result?.elements[0].data).toBeDefined();
+
+    const imageData = result?.elements[0].data[0];
+    expect(imageData.func).toBe("image_src_from_media_item");
+    expect(imageData.args).toEqual(["custom_image", false]);
+    expect(imageData.propName).toBe("uri");
+  });
+
+  it("should return null when secondary image is disabled", () => {
+    const config = {
+      secondary_image_switch: false,
+    };
+
+    const result = SecondaryImage({
+      value: mockValue(config),
+      currentPosition: "over_image",
+      state: "default",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("should return null when position does not match currentPosition", () => {
+    const config = {
+      secondary_image_switch: true,
+      secondary_image_position: "above_text_label_1",
+      secondary_image_visibility: "always",
+    };
+
+    const result = SecondaryImage({
+      value: mockValue(config),
+      currentPosition: "over_image",
+      state: "default",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("should return null when visibility does not match state", () => {
+    const config = {
+      secondary_image_switch: true,
+      secondary_image_position: "over_image",
+      secondary_image_visibility: "focused",
+    };
+
+    const result = SecondaryImage({
+      value: mockValue(config),
+      currentPosition: "over_image",
+      state: "default",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("should include display mode and image sizing in additionalProps", () => {
+    const config = {
+      secondary_image_switch: true,
+      secondary_image_position: "over_image",
+      secondary_image_visibility: "always",
+      secondary_image_image_key: "logo",
+      secondary_image_display_mode: "fixed",
+      secondary_image_image_sizing: "fill",
+      secondary_image_fit_position: "center",
+      secondary_image_fixed_width: 200,
+      secondary_image_fixed_height: 150,
+    };
+
+    const result = SecondaryImage({
+      value: mockValue(config),
+      currentPosition: "over_image",
+      state: "default",
+    });
+
+    expect(result?.elements[0].additionalProps).toMatchObject({
+      displayMode: "fixed",
+      imageSizing: "fill",
+      fitPosition: "center",
+      fixedWidth: 200,
+      fixedHeight: 150,
+    });
+  });
+
+  it("should apply correct styles including margins and border radius", () => {
+    const config = {
+      secondary_image_switch: true,
+      secondary_image_position: "over_image",
+      secondary_image_visibility: "always",
+      secondary_image_display_mode: "fixed",
+      secondary_image_fixed_width: 100,
+      secondary_image_fixed_height: 100,
+      secondary_image_corner_radius: 12,
+      secondary_image_margin_top: 10,
+      secondary_image_margin_left: 5,
+      secondary_image_margin_right: 5,
+      secondary_image_margin_bottom: 10,
+    };
+
+    const result = SecondaryImage({
+      value: mockValue(config),
+      currentPosition: "over_image",
+      state: "default",
+    });
+
+    expect(result?.elements[0].style).toMatchObject({
+      width: 100,
+      height: 100,
+      borderRadius: 12,
+      marginTop: 10,
+      marginLeft: 5,
+      marginRight: 5,
+      marginBottom: 10,
+    });
+  });
+});

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

@@ -103,7 +103,7 @@ export const SecondaryImage = ({ value, currentPosition, state }: Props) => {
         data: [
           {
             func: "image_src_from_media_item",
-            args: [imageKey],
+            args: [imageKey, false],
             propName: "uri",
           },
         ],

package/Components/MasterCell/hoc/__tests__/withAsyncRender.test.tsx

@@ -0,0 +1,219 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+import { Text, View } from "react-native";
+import { withAsyncRenderHOC } from "../withAsyncRender";
+
+describe("withAsyncRenderHOC", () => {
+  // Test component that requires onAsyncRender
+  const TestComponent = ({
+    onAsyncRender,
+    text,
+  }: {
+    onAsyncRender: () => void;
+    text?: string;
+  }) => {
+    React.useEffect(() => {
+      onAsyncRender();
+    }, [onAsyncRender]);
+
+    return (
+      <View>
+        <Text>{text || "Test"}</Text>
+      </View>
+    );
+  };
+
+  it("should wrap component and provide onAsyncRender callback", () => {
+    const WrappedComponent = withAsyncRenderHOC(TestComponent);
+
+    const wrapper = render(<WrappedComponent text="Hello" />);
+
+    expect(wrapper.toJSON()).not.toBeNull();
+    expect(wrapper.getByText("Hello")).toBeDefined();
+  });
+
+  it("should call emitAsyncElementRegistrate on mount", () => {
+    const mockRegistrate = jest.fn();
+    const WrappedComponent = withAsyncRenderHOC(TestComponent);
+
+    render(<WrappedComponent emitAsyncElementRegistrate={mockRegistrate} />);
+
+    expect(mockRegistrate).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call emitAsyncElementLayout when onAsyncRender is called", () => {
+    const mockLayout = jest.fn();
+
+    const ComponentWithAsyncCall = ({
+      onAsyncRender,
+    }: {
+      onAsyncRender: () => void;
+    }) => {
+      return (
+        <View onLayout={onAsyncRender}>
+          <Text>Async Component</Text>
+        </View>
+      );
+    };
+
+    const WrappedComponent = withAsyncRenderHOC(ComponentWithAsyncCall);
+
+    const wrapper = render(
+      <WrappedComponent emitAsyncElementLayout={mockLayout} />
+    );
+
+    // Trigger onLayout
+    const view = wrapper.UNSAFE_getByType(View);
+    view.props.onLayout();
+
+    expect(mockLayout).toHaveBeenCalled();
+  });
+
+  it("should return unsubscribe function from emitAsyncElementRegistrate", () => {
+    const mockUnsubscribe = jest.fn();
+    const mockRegistrate = jest.fn(() => mockUnsubscribe);
+    const WrappedComponent = withAsyncRenderHOC(TestComponent);
+
+    const { unmount } = render(
+      <WrappedComponent emitAsyncElementRegistrate={mockRegistrate} />
+    );
+
+    expect(mockRegistrate).toHaveBeenCalledTimes(1);
+
+    // Unmount should trigger cleanup
+    unmount();
+
+    expect(mockUnsubscribe).toHaveBeenCalled();
+  });
+
+  it("should work without emitAsyncElementRegistrate prop", () => {
+    const WrappedComponent = withAsyncRenderHOC(TestComponent);
+
+    const wrapper = render(<WrappedComponent text="No Registration" />);
+
+    expect(wrapper.toJSON()).not.toBeNull();
+    expect(wrapper.getByText("No Registration")).toBeDefined();
+  });
+
+  it("should work without emitAsyncElementLayout prop", () => {
+    const ComponentWithLayout = ({
+      onAsyncRender,
+    }: {
+      onAsyncRender: () => void;
+    }) => {
+      return (
+        <View onLayout={onAsyncRender}>
+          <Text>Test Layout</Text>
+        </View>
+      );
+    };
+
+    const WrappedComponent = withAsyncRenderHOC(ComponentWithLayout);
+
+    const wrapper = render(<WrappedComponent />);
+
+    // Should not throw when calling onLayout without emitAsyncElementLayout
+    const view = wrapper.UNSAFE_getByType(View);
+    expect(() => view.props.onLayout()).not.toThrow();
+  });
+
+  it("should pass through all other props to wrapped component", () => {
+    const ComponentWithProps = ({
+      customProp,
+      anotherProp,
+    }: {
+      onAsyncRender: () => void;
+      customProp: string;
+      anotherProp: number;
+    }) => {
+      return (
+        <View>
+          <Text>{customProp}</Text>
+          <Text>{anotherProp}</Text>
+        </View>
+      );
+    };
+
+    const WrappedComponent = withAsyncRenderHOC(ComponentWithProps);
+
+    const wrapper = render(
+      <WrappedComponent customProp="custom value" anotherProp={42} />
+    );
+
+    expect(wrapper.getByText("custom value")).toBeDefined();
+    expect(wrapper.getByText("42")).toBeDefined();
+  });
+
+  it("should call emitAsyncElementLayout multiple times if onAsyncRender is called multiple times", () => {
+    const mockLayout = jest.fn();
+
+    const ComponentWithMultipleCalls = ({
+      onAsyncRender,
+    }: {
+      onAsyncRender: () => void;
+    }) => {
+      return (
+        <View>
+          <View onLayout={onAsyncRender} testID="view1">
+            <Text>First</Text>
+          </View>
+          <View onLayout={onAsyncRender} testID="view2">
+            <Text>Second</Text>
+          </View>
+        </View>
+      );
+    };
+
+    const WrappedComponent = withAsyncRenderHOC(ComponentWithMultipleCalls);
+
+    const wrapper = render(
+      <WrappedComponent emitAsyncElementLayout={mockLayout} />
+    );
+
+    // Trigger both onLayout callbacks
+    const view1 = wrapper.getByTestId("view1");
+    const view2 = wrapper.getByTestId("view2");
+
+    view1.props.onLayout();
+    view2.props.onLayout();
+
+    expect(mockLayout).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle components that use onAsyncRender in effects", () => {
+    const mockLayout = jest.fn();
+
+    const ComponentWithEffect = ({
+      onAsyncRender,
+    }: {
+      onAsyncRender: () => void;
+    }) => {
+      React.useEffect(() => {
+        // Simulate async operation completing
+        const timer = setTimeout(() => {
+          onAsyncRender();
+        }, 0);
+
+        return () => clearTimeout(timer);
+      }, [onAsyncRender]);
+
+      return (
+        <View>
+          <Text>Effect Component</Text>
+        </View>
+      );
+    };
+
+    const WrappedComponent = withAsyncRenderHOC(ComponentWithEffect);
+
+    render(<WrappedComponent emitAsyncElementLayout={mockLayout} />);
+
+    // The effect should have been triggered
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        expect(mockLayout).toHaveBeenCalled();
+        resolve(true);
+      }, 10);
+    });
+  });
+});

package/Components/MasterCell/hoc/withAsyncRender.tsx

@@ -6,12 +6,12 @@ type withAsyncRenderHOCProps = {
   emitAsyncElementLayout?: () => void;
 };
 
-type withAsyncRenderHOCT = (
-  Component: React.ComponentType<{ onAsyncRender: () => void }>
-) => React.FC<withAsyncRenderHOCProps>;
-
-export const withAsyncRenderHOC: withAsyncRenderHOCT = (Component) => {
-  const WithAsyncRender = (props: withAsyncRenderHOCProps) => {
+export const withAsyncRenderHOC = <P extends { onAsyncRender: () => void }>(
+  Component: React.ComponentType<P>
+): React.FC<Omit<P, "onAsyncRender"> & withAsyncRenderHOCProps> => {
+  const WithAsyncRender = (
+    props: Omit<P, "onAsyncRender"> & withAsyncRenderHOCProps
+  ) => {
     const { emitAsyncElementRegistrate = noop, emitAsyncElementLayout = noop } =
       props;
 
@@ -27,7 +27,9 @@ export const withAsyncRenderHOC: withAsyncRenderHOCT = (Component) => {
       }
     }, [emitAsyncElementLayout]);
 
-    return <Component {...props} onAsyncRender={onAsyncRender} />;
+    return (
+      <Component {...(props as unknown as P)} onAsyncRender={onAsyncRender} />
+    );
   };
 
   return WithAsyncRender;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-ui-components",
-  "version": "14.0.7",
+  "version": "14.0.8",
   "description": "Applicaster Zapp React Native ui components for the Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,10 +28,10 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "14.0.7",
-    "@applicaster/zapp-react-native-bridge": "14.0.7",
-    "@applicaster/zapp-react-native-redux": "14.0.7",
-    "@applicaster/zapp-react-native-utils": "14.0.7",
+    "@applicaster/applicaster-types": "14.0.8",
+    "@applicaster/zapp-react-native-bridge": "14.0.8",
+    "@applicaster/zapp-react-native-redux": "14.0.8",
+    "@applicaster/zapp-react-native-utils": "14.0.8",
     "fast-json-stable-stringify": "^2.1.0",
     "promise": "^8.3.0",
     "url": "^0.11.0",