@applicaster/zapp-react-native-ui-components 15.0.0-rc.13 → 15.0.0-rc.132

package/Contexts/ZappPipesContext/ZappPipesContextFactory.tsx

@@ -5,10 +5,10 @@ import React, {
   useMemo,
   useState,
 } from "react";
-import * as R from "ramda";
 
-type ProviderProps = {
+type ProviderProps<S> = {
   children: React.ReactChild;
+  initialContextValue?: S;
 };
 
 type ContextType<T> = {
@@ -27,21 +27,29 @@ export function createZappPipesContext<T, S = T>(
 ) {
   const Context = createContext<ContextType<S>>(initialContext);
 
-  const { selector = R.identity, prepareContext = R.identity } = options || {};
+  const defaultSelector = (c: any) => c;
+  const defaultPrepareContext = (n: any) => n;
+  const joinArgs = (args: any[]) => args.join("-");
+
+  const { selector = defaultSelector, prepareContext = defaultPrepareContext } =
+    options || {};
 
   function useZappPipesContext(...hookArgs: any[]): [T, (T) => void] {
     const { context, setContext } = useContext(Context);
+    const joinedArgs = joinArgs(hookArgs);
 
     const contextValue = useMemo(
       () => selector(context, ...hookArgs),
-      [context, R.join("-", hookArgs)]
+      // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+      [context, joinedArgs]
     );
 
     const contextSetter = useCallback(
       (newContext: T) => {
         setContext(prepareContext(newContext, context, ...hookArgs));
       },
-      [context, setContext, R.join("-", hookArgs)]
+      // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+      [context, joinedArgs]
     );
 
     return useMemo(
@@ -50,8 +58,11 @@ export function createZappPipesContext<T, S = T>(
     );
   }
 
-  function Provider({ children }: ProviderProps) {
-    const [context, setContext] = useState<S>(initialContext.context);
+  /** Provider accepts `initialContextValue` prop to set the initial context value */
+  function Provider({ children, initialContextValue }: ProviderProps<S>) {
+    const [context, setContext] = useState<S>(
+      initialContextValue ?? initialContext.context
+    );
 
     return (
       <Context.Provider value={{ context, setContext }}>

package/Contexts/index.ts

@@ -12,8 +12,6 @@ export { HorizontalScrollContext } from "./HorizontalScrollContext";
 
 export { RiverOffsetContext } from "./RiverOffsetContext";
 
-export { ZappHookModalContext } from "./ZappHookModalContext";
-
 export { MeasurementContext } from "./MeasurementContext";
 
 export * from "./ZappPipesContext";

package/Decorators/Analytics/index.tsx

@@ -1,7 +1,6 @@
 import React from "react";
 
 import { getAnalyticsFunctions } from "@applicaster/zapp-react-native-utils/analyticsUtils";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 type ComponentProps = {
   component: {
@@ -21,11 +20,13 @@ type ComponentProps = {
 
 function withAnalytics(Component) {
   return function WithAnalytics(props: ComponentProps) {
-    const { appData } = usePickFromState(["appData"]);
-
     const analyticsFunctions = React.useMemo(
-      () => getAnalyticsFunctions({ props, appData }),
-      [props, appData]
+      () =>
+        getAnalyticsFunctions({
+          component: props.component,
+          zappPipesData: props.zappPipesData,
+        } as any),
+      [props.component, props.zappPipesData]
     );
 
     return (

package/Decorators/ConfigurationWrapper/__tests__/__snapshots__/withConfigurationProvider.test.tsx.snap

@@ -88,6 +88,7 @@ exports[`withConfigurationProvider correctly passes all the configuration keys c
   tab_cell_padding_right={10}
   tab_cell_padding_top={14}
   tablet_theme={false}
+  tabs_screen_background_color="transparent"
   target={false}
   target_screen_switch={false}
   text_label_active_font_color="rgba(239, 239, 239, 0.5)"

package/Decorators/ConfigurationWrapper/const.ts

@@ -208,4 +208,5 @@ export const keysMap: Record<string, Function> = {
   tab_bar_item_margin_right: castOrDefaultValue(Number, 0),
   tab_bar_item_margin_bottom: castOrDefaultValue(Number, 0),
   tab_bar_item_margin_left: castOrDefaultValue(Number, 0),
+  tabs_screen_background_color: castOrDefaultValue(R.identity, "transparent"),
 };

package/Decorators/ZappPipesDataConnector/ResolverSelector.tsx

@@ -1,4 +1,3 @@
-// ResolverSelector.tsx
 import React from "react";
 import { ComponentDataSourceContext, ZappPipesDataProps } from "./types";
 import { StaticFeedResolver } from "./resolvers/StaticFeedResolver";
@@ -12,14 +11,33 @@ type ResolverSelectorProps = ComponentDataSourceContext & {
 export function ResolverSelector(props: ResolverSelectorProps) {
   const { getStaticComponentFeed, component, feedUrl, children } = props;
 
-  // Determine which resolver to use
+  const renderDefaultResolver = (
+    fallbackChildren: (dataProps: ZappPipesDataProps) => React.ReactNode
+  ) => {
+    if (feedUrl || component?.data?.source) {
+      return <UrlFeedResolver {...props}>{fallbackChildren}</UrlFeedResolver>;
+    }
+
+    return <NullFeedResolver>{fallbackChildren}</NullFeedResolver>;
+  };
+
   if (getStaticComponentFeed) {
-    return <StaticFeedResolver {...props}>{children}</StaticFeedResolver>;
-  }
+    return (
+      <StaticFeedResolver {...props}>
+        {(zappPipesDataProps) => {
+          const { data, loading, error } = zappPipesDataProps.zappPipesData;
+
+          const shouldFallback = !loading && data === null && !error;
+
+          if (shouldFallback) {
+            return renderDefaultResolver(children);
+          }
 
-  if (feedUrl || component?.data?.source) {
-    return <UrlFeedResolver {...props}>{children}</UrlFeedResolver>;
+          return children(zappPipesDataProps);
+        }}
+      </StaticFeedResolver>
+    );
   }
 
-  return <NullFeedResolver>{children}</NullFeedResolver>;
+  return renderDefaultResolver(children);
 }

package/Decorators/ZappPipesDataConnector/__tests__/ResolverSelector.test.tsx

@@ -7,15 +7,30 @@ import { UrlFeedResolver } from "../resolvers/UrlFeedResolver";
 import { NullFeedResolver } from "../resolvers/NullFeedResolver";
 
 jest.mock("../resolvers/StaticFeedResolver", () => ({
-  StaticFeedResolver: jest.fn(() => null),
+  StaticFeedResolver: jest.fn(({ children }) =>
+    children({
+      zappPipesData: { loading: true, data: null, error: null },
+      reloadData: jest.fn(),
+    })
+  ),
 }));
 
 jest.mock("../resolvers/UrlFeedResolver", () => ({
-  UrlFeedResolver: jest.fn(() => null),
+  UrlFeedResolver: jest.fn(({ children }) =>
+    children({
+      zappPipesData: { loading: true, data: null, error: null },
+      reloadData: jest.fn(),
+    })
+  ),
 }));
 
 jest.mock("../resolvers/NullFeedResolver", () => ({
-  NullFeedResolver: jest.fn(() => null),
+  NullFeedResolver: jest.fn(({ children }) =>
+    children({
+      zappPipesData: { loading: false, data: null, error: null },
+      reloadData: jest.fn(),
+    })
+  ),
 }));
 
 const testPlugin = {
@@ -52,7 +67,7 @@ describe("ResolverSelector", () => {
       expect.objectContaining({
         getStaticComponentFeed: props.getStaticComponentFeed,
         component: mockComponent,
-        children: mockChildren,
+        children: expect.any(Function),
       }),
       expect.anything()
     );
@@ -151,7 +166,10 @@ describe("ResolverSelector", () => {
     render(<ResolverSelector {...props} />);
 
     expect(StaticFeedResolver).toHaveBeenCalledWith(
-      expect.objectContaining(props),
+      expect.objectContaining({
+        ...props,
+        children: expect.any(Function),
+      }),
       expect.anything()
     );
   });
@@ -202,4 +220,193 @@ describe("ResolverSelector", () => {
     expect(UrlFeedResolver).not.toHaveBeenCalled();
     expect(NullFeedResolver).not.toHaveBeenCalled();
   });
+
+  describe("Fallback Logic", () => {
+    it("should fallback to UrlFeedResolver when StaticFeedResolver returns null and feedUrl is present", () => {
+      const props = {
+        getStaticComponentFeed: jest.fn(),
+        feedUrl: "https://example.com/feed",
+        component: mockComponent,
+        children: mockChildren,
+        riverId: "test-river",
+      };
+
+      (StaticFeedResolver as jest.Mock).mockImplementation(({ children }) =>
+        children({
+          zappPipesData: { loading: false, data: null, error: null },
+          reloadData: jest.fn(),
+        })
+      );
+
+      render(<ResolverSelector {...props} />);
+
+      expect(StaticFeedResolver).toHaveBeenCalled();
+
+      expect(UrlFeedResolver).toHaveBeenCalledWith(
+        expect.objectContaining({
+          feedUrl: props.feedUrl,
+          component: mockComponent,
+          children: mockChildren,
+        }),
+        expect.anything()
+      );
+    });
+
+    it("should fallback to UrlFeedResolver when StaticFeedResolver returns null and component.data.source is present", () => {
+      const componentWithSource = {
+        ...mockComponent,
+        data: {
+          source: "data-source",
+        },
+      };
+
+      const props = {
+        getStaticComponentFeed: jest.fn(),
+        component: componentWithSource,
+        children: mockChildren,
+        riverId: "test-river",
+      };
+
+      (StaticFeedResolver as jest.Mock).mockImplementation(({ children }) =>
+        children({
+          zappPipesData: { loading: false, data: null, error: null },
+          reloadData: jest.fn(),
+        })
+      );
+
+      render(<ResolverSelector {...props} />);
+
+      expect(StaticFeedResolver).toHaveBeenCalled();
+
+      expect(UrlFeedResolver).toHaveBeenCalledWith(
+        expect.objectContaining({
+          component: componentWithSource,
+          children: mockChildren,
+        }),
+        expect.anything()
+      );
+    });
+
+    it("should fallback to NullFeedResolver when StaticFeedResolver returns null and no feedUrl/source is present", () => {
+      const props = {
+        getStaticComponentFeed: jest.fn(),
+        component: mockComponent,
+        children: mockChildren,
+        riverId: "test-river",
+      };
+
+      (StaticFeedResolver as jest.Mock).mockImplementation(({ children }) =>
+        children({
+          zappPipesData: { loading: false, data: null, error: null },
+          reloadData: jest.fn(),
+        })
+      );
+
+      render(<ResolverSelector {...props} />);
+
+      expect(StaticFeedResolver).toHaveBeenCalled();
+      expect(UrlFeedResolver).not.toHaveBeenCalled();
+
+      expect(NullFeedResolver).toHaveBeenCalledWith(
+        expect.objectContaining({
+          children: mockChildren,
+        }),
+        expect.anything()
+      );
+    });
+
+    it("should NOT fallback and call children with static data when StaticFeedResolver returns data", () => {
+      const staticData = { entry: [{ id: "1" }] };
+
+      const props = {
+        getStaticComponentFeed: jest.fn(),
+        feedUrl: "https://example.com/feed",
+        component: mockComponent,
+        children: mockChildren,
+        riverId: "test-river",
+      };
+
+      (StaticFeedResolver as jest.Mock).mockImplementation(({ children }) =>
+        children({
+          zappPipesData: { loading: false, data: staticData, error: null },
+          reloadData: jest.fn(),
+        })
+      );
+
+      render(<ResolverSelector {...props} />);
+
+      expect(StaticFeedResolver).toHaveBeenCalled();
+      expect(UrlFeedResolver).not.toHaveBeenCalled();
+
+      expect(mockChildren).toHaveBeenCalledWith(
+        expect.objectContaining({
+          zappPipesData: expect.objectContaining({
+            data: staticData,
+          }),
+        })
+      );
+    });
+
+    it("should NOT fallback and call children with loading state when StaticFeedResolver is loading", () => {
+      const props = {
+        getStaticComponentFeed: jest.fn(),
+        feedUrl: "https://example.com/feed",
+        component: mockComponent,
+        children: mockChildren,
+        riverId: "test-river",
+      };
+
+      (StaticFeedResolver as jest.Mock).mockImplementation(({ children }) =>
+        children({
+          zappPipesData: { loading: true, data: null, error: null },
+          reloadData: jest.fn(),
+        })
+      );
+
+      render(<ResolverSelector {...props} />);
+
+      expect(StaticFeedResolver).toHaveBeenCalled();
+      expect(UrlFeedResolver).not.toHaveBeenCalled();
+
+      expect(mockChildren).toHaveBeenCalledWith(
+        expect.objectContaining({
+          zappPipesData: expect.objectContaining({
+            loading: true,
+          }),
+        })
+      );
+    });
+
+    it("should NOT fallback and call children with error when StaticFeedResolver returns error", () => {
+      const error = new Error("Static error");
+
+      const props = {
+        getStaticComponentFeed: jest.fn(),
+        feedUrl: "https://example.com/feed",
+        component: mockComponent,
+        children: mockChildren,
+        riverId: "test-river",
+      };
+
+      (StaticFeedResolver as jest.Mock).mockImplementation(({ children }) =>
+        children({
+          zappPipesData: { loading: false, data: null, error },
+          reloadData: jest.fn(),
+        })
+      );
+
+      render(<ResolverSelector {...props} />);
+
+      expect(StaticFeedResolver).toHaveBeenCalled();
+      expect(UrlFeedResolver).not.toHaveBeenCalled();
+
+      expect(mockChildren).toHaveBeenCalledWith(
+        expect.objectContaining({
+          zappPipesData: expect.objectContaining({
+            error,
+          }),
+        })
+      );
+    });
+  });
 });

package/Decorators/ZappPipesDataConnector/__tests__/UrlFeedResolver.test.tsx

@@ -1,6 +1,5 @@
 import React from "react";
 import * as useFeedLoaderModule from "@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedLoader";
-import * as useFeedRefreshModule from "@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedRefresh";
 import { favoritesListener } from "@applicaster/zapp-react-native-bridge/Favorites";
 import { UrlFeedResolver } from "../resolvers/UrlFeedResolver";
 import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
@@ -14,10 +13,6 @@ jest
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedLoader");
 
-jest.mock(
-  "@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedRefresh"
-);
-
 jest.mock("@applicaster/zapp-pipes-v2-client");
 
 jest.mock("@applicaster/zapp-react-native-bridge/Favorites", () => ({
@@ -62,6 +57,9 @@ describe("UrlFeedResolver", () => {
       component: { ...componentRequiredKeys } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -82,6 +80,9 @@ describe("UrlFeedResolver", () => {
       } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -103,6 +104,9 @@ describe("UrlFeedResolver", () => {
       } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -132,6 +136,9 @@ describe("UrlFeedResolver", () => {
       } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -155,6 +162,9 @@ describe("UrlFeedResolver", () => {
       children: mockChildren,
       riverId: "test-river",
       plugins: [],
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -173,6 +183,9 @@ describe("UrlFeedResolver", () => {
       component: { ...componentRequiredKeys } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -197,6 +210,9 @@ describe("UrlFeedResolver", () => {
           },
         },
       ] as any,
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -215,6 +231,9 @@ describe("UrlFeedResolver", () => {
       } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     (useFeedLoaderModule.useFeedLoader as jest.Mock).mockReturnValue({
@@ -250,6 +269,9 @@ describe("UrlFeedResolver", () => {
       children: mockChildren,
       riverId: "test-river",
       isLast: true,
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props1} />);
@@ -272,6 +294,9 @@ describe("UrlFeedResolver", () => {
       children: mockChildren,
       riverId: "test-river",
       isLast: false,
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props2} />);
@@ -294,6 +319,9 @@ describe("UrlFeedResolver", () => {
       children: mockChildren,
       riverId: "test-river",
       isLast: false,
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props3} />);
@@ -311,6 +339,9 @@ describe("UrlFeedResolver", () => {
       component: { ...componentRequiredKeys } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     renderWithProviders(<UrlFeedResolver {...props} />);
@@ -327,22 +358,6 @@ describe("UrlFeedResolver", () => {
     });
   });
 
-  it("should apply feed refresh hook", () => {
-    const props = {
-      feedUrl: "https://example.com/feed",
-      component: { ...componentRequiredKeys } as any,
-      children: mockChildren,
-      riverId: "test-river",
-    };
-
-    renderWithProviders(<UrlFeedResolver {...props} />);
-
-    expect(useFeedRefreshModule.useFeedRefresh).toHaveBeenCalledWith({
-      reloadData: mockReloadData,
-      component: props.component,
-    });
-  });
-
   it("should clean up listeners on unmount", () => {
     const props = {
       component: {
@@ -354,6 +369,9 @@ describe("UrlFeedResolver", () => {
       } as any,
       children: mockChildren,
       riverId: "test-river",
+      screenContext: {
+        id: "screenId",
+      },
     };
 
     const { unmount } = renderWithProviders(<UrlFeedResolver {...props} />);

package/Decorators/ZappPipesDataConnector/__tests__/zappPipesDataConnector.test.js

@@ -3,7 +3,7 @@ import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUt
 
 import * as zappPipesRedux from "@applicaster/zapp-react-native-redux/ZappPipes";
 import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
+import { thunk } from "redux-thunk";
 
 import { zappPipesDataConnector } from "../index";
 

package/Decorators/ZappPipesDataConnector/index.tsx

@@ -2,7 +2,7 @@
 /// <reference types="@applicaster/zapp-react-native-ui-components" />
 import React from "react";
 import { useRoute } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
 import { ZappPipesSearchContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import { useScreenContext } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext";
 import { ResolverSelector } from "./ResolverSelector";
@@ -23,7 +23,7 @@ export function zappPipesDataConnector(
 ) {
   return function WrappedWithZappPipesData(props: Props) {
     const { screenData } = useRoute();
-    const { plugins } = usePickFromState(["plugins"]);
+    const plugins = usePlugins();
     const screenContextData = useScreenContext();
 
     const {

package/Decorators/ZappPipesDataConnector/resolvers/StaticFeedResolver.tsx

@@ -76,7 +76,7 @@ export function StaticFeedResolver({
 
   const zappPipesDataProps = useMemo(
     () => ({
-      zappPipesData: { url, loading, data, error },
+      zappPipesData: { url, loading, data, error }, // todo: add applyItemLimit
       reloadData,
       loadNextData: undefined, // Static resolver doesn't support pagination
     }),

package/Decorators/ZappPipesDataConnector/resolvers/UrlFeedResolver.tsx

@@ -9,9 +9,9 @@ import {
   getInflatedDataSourceUrl,
   getSearchContext,
   useFeedLoader,
-  useFeedRefresh,
   useRoute,
 } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { refreshCoordinator } from "@applicaster/zapp-react-native-utils/refreshUtils/RefreshCoordinator";
 
 import { ComponentDataSourceContext, ZappPipesDataProps } from "../types";
 import { useScreenStateStore } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useScreenStateStore";
@@ -199,6 +199,8 @@ export function UrlFeedResolver({
   const { pathname } = useRoute();
   const screenStateStore = useScreenStateStore();
 
+  const screenId = (screenContext?.id || "unknown_screen_id") as string;
+
   // Setup listeners for data source URL
   useEffect(() => {
     if (!reloadData) {
@@ -214,10 +216,19 @@ export function UrlFeedResolver({
         url: dataSourceUrl,
         pathname,
         screenStateStore,
+        component,
+        screenId,
         callback: reloadData,
       });
     }
-  }, [dataSourceUrl, reloadData, pathname, screenStateStore]);
+  }, [
+    dataSourceUrl,
+    reloadData,
+    pathname,
+    screenStateStore,
+    component,
+    screenId,
+  ]);
 
   // Setup favorites listener
   useEffect(() => {
@@ -230,11 +241,11 @@ export function UrlFeedResolver({
     }
   }, [type, reloadData]);
 
-  // Apply feed refresh hook
-  useFeedRefresh({
-    reloadData,
-    component,
-  });
+  useEffect(() => {
+    const unregister = refreshCoordinator.register(component, screenId);
+
+    return () => unregister();
+  }, [component, screenId]);
 
   const loadNextData = useMemo(
     () => (!isLast && isVerticalListOrGrid(component) ? undefined : loadNext),