@applicaster/zapp-react-native-utils 14.0.0-rc.51 → 14.0.0-rc.53

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,10 +1,13 @@
 import { ContextKeysManager } from "./index";
 import * as R from "ramda";
+import * as _ from "lodash";
+import { useScreenStateStore } from "../../reactHooks/navigation/useScreenStateStore";
 
-interface IResolver {
+export interface IResolver {
   resolve: (string) => Promise<string | number | object>;
 }
 
+// TODO: Rename to ObjectKeyResolver or similar
 export class EntryResolver implements IResolver {
   entry: ZappEntry;
 
@@ -21,6 +24,28 @@ export class EntryResolver implements IResolver {
   }
 }
 
+// TODO: Move to proper place
+
+export class ScreenStateResolver implements IResolver {
+  constructor(
+    private screenStateStore: ReturnType<typeof useScreenStateStore>
+  ) {}
+
+  async resolve(key: string) {
+    const screenState = this.screenStateStore.getState().data;
+
+    if (!key || key.length === 0) {
+      return screenState;
+    }
+
+    if (key.includes(".")) {
+      return R.view(R.lensPath(key.split(".")), screenState);
+    }
+
+    return screenState?.[key];
+  }
+}
+
 export class ContextResolver implements IResolver {
   resolve = async (compositeKey: string) =>
     ContextKeysManager.instance.getKey(compositeKey);
@@ -64,3 +89,19 @@ export const resolveObjectValues = async (
 
   return Object.fromEntries(resolvedEntries);
 };
+
+export const extractAtValues = _.memoize((input: any): string[] => {
+  return _.flatMapDeep(input, (value: any) => {
+    if (_.isString(value)) {
+      const matches = value.match(/@\{([^}]*)\}/g);
+
+      return matches ? matches.map((match) => match.slice(2, -1)) : [];
+    }
+
+    if (_.isObject(value)) {
+      return extractAtValues(_.values(value));
+    }
+
+    return [];
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "14.0.0-rc.51",
+  "version": "14.0.0-rc.53",
   "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-rc.51",
+    "@applicaster/applicaster-types": "14.0.0-rc.53",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

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/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";

package/reactHooks/feed/useBatchLoading.ts

@@ -1,15 +1,12 @@
 import { complement, compose, isNil, map, min, prop, take, uniq } from "ramda";
 import * as React from "react";
-import {
-  ZappPipes,
-  useAppDispatch,
-  useZappPipesFeed,
-} from "@applicaster/zapp-react-native-redux";
+import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux";
 import { isNilOrEmpty } from "../../reactUtils/helpers";
 import { ZappPipesSearchContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import {
   getInflatedDataSourceUrl,
   getSearchContext,
+  useLoadPipesDataDispatch,
 } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { isGallery } from "@applicaster/zapp-react-native-utils/componentsUtils";
 import { useScreenContext } from "../screen";
@@ -65,7 +62,6 @@ export const useBatchLoading = (
   componentsToRender: { data?: ZappDataSource; component_type: string }[],
   options: Options
 ) => {
-  const dispatch = useAppDispatch();
   const { screen: screenContext, entry: entryContext } = useScreenContext();
   const [searchContext] = ZappPipesSearchContext.useZappPipesContext();
   const [hasEverBeenReady, setHasEverBeenReady] = React.useState(false);
@@ -122,6 +118,8 @@ export const useBatchLoading = (
 
   const feeds = useZappPipesFeed(feedUrls);
 
+  const loadPipesDataDispatcher = useLoadPipesDataDispatch();
+
   // dispatch loadPipesData for each feed that is not loaded
   const runBatchLoading = React.useCallback(() => {
     batchComponents.forEach((rawData: any) => {
@@ -140,13 +138,20 @@ export const useBatchLoading = (
 
         if (mappedFeedUrl) {
           // 4. load data
-          return dispatch(
-            ZappPipes.loadPipesData(mappedFeedUrl, { riverId: options.riverId })
+          return loadPipesDataDispatcher(
+            mappedFeedUrl,
+            {
+              riverId: options.riverId,
+            },
+            {
+              withResolvers: true,
+              withScreenRouteMapping: true,
+            }
           );
         }
       }
     });
-  }, [feedUrls, feeds]);
+  }, [feedUrls, feeds, loadPipesDataDispatcher]);
 
   React.useEffect(() => {
     runBatchLoading();

package/reactHooks/feed/useFeedLoader.tsx

@@ -1,15 +1,11 @@
 import React, { useEffect } from "react";
 
-import {
-  ZappPipes,
-  useAppDispatch,
-  useZappPipesFeed,
-} from "@applicaster/zapp-react-native-redux";
+import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux";
 
 import { reactHooksLogger } from "../logger";
 import { shouldDispatchData, useIsInitialRender } from "../utils";
 import { useInflatedUrl } from "./useInflatedUrl";
-import { useRoute } from "../navigation";
+import { useLoadPipesDataDispatch } from "./useLoadPipesDataDispatch";
 
 const logger = reactHooksLogger.addSubsystem("useFeedLoader");
 
@@ -51,29 +47,26 @@ export const useFeedLoader = ({
   }, []);
 
   const isInitialRender = useIsInitialRender();
-  const dispatch = useAppDispatch();
-  const { screenData } = useRoute();
 
   const callableFeedUrl = useInflatedUrl({ feedUrl, mapping });
 
   const currentFeed = useZappPipesFeed(callableFeedUrl);
 
-  const riverId =
-    (screenData as LegacyNavigationScreenData)?.targetScreen?.id ??
-    screenData?.id;
+  const loadPipesDataDispatcher = useLoadPipesDataDispatch();
 
   const reloadData = React.useCallback<ReloadDataFunction>(
     (silentRefresh = true, callback) => {
-      if (callableFeedUrl) {
-        dispatch(
-          ZappPipes.loadPipesData(callableFeedUrl, {
-            clearCache: true,
-            silentRefresh,
-            callback,
-            riverId,
-          })
-        );
-      }
+      loadPipesDataDispatcher(
+        callableFeedUrl,
+        {
+          clearCache: true,
+          silentRefresh,
+          callback,
+        },
+        {
+          withResolvers: true,
+        }
+      );
     },
     [callableFeedUrl]
   );
@@ -82,15 +75,16 @@ export const useFeedLoader = ({
     if (callableFeedUrl) {
       const nextFeed = currentFeed?.data?.next;
 
-      if (nextFeed) {
-        dispatch(
-          ZappPipes.loadPipesData(nextFeed, {
-            silentRefresh: true,
-            parentFeed: callableFeedUrl,
-            riverId,
-          })
-        );
-      }
+      loadPipesDataDispatcher(
+        nextFeed,
+        {
+          silentRefresh: true,
+          parentFeed: callableFeedUrl,
+        },
+        {
+          withResolvers: true,
+        }
+      );
     }
   }, [callableFeedUrl, currentFeed?.data?.next]);
 
@@ -99,12 +93,16 @@ export const useFeedLoader = ({
       shouldDispatchData(callableFeedUrl, currentFeed, pipesOptions.clearCache)
     ) {
       if (callableFeedUrl && !pipesOptions.skipLoading) {
-        dispatch(
-          ZappPipes.loadPipesData(callableFeedUrl, {
+        loadPipesDataDispatcher(
+          callableFeedUrl,
+          {
             ...pipesOptions,
             clearCache: true,
-            riverId,
-          })
+          },
+          {
+            withResolvers: true,
+            withScreenRouteMapping: true,
+          }
         );
       } else if (!callableFeedUrl) {
         logger.info({
@@ -133,11 +131,11 @@ export const useFeedLoader = ({
   // Reload feed when feedUrl changes, unless skipLoading is true
   useEffect(() => {
     if (!isInitialRender && callableFeedUrl && !pipesOptions.skipLoading) {
-      dispatch(
-        ZappPipes.loadPipesData(callableFeedUrl, { ...pipesOptions, riverId })
-      );
+      loadPipesDataDispatcher(callableFeedUrl, pipesOptions, {
+        withResolvers: true,
+      });
     }
-  }, [callableFeedUrl]);
+  }, [callableFeedUrl, isInitialRender, pipesOptions.skipLoading]);
 
   return React.useMemo(() => {
     if (!callableFeedUrl || !feedUrl) {

package/reactHooks/feed/useLoadPipesDataDispatch.ts

@@ -0,0 +1,57 @@
+import {
+  useAppDispatch,
+  ZappPipes,
+} from "@applicaster/zapp-react-native-redux";
+import { applyScreenRouteDefaults } from "@applicaster/zapp-react-native-redux/ZappPipes/feedProcessor";
+import React from "react";
+import { useScreenResolvers } from "../../actionsExecutor/screenResolver";
+import { useRoute } from "../navigation";
+import { useScreenStateStore } from "../navigation/useScreenStateStore";
+
+export const useLoadPipesDataDispatch = () => {
+  const screenStateStore = useScreenStateStore();
+  const resolvers = useScreenResolvers();
+  const dispatch = useAppDispatch();
+
+  const { pathname, screenData } = useRoute();
+
+  const riverId =
+    (screenData as LegacyNavigationScreenData)?.targetScreen?.id ??
+    screenData?.id;
+
+  const onLoadCB = (options) => (data, _err) => {
+    options?.callback?.();
+
+    if (data) {
+      applyScreenRouteDefaults(data, screenStateStore, pathname);
+    }
+  };
+
+  return React.useCallback(
+    (
+      url: string,
+      options = {},
+      {
+        withResolvers = false,
+        withScreenRouteMapping = false,
+      }: {
+        withResolvers?: boolean;
+        withScreenRouteMapping?: boolean;
+      } = {}
+    ) => {
+      if (url) {
+        dispatch(
+          ZappPipes.loadPipesData(url, {
+            riverId,
+            resolvers: withResolvers ? resolvers : undefined,
+            ...options,
+            callback: withScreenRouteMapping
+              ? onLoadCB(options)
+              : options?.callback,
+          })
+        );
+      }
+    },
+    []
+  );
+};

package/reactHooks/navigation/useRoute.ts

@@ -28,14 +28,19 @@ const isHookPathname = (pathname: string) => /^\/hooks\//.test(pathname);
 
 type VariousScreenData = LegacyNavigationScreenData | ZappRiver | ZappEntry;
 
-export const useRoute = (): {
+export const useRoute = (
+  useLegacy = true
+): {
   screenData: VariousScreenData;
   pathname: string;
 } => {
   const pathname = usePathname() || "";
   const navigator = useNavigation();
+  const screenContext = useContext(ScreenDataContext);
 
-  const screenDataContext = legacyScreenData(useContext(ScreenDataContext));
+  const screenDataContext = useLegacy
+    ? legacyScreenData(screenContext)
+    : screenContext;
 
   const { plugins, contentTypes, rivers } = usePickFromState([
     "plugins",

package/reactHooks/navigation/useScreenStateStore.ts

@@ -0,0 +1,8 @@
+import { useScreenContextV2 } from "../screen/useScreenContext";
+import { useMemo } from "react";
+
+export const useScreenStateStore = () => {
+  const _stateStore = useScreenContextV2()._stateStore;
+
+  return useMemo(() => _stateStore, []);
+};