@applicaster/zapp-react-native-utils 15.0.0-rc.98 → 15.1.0-rc.1

package/reactHooks/layout/useDimensions/__tests__/{useDimensions.test.tsx → useDimensions.test.ts}

@@ -1,10 +1,16 @@
-import React from "react";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import { Dimensions, StatusBar } from "react-native";
 import { useDimensions } from "../useDimensions";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux";
 
 import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive";
-import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+
+jest.mock("@applicaster/zapp-react-native-redux/hooks", () => {
+  return {
+    ...jest.requireActual("@applicaster/zapp-react-native-redux/hooks"),
+    usePickFromState: jest.fn(),
+  };
+});
 
 jest.mock(
   "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
@@ -36,22 +42,12 @@ describe("useDimensions", () => {
 
   beforeEach(() => {
     StatusBar.currentHeight = 20;
+    (usePickFromState as jest.Mock).mockReturnValue({ appData: mockAppData });
   });
 
   it("returns correct initial dimensions", () => {
-    const { result } = renderHook(
-      () => useDimensions("window", { fullDimensions: false }),
-      {
-        wrapper: ({ children }) => (
-          <WrappedWithProviders
-            store={{
-              appData: mockAppData,
-            }}
-          >
-            {children}
-          </WrappedWithProviders>
-        ),
-      }
+    const { result } = renderHook(() =>
+      useDimensions("window", { fullDimensions: false })
     );
 
     expect(result.current).toMatchObject({
@@ -60,17 +56,7 @@ describe("useDimensions", () => {
   });
 
   it("calls handler on mount", () => {
-    renderHook(() => useDimensions("window", { fullDimensions: false }), {
-      wrapper: ({ children }) => (
-        <WrappedWithProviders
-          store={{
-            appData: mockAppData,
-          }}
-        >
-          {children}
-        </WrappedWithProviders>
-      ),
-    });
+    renderHook(() => useDimensions("window", { fullDimensions: false }));
 
     expect(Dimensions.addEventListener).toHaveBeenCalledWith(
       "change",
@@ -79,23 +65,12 @@ describe("useDimensions", () => {
   });
 
   it("calls handler on isActive change", () => {
-    const { rerender } = renderHook(
-      () => useDimensions("window", { fullDimensions: false }),
-      {
-        wrapper: ({ children }) => (
-          <WrappedWithProviders
-            store={{
-              appData: mockAppData,
-            }}
-          >
-            {children}
-          </WrappedWithProviders>
-        ),
-      }
+    const { rerender } = renderHook(() =>
+      useDimensions("window", { fullDimensions: false })
     );
 
     (useIsScreenActive as jest.Mock).mockReturnValue(false);
-    rerender({});
+    rerender();
 
     expect(Dimensions.addEventListener).toHaveBeenCalledWith(
       "change",
@@ -104,19 +79,8 @@ describe("useDimensions", () => {
   });
 
   it("handles fullDimensions option", () => {
-    const { result } = renderHook(
-      () => useDimensions("window", { fullDimensions: true }),
-      {
-        wrapper: ({ children }) => (
-          <WrappedWithProviders
-            store={{
-              appData: mockAppData,
-            }}
-          >
-            {children}
-          </WrappedWithProviders>
-        ),
-      }
+    const { result } = renderHook(() =>
+      useDimensions("window", { fullDimensions: true })
     );
 
     expect(result.current).toMatchObject({
@@ -127,19 +91,8 @@ describe("useDimensions", () => {
   });
 
   it("handles excludeStatusBar option", () => {
-    const { result } = renderHook(
-      () => useDimensions("window", { excludeStatusBar: true }),
-      {
-        wrapper: ({ children }) => (
-          <WrappedWithProviders
-            store={{
-              appData: mockAppData,
-            }}
-          >
-            {children}
-          </WrappedWithProviders>
-        ),
-      }
+    const { result } = renderHook(() =>
+      useDimensions("window", { excludeStatusBar: true })
     );
 
     expect(result.current.height).toBe(
@@ -148,19 +101,8 @@ describe("useDimensions", () => {
   });
 
   it("handles rounded option", () => {
-    const { result } = renderHook(
-      () => useDimensions("window", { rounded: true }),
-      {
-        wrapper: ({ children }) => (
-          <WrappedWithProviders
-            store={{
-              appData: mockAppData,
-            }}
-          >
-            {children}
-          </WrappedWithProviders>
-        ),
-      }
+    const { result } = renderHook(() =>
+      useDimensions("window", { rounded: true })
     );
 
     expect(result.current.width).toBe(Math.ceil(mockDimensions.width));
@@ -168,19 +110,8 @@ describe("useDimensions", () => {
   });
 
   it("handles deviceInfo option", () => {
-    const { result } = renderHook(
-      () => useDimensions("window", { deviceInfo: true }),
-      {
-        wrapper: ({ children }) => (
-          <WrappedWithProviders
-            store={{
-              appData: mockAppData,
-            }}
-          >
-            {children}
-          </WrappedWithProviders>
-        ),
-      }
+    const { result } = renderHook(() =>
+      useDimensions("window", { deviceInfo: true })
     );
 
     expect(result.current.deviceInfo).toMatchObject({
@@ -190,18 +121,7 @@ describe("useDimensions", () => {
 
   it("logs deprecation warning when fullDimensions is boolean", () => {
     const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation();
-
-    renderHook(() => useDimensions("window", true), {
-      wrapper: ({ children }) => (
-        <WrappedWithProviders
-          store={{
-            appData: mockAppData,
-          }}
-        >
-          {children}
-        </WrappedWithProviders>
-      ),
-    });
+    renderHook(() => useDimensions("window", true));
 
     expect(consoleWarnSpy).toHaveBeenCalledWith(
       "Deprecation Warning\nSecond argument is now the options object. {fullDimensions: boolean, ...}"

package/reactHooks/layout/useDimensions/useDimensions.ts

@@ -3,7 +3,7 @@ import { useLayoutEffect, useMemo, useRef, useState } from "react";
 import * as R from "ramda";
 
 import { Dimensions, Platform, StatusBar } from "react-native";
-import { useAppData } from "@applicaster/zapp-react-native-redux/hooks";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { isTV } from "../../../reactUtils";
 
@@ -37,7 +37,7 @@ export const useDimensions: UseDimensions = (
 ) => {
   const statusBarHeight = StatusBar?.currentHeight;
   const isActive = useIsScreenActive();
-  const appData = useAppData();
+  const { appData } = usePickFromState(["appData"]);
 
   if (typeof fullDimensions === "boolean") {
     // eslint-disable-next-line no-console

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 { renderHook } from "@testing-library/react-hooks";
 import { isNavBarVisible, useRoute } from "../";
 import { Provider } from "react-redux";
 import configureMockStore from "redux-mock-store";
@@ -86,11 +86,11 @@ const hookModalContextState = {
 };
 
 const hooksModalPathname = `${ROUTE_TYPES.HOOKS_MODAL}/${hookModalContextState.state.screenData.payload.id}`;
-const videoModalPathname = `${ROUTE_TYPES.VIDEO_MODAL}/${videoModalNavigator.videoModalState.item.id}`;
 
 jest.mock(
   "@applicaster/zapp-react-native-ui-components/Contexts/ZappHookModalContext",
   () => {
+    // Define state inside mock factory to avoid hoisting issues
     const mockState = {
       isRunningInBackground: false,
       setIsRunningInBackground: jest.fn(),
@@ -111,6 +111,7 @@ jest.mock(
       return selector ? selector(mockState) : mockState;
     }) as jest.MockedFunction<any> & { getState: () => typeof mockState };
 
+    // Add getState method to the mock hook (Zustand stores have this)
     mockHook.getState = jest.fn(() => mockState);
 
     return {
@@ -120,6 +121,7 @@ jest.mock(
   }
 );
 
+const videoModalPathname = `${ROUTE_TYPES.VIDEO_MODAL}/${videoModalNavigator.videoModalState.item.id}`;
 const mockStore = configureMockStore();
 
 const store = mockStore({

package/reactHooks/navigation/index.ts

@@ -4,7 +4,7 @@ import { shallow } from "zustand/shallow";
 
 import {
   useContentTypes,
-  usePlugins,
+  usePickFromState,
 } from "@applicaster/zapp-react-native-redux/hooks";
 import { HooksManager } from "@applicaster/zapp-react-native-utils/appUtils/HooksManager";
 
@@ -17,8 +17,6 @@ import { useConnectionInfo } from "../connection";
 import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { pick } from "@applicaster/zapp-react-native-utils/utils";
 import { useNavbarState } from "../screen";
-import { useRivers } from "../state";
-import { useLayoutVersion } from "../layout";
 
 export { useNavigation } from "./useNavigation";
 
@@ -181,10 +179,11 @@ export const useZappHooksForEntry = (
     shallow
   );
 
-  const plugins = usePlugins();
-  const rivers = useRivers();
-
-  const layoutVersion = useLayoutVersion();
+  const {
+    appData: { layoutVersion },
+    rivers,
+    plugins,
+  } = usePickFromState(["appData", "rivers", "plugins"]);
 
   const contentTypes = useContentTypes();
 

package/reactHooks/navigation/useRoute.ts

@@ -3,10 +3,7 @@
 
 import { useContext } from "react";
 
-import {
-  useContentTypes,
-  usePlugins,
-} from "@applicaster/zapp-react-native-redux/hooks";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { legacyScreenData } from "@applicaster/quick-brick-core/App/NavigationProvider/utils";
 
@@ -17,7 +14,6 @@ import { useNavigation } from "./useNavigation";
 import { useModalStoreState } from "../../modalState";
 import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 import { usePathname } from "./usePathname";
-import { useRivers } from "../state";
 
 // starts with modal/
 const isModalPathname = (pathname: string) => /^modal\//.test(pathname);
@@ -46,9 +42,11 @@ export const useRoute = (
     ? legacyScreenData(screenContext)
     : screenContext;
 
-  const plugins = usePlugins();
-  const rivers = useRivers();
-  const contentTypes = useContentTypes();
+  const { plugins, contentTypes, rivers } = usePickFromState([
+    "plugins",
+    "rivers",
+    "contentTypes",
+  ]);
 
   const modalState = useModalStoreState();
 

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -147,34 +147,17 @@ export class TVSeekController
 
     let targetPos = currentPos;
 
-    const isLive = this.playerController.isLive();
-
-    if (isLive) {
-      if (this.currentSeekType === SEEK_TYPE.REWIND) {
-        targetPos = Math.min(
-          currentPos + offset,
-          this.playerController.getSeekableDuration()
-        );
-      } else if (this.currentSeekType === SEEK_TYPE.FORWARD) {
-        targetPos = Math.max(0, currentPos - offset);
-      } else {
-        log_warning(
-          `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
-        );
-      }
+    if (this.currentSeekType === SEEK_TYPE.FORWARD) {
+      targetPos = Math.min(
+        currentPos + offset,
+        this.playerController.getSeekableDuration()
+      );
+    } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
+      targetPos = Math.max(0, currentPos - offset);
     } else {
-      if (this.currentSeekType === SEEK_TYPE.FORWARD) {
-        targetPos = Math.min(
-          currentPos + offset,
-          this.playerController.getSeekableDuration()
-        );
-      } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
-        targetPos = Math.max(0, currentPos - offset);
-      } else {
-        log_warning(
-          `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
-        );
-      }
+      log_warning(
+        `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+      );
     }
 
     log_debug(

package/reactHooks/player/__tests__/useAutoSeek._test.tsx

@@ -1,4 +1,4 @@
-import { act, renderHook } from "@testing-library/react-native";
+import { act, renderHook } from "@testing-library/react-hooks";
 import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
 
 import { ON_HOLD_INTERVAL, SEEK_TYPE, SKIP_TIME_BASE } from "../const";

package/reactHooks/player/__tests__/useTapSeek._test.ts

@@ -1,4 +1,4 @@
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
 import { useTapSeek } from "../useTapSeek";
 

package/reactHooks/resolvers/__tests__/useCellResolver.test.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { View } from "react-native";
-import { cleanup, renderHook } from "@testing-library/react-native";
+import { cleanup, renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
 import { Provider } from "react-redux";
 

package/reactHooks/resolvers/__tests__/useComponentResolver.test.tsx

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { renderHook, cleanup } from "@testing-library/react-native";
+import { renderHook, cleanup } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
 import { Provider } from "react-redux";
 

package/reactHooks/resolvers/useCellResolver.ts

@@ -3,10 +3,7 @@ import memoizee from "memoizee";
 import * as R from "ramda";
 
 import { CellRendererResolver } from "@applicaster/zapp-react-native-ui-components/Components/CellRendererResolver";
-import {
-  usePlugins,
-  useCellStyles,
-} from "@applicaster/zapp-react-native-redux";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import { useDimensions } from "../layout";
 import { useIsRTL } from "../../localizationUtils";
 
@@ -56,8 +53,7 @@ export function useCellResolver({
     updateForInactiveScreens: false,
   });
 
-  const plugins = usePlugins();
-  const cellStyles = useCellStyles();
+  const { plugins, cellStyles } = usePickFromState(["plugins", "cellStyles"]);
   const isRTL = useIsRTL();
 
   const options = {

package/reactHooks/resolvers/useComponentResolver.ts

@@ -1,12 +1,10 @@
 /// <reference types="@applicaster/applicaster-types" />
 import * as React from "react";
 
+import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
+
 import { findComponentByType } from "@applicaster/zapp-react-native-utils/pluginUtils";
-import {
-  usePlugins,
-  useAppSelector,
-  selectComponents,
-} from "@applicaster/zapp-react-native-redux";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 type Decorator = (component: React.Component<any>) => React.Component<any>;
 type Watcher = Array<any>;
@@ -19,11 +17,9 @@ export function useComponentResolver(
   { componentType, decorators }: Props,
   watchers?: Watcher
 ): React.ComponentType<any> {
-  const plugins = usePlugins();
-
-  const components = useAppSelector(selectComponents);
+  const { plugins, components } = usePickFromState(["plugins", "components"]);
 
-  return React.useMemo(
+  const component = React.useMemo(
     () =>
       findComponentByType({
         components,
@@ -33,4 +29,12 @@ export function useComponentResolver(
       }),
     watchers
   );
+
+  if (!component) {
+    coreLogger.warn({
+      message: `useComponentResolver: Component of type ${componentType} not found`,
+    });
+  }
+
+  return component;
 }

package/reactHooks/screen/__tests__/useCurrentScreenData.test.tsx

@@ -1,8 +1,8 @@
 import * as React from "react";
 import { Provider } from "react-redux";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
-import { thunk } from "redux-thunk";
+import thunk from "redux-thunk";
 
 const mockStore = configureStore([thunk]);
 

package/reactHooks/screen/__tests__/useCurrentScreenIsHook.test.ts

@@ -0,0 +1,103 @@
+import { renderHook } from "@testing-library/react-native";
+import { useCurrentScreenIsHook } from "../useCurrentScreenIsHook";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { last } from "@applicaster/zapp-react-native-utils/utils";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks");
+jest.mock("@applicaster/zapp-react-native-utils/utils");
+jest.mock("@applicaster/zapp-react-native-utils/booleanUtils");
+
+const mockUseNavigation = useNavigation as jest.Mock;
+const mockLast = last as jest.Mock;
+const mockToBoolean = toBooleanWithDefaultFalse as jest.Mock;
+
+describe("useCurrentScreenIsHook", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // sensible defaults
+    mockUseNavigation.mockReturnValue({ mainStack: [] });
+    mockLast.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+  });
+
+  it("returns true when last route includes 'hook'", () => {
+    const stack = [{ route: "some-hook-screen" }];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+    mockToBoolean.mockReturnValue(true);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockLast).toHaveBeenCalledWith(stack);
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+
+  it("returns false when last route does not include 'hook'", () => {
+    const stack = [{ route: "home-screen" }];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(false);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when route is undefined", () => {
+    const stack = [{}];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when last(mainStack) is undefined (empty stack)", () => {
+    mockUseNavigation.mockReturnValue({ mainStack: [] });
+    mockLast.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockLast).toHaveBeenCalledWith([]);
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("uses default empty array when mainStack is undefined", () => {
+    mockUseNavigation.mockReturnValue({});
+    mockLast.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockLast).toHaveBeenCalledWith([]);
+    expect(result.current).toBe(false);
+  });
+
+  it("passes correct boolean result from includes('hook')", () => {
+    const stack = [{ route: "hook" }];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+
+    // simulate actual includes result flowing through
+    mockToBoolean.mockImplementation((val) => Boolean(val));
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+});

package/reactHooks/screen/__tests__/useCurrentScreenIsStartupHook.test.ts

@@ -0,0 +1,94 @@
+import { renderHook } from "@testing-library/react-native";
+import { useCurrentScreenIsStartupHook } from "../useCurrentScreenIsStartupHook";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { isFilledArray } from "@applicaster/zapp-react-native-utils/arrayUtils";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks");
+jest.mock("@applicaster/zapp-react-native-utils/arrayUtils");
+
+const mockUseNavigation = useNavigation as jest.Mock;
+const mockIsFilledArray = isFilledArray as jest.Mock;
+
+describe("useCurrentScreenIsStartupHook", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns true when startUpHooks is a filled array", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: ["hook1"],
+    });
+
+    mockIsFilledArray.mockReturnValue(true);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(true);
+    expect(mockIsFilledArray).toHaveBeenCalledWith(["hook1"]);
+  });
+
+  it('returns true when startUpHooks is "in_process"', () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: "in_process",
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(true);
+    expect(mockIsFilledArray).toHaveBeenCalledWith("in_process");
+  });
+
+  it("returns false when startUpHooks is empty array", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: [],
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(false);
+    expect(mockIsFilledArray).toHaveBeenCalledWith([]);
+  });
+
+  it("returns false when startUpHooks is undefined", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: undefined,
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(false);
+    expect(mockIsFilledArray).toHaveBeenCalledWith(undefined);
+  });
+
+  it("returns false when startUpHooks is null", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: null,
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(false);
+    expect(mockIsFilledArray).toHaveBeenCalledWith(null);
+  });
+
+  it("prioritizes filled array over string comparison", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: ["hook1"],
+    });
+
+    mockIsFilledArray.mockReturnValue(true);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(true);
+  });
+});

package/reactHooks/screen/__tests__/useScreenBackgroundColor.test.tsx

@@ -1,4 +1,4 @@
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 
 jest.mock(
   "@applicaster/zapp-react-native-ui-components/Components/River/useScreenConfiguration",