@applicaster/zapp-react-native-utils 12.0.0-alpha.4433422595 → 12.0.0-alpha.4440903139

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

@@ -4,38 +4,77 @@ import {
   timers,
 } from "@applicaster/zapp-react-native-utils/reactHooks/debugging";
 
-jest.useFakeTimers();
-
 describe("Debug utils", () => {
+  let performanceNowMock;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    // 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
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+    performanceNowMock.mockRestore();
+  });
+
   describe("Unit Test: time", () => {
     it("should create new timer if timer with a label does not exist", () => {
+      performanceNowMock.mockReturnValue(1000);
       time("timer1");
       expect(timers["timer1"]).toBeDefined();
+      expect(timers["timer1"].startTime).toBe(1000);
     });
 
     it("should update start time of timer if timer with a label exists", () => {
+      // First call to time()
+      performanceNowMock.mockReturnValue(1000);
+      time("timer1");
       const previousStartTime = timers["timer1"].startTime;
-      jest.advanceTimersByTime(1000);
+
+      // Second call to time()
+      performanceNowMock.mockReturnValue(2000);
       time("timer1");
       const currentStartTime = timers["timer1"].startTime;
-      expect(previousStartTime).not.toEqual(currentStartTime);
+
+      expect(previousStartTime).toBe(1000);
+      expect(currentStartTime).toBe(2000);
     });
   });
 
   describe("Unit Test: timeEnd", () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+      jest.spyOn(console, "log").mockImplementation(() => {});
+    });
 
     it("should log elapsed time", () => {
       const logSpy = jest.spyOn(console, "log");
 
+      performanceNowMock.mockReturnValue(1000);
+      time("timer1");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer1");
 
-      expect(logSpy).toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith(
+        "timer1: 1000.000ms 2",
+        expect.any(Object)
+      );
     });
 
     it("should not log elapsed time if accumulative: true in settings", () => {
       const logSpy = jest.spyOn(console, "log");
 
+      performanceNowMock.mockReturnValue(1000);
+      time("timer1");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer1", { accumulative: true });
 
       expect(logSpy).not.toHaveBeenCalled();
@@ -43,21 +82,52 @@ describe("Debug utils", () => {
   });
 
   describe("Integration Test: time and timeEnd", () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+      jest.spyOn(console, "log").mockImplementation(() => {});
+    });
 
     it("should log elapsed time on timeEnd call", () => {
       const logSpy = jest.spyOn(console, "log");
+
+      performanceNowMock.mockReturnValue(1000);
       time("timer1");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer1");
-      expect(logSpy).toHaveBeenCalled();
+
+      expect(logSpy).toHaveBeenCalledWith(
+        "timer1: 1000.000ms 2",
+        expect.objectContaining({
+          label: "timer1",
+          settings: undefined,
+        })
+      );
     });
 
-    it("should log total and average time on timeEnd call without accumulative option", () => {
+    it("should log total and average time when accumulative timing is complete", () => {
       const logSpy = jest.spyOn(console, "log");
+
+      // First timing
+      performanceNowMock.mockReturnValue(1000);
       time("timer2");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer2", { accumulative: true });
-      timeEnd("timer2");
-      expect(logSpy).toHaveBeenCalled();
+
+      // Second timing
+      performanceNowMock.mockReturnValue(3000);
+      time("timer2");
+
+      performanceNowMock.mockReturnValue(5000);
+      timeEnd("timer2"); // This will log because timer is accumulative (callCount > 1)
+
+      expect(logSpy).toHaveBeenCalledWith(
+        "timer2: 2000.000ms 2",
+        expect.objectContaining({
+          label: "timer2",
+          settings: undefined,
+        })
+      );
     });
   });
 });

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

@@ -77,8 +77,6 @@ describe("useBatchLoading", () => {
 
     const actions = store.getActions();
 
-    expect(useDispatchSpy).toBeCalledTimes(1);
-
     expect(actions).toHaveLength(2);
 
     expect(actions[0]).toMatchObject({
@@ -129,6 +127,8 @@ describe("useBatchLoading", () => {
       // ... more items
     ];
 
+    expect(useDispatchSpy).toBeCalledTimes(0);
+
     renderHook(() => useBatchLoading(data, { initialBatchSize, riverId }), {
       wrapper,
       initialProps: { store },
@@ -136,8 +136,6 @@ describe("useBatchLoading", () => {
 
     const actions = store.getActions();
 
-    expect(useDispatchSpy).toBeCalledTimes(1);
-
     expect(actions).toHaveLength(1);
 
     expect(actions[0]).toMatchObject({
@@ -172,8 +170,6 @@ describe("useBatchLoading", () => {
       initialProps: { store },
     });
 
-    expect(useDispatchSpy).toBeCalledTimes(1);
-
     const actions = store.getActions();
 
     expect(actions).toHaveLength(3);
@@ -218,6 +214,73 @@ describe("useBatchLoading", () => {
 
     expect(result.current).toBe(true);
   });
+
+  it("gallery-qb: loadPipesData should be called only once for first component in the gallery", () => {
+    const store = mockStore({
+      zappPipes: {},
+      test: "true",
+    });
+
+    useDispatchSpy.mockReturnValue(store.dispatch);
+
+    const initialBatchSize = 3;
+    const riverId = "123";
+
+    const data = [
+      {
+        component_type: "gallery-qb",
+        ui_components: [{ data: { source: "url1" } }],
+      },
+      { data: { source: "url2" } },
+      { data: { source: "url3" } },
+      { data: { source: "url4" } },
+      { data: { source: "url5" } },
+      { data: { source: "url6" } },
+      // ... more items
+    ];
+
+    renderHook(() => useBatchLoading(data, { initialBatchSize, riverId }), {
+      wrapper,
+      initialProps: { store },
+    });
+
+    const actions = store.getActions();
+
+    expect(actions).toHaveLength(1);
+  });
+
+  it("gallery-qb: initial batch ready when all initial items loaded", () => {
+    const store = mockStore({
+      zappPipes: {
+        url1: {
+          loading: false,
+          error: false,
+          data: {},
+        },
+      },
+    });
+
+    useDispatchSpy.mockReturnValue(store.dispatch);
+
+    const initialBatchSize = 3;
+    const riverId = "123";
+
+    const data: Partial<ZappUIComponent>[] = [
+      {
+        component_type: "gallery-qb",
+        ui_components: [{ data: { source: "url1" } }],
+      },
+      { data: { source: "url2" } },
+      { data: { source: "url3" } },
+    ];
+
+    const { result } = renderHook(
+      () => useBatchLoading(data, { initialBatchSize, riverId }),
+      { wrapper, initialProps: { store } }
+    );
+
+    expect(result.current).toBe(true);
+  });
 });
 
 describe("allFeedsIsReady", () => {

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

@@ -1,77 +1,26 @@
-import React from "react";
 import { renderHook } from "@testing-library/react-hooks";
-import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { Provider } from "react-redux";
-
 import { encodeParams } from "@applicaster/zapp-pipes-v2-client/src/utils";
 
-const mockStore = configureStore([thunk]);
-
-jest.useFakeTimers();
-
 const appData = {
   platform: "foo",
   version_name: "1.2.0",
   sdk_version: "2.0.0",
 };
 
-const pipesEndpoints = {
-  "http://foo.com/show": {
-    context_obj: [
-      { type: "ctx", key: "platform" },
-      { type: "query", mapper: "version", key: "appVersion" },
-      { type: "header", mapper: "SDK", key: "sdkVersion" },
-    ],
-  },
-};
-
-const store_mock = { appData, pipesEndpoints };
-
-const defaultStore = mockStore({
-  pipesEndpoints,
-  appData,
-});
+let INFLATED_URL;
 
-const wrapper: React.FC<any> = ({ children, store }) => (
-  <Provider store={store}>{children}</Provider>
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/feed/useInflatedUrl",
+  () => ({
+    useInflatedUrl: () => INFLATED_URL,
+  })
 );
 
-const navigator = {
-  currentRoute: "/river/A1234",
-};
-
-jest.mock("../../navigation", () => ({
-  useNavigation: jest.fn(() => navigator),
-  useRoute: jest.fn(() => ({})),
-}));
-
-const contexts = {
-  entry: { id: "show-1" },
-  search: {},
-  screen: {},
-};
-
-const contextMock = (type) => ({
-  useZappPipesContext: () => [contexts[type] || {}],
-});
-
-jest.mock("@applicaster/zapp-react-native-ui-components/Contexts", () => ({
-  ZappPipesEntryContext: contextMock("entry"),
-  ZappPipesSearchContext: contextMock("search"),
-  ZappPipesScreenContext: contextMock("screen"),
-}));
-
-jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
-  appStore: {
-    get: jest.fn((prop) => store_mock[prop]),
-  },
-}));
-
 const { useBuildPipesUrl } = require("../useBuildPipesUrl");
 
 describe("useBuildPipesUrl", () => {
   it("returns the proper url", async () => {
+    INFLATED_URL = "http://foo.com/show/show-1";
     const url = "http://foo.com/show/{{showId}}";
 
     const mapping = {
@@ -81,12 +30,20 @@ describe("useBuildPipesUrl", () => {
       },
     };
 
-    const { result, waitForNextUpdate } = renderHook(
-      () => useBuildPipesUrl({ url, mapping }),
-      {
-        wrapper,
-        initialProps: { store: defaultStore },
-      }
+    const buildResult = {
+      params: {
+        ctx: encodeParams({ platform: appData.platform }),
+        version: appData.version_name,
+      },
+      headers: { SDK: appData.sdk_version },
+    };
+
+    const mockedRequestBuilder = {
+      build: jest.fn(() => Promise.resolve(buildResult)),
+    };
+
+    const { result, waitForNextUpdate } = renderHook(() =>
+      useBuildPipesUrl({ url, mapping, requestBuilder: mockedRequestBuilder })
     );
 
     expect(result.current.url).toBe("http://foo.com/show/show-1");
@@ -108,6 +65,7 @@ describe("useBuildPipesUrl", () => {
   });
 
   it("returns empty object if url is not in endpoints", async () => {
+    INFLATED_URL = "http://foobar.com/show-1";
     const url = "http://foobar.com/{{showId}}";
 
     const mapping = {
@@ -117,12 +75,14 @@ describe("useBuildPipesUrl", () => {
       },
     };
 
-    const { result, waitForNextUpdate } = renderHook(
-      () => useBuildPipesUrl({ url, mapping }),
-      {
-        wrapper,
-        initialProps: { store: defaultStore },
-      }
+    const buildResult = {};
+
+    const mockedRequestBuilder = {
+      build: jest.fn(() => Promise.resolve(buildResult)),
+    };
+
+    const { result, waitForNextUpdate } = renderHook(() =>
+      useBuildPipesUrl({ url, mapping, requestBuilder: mockedRequestBuilder })
     );
 
     expect(result.current.url).toBe("http://foobar.com/show-1");

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

@@ -1,9 +1,13 @@
 import { renderHook } from "@testing-library/react-hooks";
 
-import { useFeedRefresh, feedRefreshLogger } from "../";
-
 jest.useFakeTimers();
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
+  useIsScreenActive: () => true,
+}));
+
+const { useFeedRefresh, feedRefreshLogger } = require("..");
+
 describe("useFeedRefresh", () => {
   const reloadData = jest.fn();
 

package/reactHooks/feed/__tests__/useInflatedUrl.test.ts

@@ -12,9 +12,21 @@ const {
 
 const { reactHooksLogger } = require("../../logger");
 
+let mockStore;
+
 describe("getInflatedDataSourceUrl", () => {
   beforeEach(() => {
     reactHooksLogger.warning.mockClear();
+
+    const {
+      appStore,
+    } = require("@applicaster/zapp-react-native-redux/AppStore");
+
+    mockStore = {
+      getState: jest.fn().mockReturnValue({ pipesEndpoints: {} }),
+    };
+
+    appStore.set(mockStore);
   });
 
   it("returns the url inflated with the right params", () => {
@@ -72,7 +84,8 @@ describe("getInflatedDataSourceUrl", () => {
     expect(reactHooksLogger.warning).toHaveBeenCalledTimes(1);
 
     expect(reactHooksLogger.warning).toHaveBeenCalledWith({
-      message: "Not enough data to fully inflate url",
+      message:
+        "Not enough data to fully inflate url: {{entry.id}} source: http://foo.com/show/seriesId={{seriesId}}",
       data: { source, contexts, mapping },
     });
   });
@@ -107,7 +120,8 @@ describe("getInflatedDataSourceUrl", () => {
     expect(reactHooksLogger.warning).toHaveBeenCalledTimes(1);
 
     expect(reactHooksLogger.warning).toHaveBeenCalledWith({
-      message: "Not enough data to fully inflate url",
+      message:
+        "Not enough data to fully inflate url: {{entry.extensions.groupName}} source: https://zapp-1689-emmys.web.app/emmys/group-categories/{{groupName}}",
       data: { source, contexts, mapping },
     });
   });
@@ -148,7 +162,8 @@ describe("getInflatedDataSourceUrl", () => {
     expect(reactHooksLogger.warning).toHaveBeenCalledTimes(1);
 
     expect(reactHooksLogger.warning).toHaveBeenCalledWith({
-      message: "Not enough data to fully inflate url",
+      message:
+        "Not enough data to fully inflate url: {{entry.extensions.groupName2}} source: https://zapp-1689-emmys.web.app/emmys/group-categories/{{groupName1}}?test={{groupName2}}",
       data: { source, contexts, mapping },
     });
   });

package/reactHooks/feed/useBatchLoading.ts

@@ -45,19 +45,23 @@ const filterEmptyData = (data) => {
   return true;
 };
 
-const extractData = compose(uniq, map(dataOf));
+const getData = (rawData) =>
+  rawData.component_type === "gallery-qb"
+    ? rawData.ui_components[0].data
+    : rawData.data;
+
+const extractData = compose(uniq, map(getData));
 
 export const allFeedsIsReady = (
   feeds: ZappPipesCollection,
   urls: (ZappDataSourceSource | null)[]
 ): boolean =>
-  urls
-    .filter(complement(isNil))
-    .map((url) => (url ? checkFeedIsReady(feeds[url]) : false))
-    .every(Boolean);
+  urls.every((url) =>
+    isNil(url) ? true : url && feeds[url] ? checkFeedIsReady(feeds[url]) : false
+  );
 
 export const useBatchLoading = (
-  data: { data?: ZappDataSource }[],
+  componentsToRender: { data?: ZappDataSource; component_type: string }[],
   options: Options
 ) => {
   const dispatch = useDispatch();
@@ -65,10 +69,18 @@ export const useBatchLoading = (
   const [searchContext] = ZappPipesSearchContext.useZappPipesContext();
   const [hasEverBeenReady, setHasEverBeenReady] = React.useState(false);
 
-  const takeBatchSize = take(
-    min(options.initialBatchSize ?? DEFAULT_BATCH_SIZE, data.length)
-  );
+  // if first component is gallery-qb, take only one component for initial load
+  const takeSize =
+    componentsToRender?.[0]?.component_type === "gallery-qb"
+      ? 1
+      : min(
+          options.initialBatchSize ?? DEFAULT_BATCH_SIZE,
+          componentsToRender.length
+        );
+
+  const takeBatchSize = React.useCallback(take(takeSize), [takeSize]);
 
+  // Prepare inflated url for datasource
   const getUrl = React.useCallback(
     (data) => {
       const mappedFeed = data.mapping
@@ -88,13 +100,16 @@ export const useBatchLoading = (
     [entryContext, screenContext, searchContext]
   );
 
-  const batchData = takeBatchSize(data);
+  // components for initial load
+  const batchComponents = takeBatchSize(componentsToRender);
 
+  // contains datasources from batch components loading
   const feedData: ZappDataSource[] = React.useMemo(
-    () => extractData(batchData).filter(filterEmptyData),
-    [batchData]
+    () => extractData(batchComponents).filter(filterEmptyData),
+    [batchComponents]
   );
 
+  // contains inflated urls from batch components loading
   const feedUrls: ZappDataSourceSource[] = React.useMemo(
     () =>
       feedData.map((data) => {
@@ -102,34 +117,43 @@ export const useBatchLoading = (
 
         return mappedFeedUrl;
       }),
-    [] // No watchers as batch loaders is used only for initial load
+    []
   );
 
   const feeds = useZappPipesFeeds(feedUrls);
 
-  React.useEffect(() => {
-    const datasources = map(dataOf, batchData)
-      .filter(filterEmptyData)
-      .filter((data) => {
-        const feed = feeds[data.source];
+  // dispatch loadPipesData for each feed that is not loaded
+  const runBatchLoading = React.useCallback(() => {
+    batchComponents.forEach((rawData: any) => {
+      // 1. get data (dataOf)
 
-        if (!feed) return true;
+      const data = getData(rawData);
 
-        return !feedHasData(feed) && !feedIsLoading(feed);
-      });
+      // 2. filter out empty data filterEmptyData
+      if (!filterEmptyData(data)) return false;
 
-    datasources.forEach((data) => {
-      const mappedFeedUrl = getUrl(data);
+      // 3. filter out data that is already loaded (feeds[data.source]) &  !feedHasData(feed) && !feedIsLoading(feed);
+      const feed = feeds[data?.source];
 
-      if (mappedFeedUrl) {
-        return dispatch(
-          loadPipesData(mappedFeedUrl, { riverId: options.riverId })
-        );
+      if (!feed || (!feedHasData(feed) && !feedIsLoading(feed))) {
+        const mappedFeedUrl = getUrl(data);
+
+        if (mappedFeedUrl) {
+          // 4. load data
+          return dispatch(
+            loadPipesData(mappedFeedUrl, { riverId: options.riverId })
+          );
+        }
       }
     });
-  }, []); // No watchers as batch loaders is used only for initial load
+  }, [feedUrls]);
+
+  React.useEffect(() => {
+    runBatchLoading();
+  }, []);
 
   React.useEffect(() => {
+    // check if all feeds are ready and set hasEverBeenReady to true
     if (allFeedsIsReady(feeds, feedUrls) && !hasEverBeenReady) {
       setHasEverBeenReady(true);
     }

package/reactHooks/feed/useBuildPipesUrl.ts

@@ -1,7 +1,6 @@
-// @ts-ignore
 import { RequestBuilder } from "@applicaster/zapp-pipes-v2-client";
-import { useEffect, useState } from "react";
-import { useInflatedUrl } from "./useInflatedUrl";
+import * as React from "react";
+import { useInflatedUrl } from "@applicaster/zapp-react-native-utils/reactHooks/feed/useInflatedUrl";
 import { reactHooksLogger } from "../logger";
 
 export const logger = reactHooksLogger.addSubsystem("build-pipes-url");
@@ -15,18 +14,16 @@ type PipesBuildRequestObject = {
 export function useBuildPipesUrl({
   url,
   mapping = {},
+  requestBuilder = new RequestBuilder(),
 }): PipesBuildRequestObject {
-  const [requestParams, setRequestParams] = useState<object | null>(null);
-  const [error, setError] = useState(null);
+  const [requestParams, setRequestParams] = React.useState<object | null>(null);
 
+  const [error, setError] = React.useState(null);
   const inflatedUrl = useInflatedUrl({ feedUrl: url, mapping });
 
-  const requestBuilder = new RequestBuilder();
-
   const buildRequest = async (_url) => {
     try {
       const result = await requestBuilder.build(_url);
-
       setRequestParams(result);
     } catch (e) {
       setError(e);
@@ -34,7 +31,7 @@ export function useBuildPipesUrl({
     }
   };
 
-  useEffect(() => {
+  React.useEffect(() => {
     if (inflatedUrl && !requestParams) {
       buildRequest(inflatedUrl);
     }
@@ -42,7 +39,7 @@ export function useBuildPipesUrl({
 
   return {
     url: inflatedUrl || "",
-    requestParams: requestParams, // TODO should it be: || {} ?
+    requestParams, // TODO should it be: || {} ?
     error: error || undefined,
   };
 }

package/reactHooks/feed/useFeedRefresh.tsx

@@ -1,7 +1,8 @@
 import * as React from "react";
-import * as R from "ramda";
+import { path, max } from "ramda";
 import { isTrue } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { toNumberWithDefault } from "@applicaster/zapp-react-native-utils/numberUtils";
+import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 
 import { reactHooksLogger } from "../logger";
 import { ReloadDataFunction } from "./useFeedLoader";
@@ -18,9 +19,8 @@ const minimumRefreshingInterval = 5;
 const defaultRefreshInterval = 60;
 
 export const useFeedRefresh = ({ reloadData, component }: Props): void => {
-  const enable_data_refreshing = R.path(
-    ["rules", "enable_data_refreshing"],
-    component
+  const isDataRefreshingEnabled = isTrue(
+    path(["rules", "enable_data_refreshing"], component)
   );
 
   const refreshing_interval = toNumberWithDefault(
@@ -29,10 +29,12 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
   );
 
   const refreshingIntervalInMilliseconds =
-    R.max(refreshing_interval, minimumRefreshingInterval) * 1000;
+    max(refreshing_interval, minimumRefreshingInterval) * 1000;
+
+  const isScreenActive = useIsScreenActive();
 
   React.useEffect(() => {
-    if (isTrue(enable_data_refreshing) && refreshing_interval) {
+    if (isDataRefreshingEnabled && refreshing_interval && isScreenActive) {
       if (refreshing_interval < minimumRefreshingInterval) {
         feedRefreshLogger.warning({
           message: `You set your feed refresh interval to ${refreshing_interval} when minimum value is ${minimumRefreshingInterval}seconds.Your feed will refresh after ${minimumRefreshingInterval}seconds.`,
@@ -59,5 +61,5 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
         clearInterval(refreshInterval);
       };
     }
-  }, [reloadData]);
+  }, [reloadData, isScreenActive]);
 };