@applicaster/zapp-react-native-utils 16.0.0-alpha.3112220329 → 16.0.0-alpha.3202041045

package/reactHooks/cell-click/index.ts

@@ -83,6 +83,12 @@ export const useCellClick = ({
 
       logOnPress(selectedItem, pathname, component, onCellTap);
 
+      const tapActions = selectedItem?.extensions?.tap_actions?.actions;
+
+      const finishesHook =
+        Array.isArray(tapActions) &&
+        tapActions.some((action) => action?.type === "finishHook");
+
       if (selectedItem) {
         await actionExecutor?.handleEntryActions(selectedItem, {
           component,
@@ -101,20 +107,21 @@ export const useCellClick = ({
             url: selectedItem.link.href,
           });
         }
-      } else {
-        if (isFunction(onCellTap)) {
-          onCellTap?.(selectedItem, _index);
-        } else {
-          if (currentRoute === pathname || pathname.includes("video-modal")) {
-            const targetScreen = component?.data?.target;
-
-            push(
-              R.when(
-                () => targetScreen,
-                R.mergeLeft({ screen_type: targetScreen })
-              )(selectedItem)
-            );
-          }
+      } else if (isFunction(onCellTap)) {
+        onCellTap?.(selectedItem, _index);
+      } else if (!finishesHook) {
+        // finishHook already completes the hook and navigates to the original
+        // target. Pushing the cell as well stacks a second copy of that screen
+        // (e.g. home/home after a profile selector hook).
+        if (currentRoute === pathname || pathname.includes("video-modal")) {
+          const targetScreen = component?.data?.target;
+
+          push(
+            R.when(
+              () => targetScreen,
+              R.mergeLeft({ screen_type: targetScreen })
+            )(selectedItem)
+          );
         }
       }
     },

package/reactHooks/connection/index.tsx

@@ -4,6 +4,11 @@ import { NetInfoState } from "@react-native-community/netinfo";
 import { NetworkStatusContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NetworkStatusContext";
 import { isOnline } from "@applicaster/quick-brick-core/App/NetworkStatusProvider/utils";
 
+type ConnectionInfo = NetInfoState & {
+  deviceStatus: NetStatus;
+  stillOfflineAfterResumeCount?: number;
+};
+
 /**
  * This hook returns connection type from RN NetInfo component or boolean for iConnected if justOnlineStatus flag is set
  * @param {boolean} justOnlineStatus - flag if to return boolean for isConnected
@@ -12,16 +17,14 @@ import { isOnline } from "@applicaster/quick-brick-core/App/NetworkStatusProvide
 
 export function useConnectionInfo(justOnlineStatus: true): boolean;
 
-export function useConnectionInfo(
-  justOnlineStatus: false
-): NetInfoState & { deviceStatus: NetStatus };
+export function useConnectionInfo(justOnlineStatus: false): ConnectionInfo;
 
 export function useConnectionInfo(
   justOnlineStatus: boolean
-): boolean | (NetInfoState & { deviceStatus: NetStatus }) {
+): boolean | ConnectionInfo {
   const connectionInfo = React.useContext(
     NetworkStatusContext
-  ) as NetInfoState & { deviceStatus: NetStatus };
+  ) as ConnectionInfo;
 
   return justOnlineStatus ? isOnline(connectionInfo) === true : connectionInfo;
 }

package/reactHooks/feed/__tests__/useMarkPipesDataStale.test.tsx

@@ -0,0 +1,243 @@
+import { renderHook } from "@testing-library/react-native";
+import * as zappPipesModule from "@applicaster/zapp-react-native-redux/ZappPipes";
+import * as useRouteHook from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useRoute";
+import * as useNavigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
+import * as useIsScreenActiveHook from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive";
+import { refreshCoordinator } from "../../../refreshUtils/RefreshCoordinator";
+import { useMarkPipesDataStale } from "../useMarkPipesDataStale";
+
+const mockDispatch = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux", () => ({
+  ...jest.requireActual("@applicaster/zapp-react-native-redux"),
+  useAppDispatch: () => mockDispatch,
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/getDatasourceUrl",
+  () => ({
+    getDatasourceUrl: jest.fn(
+      (_ctx, component) => component?.data?.source || null
+    ),
+  })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/usePipesContexts",
+  () => ({
+    usePipesContexts: jest.fn(() => ({})),
+  })
+);
+
+describe("useMarkPipesDataStale", () => {
+  let mockNavigator: any;
+  let mockRoute: any;
+  let mockIsActive: boolean;
+
+  const riverId = "river-123";
+
+  const refreshableComponent: any = {
+    id: "comp-1",
+    rules: { clear_cache_on_reload: true },
+    data: { source: "https://feed.example.com/data1" },
+  };
+
+  const stringBooleanComponent: any = {
+    id: "comp-2",
+    rules: { clear_cache_on_reload: "true" },
+    data: { source: "https://feed.example.com/data2" },
+  };
+
+  const nonRefreshableComponent: any = {
+    id: "comp-3",
+    rules: { clear_cache_on_reload: false },
+    data: { source: "https://feed.example.com/data3" },
+  };
+
+  const noSourceComponent: any = {
+    id: "comp-4",
+    rules: { clear_cache_on_reload: true },
+  };
+
+  const allComponents = [
+    refreshableComponent,
+    stringBooleanComponent,
+    nonRefreshableComponent,
+    noSourceComponent,
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockIsActive = true;
+
+    mockNavigator = {
+      currentRoute: "river/river-123",
+    };
+
+    mockRoute = {
+      pathname: "river/river-123",
+      screenData: { id: riverId },
+    };
+
+    jest
+      .spyOn(useNavigationHooks, "useNavigation")
+      .mockImplementation(() => mockNavigator);
+
+    jest.spyOn(useRouteHook, "useRoute").mockImplementation(() => mockRoute);
+
+    jest
+      .spyOn(useIsScreenActiveHook, "useIsScreenActive")
+      .mockImplementation(() => mockIsActive);
+
+    jest
+      .spyOn(refreshCoordinator, "triggerRefresh")
+      .mockImplementation(jest.fn());
+
+    jest
+      .spyOn(zappPipesModule, "markPipesDataStale")
+      .mockImplementation(
+        (url, opts) => ({ type: "MARK_STALE", url, opts }) as any
+      );
+  });
+
+  describe("on unmount", () => {
+    it("marks clear_cache_on_reload feeds stale on unmount", () => {
+      const { unmount } = renderHook(() =>
+        useMarkPipesDataStale(riverId, allComponents)
+      );
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+
+      unmount();
+
+      expect(zappPipesModule.markPipesDataStale).toHaveBeenCalledWith(
+        "https://feed.example.com/data1",
+        { riverId }
+      );
+
+      expect(zappPipesModule.markPipesDataStale).toHaveBeenCalledWith(
+        "https://feed.example.com/data2",
+        { riverId }
+      );
+
+      expect(zappPipesModule.markPipesDataStale).not.toHaveBeenCalledWith(
+        "https://feed.example.com/data3",
+        expect.anything()
+      );
+
+      expect(mockDispatch).toHaveBeenCalledTimes(2);
+    });
+
+    it("does not mark stale on unmount if pathname includes videoModal", () => {
+      mockRoute.pathname = "videoModal/item-123";
+
+      const { unmount } = renderHook(() =>
+        useMarkPipesDataStale(riverId, allComponents)
+      );
+
+      unmount();
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("on screen return (screen not unmounted in Transitioner)", () => {
+    it("does not trigger refresh on initial mount", () => {
+      renderHook(() => useMarkPipesDataStale(riverId, allComponents));
+
+      expect(refreshCoordinator.triggerRefresh).not.toHaveBeenCalled();
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it("triggers refresh and marks stale when returning from a deeper screen", () => {
+      const { rerender } = renderHook(() =>
+        useMarkPipesDataStale(riverId, allComponents)
+      );
+
+      // 1. User navigates away to a deeper screen
+      mockNavigator.currentRoute = "river/deeper-screen";
+      mockIsActive = false;
+      rerender({});
+
+      expect(refreshCoordinator.triggerRefresh).not.toHaveBeenCalled();
+      expect(mockDispatch).not.toHaveBeenCalled();
+
+      // 2. User presses back and returns to original screen
+      mockNavigator.currentRoute = "river/river-123";
+      mockIsActive = true;
+      rerender({});
+
+      expect(refreshCoordinator.triggerRefresh).toHaveBeenCalledTimes(1);
+
+      expect(refreshCoordinator.triggerRefresh).toHaveBeenCalledWith(
+        [refreshableComponent, stringBooleanComponent],
+        riverId
+      );
+
+      expect(zappPipesModule.markPipesDataStale).toHaveBeenCalledWith(
+        "https://feed.example.com/data1",
+        { riverId }
+      );
+
+      expect(zappPipesModule.markPipesDataStale).toHaveBeenCalledWith(
+        "https://feed.example.com/data2",
+        { riverId }
+      );
+
+      expect(mockDispatch).toHaveBeenCalledTimes(2);
+    });
+
+    it("does not trigger duplicate refreshes on subsequent re-renders on the same screen", () => {
+      const { rerender } = renderHook(() =>
+        useMarkPipesDataStale(riverId, allComponents)
+      );
+
+      // Navigate away
+      mockNavigator.currentRoute = "river/deeper-screen";
+      mockIsActive = false;
+      rerender({});
+
+      // Return
+      mockNavigator.currentRoute = "river/river-123";
+      mockIsActive = true;
+      rerender({});
+
+      expect(refreshCoordinator.triggerRefresh).toHaveBeenCalledTimes(1);
+
+      // Subsequent re-render without navigation
+      rerender({});
+      rerender({});
+
+      expect(refreshCoordinator.triggerRefresh).toHaveBeenCalledTimes(1);
+    });
+
+    it("triggers refresh again if user navigates away a second time and returns", () => {
+      const { rerender } = renderHook(() =>
+        useMarkPipesDataStale(riverId, allComponents)
+      );
+
+      // First trip: navigate away and return
+      mockNavigator.currentRoute = "river/screen-2";
+      mockIsActive = false;
+      rerender({});
+
+      mockNavigator.currentRoute = "river/river-123";
+      mockIsActive = true;
+      rerender({});
+
+      expect(refreshCoordinator.triggerRefresh).toHaveBeenCalledTimes(1);
+
+      // Second trip: navigate away to another screen and return
+      mockNavigator.currentRoute = "river/screen-3";
+      mockIsActive = false;
+      rerender({});
+
+      mockNavigator.currentRoute = "river/river-123";
+      mockIsActive = true;
+      rerender({});
+
+      expect(refreshCoordinator.triggerRefresh).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/reactHooks/feed/useMarkPipesDataStale.ts

@@ -3,46 +3,91 @@ import React from "react";
 import { getDatasourceUrl } from "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/getDatasourceUrl";
 import { usePipesContexts } from "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/usePipesContexts";
 import { markPipesDataStale } from "@applicaster/zapp-react-native-redux/ZappPipes";
-
-import { useRoute } from "../navigation";
 import { useAppDispatch } from "@applicaster/zapp-react-native-redux";
+import { isTrue } from "../../booleanUtils";
+import { refreshCoordinator } from "../../refreshUtils/RefreshCoordinator";
+import { useNavigation, useRoute } from "../navigation";
+import { usePrevious } from "../utils";
+
+const getRefreshableComponents = (components: ZappUIComponent[]) =>
+  components?.filter(
+    (c) => isTrue(c?.rules?.clear_cache_on_reload) && c?.data?.source
+  ) || [];
 
 /**
  * Mark a river's `clear_cache_on_reload` feeds as stale when the screen is
  * unmounted. The cached data is kept (so a screen sharing the same feed does
  * not lose it mid-mount) and revalidated on next access.
+ *
+ * Also triggers refresh for mounted components and marks feeds stale when
+ * returning back to this screen from a deeper route in the Transitioner
+ * (where the screen was kept mounted in the background).
+ *
  * @param {string} riverId screen id
  * @param {Array} riverComponents list of UI components
  */
-export const useMarkPipesDataStale = (riverId, riverComponents) => {
+export const useMarkPipesDataStale = (
+  riverId: string,
+  riverComponents: ZappUIComponent[]
+) => {
   const dispatch = useAppDispatch();
   const { screenData, pathname } = useRoute();
   const pipesContexts = usePipesContexts(riverId, pathname);
+  const { currentRoute } = useNavigation();
+  const prevRoute = usePrevious(currentRoute);
 
-  React.useEffect(() => {
-    return () => {
-      riverComponents.forEach((component) => {
-        if (
-          component?.rules?.clear_cache_on_reload &&
-          component?.data?.source &&
-          // We don't want to refresh cache when closing/minimising videoModal
-          !pathname.includes("videoModal")
-        ) {
-          const url = getDatasourceUrl(
-            {
-              screenData,
-              ...pipesContexts,
-            },
-            component
-          );
-
-          if (url) {
-            dispatch(markPipesDataStale(url, { riverId }));
-          }
+  const isBackToScreen = Boolean(
+    prevRoute && prevRoute !== currentRoute && currentRoute === pathname
+  );
+
+  const invalidateComponents = React.useCallback(
+    (components: ZappUIComponent[]) => {
+      components.forEach((component) => {
+        const url = getDatasourceUrl(
+          { screenData, ...pipesContexts },
+          component
+        );
+
+        if (url) {
+          dispatch(markPipesDataStale(url, { riverId }));
         }
       });
+    },
+    [dispatch, screenData, pipesContexts, riverId]
+  );
+
+  // Stale invalidation on unmount (existing behavior)
+  /* eslint-disable @wogns3623/better-exhaustive-deps/exhaustive-deps */
+  React.useEffect(() => {
+    return () => {
+      if (pathname?.includes("videoModal")) return;
+
+      invalidateComponents(getRefreshableComponents(riverComponents));
     };
   }, []);
+  /* eslint-enable @wogns3623/better-exhaustive-deps/exhaustive-deps */
+
+  // Reload when returning back to this screen from another screen
+  React.useEffect(() => {
+    if (!isBackToScreen || pathname?.includes("videoModal")) {
+      return;
+    }
+
+    const refreshable = getRefreshableComponents(riverComponents);
+
+    if (refreshable.length === 0) {
+      return;
+    }
+
+    invalidateComponents(refreshable);
+    refreshCoordinator.triggerRefresh(refreshable, riverId);
+  }, [
+    isBackToScreen,
+    pathname,
+    riverComponents,
+    riverId,
+    invalidateComponents,
+  ]);
 };
 
 /**

package/reactHooks/navigation/__tests__/index.test.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import { PathnameContext } from "@applicaster/zapp-react-native-ui-components/Contexts/PathnameContext";
-import { renderHook } from "@testing-library/react-native";
+import { act, render, renderHook } from "@testing-library/react-native";
 import { isNavBarVisible, useRoute } from "../";
 import { Provider } from "react-redux";
 import configureMockStore from "redux-mock-store";
@@ -181,6 +181,45 @@ const hookModalWrapper = ({ children }) => (
   </Provider>
 );
 
+// Reports every render of useRoute so the tests below can assert on route
+// transitions and on subscription behaviour, not just on a one-shot result.
+function RouteProbe({ onRender }: { onRender: (route: any) => void }) {
+  onRender(useRoute());
+
+  return null;
+}
+
+const openRiverModal = () =>
+  act(() => {
+    modalStore.getState().openModal({
+      item: rivers["river-general"] as any,
+      props: { entry: modalEntry },
+    });
+  });
+
+const renderRouteProbe = (pathname: string, onRender: (route: any) => void) => {
+  const tree = (currentPathname: string) => (
+    <Provider store={store}>
+      <ScreenDataContext.Provider value={homeStack.state}>
+        <NavigationContext.Provider value={videoModalNavigator}>
+          <PathnameContext.Provider value={currentPathname}>
+            <RouteProbe onRender={onRender} />
+          </PathnameContext.Provider>
+        </NavigationContext.Provider>
+      </ScreenDataContext.Provider>
+    </Provider>
+  );
+
+  const { rerender } = render(tree(pathname));
+
+  return {
+    navigateTo: (nextPathname: string) =>
+      act(() => {
+        rerender(tree(nextPathname));
+      }),
+  };
+};
+
 describe("navigation", () => {
   describe("useRoute", () => {
     describe("Main stack components", () => {
@@ -279,6 +318,94 @@ describe("navigation", () => {
         );
       });
     });
+
+    describe("store subscriptions", () => {
+      afterEach(() => {
+        act(() => {
+          modalStore.getState().dismissModal();
+        });
+      });
+
+      // Every hook in useRoute must run on every render. When the modal and
+      // hook-modal subscriptions lived inside the route branches, walking a
+      // single mounted component through the route types changed the hook
+      // count and React threw "Rendered more hooks than during the previous
+      // render".
+      it("keeps a stable hook order when the route type changes", () => {
+        let route: any;
+
+        const { navigateTo } = renderRouteProbe(homeStack.route, (current) => {
+          route = current;
+        });
+
+        expect(route.screenData.id).toEqual(entry.id);
+        expect(route.screenData.targetScreen.id).toEqual(screen.id);
+
+        openRiverModal();
+        navigateTo(modalPathname);
+
+        expect(route.pathname).toEqual(modalPathname);
+        expect(route.screenData.id).toEqual(modalEntry.id);
+
+        expect(route.screenData.targetScreen.id).toEqual(
+          rivers["river-general"].id
+        );
+
+        navigateTo(hooksModalPathname);
+
+        expect(route.pathname).toEqual(hooksModalPathname);
+
+        expect(route.screenData.id).toEqual(
+          hookModalContextState.state.screenData.payload.id
+        );
+
+        navigateTo(videoModalPathname);
+
+        expect(route.pathname).toEqual(videoModalPathname);
+        expect(route.screenData.id).toEqual(videoItem.id);
+
+        expect(route.screenData.targetScreen.id).toEqual(
+          rivers["river-player"].id
+        );
+
+        navigateTo(homeStack.route);
+
+        expect(route.pathname).toEqual(homeStack.route);
+        expect(route.screenData.id).toEqual(entry.id);
+      });
+
+      it("does not re-render a non-modal route when modal state changes", () => {
+        let renders = 0;
+
+        renderRouteProbe(homeStack.route, () => {
+          renders += 1;
+        });
+
+        const rendersBeforeOpen = renders;
+
+        openRiverModal();
+
+        expect(renders).toBe(rendersBeforeOpen);
+      });
+
+      it("re-renders a modal route when modal state changes", () => {
+        let route: any;
+
+        renderRouteProbe(modalPathname, (current) => {
+          route = current;
+        });
+
+        expect(route.screenData).toEqual({});
+
+        openRiverModal();
+
+        expect(route.screenData.id).toEqual(modalEntry.id);
+
+        expect(route.screenData.targetScreen.id).toEqual(
+          rivers["river-general"].id
+        );
+      });
+    });
   });
 
   describe("isNavBarVisible", () => {

package/reactHooks/navigation/useRoute.ts

@@ -50,14 +50,18 @@ export const useRoute = (
   const rivers = useRivers();
   const contentTypes = useContentTypes();
 
-  const modalState = useModalStoreState();
-
-  const modalScreenData = modalState.screen;
-
+  // useRoute runs in every cell, so both modal stores are subscribed to only on
+  // the routes that actually read them. Off those routes the selectors return a
+  // stable reference, which keeps an unrelated modal opening or closing from
+  // re-rendering the whole tree.
   const hookModalScreenData = useHookModalScreenData(
     !isHookModalPathname(pathname)
   );
 
+  const modalState = useModalStoreState(!isModalPathname(pathname));
+
+  const modalScreenData = modalState.screen;
+
   const videoModalScreenData =
     navigator?.videoModalState?.item &&
     legacyScreenData(