@applicaster/zapp-react-native-utils 15.0.0-alpha.4153840309 → 15.0.0-alpha.4200413542

package/appUtils/playerManager/playerNative.ts

@@ -15,6 +15,22 @@ const logger = createLogger({
 
 const { log_warning } = logger;
 
+interface PlayerMethods {
+  seeking?: (position: number) => void;
+  forward?: (deltaTime: number) => void;
+  rewind?: (deltaTime: number) => void;
+  startSleepTimer?: (sleepTimestamp: number) => void;
+  selectTrack?: (
+    selected: QuickBrickPlayer.TextTrack | QuickBrickPlayer.AudioTrack
+  ) => void;
+  setPlaybackRate?: (rate: number) => void;
+  appStateChange?: (appState: string, previousAppState: string) => void;
+  closeNativePlayer?: () => void;
+  togglePlayPause?: () => void;
+}
+
+type PlayerComponent = ReactComponent<PlayerRefProps> & PlayerMethods;
+
 type PlayerPlugnId = "QuickBrickPlayerPlugin" | "KalturaPlayerPlugin";
 
 type Props = {
@@ -62,7 +78,7 @@ export class PlayerNative extends Player {
     return this.playerState.contentPosition;
   };
 
-  currentPlayerComponent = (): ReactComponent<PlayerRefProps> =>
+  currentPlayerComponent = (): PlayerComponent | null =>
     this.playerComponent?.current;
 
   getState = () => this.playerState;
@@ -121,7 +137,7 @@ export class PlayerNative extends Player {
 
       this.playerState.seekPosition = newPosition;
 
-      this.currentPlayerComponent()?.["seeking"](this.playerState.seekPosition);
+      this.currentPlayerComponent()?.seeking?.(this.playerState.seekPosition);
     }
 
     this.logState(PlayerModuleFuncNames.seekTo, { position });
@@ -135,7 +151,7 @@ export class PlayerNative extends Player {
     if (!this.invokeNativeFunction(PlayerModuleFuncNames.forward, deltaTime)) {
       // Kaltura does not have yet this implementation, use legacy code
 
-      this.currentPlayerComponent()?.["forward"](deltaTime);
+      this.currentPlayerComponent()?.forward?.(deltaTime);
     }
 
     this.notifyPlayHeadPositionUpdate();
@@ -151,7 +167,7 @@ export class PlayerNative extends Player {
     if (!this.invokeNativeFunction(PlayerModuleFuncNames.rewind, deltaTime)) {
       // Kaltura does not have yet this implementation, use legacy code
 
-      this.currentPlayerComponent()?.["rewind"](deltaTime);
+      this.currentPlayerComponent()?.rewind?.(deltaTime);
     }
 
     this.notifyPlayHeadPositionUpdate();
@@ -178,7 +194,7 @@ export class PlayerNative extends Player {
         sleepTimestamp
       )
     ) {
-      this.currentPlayerComponent()?.["startSleepTimer"](sleepTimestamp);
+      this.currentPlayerComponent()?.startSleepTimer?.(sleepTimestamp);
     }
   };
 
@@ -195,11 +211,11 @@ export class PlayerNative extends Player {
   selectTrack = (
     selected: QuickBrickPlayer.TextTrack | QuickBrickPlayer.AudioTrack
   ) => {
-    this.currentPlayerComponent()?.["selectTrack"]?.(selected);
+    this.currentPlayerComponent()?.selectTrack?.(selected);
   };
 
   setPlaybackRate = (rate: number) => {
-    this.currentPlayerComponent()?.["setPlaybackRate"]?.(rate);
+    this.currentPlayerComponent()?.setPlaybackRate?.(rate);
   };
 
   getPluginConfiguration = () => {
@@ -209,19 +225,16 @@ export class PlayerNative extends Player {
   getProps = () => (this.currentPlayerComponent() as any)?.props;
 
   appStateChange = (appState, previousAppState) => {
-    this.currentPlayerComponent()?.["appStateChange"]?.(
-      appState,
-      previousAppState
-    );
+    this.currentPlayerComponent()?.appStateChange?.(appState, previousAppState);
   };
 
   closeNativePlayer = () => {
     // TODO: Delete does not work
-    this.currentPlayerComponent()?.["closeNativePlayer"]?.();
+    this.currentPlayerComponent()?.closeNativePlayer?.();
   };
 
   togglePlayPause = () => {
-    this.currentPlayerComponent()?.["togglePlayPause"]?.();
+    this.currentPlayerComponent()?.togglePlayPause?.();
   };
 
   onVideoLoad = (event) => {
@@ -289,19 +302,19 @@ export class PlayerNative extends Player {
   isFullScreenSupported = (): boolean => {
     const config = this.getConfig();
 
-    const disableFullScreen = config?.["disable_fullscreen"];
+    const disableFullScreen = config?.disable_fullscreen;
 
     if (disableFullScreen) {
       return false;
     }
 
-    const isFullScreenAudioPlayer = config?.["full_screen_audio_player"];
+    const isFullScreenAudioPlayer = config?.full_screen_audio_player;
 
     return !(isFullScreenAudioPlayer && this.isAudioItem());
   };
 
   supportsNativeControls = (): boolean =>
-    toBooleanWithDefaultFalse(this.getConfig()?.["supports_native_controls"]);
+    toBooleanWithDefaultFalse(this.getConfig()?.supports_native_controls);
 
   supportNativeCast = (): boolean =>
     toBooleanWithDefaultFalse(

package/appUtils/playerManager/usePlayerState.tsx

@@ -2,7 +2,7 @@ import * as React from "react";
 import { Player } from "./player";
 import { usePlayer } from "./usePlayer";
 
-type PlayerState = {
+export type PlayerState = {
   currentTime: number;
   duration: number;
   seekableDuration: number;
@@ -10,6 +10,8 @@ type PlayerState = {
   isPaused: boolean;
   isBuffering: boolean;
   isReadyToPlay: boolean;
+  trackState?: QuickBrickPlayer.TracksState;
+  isAd: boolean;
 };
 
 export const usePlayerState = (
@@ -24,6 +26,8 @@ export const usePlayerState = (
     isPaused: null,
     isBuffering: false,
     isReadyToPlay: false,
+    trackState: null,
+    isAd: false,
   });
 
   const player: Player = usePlayer(playerId);
@@ -37,6 +41,8 @@ export const usePlayerState = (
       isPaused: player.isPaused(),
       isBuffering: player.isBuffering(),
       isReadyToPlay: player.isReadyToPlay(),
+      trackState: player.getTracksState(),
+      isAd: player.isAd(),
     });
   }, [player]);
 
@@ -54,10 +60,16 @@ export const usePlayerState = (
           onPlayerPause: onPlayerChangeState,
           onPlayerResume: onPlayerChangeState,
           onPlayerSeekComplete: onPlayerChangeState,
+          onTracksChanged: onPlayerChangeState,
+          onAdBreakBegin: onPlayerChangeState,
+          onAdBreakEnd: onPlayerChangeState,
+          onAdBegin: onPlayerChangeState,
+          onAdEnd: onPlayerChangeState,
+          onAdError: onPlayerChangeState,
         },
       });
     }
-  }, [player]);
+  }, [listenerId, onPlayerChangeState, player]);
 
   return state;
 };

package/cloudEventsUtils/__tests__/index.test.ts

@@ -0,0 +1,529 @@
+// Mock dependencies are set up before requiring the module
+// The module is required dynamically in beforeEach to allow test-specific setup
+// and state is reset using resetCloudEventsSource() between tests
+jest.mock("uuid", () => ({
+  v4: jest.fn(() => "test-uuid-1234"),
+}));
+
+jest.mock("@applicaster/zapp-pipes-v2-client", () => ({
+  RequestBuilder: jest.fn().mockImplementation(() => ({
+    setUrl: jest.fn().mockReturnThis(),
+    setMethod: jest.fn().mockReturnThis(),
+    addBodyParams: jest.fn().mockReturnThis(),
+    call: jest.fn().mockResolvedValue({ success: true }),
+  })),
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage",
+  () => ({
+    sessionStorage: {
+      getItem: jest.fn(),
+    },
+  })
+);
+
+jest.mock("@applicaster/zapp-react-native-utils/appDataUtils", () => ({
+  getAppUrlScheme: jest.fn(),
+}));
+
+import { v4 as uuid } from "uuid";
+import { RequestBuilder } from "@applicaster/zapp-pipes-v2-client";
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { getAppUrlScheme } from "@applicaster/zapp-react-native-utils/appDataUtils";
+import type { CloudEvent, CreateCloudEventParams } from "../index";
+
+describe("cloudEventsUtils", () => {
+  const mockGetAppUrlScheme = getAppUrlScheme as jest.MockedFunction<
+    typeof getAppUrlScheme
+  >;
+
+  const mockSessionStorageGetItem =
+    sessionStorage.getItem as jest.MockedFunction<
+      typeof sessionStorage.getItem
+    >;
+
+  const mockUuid = uuid as jest.MockedFunction<typeof uuid>;
+
+  let createCloudEvent: <T = any>(
+    params: CreateCloudEventParams<T>
+  ) => Promise<CloudEvent<T>>;
+
+  let sendCloudEvent: <T = any>(
+    cloudEvent: CloudEvent<T>,
+    url: string
+  ) => Promise<any>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Setup default mocks
+    mockGetAppUrlScheme.mockReturnValue("myapp");
+
+    mockSessionStorageGetItem
+      .mockResolvedValueOnce("com.example.app") // bundleId
+      .mockResolvedValueOnce("1.0.0"); // appVersion
+
+    mockUuid.mockReturnValue("test-uuid-1234");
+
+    const utils = require("../");
+    createCloudEvent = utils.createCloudEvent;
+    sendCloudEvent = utils.sendCloudEvent;
+    utils.resetCloudEventsSource();
+
+    // Note: Source caching means tests will reuse the source from the first test
+    // Tests that need specific source values or error conditions should run in isolation
+  });
+
+  describe("createCloudEvent", () => {
+    it("should create a cloud event with all required fields", async () => {
+      const { createCloudEvent } = require("../index");
+
+      const event = await createCloudEvent({
+        type: "user.action",
+        subject: "button.click",
+        data: { buttonId: "submit" },
+      });
+
+      expect(event).toHaveProperty("specversion", "1.0");
+      expect(event).toHaveProperty("type", "user.action");
+      expect(event).toHaveProperty("subject", "button.click");
+      expect(event).toHaveProperty("datacontenttype", "application/json");
+      expect(event).toHaveProperty("source");
+      expect(event).toHaveProperty("time");
+      expect(event).toHaveProperty("id", "test-uuid-1234");
+      expect(event).toHaveProperty("data", { buttonId: "submit" });
+    });
+
+    it("should generate source from appUrlScheme, bundleId, and appVersion", async () => {
+      mockGetAppUrlScheme.mockReset();
+      mockGetAppUrlScheme.mockReturnValue("testapp");
+
+      mockSessionStorageGetItem.mockReset();
+
+      mockSessionStorageGetItem
+        .mockResolvedValueOnce("com.test.bundle")
+        .mockResolvedValueOnce("2.3.4");
+
+      const { createCloudEvent } = require("../index");
+
+      const event = await createCloudEvent({
+        type: "test.event",
+        subject: "test",
+        data: {},
+      });
+
+      expect(event.source).toBe("testapp://com.test.bundle/versions/2.3.4");
+    });
+
+    it("should generate unique ID using uuid", async () => {
+      mockUuid.mockReturnValueOnce("uuid-1").mockReturnValueOnce("uuid-2");
+
+      const { createCloudEvent } = require("../index");
+
+      const event1 = await createCloudEvent({
+        type: "event1",
+        subject: "subject1",
+        data: {},
+      });
+
+      const event2 = await createCloudEvent({
+        type: "event2",
+        subject: "subject2",
+        data: {},
+      });
+
+      expect(event1.id).toBe("uuid-1");
+      expect(event2.id).toBe("uuid-2");
+    });
+
+    it("should generate ISO timestamp for time field", async () => {
+      const event = await createCloudEvent({
+        type: "test.event",
+        subject: "test",
+        data: {},
+      });
+
+      // Verify ISO 8601 format
+      expect(event.time).toMatch(
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
+      );
+
+      // Verify it's a valid date
+      expect(new Date(event.time).getTime()).toBeGreaterThan(0);
+    });
+
+    it("should include custom data in event", async () => {
+      const customData = {
+        userId: "user123",
+        action: "purchase",
+        amount: 99.99,
+        items: ["item1", "item2"],
+      };
+
+      const event = await createCloudEvent({
+        type: "commerce.purchase",
+        subject: "order.completed",
+        data: customData,
+      });
+
+      expect(event.data).toEqual(customData);
+    });
+
+    it("should throw error when appUrlScheme is missing", async () => {
+      jest.clearAllMocks();
+      mockSessionStorageGetItem.mockReset();
+      mockGetAppUrlScheme.mockReturnValue(null as any);
+
+      mockSessionStorageGetItem
+        .mockResolvedValueOnce("com.example.app")
+        .mockResolvedValueOnce("1.0.0");
+
+      mockUuid.mockReturnValue("test-uuid-1234");
+
+      const { createCloudEvent: freshCreate } = require("../index");
+
+      await expect(
+        freshCreate({
+          type: "test",
+          subject: "test",
+          data: {},
+        })
+      ).rejects.toThrow("Can not create client data addSource");
+    });
+
+    it("should throw error when bundleId is missing", async () => {
+      jest.clearAllMocks();
+      mockSessionStorageGetItem.mockReset();
+      mockGetAppUrlScheme.mockReturnValue("myapp");
+
+      mockSessionStorageGetItem
+        .mockResolvedValueOnce(null) // bundleId
+        .mockResolvedValueOnce("1.0.0");
+
+      mockUuid.mockReturnValue("test-uuid-1234");
+
+      const { createCloudEvent: freshCreate } = require("../index");
+
+      await expect(
+        freshCreate({
+          type: "test",
+          subject: "test",
+          data: {},
+        })
+      ).rejects.toThrow("Can not create client data addSource");
+    });
+
+    it("should throw error when appVersion is missing", async () => {
+      jest.clearAllMocks();
+      mockSessionStorageGetItem.mockReset();
+      mockGetAppUrlScheme.mockReturnValue("myapp");
+
+      mockSessionStorageGetItem
+        .mockResolvedValueOnce("com.example.app")
+        .mockResolvedValueOnce(null); // appVersion
+
+      mockUuid.mockReturnValue("test-uuid-1234");
+
+      const { createCloudEvent: freshCreate } = require("../index");
+
+      await expect(
+        freshCreate({
+          type: "test",
+          subject: "test",
+          data: {},
+        })
+      ).rejects.toThrow("Can not create client data addSource");
+    });
+
+    it("should cache source after first call", async () => {
+      jest.clearAllMocks();
+      mockGetAppUrlScheme.mockReturnValue("myapp");
+
+      mockSessionStorageGetItem.mockReset();
+
+      mockSessionStorageGetItem
+        .mockResolvedValueOnce("com.example.app")
+        .mockResolvedValueOnce("1.0.0");
+
+      mockUuid.mockReturnValueOnce("uuid-1").mockReturnValueOnce("uuid-2");
+
+      const freshUtils = require("../index");
+      freshUtils.resetCloudEventsSource();
+
+      const { createCloudEvent: freshCreate } = freshUtils;
+
+      const event1 = await freshCreate({
+        type: "event1",
+        subject: "subject1",
+        data: {},
+      });
+
+      const event2 = await freshCreate({
+        type: "event2",
+        subject: "subject2",
+        data: {},
+      });
+
+      expect(event1.source).toBe(event2.source);
+      expect(mockGetAppUrlScheme).toHaveBeenCalledTimes(1);
+      expect(mockSessionStorageGetItem).toHaveBeenCalledTimes(2);
+    });
+
+    it("should handle empty data object", async () => {
+      const event = await createCloudEvent({
+        type: "test.event",
+        subject: "test.subject",
+        data: {},
+      });
+
+      expect(event.data).toEqual({});
+    });
+
+    it("should handle null data", async () => {
+      const event = await createCloudEvent({
+        type: "test.event",
+        subject: "test.subject",
+        data: null,
+      });
+
+      expect(event.data).toBeNull();
+    });
+
+    it("should handle complex nested data", async () => {
+      const complexData = {
+        level1: {
+          level2: {
+            level3: {
+              value: "deep",
+            },
+          },
+        },
+        array: [1, 2, { nested: true }],
+      };
+
+      const event = await createCloudEvent({
+        type: "test.event",
+        subject: "test.subject",
+        data: complexData,
+      });
+
+      expect(event.data).toEqual(complexData);
+    });
+  });
+
+  describe("sendCloudEvent", () => {
+    let mockRequestBuilder: any;
+
+    beforeEach(() => {
+      mockRequestBuilder = {
+        setUrl: jest.fn().mockReturnThis(),
+        setMethod: jest.fn().mockReturnThis(),
+        addBodyParams: jest.fn().mockReturnThis(),
+        call: jest.fn().mockResolvedValue({ success: true, data: "response" }),
+      };
+
+      (
+        RequestBuilder as jest.MockedClass<typeof RequestBuilder>
+      ).mockImplementation(() => mockRequestBuilder);
+    });
+
+    it("should send cloud event to specified URL", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      const url = "https://api.example.com/events";
+
+      await sendCloudEvent(cloudEvent, url);
+
+      expect(mockRequestBuilder.setUrl).toHaveBeenCalledWith(url);
+      expect(mockRequestBuilder.setMethod).toHaveBeenCalledWith("POST");
+      expect(mockRequestBuilder.addBodyParams).toHaveBeenCalledWith(cloudEvent);
+      expect(mockRequestBuilder.call).toHaveBeenCalled();
+    });
+
+    it("should return response from API call", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      const expectedResponse = { success: true, eventId: "evt-123" };
+      mockRequestBuilder.call.mockResolvedValue(expectedResponse);
+
+      const result = await sendCloudEvent(
+        cloudEvent,
+        "https://api.example.com/events"
+      );
+
+      expect(result).toEqual(expectedResponse);
+    });
+
+    it("should throw error when URL is missing", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      await expect(sendCloudEvent(cloudEvent, "")).rejects.toThrow(
+        "Feed locator is missing"
+      );
+    });
+
+    it("should throw error when URL is null", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      await expect(sendCloudEvent(cloudEvent, null as any)).rejects.toThrow(
+        "Feed locator is missing"
+      );
+    });
+
+    it("should throw error when URL is undefined", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      await expect(
+        sendCloudEvent(cloudEvent, undefined as any)
+      ).rejects.toThrow("Feed locator is missing");
+    });
+
+    it("should handle API errors", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      mockRequestBuilder.call.mockRejectedValue(new Error("Network error"));
+
+      await expect(
+        sendCloudEvent(cloudEvent, "https://api.example.com/events")
+      ).rejects.toThrow("Network error");
+    });
+
+    it("should send event with all cloud event properties", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "user.created",
+        subject: "user/123",
+        source: "app://com.example/versions/1.0.0",
+        id: "uuid-123",
+        time: "2023-01-01T00:00:00.000Z",
+        datacontenttype: "application/json" as const,
+        data: {
+          userId: "123",
+          username: "testuser",
+        },
+      };
+
+      await sendCloudEvent(cloudEvent, "https://api.example.com/events");
+
+      expect(mockRequestBuilder.addBodyParams).toHaveBeenCalledWith(cloudEvent);
+    });
+
+    it("should handle different URL formats", async () => {
+      const cloudEvent: CloudEvent = {
+        specversion: "1.0" as const,
+        type: "test.event",
+        subject: "test",
+        source: "test://source",
+        id: "123",
+        time: new Date().toISOString(),
+        datacontenttype: "application/json" as const,
+        data: {},
+      };
+
+      const urls = [
+        "https://api.example.com/events",
+        "http://localhost:3000/events",
+        "https://api.example.com/v1/events?apiKey=123",
+      ];
+
+      for (const url of urls) {
+        mockRequestBuilder.setUrl.mockClear();
+        await sendCloudEvent(cloudEvent, url);
+        expect(mockRequestBuilder.setUrl).toHaveBeenCalledWith(url);
+      }
+    });
+  });
+
+  describe("integration", () => {
+    it("should create and send cloud event together", async () => {
+      const mockResponse = { success: true, eventId: "evt-123" };
+
+      const mockRequestBuilder = {
+        setUrl: jest.fn().mockReturnThis(),
+        setMethod: jest.fn().mockReturnThis(),
+        addBodyParams: jest.fn().mockReturnThis(),
+        call: jest.fn().mockResolvedValue(mockResponse),
+      };
+
+      (
+        RequestBuilder as jest.MockedClass<typeof RequestBuilder>
+      ).mockImplementation(() => mockRequestBuilder as any);
+
+      const event = await createCloudEvent({
+        type: "user.action",
+        subject: "button.click",
+        data: { buttonId: "submit" },
+      });
+
+      const response = await sendCloudEvent(
+        event,
+        "https://api.example.com/events"
+      );
+
+      expect(mockRequestBuilder.addBodyParams).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "user.action",
+          subject: "button.click",
+          data: { buttonId: "submit" },
+        })
+      );
+
+      expect(response).toEqual(mockResponse);
+    });
+  });
+});