@applicaster/zapp-react-native-ui-components 15.0.0-rc.11 → 15.0.0-rc.111

package/Contexts/ZappHookModalContext/index.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback } from "react";
+import { create } from "zustand";
 
 type HookModalState = {
   path: string;
@@ -10,11 +10,12 @@ export type HookModalContextT = {
   setIsHooksExecutionInProgress: (hookExecutionState?: boolean) => void;
   isRunningInBackground: boolean;
   isPresentationFullScreen: boolean;
-  setIsRunningInBackground: (hookBackgroundProcessState?: boolean) => void;
-  setIsPresentingFullScreen: (hookBackgroundProcessState?: boolean) => void;
+  setIsRunningInBackground: () => void;
+  setIsPresentingFullScreen: () => void;
   state: HookModalState;
   setState: (state: HookModalState) => void;
   resetState: () => void;
+  hookPresentationMode: HookPresentationMode;
 };
 
 const initialState = {
@@ -24,68 +25,43 @@ const initialState = {
 
 type HookPresentationMode = "background" | "fullScreen";
 
-const ReactContext = React.createContext<HookModalContextT>({
-  isHooksExecutionInProgress: false,
-  setIsHooksExecutionInProgress: () => {},
-  isRunningInBackground: null,
-  setIsRunningInBackground: () => {},
-  setIsPresentingFullScreen: () => {},
-  isPresentationFullScreen: null,
+// Use useZappHookModalStore() in React components (hooks)
+// Use zappHookModalStore.getState() in non-React functions (utility functions, etc.)
+export const useZappHookModalStore = create<HookModalContextT>()((set) => ({
   state: initialState,
-  setState: () => null,
-  resetState: () => null,
-});
-
-const Provider = ({ children }: { children: React.ReactNode }) => {
-  const [state, setState] = React.useState<HookModalState>(initialState);
-
-  const [hookPresentationMode, setHookPresentationMode] =
-    React.useState<HookPresentationMode>(null);
-
-  const resetState = useCallback(() => {
-    setState(initialState);
-  }, [setState]);
-
-  const [isHooksExecutionInProgress, setIsHooksExecutionInProgress] =
-    React.useState(false);
+  isHooksExecutionInProgress: false,
+  hookPresentationMode: null as HookPresentationMode,
+  isRunningInBackground: false,
+  isPresentationFullScreen: false,
 
-  const setIsRunningInBackground = () => {
-    setHookPresentationMode("background");
-  };
+  setState: (newState: HookModalState) => {
+    set({ state: newState });
+  },
 
-  const setIsPresentingFullScreen = () => {
-    setHookPresentationMode("fullScreen");
-  };
+  setIsHooksExecutionInProgress: (hookExecutionState?: boolean) => {
+    set({ isHooksExecutionInProgress: hookExecutionState ?? false });
+  },
 
-  return (
-    <ReactContext.Provider
-      value={{
-        isRunningInBackground: hookPresentationMode === "background",
-        setIsRunningInBackground,
-        setIsPresentingFullScreen,
-        isPresentationFullScreen: hookPresentationMode === "fullScreen",
-        isHooksExecutionInProgress,
-        setIsHooksExecutionInProgress,
-        state,
-        setState,
-        resetState,
-      }}
-    >
-      {children}
-    </ReactContext.Provider>
-  );
-};
+  setIsRunningInBackground: () => {
+    set({
+      hookPresentationMode: "background",
+      isRunningInBackground: true,
+      isPresentationFullScreen: false,
+    });
+  },
 
-const withProvider = (Component) => {
-  const WithProvider = (props) => {
-    return (
-      <Provider>
-        <Component {...props} />
-      </Provider>
-    );
-  };
+  setIsPresentingFullScreen: () => {
+    set({
+      hookPresentationMode: "fullScreen",
+      isRunningInBackground: false,
+      isPresentationFullScreen: true,
+    });
+  },
 
-  return WithProvider;
-};
+  resetState: () => {
+    set({ state: initialState });
+  },
+}));
 
-export const ZappHookModalContext = { withProvider, ReactContext };
+// Export an alias for clearer non-React usage (utility functions, etc.)
+export const zappHookModalStore = useZappHookModalStore;

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} />);