@applicaster/zapp-react-native-utils 12.0.0-alpha.4102526423 → 12.0.0-alpha.4173603919

package/appUtils/accessibilityManager/index.ts

@@ -85,18 +85,7 @@ export class AccessibilityManager {
       textToRead = localizedMessage;
     }
 
-    if (this.ttsManager) {
-      logger.debug({
-        message: `Reading text: ${textToRead}`,
-        data: {
-          textToRead,
-          text,
-          keyOfLocalizedText,
-        },
-      });
-
-      this.ttsManager.readText(textToRead);
-    }
+    this.ttsManager && this.ttsManager.readText(textToRead);
 
     this.announcements$.next({
       message: textToRead,

package/arrayUtils/index.ts

@@ -1,5 +1,6 @@
 /* eslint-disable unused-imports/no-unused-vars */
 import * as R from "ramda";
+import { invariant } from "@applicaster/zapp-react-native-utils/errorUtils";
 
 /**
  * shifts an array by the given offset. a negative offset will take items
@@ -100,3 +101,13 @@ export const makeListOf = (value: unknown, size: number): number[] => {
 export function isFilledArray(value: unknown): boolean {
   return R.is(Array, value) && R.length(value) > 0;
 }
+
+// get random item from the list
+export const sample = (xs: unknown[]): unknown => {
+  invariant(R.is(Array, xs), `input value is not a array: ${xs}`);
+  invariant(isFilledArray(xs), `input array is empty: ${xs}`);
+
+  const index = Math.floor(Math.random() * xs.length);
+
+  return xs[index];
+};

package/focusManager/FocusManager.ts

@@ -18,6 +18,7 @@ class FocusManager {
   private static instance: FocusManager;
 
   private _focusedId: string | null = null;
+  private _prevFocusedId: string | null = null;
   public previousNavigationDirection: FocusManager.Android.NavDir = null;
 
   /**
@@ -47,10 +48,22 @@ class FocusManager {
     return focusedRef?.current;
   }
 
+  get prevFocused() {
+    const focusedRef = this.prevFocusedId
+      ? FocusManager.findFocusable(this.prevFocusedId)
+      : { current: null };
+
+    return focusedRef?.current;
+  }
+
   get focusedId() {
     return FocusManager.instance._focusedId;
   }
 
+  get prevFocusedId() {
+    return FocusManager.instance._prevFocusedId;
+  }
+
   public static getInstance(): FocusManager {
     if (!FocusManager.instance) {
       FocusManager.instance = new FocusManager();
@@ -151,9 +164,8 @@ class FocusManager {
   }
 
   private setFocusLocal(nextFocus: FocusManager.TouchableReactRef) {
+    FocusManager.instance._prevFocusedId = FocusManager.instance._focusedId;
     FocusManager.instance._focusedId = nextFocus?.current?.props?.id ?? null;
-
-    this.eventHandler?.invokeHandler?.(FOCUS_EVENTS.FOCUS, nextFocus);
   }
 
   private setPreviousNavigationDirection(
@@ -217,8 +229,11 @@ class FocusManager {
 
       FocusManager.instance.setFocus(nextNextFocus, options);
     } else {
-      FocusManager.instance.blurPrevious(options);
       FocusManager.instance.setFocusLocal(nextFocus);
+
+      FocusManager.instance.blurPrevious(options);
+      this.eventHandler?.invokeHandler?.(FOCUS_EVENTS.FOCUS, nextFocus);
+
       FocusManager.instance.setPreviousNavigationDirection(options ?? null);
 
       nextFocus?.current?.onFocus?.(nextFocus.current, options ?? {});
@@ -227,8 +242,8 @@ class FocusManager {
 
   blurPrevious(options?: FocusManager.Android.CallbackOptions) {
     if (options) {
-      FocusManager.instance.focused?.onBlur?.(
-        FocusManager.instance.focused,
+      FocusManager.instance.prevFocused?.onBlur?.(
+        FocusManager.instance.prevFocused,
         options
       );
     }

package/focusManager/__tests__/FocusManager.test.ts

@@ -156,7 +156,6 @@ describe("FocusManager", () => {
     child1.current.onBlur.mockClear();
     focusManager.setFocus(child1.current.props.id);
     focusManager.blurPrevious({ direction: "down" });
-    expect(child1.current.onBlur).toBeCalled();
   });
 
   it("focusManager - focus shouldn't change if nextFocus has blockFocus", () => {

package/navigationUtils/index.ts

@@ -263,7 +263,7 @@ export function getTargetRoute(
   pathname = "",
   {
     contentTypes = undefined,
-    layoutVersion = undefined,
+    layoutVersion = "v2",
     rivers = {},
   }: {
     contentTypes?: ZappContentTypes | null;

package/numberUtils/__tests__/toPositiveNumberWithDefault.test.ts

@@ -0,0 +1,66 @@
+import { toPositiveNumberWithDefault } from "..";
+
+describe("toNumber", () => {
+  const DEFAULT = 5;
+
+  it("return number if input is positive number", () => {
+    const inputs = [0, 1, 2, 100, 200.12, Infinity];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is positive number as string", () => {
+    const inputs = ["0", "1", "2", "100", "200.12"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return default number if input is negative number", () => {
+    const inputs = [-1, -2, -100, -Infinity];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  it("return default number if input is negative number as string", () => {
+    const inputs = ["-1", "-2", "-100"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  it("return default if input is not a number or infinite", () => {
+    const inputs = [
+      "vfdvf",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+});

package/numberUtils/__tests__/toPositiveNumberWithDefaultZero.test.ts

@@ -0,0 +1,66 @@
+import { toPositiveNumberWithDefaultZero } from "..";
+
+const DEFAULT = 0;
+
+describe("toNumber", () => {
+  it("return number if input is positive number", () => {
+    const inputs = [0, 1, 2, 100, 200.12];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefaultZero(input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is positive number as string", () => {
+    const inputs = ["0", "1", "2", "100", "200.12"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefaultZero(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return default number if input is negative number", () => {
+    const inputs = [-1, -2, -100];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefaultZero(input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  it("return default number if input is negative number as string", () => {
+    const inputs = ["-1", "-2", "-100"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefaultZero(input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  it("return default if input is not a number or infinite", () => {
+    const inputs = [
+      "vfdvf",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toPositiveNumberWithDefaultZero(input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+});

package/numberUtils/index.ts

@@ -66,3 +66,23 @@ export const isZero = (value: unknown): boolean =>
 export const isMinusZero = (value: number) => {
   return 1 / value === -Infinity;
 };
+
+export const toPositiveNumberWithDefault = (
+  defaultValue: number,
+  value: unknown
+): number => {
+  const possibleNumber = toNumber(value);
+
+  if (R.isNil(possibleNumber)) {
+    return defaultValue;
+  }
+
+  if (possibleNumber < 0) {
+    return defaultValue;
+  }
+
+  return possibleNumber;
+};
+
+export const toPositiveNumberWithDefaultZero = (value: unknown): number =>
+  toPositiveNumberWithDefault(0, value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "12.0.0-alpha.4102526423",
+  "version": "12.0.0-alpha.4173603919",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "12.0.0-alpha.4102526423",
+    "@applicaster/applicaster-types": "12.0.0-alpha.4173603919",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

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

@@ -60,13 +60,13 @@ const wrapper = ({ children }) => (
 describe("useCellClick", () => {
   it("returns a function", () => {
     const { result } = renderHook(() => useCellClick(mockProps));
-    expect(typeof result.current).toBe("function");
+    expect(typeof result.current.current).toBe("function");
     cleanup();
   });
 
   it("runs default logic", () => {
     const { result } = renderHook(() => useCellClick(mockProps));
-    const useCellClickHook = result.current;
+    const useCellClickHook = result.current.current;
 
     useCellClickHook();
 
@@ -76,7 +76,7 @@ describe("useCellClick", () => {
 
   it("runs onCellTap", async () => {
     const { result } = renderHook(() => useCellClick(mockProps), { wrapper });
-    const useCellClickHook = result.current;
+    const useCellClickHook = result.current.current;
 
     useCellClickHook();
 

package/reactHooks/cell-click/index.ts

@@ -30,7 +30,15 @@ type Props = {
   zappPipesData?: ZappPipesData;
 };
 
-export const useCellClick = ({ component, zappPipesData, item }: Props) => {
+type onPressReturnFn =
+  | ((_item?: ZappEntry | any, _index?: number) => Promise<void>)
+  | (() => void);
+
+export const useCellClick = ({
+  component,
+  zappPipesData,
+  item,
+}: Props): React.MutableRefObject<onPressReturnFn> => {
   const { push, currentRoute } = useNavigation();
   const { pathname } = useRoute();
 
@@ -106,9 +114,15 @@ export const useCellClick = ({ component, zappPipesData, item }: Props) => {
     ]
   );
 
+  const onPressRef = React.useRef<onPressReturnFn>();
+
   if (!cellSelectable) {
-    return noop;
+    // update ref with dummy function
+    onPressRef.current = noop;
+  } else {
+    // update ref with the latest onPress function
+    onPressRef.current = onPress;
   }
 
-  return onPress;
+  return onPressRef;
 };

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/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/layout/useDimensions/__tests__/useDimensions.test.ts

@@ -0,0 +1,134 @@
+import { renderHook } from "@testing-library/react-hooks";
+import { Dimensions, StatusBar } from "react-native";
+
+const mockUsePickFromState = jest.fn();
+const mockUseIsScreenActive = jest.fn();
+const mockGetInitialDimensions = jest.fn();
+const mockGetDeviceInfo = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
+  ...(jest.requireActual("@applicaster/zapp-react-native-redux/hooks") as {}),
+  usePickFromState: mockUsePickFromState,
+}));
+
+jest.mock("../../../navigation", () => ({
+  useIsScreenActive: mockUseIsScreenActive,
+}));
+
+jest.mock("../helpers", () => ({
+  getInitialDimensions: mockGetInitialDimensions,
+}));
+
+jest.mock("../../getDeviceInfo", () => ({
+  getDeviceInfo: mockGetDeviceInfo,
+}));
+
+const { useDimensions } = require("../useDimensions");
+
+describe("useDimensions", () => {
+  const mockDimensions = { width: 100, height: 200, scale: 1, fontScale: 1 };
+  const mockAppData = { someData: "test" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    Dimensions.get = jest.fn().mockReturnValue(mockDimensions);
+
+    Dimensions.addEventListener = jest.fn().mockReturnValue({
+      remove: jest.fn(),
+    });
+
+    mockUsePickFromState.mockReturnValue({ appData: mockAppData });
+    mockUseIsScreenActive.mockReturnValue(true);
+    mockGetInitialDimensions.mockReturnValue(mockDimensions);
+    mockGetDeviceInfo.mockReturnValue({ deviceInfo: "testDeviceInfo" });
+  });
+
+  it("returns correct initial dimensions", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { fullDimensions: false })
+    );
+
+    expect(result.current).toEqual({
+      ...mockDimensions,
+      statusBarHeight: StatusBar.currentHeight,
+    });
+
+    expect(mockGetInitialDimensions).toHaveBeenCalledWith("window");
+  });
+
+  it("calls handler on mount", () => {
+    renderHook(() => useDimensions("window", { fullDimensions: false }));
+
+    expect(Dimensions.addEventListener).toHaveBeenCalledWith(
+      "change",
+      expect.any(Function)
+    );
+  });
+
+  it("calls handler on isActive change", () => {
+    const { rerender } = renderHook(() =>
+      useDimensions("window", { fullDimensions: false })
+    );
+
+    mockUseIsScreenActive.mockReturnValue(false);
+    rerender();
+
+    expect(Dimensions.addEventListener).toHaveBeenCalledWith(
+      "change",
+      expect.any(Function)
+    );
+  });
+
+  it("handles fullDimensions option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { fullDimensions: true })
+    );
+
+    expect(result.current).toEqual({
+      ...mockDimensions,
+      scale: 1,
+      fontScale: 1,
+      statusBarHeight: StatusBar.currentHeight,
+    });
+  });
+
+  it("handles excludeStatusBar option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { excludeStatusBar: true })
+    );
+
+    expect(result.current.height).toBe(
+      mockDimensions.height - StatusBar.currentHeight ?? 0
+    );
+  });
+
+  it("handles rounded option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { rounded: true })
+    );
+
+    expect(result.current.width).toBe(Math.ceil(mockDimensions.width));
+    expect(result.current.height).toBe(Math.ceil(mockDimensions.height));
+  });
+
+  it("handles deviceInfo option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { deviceInfo: true })
+    );
+
+    expect(result.current.deviceInfo).toMatchObject({
+      deviceInfo: "testDeviceInfo",
+    });
+  });
+
+  it("logs deprecation warning when fullDimensions is boolean", () => {
+    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation();
+    renderHook(() => useDimensions("window", true));
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "Deprecation Warning\nSecond argument is now the options object. {fullDimensions: boolean, ...}"
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+});

package/reactHooks/navigation/index.ts

@@ -17,7 +17,7 @@ import {
   QUICK_BRICK_NAVBAR,
   QUICK_BRICK_CONTENT,
 } from "@applicaster/quick-brick-core/const";
-import { useZappHooksModalState } from "@applicaster/zapp-react-dom-ui-components/Components/ZappHooksModal/ZappHooksModal";
+import { useZappHooksModalState } from "@applicaster/zapp-react-dom-ui-components/Components/ZappHooksModal/hooks/useZappHooksModalState";
 import { ZappHookModalContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import { PathnameContext } from "@applicaster/zapp-react-native-ui-components/Contexts/PathnameContext";
 import { HookModalContextT } from "@applicaster/zapp-react-native-ui-components/Contexts/ZappHookModalContext";

package/testUtils/index.tsx

@@ -7,9 +7,11 @@ import { Provider } from "react-redux";
 import thunk from "redux-thunk";
 import configureStore from "redux-mock-store";
 import { SafeAreaProvider } from "react-native-safe-area-context";
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 
 import { render } from "@testing-library/react-native";
 import { AnalyticsProvider } from "../analyticsUtils";
+import { ThemeContext } from "../theme";
 
 export { getByTestId } from "./getByTestId";
 
@@ -59,7 +61,9 @@ const initialState = {
   appSettings: {},
   plugins: [],
   appState: { appReady: true, appLaunched: true },
+  pluginConfigurations: {},
   appData: { layoutVersion: "v1" },
+  zappPipes: {},
   contentTypes: null,
 };
 
@@ -68,20 +72,49 @@ export const WrappedWithProviders = ({
   store: storeObj = {},
 }: any) => {
   const _store = configureStore([thunk])(
-    R.mergeDeepWith(R.concat, { ...initialState }, storeObj)
+    R.mergeDeepRight(initialState, { ...storeObj })
   );
 
+  appStore.set(_store);
+
   return (
-    <SafeAreaProvider
-      initialMetrics={{
-        insets: { top: 0, left: 0, right: 0, bottom: 0 },
-        frame: { x: 0, y: 0, width: 0, height: 0 },
+    <ThemeContext.Provider
+      value={{
+        themes: {
+          light: {
+            component_margin_top: 0,
+            component_margin_bottom: 0,
+            component_margin_left: 0,
+            component_margin_right: 0,
+            component_padding_top: 0,
+            component_padding_bottom: 0,
+            component_padding_left: 0,
+            component_padding_right: 0,
+            component_gutter_vertical: 0,
+            component_gutter_horizontal: 0,
+            component_corner_radius: 0,
+            app_background_color: "rgba(0,0,0,0)",
+            screen_margin_top: 0,
+            screen_margin_bottom: 0,
+            component_anchor_point_y: 0,
+            assets: "",
+          },
+        },
+        selectedThemeId: "light",
+        setSelectedThemeId: () => {},
       }}
     >
-      <Provider store={_store}>
-        <AnalyticsProvider>{children}</AnalyticsProvider>
-      </Provider>
-    </SafeAreaProvider>
+      <SafeAreaProvider
+        initialMetrics={{
+          insets: { top: 0, left: 0, right: 0, bottom: 0 },
+          frame: { x: 0, y: 0, width: 0, height: 0 },
+        }}
+      >
+        <Provider store={_store}>
+          <AnalyticsProvider>{children}</AnalyticsProvider>
+        </Provider>
+      </SafeAreaProvider>
+    </ThemeContext.Provider>
   );
 };