@applicaster/zapp-react-native-utils 15.1.0-rc.8 → 16.0.0-alpha.1833861900

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

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

package/reactHooks/resolvers/useCellResolver.ts

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

package/reactHooks/resolvers/useComponentResolver.ts

@@ -4,7 +4,11 @@ import * as React from "react";
 import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
 
 import { findComponentByType } from "@applicaster/zapp-react-native-utils/pluginUtils";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  selectComponents,
+  useAppSelector,
+  usePlugins,
+} from "@applicaster/zapp-react-native-redux";
 
 type Decorator = (component: React.Component<any>) => React.Component<any>;
 type Watcher = Array<any>;
@@ -17,7 +21,9 @@ export function useComponentResolver(
   { componentType, decorators }: Props,
   watchers?: Watcher
 ): React.ComponentType<any> {
-  const { plugins, components } = usePickFromState(["plugins", "components"]);
+  const plugins = usePlugins();
+
+  const components = useAppSelector(selectComponents);
 
   const component = React.useMemo(
     () =>

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-hooks";
+import { renderHook } from "@testing-library/react-native";
 import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
+import { thunk } from "redux-thunk";
 
 const mockStore = configureStore([thunk]);
 

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

@@ -0,0 +1,114 @@
+import { renderHook } from "@testing-library/react-native";
+import { useIsStandaloneFullscreen } from "../useIsStandaloneFullscreen";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks");
+jest.mock("@applicaster/zapp-react-native-utils/booleanUtils");
+
+const mockUseNavigation = useNavigation as jest.Mock;
+const mockToBoolean = toBooleanWithDefaultFalse as jest.Mock;
+
+describe("useIsStandaloneFullscreen", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: {
+        general: { allow_screen_plugin_presentation: true },
+      },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+  });
+
+  it("returns true when cannot go back and screen plugin presentation is allowed", () => {
+    mockToBoolean.mockReturnValue(true);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+
+  it("returns false when can go back even if screen plugin presentation is allowed", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(true),
+      screenData: {
+        general: { allow_screen_plugin_presentation: true },
+      },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(false);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when cannot go back but screen plugin presentation is not allowed", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: {
+        general: { allow_screen_plugin_presentation: false },
+      },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(false);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when screen plugin presentation flag is undefined", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: { general: {} },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when navigator is undefined", () => {
+    mockUseNavigation.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when screenData is undefined", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: undefined,
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("passes the combined condition through toBooleanWithDefaultFalse", () => {
+    mockToBoolean.mockImplementation((val) => Boolean(val));
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+});

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

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

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

@@ -1,4 +1,4 @@
-import { renderHook } from "@testing-library/react-hooks";
+import { renderHook } from "@testing-library/react-native";
 import configureStore from "redux-mock-store";
 
 const mockStore = configureStore();

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

@@ -1,16 +1,24 @@
 import * as React from "react";
 import { Provider } from "react-redux";
-import { renderHook } from "@testing-library/react-hooks";
+import { renderHook } from "@testing-library/react-native";
 import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
+import { thunk } from "redux-thunk";
 
 const mockStore = configureStore([thunk]);
 
 import { useTargetScreenData } from "../useTargetScreenData";
 
 describe("useTargetScreenData", function () {
-  const river_id_2 = {};
-  const river_id_1 = {};
+  const river_id_2 = {
+    id: "river_id_2",
+    type: "any",
+  };
+
+  const river_id_1 = {
+    id: "river_id_1",
+    type: "any",
+  };
+
   const screenId = "river_id_2";
   const entry = { id: "test", type: { value: "video" } };
 

package/reactHooks/screen/useTargetScreenData.ts

@@ -1,7 +1,8 @@
 import React from "react";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import * as R from "ramda";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { useRivers } from "../state";
 
 export function getTargetScreenData(
   entry: ZappEntry,
@@ -43,7 +44,8 @@ export function getTargetScreenDataFromEntry(entry: ZappEntry): ZappRiver {
 }
 
 export const useTargetScreenData = (entry: ZappEntry) => {
-  const { rivers, contentTypes } = usePickFromState(["rivers", "contentTypes"]);
+  const rivers = useRivers();
+  const contentTypes = useContentTypes();
 
   return React.useMemo(
     () => getTargetScreenData(entry, rivers, contentTypes),

package/reactHooks/state/useRivers.ts

@@ -3,6 +3,6 @@ import {
   selectRivers,
 } from "@applicaster/zapp-react-native-redux";
 
-export function useRivers(): Record<string, ZappRiver> {
+export function useRivers() {
   return useAppSelector(selectRivers);
 }