@applicaster/zapp-react-native-utils 14.0.0-alpha.2175196485 → 14.0.0-alpha.2292190333

package/focusManager/aux/index.ts

@@ -0,0 +1,170 @@
+import {
+  isNil,
+  startsWith,
+  find,
+  pathOr,
+} from "@applicaster/zapp-react-native-utils/utils";
+
+import {
+  QUICK_BRICK_CONTENT,
+  QUICK_BRICK_NAVBAR,
+} from "@applicaster/quick-brick-core/const";
+
+const isNavBar = (node) => startsWith(QUICK_BRICK_NAVBAR, node?.id);
+const isContent = (node) => startsWith(QUICK_BRICK_CONTENT, node?.id);
+
+// FIXME
+const sectionIds = {
+  right: "nav-bar-right",
+  menu: "navbar-items",
+  left: "nav-bar-left",
+};
+
+// SCREEN_PICKER_SELECTOR_CONTAINER
+let screenPickerSelectorContainerId;
+
+export const onRegisterScreenPickerSelectorContainer = (id) => {
+  screenPickerSelectorContainerId = id;
+};
+
+export const onUnRegisterScreenPickerSelectorContainer = (id) => {
+  // reset screenSelectorId on unregistration
+  if (screenPickerSelectorContainerId === id) {
+    screenPickerSelectorContainerId = undefined;
+  }
+};
+// SCREEN_PICKER_SELECTOR_CONTAINER
+
+// SCREEN_PICKER_CONTENT_CONTAINER
+let screenPickerContentContainerId;
+
+export const onRegisterScreenPickerContentContainer = (id) => {
+  screenPickerContentContainerId = id;
+};
+
+export const onUnRegisterScreenPickerContentContainer = (id) => {
+  // reset screenSelectorId on unregistration
+  if (screenPickerContentContainerId === id) {
+    screenPickerContentContainerId = undefined;
+  }
+};
+
+const isScreenPickerContentContainer = (node) =>
+  screenPickerContentContainerId === node?.id;
+
+// SCREEN_PICKER_CONTENT_CONTAINER
+
+const findSelectedMenuIdInSection = (focusableTree, section) => {
+  const children = pathOr([], ["children"], focusableTree.find(section));
+
+  return find((child) => child.component.current.props.isSelected(), children)
+    ?.id;
+};
+
+export const findSelectedMenuId = (focusableTree) => {
+  const selectedMenuItemIdInLeftSection = findSelectedMenuIdInSection(
+    focusableTree,
+    sectionIds.left
+  );
+
+  if (selectedMenuItemIdInLeftSection) {
+    return selectedMenuItemIdInLeftSection;
+  }
+
+  const selectedMenuItemIdInMenuSection = findSelectedMenuIdInSection(
+    focusableTree,
+    sectionIds.menu
+  );
+
+  if (selectedMenuItemIdInMenuSection) {
+    return selectedMenuItemIdInMenuSection;
+  }
+
+  const selectedMenuItemIdInRightSection = findSelectedMenuIdInSection(
+    focusableTree,
+    sectionIds.right
+  );
+
+  if (selectedMenuItemIdInRightSection) {
+    return selectedMenuItemIdInRightSection;
+  }
+
+  return undefined;
+};
+
+export const findSelectedTabId = (focusableTree, item: ZappEntry): string => {
+  const screenSelectorContainerNode = focusableTree.find(
+    screenPickerSelectorContainerId
+  );
+
+  // console.log("debug_2", "findSelectedTabId", {
+  //   focusableTree,
+  //   item,
+  //   screenSelectorContainerNode,
+  // });
+
+  const selectedTabId = find(
+    (child) => child.component.current.props.isSelected(item.id),
+    screenSelectorContainerNode.children
+  )?.id;
+
+  return selectedTabId;
+};
+
+export const isTabsScreenContentFocused = (focusableTree, id) => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (isScreenPickerContentContainer(node)) {
+    return true;
+  }
+
+  return isTabsScreenContentFocused(focusableTree, node.parentId);
+};
+
+export const isCurrentFocusOnMenu = (focusableTree, id): boolean => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return true;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  return isCurrentFocusOnMenu(focusableTree, node.parentId);
+};
+
+export const isCurrentFocusOnContent = (focusableTree, id) => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return true;
+  }
+
+  return isCurrentFocusOnContent(focusableTree, node.parentId);
+};

package/navigationUtils/__tests__/mapContentTypesToRivers.test.ts

@@ -0,0 +1,130 @@
+import { mapContentTypesToRivers } from "../index";
+
+describe("mapContentTypesToRivers", () => {
+  it("should return the correct content types mapped to rivers", () => {
+    const state = {
+      rivers: {
+        "river-1": {
+          plugin_type: "river",
+        },
+      },
+      contentTypes: {
+        "content-type-1": {
+          screen_id: "river-1",
+        },
+      },
+    };
+
+    const result = mapContentTypesToRivers(state);
+
+    expect(result).toEqual({
+      "content-type-1": {
+        screenType: "river",
+        screen_id: "river-1",
+      },
+    });
+  });
+
+  it("should return null if contentTypes is undefined", () => {
+    const state = {
+      rivers: {
+        "river-1": {
+          plugin_type: "river",
+        },
+      },
+      // contentTypes is missing
+    };
+
+    const result = mapContentTypesToRivers(state);
+
+    expect(result).toBeNull();
+  });
+
+  it("should skip content types whose screen does not exist in rivers", () => {
+    const state = {
+      rivers: {
+        "river-1": {
+          plugin_type: "river",
+        },
+      },
+      contentTypes: {
+        "content-type-1": {
+          screen_id: "river-1",
+        },
+        "content-type-2": {
+          screen_id: "river-2", // river-2 does not exist
+        },
+      },
+    };
+
+    const result = mapContentTypesToRivers(state);
+
+    expect(result).toEqual({
+      "content-type-1": {
+        screenType: "river",
+        screen_id: "river-1",
+      },
+    });
+
+    // result is not null, but may be undefined for missing keys
+    expect(result && result["content-type-2"]).toBeUndefined();
+  });
+
+  it("should use 'type' if 'plugin_type' is not present in river", () => {
+    const state = {
+      rivers: {
+        "river-1": {
+          type: "custom-type",
+        },
+      },
+      contentTypes: {
+        "content-type-1": {
+          screen_id: "river-1",
+        },
+      },
+    };
+
+    const result = mapContentTypesToRivers(state);
+
+    expect(result).toEqual({
+      "content-type-1": {
+        screenType: "custom-type",
+        screen_id: "river-1",
+      },
+    });
+  });
+
+  it("should skip content types if neither plugin_type nor type is present in river", () => {
+    const state = {
+      rivers: {
+        "river-1": {
+          // no plugin_type or type
+        },
+      },
+      contentTypes: {
+        "content-type-1": {
+          screen_id: "river-1",
+        },
+      },
+    };
+
+    const result = mapContentTypesToRivers(state);
+
+    expect(result).toEqual({});
+  });
+
+  it("should handle empty contentTypes object", () => {
+    const state = {
+      rivers: {
+        "river-1": {
+          plugin_type: "river",
+        },
+      },
+      contentTypes: {},
+    };
+
+    const result = mapContentTypesToRivers(state);
+
+    expect(result).toEqual({});
+  });
+});

package/navigationUtils/index.ts

@@ -13,6 +13,7 @@ import {
   isPlayable,
   isV2River,
 } from "./itemTypeMatchers";
+import { RootState } from "@applicaster/zapp-react-native-redux/store";
 
 type PathAttribute = {
   screenType: string;
@@ -377,10 +378,11 @@ export const usesVideoModal = (
   return targetScreenConfiguration?.styles?.use_video_modal;
 };
 
-export const mapContentTypesToRivers = ({
-  rivers,
-  contentTypes,
-}): ZappContentTypesMapped | null => {
+export const mapContentTypesToRivers = (
+  state: Partial<RootState>
+): ZappContentTypesMapped | null => {
+  const { rivers, contentTypes } = state;
+
   if (!contentTypes) {
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "14.0.0-alpha.2175196485",
+  "version": "14.0.0-alpha.2292190333",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "14.0.0-alpha.2175196485",
+    "@applicaster/applicaster-types": "14.0.0-alpha.2292190333",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",
@@ -38,7 +38,6 @@
   "peerDependencies": {
     "@applicaster/zapp-pipes-v2-client": "*",
     "@react-native-community/netinfo": "*",
-    "immer": "*",
     "react": "*",
     "react-native": "*",
     "uglify-js": "*",

package/reactHooks/autoscrolling/__tests__/useTrackedView.test.tsx

@@ -23,7 +23,9 @@ jest.mock(
 
 jest.useFakeTimers();
 
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation");
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation"
+);
 
 const mockStore = configureStore();
 

package/reactHooks/cell-click/__tests__/index.test.js

@@ -26,6 +26,9 @@ jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils/", () => ({
 }));
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
+  ...jest.requireActual(
+    "@applicaster/zapp-react-native-utils/reactHooks/screen"
+  ),
   useTargetScreenData: jest.fn(() => ({})),
   useCurrentScreenData: jest.fn(() => ({})),
 }));

package/reactHooks/cell-click/index.ts

@@ -16,7 +16,8 @@ import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/acti
 import { isFunction, noop } from "../../functionUtils";
 import { useSendAnalyticsOnPress } from "../analytics";
 import { logOnPress, warnEmptyContentType } from "./helpers";
-import { useCurrentScreenData } from "../screen";
+import { useCurrentScreenData, useScreenContext } from "../screen";
+import { useScreenStateStore } from "../navigation/useScreenStateStore";
 
 /**
  * If onCellTap is defined execute the function and
@@ -42,10 +43,12 @@ export const useCellClick = ({
 }: Props): onPressReturnFn => {
   const { push, currentRoute } = useNavigation();
   const { pathname } = useRoute();
+  const screenStateStore = useScreenStateStore();
 
   const onCellTap: Option<Function> = React.useContext(CellTapContext);
   const actionExecutor = React.useContext(ActionExecutorContext);
   const screenData = useCurrentScreenData();
+  const screenState = useScreenContext()?.options;
 
   const cellSelectable = toBooleanWithDefaultTrue(
     component?.rules?.component_cells_selectable
@@ -83,6 +86,9 @@ export const useCellClick = ({
         await actionExecutor?.handleEntryActions(selectedItem, {
           component,
           screenData,
+          screenState,
+          screenRoute: pathname,
+          screenStateStore,
         });
       }
 
@@ -117,6 +123,7 @@ export const useCellClick = ({
       push,
       sendAnalyticsOnPress,
       screenData,
+      screenState,
     ]
   );
 

package/reactHooks/debugging/__tests__/index.test.js

@@ -12,7 +12,6 @@ describe("Debug utils", () => {
     // Clear the timers object
     Object.keys(timers).forEach((key) => delete timers[key]);
 
-    // Mock performance.now()
     // eslint-disable-next-line no-undef
     performanceNowMock = jest.spyOn(performance, "now");
     performanceNowMock.mockReturnValue(0); // Initial value

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

@@ -2,12 +2,16 @@ import { renderHook } from "@testing-library/react-hooks";
 import { allFeedsIsReady, useBatchLoading } from "../useBatchLoading";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { waitFor } from "@testing-library/react-native";
 
 jest.mock("../../navigation");
 
 jest.mock(
   "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext",
   () => ({
+    ...jest.requireActual(
+      "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext"
+    ),
     useScreenContext: jest.fn().mockReturnValue({ screen: {}, entry: {} }),
   })
 );
@@ -33,7 +37,7 @@ describe("useBatchLoading", () => {
     jest.clearAllMocks();
   });
 
-  it("loadPipesData start loading not started requests", () => {
+  it("loadPipesData start loading not started requests", async () => {
     const store = {
       zappPipes: {
         url1: {
@@ -65,7 +69,9 @@ describe("useBatchLoading", () => {
 
     const actions = (appStore.getStore() as any).getActions();
 
-    expect(actions).toHaveLength(2);
+    await waitFor(() => {
+      expect(actions).toHaveLength(2);
+    });
 
     expect(actions[0]).toMatchObject({
       type: "ZAPP_PIPES_REQUEST_START",

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

@@ -2,15 +2,12 @@ import { renderHook } from "@testing-library/react-hooks";
 import * as R from "ramda";
 import * as zappPipesModule from "@applicaster/zapp-react-native-redux/ZappPipes";
 import * as reactReduxModules from "react-redux";
-import { Provider } from "react-redux";
 import * as React from "react";
-import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
 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 { useFeedLoader } from "../useFeedLoader";
-
-const mockStore = configureStore([thunk]);
+import { WrappedWithProviders } from "../../../testUtils";
+import { ScreenStateResolver } from "../../../appUtils/contextKeysManager/contextResolver";
 
 jest.useFakeTimers({ legacyFakeTimers: true });
 
@@ -55,13 +52,15 @@ const mockZappPipesData = {
 
 describe("useFeedLoader", () => {
   describe("with cached feed url", () => {
-    const store = mockStore({
+    const store = {
       plugins: [],
       zappPipes: { "test://testfakeurl": mockZappPipesData },
-    });
+    };
 
-    const wrapper: React.FC<any> = ({ children }) => (
-      <Provider store={store}>{children}</Provider>
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store || store}>
+        {children}
+      </WrappedWithProviders>
     );
 
     it("returns cached feed", () => {
@@ -110,8 +109,10 @@ describe("useFeedLoader", () => {
   describe("without cached feeds", () => {
     const feedUrl = "test://testfakeurl2";
 
-    const wrapper: React.FC<any> = ({ children, store }) => (
-      <Provider store={store}>{children}</Provider>
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store}>
+        {children}
+      </WrappedWithProviders>
     );
 
     it("It loads data for new url and returns it", () => {
@@ -123,10 +124,10 @@ describe("useFeedLoader", () => {
         .spyOn(zappPipesModule, "loadPipesData")
         .mockImplementation(jest.fn());
 
-      const initialStore = mockStore({
+      const initialStore = {
         plugins: [],
         zappPipes: { "test://testfakeurl": "foobar" },
-      });
+      };
 
       const { result, rerender } = renderHook(
         () => useFeedLoader({ feedUrl: "test://testfakeurl2" }),
@@ -135,15 +136,19 @@ describe("useFeedLoader", () => {
 
       expect(result.current.data).toBeNull();
 
-      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
+      expect(loadPipesDataSpy).toHaveBeenCalledWith(feedUrl, {
         clearCache: true,
         riverId: undefined,
+        callback: expect.any(Function),
+        resolvers: {
+          screen: expect.any(ScreenStateResolver),
+        },
       });
 
-      const store2 = mockStore({
+      const store2 = {
         plugins: [],
         zappPipes: { "test://testfakeurl2": mockZappPipesData },
-      });
+      };
 
       rerender({ store: store2 });
 
@@ -164,10 +169,10 @@ describe("useFeedLoader", () => {
         .spyOn(reactReduxModules, "useDispatch")
         .mockImplementation(() => jest.fn());
 
-      const initialStore = mockStore({
+      const initialStore = {
         plugins: [],
         zappPipes: { "test://testfakeurl": "foobar" },
-      });
+      };
 
       const { result, rerender } = renderHook(
         () => useFeedLoader({ feedUrl: "test://testfakeurl2" }),
@@ -176,15 +181,22 @@ describe("useFeedLoader", () => {
 
       expect(result.current.data).toBeNull();
 
-      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
+      expect(loadPipesDataSpy.mock.calls[0][0]).toBe(feedUrl);
+
+      expect(loadPipesDataSpy.mock.calls[0][1]).toMatchObject({
         clearCache: true,
         riverId: undefined,
+        resolvers: {
+          screen: {
+            screenStateStore: expect.any(Function),
+          },
+        },
       });
 
-      const store2 = mockStore({
+      const store2 = {
         plugins: [],
         zappPipes: { "test://testfakeurl2": mockZappPipesData },
-      });
+      };
 
       rerender({ store: store2 });
 
@@ -197,8 +209,10 @@ describe("useFeedLoader", () => {
     const feedUrl = "test://testfakeurl";
     const feedUrlWithNext = "test://withnexttestfakeurl";
 
-    const wrapper: React.FC<any> = ({ children, store }) => (
-      <Provider store={store}>{children}</Provider>
+    const wrapper: React.FC<any> = ({ children, ...props }) => (
+      <WrappedWithProviders store={props.store || {}}>
+        {children}
+      </WrappedWithProviders>
     );
 
     describe("reloadData", () => {
@@ -211,10 +225,10 @@ describe("useFeedLoader", () => {
           .spyOn(reactReduxModules, "useDispatch")
           .mockImplementation(() => jest.fn());
 
-        const initialStore = mockStore({
+        const initialStore = {
           plugins: [],
           zappPipes: { [feedUrl]: "foobar" },
-        });
+        };
 
         const { result } = renderHook(() => useFeedLoader({ feedUrl }), {
           wrapper,
@@ -223,11 +237,24 @@ describe("useFeedLoader", () => {
 
         const { reloadData } = result.current;
 
-        reloadData();
+        reloadData?.();
+
+        expect(loadPipesDataSpy).toHaveBeenCalled();
+
+        expect(
+          loadPipesDataSpy.mock.calls[loadPipesDataSpy.mock.calls.length - 1][0]
+        ).toBe(feedUrl);
 
-        expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
+        expect(
+          loadPipesDataSpy.mock.calls[loadPipesDataSpy.mock.calls.length - 1][1]
+        ).toMatchObject({
           clearCache: true,
           silentRefresh: true,
+          resolvers: {
+            screen: {
+              screenStateStore: expect.any(Function),
+            },
+          },
         });
 
         loadPipesDataSpy.mockRestore();
@@ -247,10 +274,10 @@ describe("useFeedLoader", () => {
           .spyOn(reactReduxModules, "useDispatch")
           .mockImplementation(() => jest.fn());
 
-        const initialStore = mockStore({
+        const initialStore = {
           plugins: [],
           zappPipes: { [feedUrlWithNext]: { data: { next: nextUrl } } },
-        });
+        };
 
         const { result } = renderHook(
           () => useFeedLoader({ feedUrl: feedUrlWithNext }),
@@ -262,11 +289,24 @@ describe("useFeedLoader", () => {
 
         const { loadNext } = result.current;
 
-        loadNext();
+        loadNext?.();
+
+        expect(loadPipesDataSpy).toHaveBeenCalled();
+
+        expect(
+          loadPipesDataSpy.mock.calls[loadPipesDataSpy.mock.calls.length - 1][0]
+        ).toBe(nextUrl);
 
-        expect(loadPipesDataSpy).toBeCalledWith(nextUrl, {
+        expect(
+          loadPipesDataSpy.mock.calls[loadPipesDataSpy.mock.calls.length - 1][1]
+        ).toMatchObject({
           parentFeed: feedUrlWithNext,
           silentRefresh: true,
+          resolvers: {
+            screen: {
+              screenStateStore: expect.any(Function),
+            },
+          },
         });
 
         loadPipesDataSpy.mockRestore();

package/reactHooks/feed/index.ts

@@ -11,3 +11,5 @@ export { useBuildPipesUrl } from "./useBuildPipesUrl";
 export { usePipesCacheReset } from "./usePipesCacheReset";
 
 export { useBatchLoading } from "./useBatchLoading";
+
+export { useLoadPipesDataDispatch } from "./useLoadPipesDataDispatch";