@applicaster/zapp-react-native-utils 16.0.0-rc.1 → 16.0.0-rc.10

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 {
@@ -351,10 +348,7 @@ export function HooksManager({
             }
           );
 
-          // 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(

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/manifestUtils/index.js

@@ -31,7 +31,7 @@ const {
 } = require("./secondaryImage");
 
 const DEFAULT_GRADIENT_IMAGE =
-  "data:image/png;base64,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";
+  "data:image/png;base64,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";
 
 module.exports = {
   fontKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-rc.1",
+  "version": "16.0.0-rc.10",
   "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-rc.1",
+    "@applicaster/applicaster-types": "16.0.0-rc.10",
     "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
@@ -80,6 +90,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) {