@applicaster/zapp-react-native-utils 16.0.0-alpha.7128076344 → 16.0.0-alpha.8112388240

package/appUtils/HooksManager/index.ts

@@ -1,14 +1,11 @@
 import * as R from "ramda";
 
 import { subscriber } from "@applicaster/zapp-react-native-utils/functionUtils";
-import {
-  QUICK_BRICK_EVENTS,
-  sendQuickBrickEvent,
-} from "@applicaster/zapp-react-native-bridge/QuickBrick";
-
 import { Hook } from "./Hook";
 import { HOOKS_EVENTS, HOOKS_TYPE } from "./constants";
 
+import { platformToBackground } from "../platform";
+
 import { hooksManagerLogger } from "./logger";
 import { HookManager, HookManagerArgs } from "./types";
 import {
@@ -90,7 +87,7 @@ export function HooksManager({
 }: HookManagerArgs): HookManager {
   hooksManagerLogger.addContext({ targetScreenId: targetScreen.id });
 
-  function logHookEvent(func, message, data) {
+  function logHookEvent(func, message, data = {}) {
     func({
       message,
       data: __DEV__ ? data : null,
@@ -347,14 +344,10 @@ export function HooksManager({
             `hookCallback: send app to background, cancelled flow blocker hook  ${hookPlugin.identifier} on home screen`,
             {
               payload,
-              hook: hookPlugin,
             }
           );
 
-          // TODO: Add this logic to platformBack and rename platformBack to platformToBackground for all platforms
-          sendQuickBrickEvent(QUICK_BRICK_EVENTS.MOVE_APP_TO_BACKGROUND, {
-            MOVE_APP_TO_BACKGROUND: true,
-          });
+          platformToBackground();
         }
       } else {
         logHookEvent(
@@ -362,17 +355,13 @@ export function HooksManager({
           `hookCallback: hook successfully finished: ${hookPlugin.identifier}`,
           {
             payload,
-            hook: hookPlugin,
           }
         );
 
         if (!callback) {
           logHookEvent(
-            hooksManagerLogger.warn,
-            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`,
-            {
-              hookPlugin,
-            }
+            hooksManagerLogger.debug,
+            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`
           );
 
           callback = hookCallback;

package/appUtils/contextKeysManager/utils/index.ts

@@ -1,40 +1,53 @@
-import * as R from "ramda";
 import { DEFAULT_NAMESPACE } from "../consts";
 import { KeyName, KeyNameObj } from "../index";
 
-const lastDotRegex = /\.([^.]+)$/;
-const splitByLastDot = R.compose(R.init, R.split(lastDotRegex));
-
 export function getNamespaceAndKey(namespacedKey: KeyName): KeyNameObj {
   if (typeof namespacedKey !== "string") return namespacedKey;
 
-  const namespacedKeyProps = namespacedKey.includes(".")
-    ? splitByLastDot(namespacedKey)
-    : [DEFAULT_NAMESPACE, namespacedKey];
+  if (!namespacedKey.includes(".")) {
+    return { namespace: DEFAULT_NAMESPACE, key: namespacedKey };
+  }
+
+  // split on the last dot - the namespace itself may contain dots
+  const lastDotIndex = namespacedKey.lastIndexOf(".");
 
-  return R.zipObj(["namespace", "key"], namespacedKeyProps);
+  return {
+    namespace: namespacedKey.slice(0, lastDotIndex),
+    key: namespacedKey.slice(lastDotIndex + 1),
+  };
 }
 
-const propIsNotNullOrUndefined = (prop) =>
-  R.compose(R.not, R.isNil, R.prop(prop));
+const hasOwn = (obj: object, prop: string): boolean =>
+  Object.prototype.hasOwnProperty.call(obj, prop);
+
+const isEmpty = (value: unknown): boolean => {
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (value !== null && typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+};
+
+export const keyIsValid = (parsedKey: unknown): boolean => {
+  if (parsedKey == null) return false;
+  if (typeof parsedKey === "string") return false;
+  if (Array.isArray(parsedKey)) return false;
 
-const propIsNotEmpty = (prop) => R.compose(R.not, R.isEmpty, R.prop(prop));
+  const obj = parsedKey as Record<string, unknown>;
 
-export const keyIsValid = R.allPass([
-  R.compose(R.not, R.isNil),
-  R.compose(R.not, R.is(String)),
-  R.compose(R.not, R.is(Array)),
-  R.has("key"),
-  R.has("namespace"),
-  propIsNotNullOrUndefined("key"),
-  propIsNotNullOrUndefined("namespace"),
-  propIsNotEmpty("key"),
-  propIsNotEmpty("namespace"),
-]);
+  if (!hasOwn(obj, "key") || !hasOwn(obj, "namespace")) return false;
+  if (obj.key == null || obj.namespace == null) return false;
+  if (isEmpty(obj.key) || isEmpty(obj.namespace)) return false;
+
+  return true;
+};
 
 export const buildNamespaceKey = (key: string, namespace: string) =>
   `${namespace}.${key}`;
 
-export const savingResultIsSuccess = (result: unknown): boolean => {
-  return R.is(Boolean, result) && !!result;
-};
+export const savingResultIsSuccess = (result: unknown): boolean =>
+  typeof result === "boolean" && result === true;

package/appUtils/platform/platformUtils.ts

@@ -1,6 +1,11 @@
 import { BehaviorSubject } from "rxjs";
 
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import {
+  QUICK_BRICK_EVENTS,
+  sendQuickBrickEvent,
+} from "@applicaster/zapp-react-native-bridge/QuickBrick";
+
 import {
   isLgPlatform,
   isSamsungPlatform,
@@ -18,6 +23,12 @@ const { log_debug } = createLogger({
   parent: utilsLogger,
 });
 
+export const platformToBackground = () => {
+  sendQuickBrickEvent(QUICK_BRICK_EVENTS.MOVE_APP_TO_BACKGROUND, {
+    MOVE_APP_TO_BACKGROUND: true,
+  });
+};
+
 export const getZappPlatform = (): ZappPlatform => {
   const platform = appStore.get("appData")?.platform;
 

package/appUtils/playerManager/__tests__/playerFactory.test.ts

@@ -0,0 +1,150 @@
+const mockAppStoreGet = jest.fn();
+const mockFindPluginByIdentifier = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: { get: (key: string) => mockAppStoreGet(key) },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/pluginUtils", () => ({
+  findPluginByIdentifier: (id: string, plugins: any) =>
+    mockFindPluginByIdentifier(id, plugins),
+}));
+
+import { PlayerRole } from "../conts";
+import { playerFactory } from "../playerFactory";
+
+const fakeComponent = () => null;
+
+class FakeController {
+  receivedConfig: any;
+  constructor(config: any) {
+    this.receivedConfig = config;
+  }
+}
+
+const baseConfig = {
+  player: {},
+  playerId: "p1",
+  autoplay: false,
+  entry: { id: "entry-1" } as any,
+  muted: false,
+  playerPluginId: "test-plugin",
+  screenConfig: { foo: "bar" },
+  playerRole: PlayerRole.Cell,
+};
+
+const installPluginWithProtocol = (
+  protocolReturn: any | ((screenConfig: any, entry: any) => any)
+) => {
+  const playerProtocol =
+    typeof protocolReturn === "function"
+      ? protocolReturn
+      : () => protocolReturn;
+
+  mockAppStoreGet.mockImplementation((key: string) =>
+    key === "plugins" ? { "test-plugin": {} } : null
+  );
+
+  mockFindPluginByIdentifier.mockReturnValue({
+    module: { playerProtocol },
+  });
+};
+
+describe("playerFactory", () => {
+  beforeEach(() => {
+    mockAppStoreGet.mockReset();
+    mockFindPluginByIdentifier.mockReset();
+  });
+
+  it("resolves with controller and Component when playerProtocol returns synchronously", async () => {
+    installPluginWithProtocol({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    });
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+
+    expect((item?.controller as FakeController).receivedConfig).toBe(
+      baseConfig
+    );
+  });
+
+  it("resolves with controller and Component when playerProtocol returns a Promise (delayed import)", async () => {
+    installPluginWithProtocol(async () => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+  });
+
+  it("passes screenConfig and entry through to playerProtocol", async () => {
+    const playerProtocol = jest.fn(() => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: { playerProtocol } });
+
+    await playerFactory(baseConfig);
+
+    expect(playerProtocol).toHaveBeenCalledWith(
+      baseConfig.screenConfig,
+      baseConfig.entry
+    );
+  });
+
+  it("resolves to null when playerPluginId is missing", async () => {
+    expect(
+      await playerFactory({ ...baseConfig, playerPluginId: "" } as any)
+    ).toBeNull();
+  });
+
+  it("resolves to null when appStore has no plugins", async () => {
+    mockAppStoreGet.mockReturnValue(null);
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when the plugin has no playerProtocol", async () => {
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: {} });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a Component", async () => {
+    installPluginWithProtocol({ controllerClass: FakeController });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a controllerClass", async () => {
+    installPluginWithProtocol({ Component: fakeComponent });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("rejects when playerProtocol throws synchronously", async () => {
+    installPluginWithProtocol(() => {
+      throw new Error("boom");
+    });
+
+    await expect(playerFactory(baseConfig)).rejects.toThrow("boom");
+  });
+});

package/appUtils/playerManager/playerFactory.ts

@@ -19,52 +19,35 @@ type PlayerFactoryProps = {
   playerRole: PlayerRole;
 };
 
-interface PlayerConstructor {
+interface PlayerControllerConstructor {
   new (params: any): Player;
 }
 
-export const playerFactory = (
-  config: PlayerFactoryProps
-): PlayerFactoryItem | null => {
-  const IDENTIFIER = config?.playerPluginId;
+type PlayerProtocol = {
+  Component: any;
+  controllerClass: PlayerControllerConstructor;
+};
 
-  if (!IDENTIFIER) {
-    return null;
-  }
+export const playerFactory = async (
+  config: PlayerFactoryProps
+): Promise<PlayerFactoryItem | null> => {
+  if (!config?.playerPluginId) return null;
 
   const plugins = appStore.get("plugins");
+  if (!plugins) return null;
 
-  if (!plugins) {
-    return null;
-  }
-
-  const playerPlugin = findPluginByIdentifier(IDENTIFIER, plugins);
+  const playerPlugin = findPluginByIdentifier(config.playerPluginId, plugins);
+  if (!playerPlugin?.module?.playerProtocol) return null;
 
-  if (!playerPlugin?.module?.playerProtocol) {
-    return null;
-  }
-
-  const playerProtocol: PlayerConstructor = playerPlugin.module.playerProtocol(
-    config?.screenConfig,
-    config?.entry
-  );
+  const playerProtocol: PlayerProtocol | null =
+    await playerPlugin.module.playerProtocol(config.screenConfig, config.entry);
 
-  const playerView = (playerProtocol as any)?.Component || null;
-
-  if (!playerView) {
+  if (!playerProtocol?.Component || !playerProtocol.controllerClass) {
     return null;
   }
 
-  const Controller = (playerProtocol as any)?.controllerClass || null;
-
-  if (Controller === null) {
-    return null;
-  }
-
-  const controller = new Controller(config);
-
   return {
-    controller,
-    Component: playerView,
+    controller: new playerProtocol.controllerClass(config),
+    Component: playerProtocol.Component,
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-alpha.7128076344",
+  "version": "16.0.0-alpha.8112388240",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-alpha.7128076344",
+    "@applicaster/applicaster-types": "16.0.0-alpha.8112388240",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/playerUtils/index.ts

@@ -9,6 +9,16 @@ import { Dimensions } from "react-native";
 
 export { getPlayerActionButtons } from "./getPlayerActionButtons";
 
+export const HLS_MIME_TYPES = [
+  "application/x-mpegURL",
+  "application/vnd.apple.mpegurl",
+];
+
+export const STREAMING_VIDEO_MIME_TYPES = [
+  ...HLS_MIME_TYPES,
+  "application/dash+xml",
+];
+
 /**
  * Gets duration value from player manager, and from extensions
  * then checks whether the value from either is a not a valid number
@@ -27,7 +37,7 @@ export function isLiveLegacy(content) {
   ]);
 
   const durationFromExt = R.path(["extensions", "duration"], content);
-  const durationFromMgr = playerManager.getDuration();
+  const durationFromMgr = playerManager.getInstanceController()?.getDuration();
   const duration = Math.floor(durationFromExt || durationFromMgr);
 
   const isLive = R.anyPass([isNotaValidNumber, R.lte(R.__, 0)])(duration);
@@ -71,7 +81,9 @@ function isLiveByManager(): boolean {
     return true;
   }
 
-  const durationFromPlayerManager = playerManager.getDuration();
+  const durationFromPlayerManager = playerManager
+    .getInstanceController()
+    ?.getDuration();
 
   return isLiveByDuration(durationFromPlayerManager);
 }
@@ -80,6 +92,16 @@ export function isLive(entry: ZappEntry): boolean {
   return isEntryLive(entry) || isLiveByManager();
 }
 
+export const isVideoItem = (item: Option<ZappEntry>) => {
+  const contentType = item?.content?.type;
+
+  return (
+    isString(contentType) &&
+    (contentType.includes("video") ||
+      STREAMING_VIDEO_MIME_TYPES.includes(contentType))
+  );
+};
+
 export const isAudioItem = (item: Option<ZappEntry>) => {
   if (
     isString(item?.content?.type) &&

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/index.ts

@@ -16,3 +16,5 @@ export { useScreenBackgroundColor } from "./useScreenBackgroundColor";
 export { useCurrentScreenIsHook } from "./useCurrentScreenIsHook";
 
 export { useCurrentScreenIsStartupHook } from "./useCurrentScreenIsStartupHook";
+
+export { useIsStandaloneFullscreen } from "./useIsStandaloneFullscreen";

package/reactHooks/screen/useIsStandaloneFullscreen.ts

@@ -0,0 +1,12 @@
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+export const useIsStandaloneFullscreen = (): boolean => {
+  const navigator = useNavigation();
+
+  return toBooleanWithDefaultFalse(
+    !navigator?.canGoBack() &&
+      // @ts-ignore
+      navigator?.screenData?.general?.allow_screen_plugin_presentation
+  );
+};

package/reactHooks/videoModal/hooks/useVideoModalScreenData.tsx

@@ -2,6 +2,12 @@ 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";
+import { createLogger } from "../../../logger";
+
+const { log_warning } = createLogger({
+  subsystem: "zapp-react-native-utils/reactHooks/videoModal",
+  category: "useVideoModalScreenData",
+});
 
 export const useVideoModalScreenData = ():
   | (ZappEntry & { targetScreen: any }) // TODO: fix ZappEntry type ( was ZappRiver but conflict )
@@ -14,10 +20,22 @@ export const useVideoModalScreenData = ():
   const rivers = useRivers();
 
   return React.useMemo(() => {
-    if (item?.type?.value) {
-      const screenId = contentTypes[item?.type?.value].screen_id;
+    const itemType = item?.type?.value;
+
+    if (!itemType) {
+      return;
+    }
 
-      return { ...item, targetScreen: rivers?.[screenId] };
+    const screenId = contentTypes[itemType]?.screen_id;
+
+    if (!screenId) {
+      log_warning(
+        `Type mapping is missing for item type: ${itemType}, title: ${item.title}`
+      );
+
+      return;
     }
-  }, [item]);
+
+    return { ...item, targetScreen: rivers?.[screenId] };
+  }, [contentTypes, item, rivers]);
 };

package/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -197,7 +197,7 @@ export const useCallbackNavigationAction = (
         }
       }
 
-      hookCallback?.({ ...args, success: false, cancelled: true });
+      hookCallback?.({ ...args, success: false, abort: true });
       const currentNavigation = navigationRef.current;
 
       switch (data.action) {