@applicaster/zapp-react-native-utils 12.0.0-rc.8 → 12.0.0-rc.80

package/reactHooks/navigation/index.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 /* eslint max-len: off */
 
-import React, { useEffect, useMemo } from "react";
+import React, { useContext, useEffect, useMemo } from "react";
 import { BackHandler, InteractionManager, NativeModules } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
@@ -12,23 +12,113 @@ import {
 import { HooksManager } from "@applicaster/zapp-react-native-utils/appUtils/HooksManager";
 
 import { legacyScreenData } from "@applicaster/quick-brick-core/App/NavigationProvider/utils";
-import { LONG_KEY_PRESS_TIMEOUT } from "@applicaster/quick-brick-core/const";
+import {
+  LONG_KEY_PRESS_TIMEOUT,
+  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 { 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";
-import { getNavigationProps } from "@applicaster/zapp-react-native-utils/navigationUtils";
 import { HOOKS_EVENTS } from "../../appUtils/HooksManager/constants";
-import { getRiverFromRoute, getTargetRoute } from "../../navigationUtils";
+import {
+  getNavigationProps,
+  getRiverFromRoute,
+  getTargetRoute,
+} from "../../navigationUtils";
 import { platformSelect } from "../../reactUtils";
 import { useConnectionInfo } from "../connection";
 import { getTargetScreenData } from "../screen/useTargetScreenData";
-import { useNavbarState } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext";
 
+import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { useNavbarState } from "../screen";
 import { useNavigation } from "./useNavigation";
+import { useModalStore } from "../../modalState";
+import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 
 export { useNavigation } from "./useNavigation";
 
+/**
+ * This function helps to decide wether the navbar should be presented on the screen
+ * based on route and / or screen Data
+ *
+ * Currently the scenarios include
+ * - players => false
+ * - search screen plugin => false
+ * - hooks with `showNavBar: true` or `presentFullScreen` not set to true, defaults to no navbar for hook screens
+ * - screens with `allow_screen_plugin_presentation` in general property => false
+ *
+ * @param {String} route current route of the screen
+ * @param {Object} screenData payload associated with the currently presented screen
+ * @returns {Boolean}
+ */
+export function isNavBarVisible(
+  route: string,
+  screenData: ZappRiver = {} as ZappRiver,
+  showNavBar: boolean,
+  canGoBack: boolean,
+  videoModalState: QuickBrickVideoModalState | null = null
+) {
+  /* screenData is not actual navigator.data
+   * or navigator.screenData,
+   * but navigator.data.screen */
+  if (route.includes("playable")) {
+    return false;
+  }
+
+  if (
+    videoModalState?.mode === "FULLSCREEN" &&
+    videoModalState?.visible === true
+  ) {
+    return false;
+  }
+
+  if (screenData?.type === "qb_search_screen" && !isTV()) {
+    return false;
+  }
+
+  /* Match if screen is Hook */
+  if (route.startsWith("/hooks/")) {
+    const module = screenData?.module;
+
+    if (module?.presentFullScreen) {
+      return false;
+    }
+
+    return module?.showNavBar ?? false;
+  }
+
+  if (screenData?.hookPlugin) {
+    const hookPlugin = screenData?.hookPlugin?.module;
+
+    return (
+      hookPlugin?.showNavBar || hookPlugin?.presentFullScreen !== true || false
+    );
+  }
+
+  if (
+    screenData?.general?.allow_screen_plugin_presentation ||
+    screenData?.general?.hide_app_nav_bar
+  ) {
+    return false;
+  }
+
+  const hideSecondaryLevel = screenData?.navigations?.some(
+    (navigation) => navigation.styles?.hide_secondary_level_menu
+  );
+
+  if (canGoBack && hideSecondaryLevel) {
+    return false;
+  }
+
+  if (typeof showNavBar === "boolean" && !showNavBar) {
+    return false;
+  }
+
+  return true;
+}
+
 const { ProfilerBridge } = NativeModules;
 
 export const usePathname = () => React.useContext(PathnameContext);
@@ -43,6 +133,88 @@ export const useBackHandler = (cb: () => boolean) => {
   }, [cb]);
 };
 
+// starts with modal/
+const isModalPathname = (pathname: string) => /^modal\//.test(pathname);
+
+const isVideoModalPathname = (pathname: string) =>
+  /^video-modal\//.test(pathname);
+
+const isHookModalPathname = (pathname: string) =>
+  /^hooks-modal\//.test(pathname);
+
+const isHookPathname = (pathname: string) => /^\/hooks\//.test(pathname);
+
+type VariousScreenData = LegacyNavigationScreenData | ZappRiver | ZappEntry;
+
+export const useRoute = (): {
+  screenData: VariousScreenData;
+  pathname: string;
+} => {
+  const pathname = usePathname() || "";
+  const navigator = useNavigation();
+  const screenDataContext = legacyScreenData(useContext(ScreenDataContext));
+
+  const { plugins, contentTypes, rivers } = usePickFromState([
+    "plugins",
+    "rivers",
+    "contentTypes",
+  ]);
+
+  const { modalState } = useModalStore();
+  const hookModalState = useZappHooksModalState();
+
+  const modalScreenData = modalState.screen;
+
+  const hookModalScreenData = hookModalState.state.screenData?.payload;
+
+  const videoModalScreenData =
+    navigator.videoModalState?.item &&
+    legacyScreenData(
+      {
+        entry: navigator.videoModalState?.item as ZappEntry,
+        screen: getTargetScreenData(
+          navigator.videoModalState?.item as ZappEntry,
+          rivers,
+          contentTypes
+        ),
+      },
+      plugins
+    );
+
+  // There are 4 route scenarios
+  // For regular screens take date from navigator stack.
+  // is path is model grab screenData from modal state
+  // if path is video modal grab screenData from video state
+  // if path is hook modal grab screenData from hook state
+  // if path is hook grab screenData from screenData
+
+  if (isModalPathname(pathname)) {
+    const screenData = modalScreenData ?? ({} as ZappEntry);
+
+    return { screenData, pathname };
+  }
+
+  if (isVideoModalPathname(pathname)) {
+    const screenData = videoModalScreenData as LegacyNavigationScreenData;
+
+    return { screenData, pathname };
+  }
+
+  if (isHookModalPathname(pathname)) {
+    const screenData = hookModalScreenData;
+
+    return { screenData, pathname };
+  }
+
+  if (isHookPathname(pathname)) {
+    return { screenData: screenDataContext, pathname };
+  }
+
+  const screenData = screenDataContext;
+
+  return { screenData, pathname };
+};
+
 type Callbacks = Partial<{
   handleHookPresent: ({
     route,
@@ -209,7 +381,7 @@ export const useRunIfLongPress = (
     React.useRef<Nullable<ReturnType<typeof setTimeout>>>(null);
 
   const resetTimeout = () => {
-    clearTimeout(pressTimeout.current);
+    clearTimeout(pressTimeout.current as ReturnType<typeof setTimeout>);
   };
 
   const startTimeout = (cb: () => void) => {
@@ -231,102 +403,85 @@ export const useRunIfLongPress = (
  * @returns boolean - navbar visiblity status
  */
 export const useIsNavBarVisible = (): boolean => {
-  const visible = useNavbarState().visible;
+  const { visible } = useNavbarState();
 
   return useMemo(() => visible, [visible]);
 };
 
-const isModalPathname = (pathname: string) => /^modal\//.test(pathname);
+const useGetNavBarTopBorderWidth = (): number => {
+  const navigator = useNavigation();
 
-const isVideoModalPathname = (pathname: string) =>
-  /^video-modal\//.test(pathname);
+  const navProps = getNavigationProps({
+    navigator,
+    title: "",
+    category: "menu",
+  });
 
-const isHookModalPathname = (pathname: string) =>
-  /^hooks-modal\//.test(pathname);
+  return Number(((navProps?.styles as any)?.top_border_width as number) ?? 0);
+};
 
-export const useRoute = () => {
-  const pathname = usePathname() || "";
-  const navigator = useNavigation();
+const TAB_BAR_HEIGHT_IOS = 49;
+const TAB_BAR_HEIGHT_ANDROID = 56;
 
-  const { plugins, contentTypes, rivers } = usePickFromState([
-    "plugins",
-    "rivers",
-    "contentTypes",
-  ]);
+const useGetTabBarHeight = () =>
+  platformSelect({
+    ios: TAB_BAR_HEIGHT_IOS + (useSafeAreaInsets().bottom ?? 0),
+    android: TAB_BAR_HEIGHT_ANDROID,
+  }) as number;
 
-  const currentStack = navigator.getStackForPathname(pathname);
-  const modalState = navigator.modalState;
-  const hookModalState = useZappHooksModalState();
+export const useGetBottomTabBarHeight = (): number => {
+  const topBorderWidth = useGetNavBarTopBorderWidth();
+  const tabBarHeight = useGetTabBarHeight();
 
-  const modalScreenData = modalState.screen;
+  const isBottomBarNavigation = useNavigationType() === MenuTypes.bottomTabBar;
 
-  const hookModalScreenData = hookModalState.state.screenData?.payload;
+  return !isBottomBarNavigation ? 0 : tabBarHeight + topBorderWidth;
+};
 
-  const videoModalScreenData =
-    navigator.videoModalState?.item &&
-    legacyScreenData(
-      {
-        entry: navigator.videoModalState?.item,
-        screen: getTargetScreenData(
-          navigator.videoModalState?.item,
-          rivers,
-          contentTypes
-        ),
-      },
-      plugins
-    );
+// If current screen is active/focused (visible to the user)
+export const useIsScreenActive = () => {
+  const pathname = usePathname();
+  const { currentRoute, videoModalState } = useNavigation();
 
-  const currentRouteScreenData = legacyScreenData(
-    {
-      screen:
-        currentStack?.state?.screen ??
-        navigator.data?.screen ??
-        ({} as ZappRiver),
-      entry: currentStack?.state?.entry ?? ({} as ZappEntry),
-    },
+  if (
+    videoModalState.visible &&
+    ["FULLSCREEN", "MAXIMIZED", "PIP"].includes(videoModalState.mode)
+  ) {
+    return false;
+  }
 
-    plugins
-  );
+  return pathname === currentRoute;
+};
 
-  // There are 4 route scenarios
-  // For regular screens take date from navigator stack.
-  // is path is model grab screenData from modal state
-  // if path is video modal grab screenData from video state
-  // if path is hook modal grab screenData from hook state
+type Return = (prefix: string) => string;
 
-  const screenData = isModalPathname(pathname)
-    ? modalScreenData
-    : isVideoModalPathname(pathname)
-    ? videoModalScreenData
-    : isHookModalPathname(pathname)
-    ? hookModalScreenData
-    : currentRouteScreenData;
+export const useUniqueRouteSuffix = (): Return => {
+  const pathname = usePathname();
+  const { currentRoute } = useNavigation();
 
-  return { screenData, pathname };
-};
+  const suffix = `currentRoute:${currentRoute}_pathname:${pathname}`;
 
-export const useGetBottomTabBarHeight = (): number => {
-  const insets = useSafeAreaInsets();
-  const navigator = useNavigation();
+  const withUniqueRouteSuffix = React.useCallback((prefix: string) => {
+    if (isWeb()) {
+      // we should use extended route prefix only on Web, where we have stack-navigator
+      return `${prefix}___${suffix}`;
+    }
 
-  const navProps = getNavigationProps({
-    navigator,
-    title: "",
-    category: "menu",
-  });
+    // for other platforms use previous version
+    return prefix;
+  }, []);
 
-  const navType = useNavigationType();
-  const isBottomBarNavigation = navType === MenuTypes.bottomTabBar;
+  return withUniqueRouteSuffix;
+};
 
-  const TAB_BAR_HEIGHT_IOS = 49;
-  const TAB_BAR_HEIGHT_ANDROID = 56;
+export const useNavbarId = () => {
+  const withUniqueRouteSuffix = useUniqueRouteSuffix();
 
-  if (!isBottomBarNavigation) return 0;
+  return withUniqueRouteSuffix(QUICK_BRICK_NAVBAR);
+};
 
-  const tabBarHeight = platformSelect({
-    ios: TAB_BAR_HEIGHT_IOS + insets.bottom,
-    android: TAB_BAR_HEIGHT_ANDROID,
-  }) as number;
+export const useContentId = () => {
+  const withUniqueRouteSuffix = useUniqueRouteSuffix();
 
-  return tabBarHeight + Number(navProps?.styles?.top_border_width ?? 0);
+  return withUniqueRouteSuffix(QUICK_BRICK_CONTENT);
 };

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

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { View } from "react-native";
-import { renderHook, cleanup } from "@testing-library/react-hooks";
+import { cleanup, renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
 import { Provider } from "react-redux";
 
@@ -12,6 +12,8 @@ jest.mock("@applicaster/zapp-react-native-utils/localizationUtils", () => ({
   useIsRTL: jest.fn(() => mock_rtl_flag),
 }));
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation");
+
 const { useCellResolver } = require("../useCellResolver");
 
 describe("cellResolver", () => {

package/reactHooks/screen/__mocks__/useScreenContext.ts

@@ -1,7 +1,7 @@
 // @ts-ignore
 import { View } from "react-native";
 
-const mockData: NavigationScreenData = {
+const mockData = {
   screen: {
     id: "screen-id",
     name: "screen",
@@ -40,3 +40,5 @@ const mockData: NavigationScreenData = {
 };
 
 export const useScreenContext = jest.fn().mockReturnValue(mockData);
+
+export const useNavbarState = () => ({ visible: true });

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

@@ -3,23 +3,28 @@ import { Provider } from "react-redux";
 import { renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
 import thunk from "redux-thunk";
-import { NavigationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NavigationContext";
 
 const mockStore = configureStore([thunk]);
 
-import { useCurrentScreenData } from "../useCurrentScreenData";
-
-describe("useScreenData", function () {
-  const river_id_2: ZappRiver = {
-    name: "River 2",
-    id: "A1234",
-    home: false,
-    home_offline: false,
-    supports_offline: false,
-    navigations: [],
-    hooks: { preload_plugins: [] },
-  };
-
+const river_id_2: ZappRiver = {
+  name: "River 2",
+  id: "A1234",
+  home: false,
+  home_offline: false,
+  supports_offline: false,
+  navigations: [],
+  hooks: { preload_plugins: [] },
+};
+
+jest.mock("../useScreenContext", () => ({
+  useScreenContext: () => ({
+    screen: river_id_2,
+  }),
+}));
+
+const { useCurrentScreenData } = require("../useCurrentScreenData");
+
+describe("useScreenData", () => {
   const river_id_1 = { id: "B5678" };
 
   const store = mockStore({
@@ -27,17 +32,10 @@ describe("useScreenData", function () {
   });
 
   const wrapper: React.FC<any> = ({ children }) => (
-    <NavigationContext.Provider
-      value={{
-        currentRoute: "/river/river_id_1/river/river_id_2",
-        data: { screen: river_id_2 },
-      }}
-    >
-      <Provider store={store}>{children}</Provider>
-    </NavigationContext.Provider>
+    <Provider store={store}>{children}</Provider>
   );
 
-  it("should return river data for the current screen/route", function () {
+  it("should return river data for the current screen/route", () => {
     const { result } = renderHook(() => useCurrentScreenData(), { wrapper });
 
     expect(result.current).toBe(river_id_2);

package/reactHooks/screen/index.ts

@@ -2,9 +2,13 @@ export { useCurrentScreenData } from "./useCurrentScreenData";
 
 export { useTargetScreenData } from "./useTargetScreenData";
 
+export { useScreenData } from "./useScreenData";
+
 export {
   useScreenContext,
   useLegacyScreenData,
   useNavbarState,
   useSetNavbarState,
 } from "./useScreenContext";
+
+export { useScreenBackgroundColor } from "./useScreenBackgroundColor";

package/reactHooks/screen/useScreenBackgroundColor.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+import { useScreenConfiguration } from "@applicaster/zapp-react-native-ui-components/Components/River/useScreenConfiguration";
+import { ifEmptyUseFallback } from "@applicaster/zapp-react-native-utils/cellUtils";
+
+export const useScreenBackgroundColor = (screenId: string): string => {
+  const { backgroundColor: screenBackgroundColor } =
+    useScreenConfiguration(screenId);
+
+  const theme = useTheme();
+
+  const themeBackgroundColor = React.useMemo(
+    () => theme.app_background_color,
+    [theme.app_background_color]
+  );
+
+  const backgroundColor = ifEmptyUseFallback(
+    screenBackgroundColor,
+    themeBackgroundColor
+  );
+
+  return backgroundColor;
+};

package/reactHooks/screen/useScreenContext.ts

@@ -2,11 +2,12 @@ import { useContext, useMemo } from "react";
 
 import { useModalNavigationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ModalNavigationContext";
 import { useNestedNavigationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NestedNavigationContext";
-import { useNavigation } from "../navigation";
+import { useNavigation } from "../navigation/useNavigation";
 
 import { ScreenContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenContext";
+import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 
-function useScreenContextV2() {
+export function useScreenContextV2() {
   return useContext(ScreenContext);
 }
 
@@ -44,9 +45,8 @@ export function useSetNavbarState() {
 
 export function useScreenContext(): NavigationScreenData {
   const navigator = useNavigation();
+  const screenData = useContext(ScreenDataContext);
 
-  const screenKey = useMemo(() => navigator?.key, [navigator]);
-  const screenData = useMemo(() => navigator?.data, [screenKey]);
   const modalScreenData = navigator?.modalData;
 
   const isModal = useModalNavigationContext();

package/reactHooks/screen/useScreenData.ts

@@ -4,7 +4,7 @@ import { useRivers } from "../state";
 
 const logger = utilsLogger.addSubsystem("useScreenData");
 
-export const useScreenData = (screenId?: string): ZappRiver => {
+export const useScreenData = (screenId: string): ZappRiver => {
   const rivers = useRivers();
 
   React.useEffect(() => {

package/reactHooks/screen/useTargetScreenData.ts

@@ -1,6 +1,7 @@
 import React from "react";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import * as R from "ramda";
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 
 export function getTargetScreenData(
   entry: ZappEntry,
@@ -35,6 +36,12 @@ export function getTargetScreenData(
   return rivers?.[screenId];
 }
 
+export function getTargetScreenDataFromEntry(entry: ZappEntry): ZappRiver {
+  const { rivers, contentTypes } = appStore.get(["rivers", "contentTypes"]);
+
+  return getTargetScreenData(entry, rivers, contentTypes);
+}
+
 export const useTargetScreenData = (entry: ZappEntry) => {
   const { rivers, contentTypes } = usePickFromState(["rivers", "contentTypes"]);
 

package/reactHooks/state/useRivers.ts

@@ -1,7 +1,9 @@
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
+const riversSelector = ["rivers"];
+
 export const useRivers = () => {
-  const { rivers } = usePickFromState(["rivers"]);
+  const { rivers } = usePickFromState(riversSelector as any);
 
   return rivers;
 };

package/reactHooks/useListenEventBusEvent.ts

@@ -13,10 +13,7 @@ export const useListenEventBusEvent = (
     // TODO: remove after implementing ReactNativeEventBusBridge on iOS
     if (Platform.OS === "android") {
       // subscribe to DeviceEventEmitter using subsciption ID
-      const sub = DeviceEventEmitter.addListener(
-        subscriptionID,
-        handler
-      );
+      const sub = DeviceEventEmitter.addListener(subscriptionID, handler);
 
       // ask native to start routing these events to RN
       ReactNativeEventBusBridge.subscribe(subscriptionID, { [source]: events });

package/reactHooks/videoModal/hooks/useVideoModalScreenData.tsx

@@ -1,8 +1,7 @@
-import {
-  useContentTypes,
-  usePickFromState,
-} from "@applicaster/zapp-react-native-redux/hooks";
+import React from "react";
+import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useRivers } from "../../state";
 
 export const useVideoModalScreenData = ():
   | (ZappEntry & { targetScreen: any }) // TODO: fix ZappEntry type ( was ZappRiver but conflict )
@@ -12,11 +11,13 @@ export const useVideoModalScreenData = ():
   } = useNavigation();
 
   const contentTypes = useContentTypes();
-  const { rivers } = usePickFromState(["rivers"]);
+  const rivers = useRivers();
 
-  if (item?.type?.value) {
-    const screenId = contentTypes[item?.type?.value].screen_id;
+  return React.useMemo(() => {
+    if (item?.type?.value) {
+      const screenId = contentTypes[item?.type?.value].screen_id;
 
-    return { ...item, targetScreen: rivers?.[screenId] };
-  }
+      return { ...item, targetScreen: rivers?.[screenId] };
+    }
+  }, [item]);
 };