@applicaster/zapp-react-native-utils 12.0.0-alpha.4043183114 → 12.0.0-alpha.4155487673

package/navigationUtils/index.ts

@@ -324,13 +324,7 @@ export function getPathAttributes({
  * @param {object} rivers
  * @returns {object}
  */
-export function getRiverFromRoute({
-  route,
-  rivers,
-}: {
-  route: string;
-  rivers: Record<string, ZappRiver>;
-}) {
+export function getRiverFromRoute({ route, rivers }) {
   if (!route) {
     return null;
   }
@@ -443,7 +437,7 @@ export const runZappHooksForEntry = async (
 
   let success;
   let payload;
-  const rivers: Record<string, ZappRiver> = appStore.get("rivers");
+  const rivers = appStore.get("rivers");
   const plugins = appStore.get("plugins");
   const appData = appStore.get("appData");
 
@@ -498,16 +492,13 @@ export const runZappHooksForEntry = async (
       payload = _payload;
     };
 
-  const hooksManager = HooksManager(hooksOptions);
-
-  hooksManager.subscriber
+  HooksManager(hooksOptions)
     .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, handleHookPresent)
     .on(HOOKS_EVENTS.START_BACKGROUND_HOOK, handleBackgroundHook)
     .on(HOOKS_EVENTS.ERROR, onFinished(false))
     .on(HOOKS_EVENTS.CANCEL, onFinished(false))
-    .on(HOOKS_EVENTS.COMPLETE, onFinished(true));
-
-  hooksManager.handleHooks(entry);
+    .on(HOOKS_EVENTS.COMPLETE, onFinished(true))
+    .handleHooks(entry);
 
   // eslint-disable-next-line no-unmodified-loop-condition
   while (success === undefined) {

package/numberUtils/__tests__/toNumber.test.ts

@@ -2,7 +2,7 @@ import { toNumber } from "..";
 
 describe("toNumber", () => {
   it("return number if input is number", () => {
-    const inputs = [-1, 0, 1, 100];
+    const inputs = [-1, 0, 1, 100, 0.2];
     expect.assertions(inputs.length);
 
     inputs.forEach((input) => {
@@ -12,7 +12,7 @@ describe("toNumber", () => {
   });
 
   it("return number if input is string as number", () => {
-    const inputs = ["-1", "0", "1", "100"];
+    const inputs = ["-1", "0", "1", "100", "0.2"];
     expect.assertions(inputs.length);
 
     inputs.forEach((input) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "12.0.0-alpha.4043183114",
+  "version": "12.0.0-alpha.4155487673",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "12.0.0-alpha.4043183114",
+    "@applicaster/applicaster-types": "12.0.0-alpha.4155487673",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

package/playerUtils/imaScriptDom.ts

@@ -0,0 +1,59 @@
+import { createLogger } from "../logger";
+
+export const logger = createLogger({
+  category: "ImaDomUtils",
+  subsystem: "Player/ImaDomUtils",
+});
+
+const { log_debug, log_error, log_verbose } = logger;
+
+const removeElement = (node) => {
+  if (node) {
+    const parentNode = node.parentNode;
+
+    if (parentNode) {
+      parentNode.removeChild(node);
+    }
+  }
+};
+
+// TODO: This should probably be loaded to root of project before player init
+export const loadIMAScript = async () => {
+  return new Promise((resolve) => {
+    // If ima script is already loaded, resolve
+    const imaScript = document.getElementById("ima-script");
+
+    if (imaScript) {
+      log_verbose("loadIMAScript: IMA script already loaded");
+
+      return resolve(true);
+    }
+
+    const script = document.createElement("script");
+
+    if (__DEV__) {
+      script.src = "https://imasdk.googleapis.com/js/sdkloader/ima3_debug.js";
+    } else {
+      script.src = "https://imasdk.googleapis.com/js/sdkloader/ima3.js";
+    }
+
+    script.async = true;
+    script.id = "ima-script";
+
+    script.onload = () => {
+      removeElement(script);
+      log_debug("loadIMAScript: Loaded ima script", script.src);
+      resolve(true);
+    };
+
+    script.onerror = (_e) => {
+      removeElement(script);
+      log_error("loadIMAScript: Failed to load ima script", script.src);
+      resolve(false);
+    };
+
+    if (document.head) {
+      document.head.appendChild(script);
+    }
+  });
+};

package/reactHooks/debugging/__tests__/index.test.js

@@ -4,38 +4,77 @@ import {
   timers,
 } from "@applicaster/zapp-react-native-utils/reactHooks/debugging";
 
-jest.useFakeTimers();
-
 describe("Debug utils", () => {
+  let performanceNowMock;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    // Clear the timers object
+    Object.keys(timers).forEach((key) => delete timers[key]);
+
+    // Mock performance.now()
+    // eslint-disable-next-line no-undef
+    performanceNowMock = jest.spyOn(performance, "now");
+    performanceNowMock.mockReturnValue(0); // Initial value
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+    performanceNowMock.mockRestore();
+  });
+
   describe("Unit Test: time", () => {
     it("should create new timer if timer with a label does not exist", () => {
+      performanceNowMock.mockReturnValue(1000);
       time("timer1");
       expect(timers["timer1"]).toBeDefined();
+      expect(timers["timer1"].startTime).toBe(1000);
     });
 
     it("should update start time of timer if timer with a label exists", () => {
+      // First call to time()
+      performanceNowMock.mockReturnValue(1000);
+      time("timer1");
       const previousStartTime = timers["timer1"].startTime;
-      jest.advanceTimersByTime(1000);
+
+      // Second call to time()
+      performanceNowMock.mockReturnValue(2000);
       time("timer1");
       const currentStartTime = timers["timer1"].startTime;
-      expect(previousStartTime).not.toEqual(currentStartTime);
+
+      expect(previousStartTime).toBe(1000);
+      expect(currentStartTime).toBe(2000);
     });
   });
 
   describe("Unit Test: timeEnd", () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+      jest.spyOn(console, "log").mockImplementation(() => {});
+    });
 
     it("should log elapsed time", () => {
       const logSpy = jest.spyOn(console, "log");
 
+      performanceNowMock.mockReturnValue(1000);
+      time("timer1");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer1");
 
-      expect(logSpy).toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith(
+        "timer1: 1000.000ms 2",
+        expect.any(Object)
+      );
     });
 
     it("should not log elapsed time if accumulative: true in settings", () => {
       const logSpy = jest.spyOn(console, "log");
 
+      performanceNowMock.mockReturnValue(1000);
+      time("timer1");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer1", { accumulative: true });
 
       expect(logSpy).not.toHaveBeenCalled();
@@ -43,21 +82,52 @@ describe("Debug utils", () => {
   });
 
   describe("Integration Test: time and timeEnd", () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+      jest.spyOn(console, "log").mockImplementation(() => {});
+    });
 
     it("should log elapsed time on timeEnd call", () => {
       const logSpy = jest.spyOn(console, "log");
+
+      performanceNowMock.mockReturnValue(1000);
       time("timer1");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer1");
-      expect(logSpy).toHaveBeenCalled();
+
+      expect(logSpy).toHaveBeenCalledWith(
+        "timer1: 1000.000ms 2",
+        expect.objectContaining({
+          label: "timer1",
+          settings: undefined,
+        })
+      );
     });
 
-    it("should log total and average time on timeEnd call without accumulative option", () => {
+    it("should log total and average time when accumulative timing is complete", () => {
       const logSpy = jest.spyOn(console, "log");
+
+      // First timing
+      performanceNowMock.mockReturnValue(1000);
       time("timer2");
+
+      performanceNowMock.mockReturnValue(2000);
       timeEnd("timer2", { accumulative: true });
-      timeEnd("timer2");
-      expect(logSpy).toHaveBeenCalled();
+
+      // Second timing
+      performanceNowMock.mockReturnValue(3000);
+      time("timer2");
+
+      performanceNowMock.mockReturnValue(5000);
+      timeEnd("timer2"); // This will log because timer is accumulative (callCount > 1)
+
+      expect(logSpy).toHaveBeenCalledWith(
+        "timer2: 2000.000ms 2",
+        expect.objectContaining({
+          label: "timer2",
+          settings: undefined,
+        })
+      );
     });
   });
 });

package/reactHooks/navigation/index.ts

@@ -320,19 +320,16 @@ export const useZappHooksForEntry = (
         callbacks?.handleHookComplete?.(props);
       };
 
-      const hookManager = HooksManager(hooksOptions);
-
-      hookManager.subscriber
+      const hookManager = HooksManager(hooksOptions)
         .on(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, handleHookPresent)
         .on(HOOKS_EVENTS.ERROR, handleHookError)
         .on(HOOKS_EVENTS.CANCEL, handleHookCancel)
         .on(HOOKS_EVENTS.START_BACKGROUND_HOOK, handleBackgroundHook)
-        .on(HOOKS_EVENTS.COMPLETE, handleHookComplete);
-
-      hookManager.handleHooks(entry);
+        .on(HOOKS_EVENTS.COMPLETE, handleHookComplete)
+        .handleHooks(entry);
 
       return () => {
-        hookManager.subscriber
+        hookManager
           .removeHandler(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, handleHookPresent)
           .removeHandler(HOOKS_EVENTS.ERROR, handleHookError)
           .removeHandler(HOOKS_EVENTS.CANCEL, handleHookCancel)

package/reactHooks/resolvers/useCellResolver.ts

@@ -48,7 +48,11 @@ export function useCellResolver({
   ...cellResolverOptions
 }: Props) {
   let _component = Object.assign({}, component);
-  const { width, height } = useDimensions("screen");
+
+  const { width, height } = useDimensions("screen", {
+    updateForInactiveScreens: false,
+  });
+
   const { plugins, cellStyles } = usePickFromState(["plugins", "cellStyles"]);
   const isRTL = useIsRTL();
 

package/reactUtils/index.ts

@@ -109,6 +109,20 @@ export const isTvOSPlatform = () => getPlatform() === "tvos";
 
 export const isAndroidTVPlatform = () => getPlatform() === "android_tv";
 
+declare global {
+  interface Window {
+    VIZIO?: {
+      Chromevox: {
+        play: (text: string) => void;
+      };
+      exitApplication: () => void;
+      setClosedCaptionHandler: (
+        callback: (isCCEnabled: boolean) => void
+      ) => void;
+    };
+  }
+}
+
 /**
  * Platforms found in userAgent string, please note that simulators
  * might not have the same agents that the devices have
@@ -138,8 +152,7 @@ export const hasTizen = typeof window?.tizen !== "undefined";
  */
 export const hasWebOS = typeof window?.webOS !== "undefined";
 
-export const getUserAgent = () =>
-  window?.navigator?.userAgent || global?.navigator?.userAgent;
+export const getUserAgent = () => window?.navigator?.userAgent;
 
 export const isLgPlatform = () => {
   const userAgent = getUserAgent();

package/appUtils/HooksManager/types.ts

@@ -1,93 +0,0 @@
-import { SubscriberObj } from "../../functionUtils";
-import { HOOKS_EVENTS } from "./constants";
-
-export interface HookConfiguration {}
-
-export interface HookModule {
-  ModalContainer: React.ComponentType<any>;
-  Component: React.ComponentType<any>;
-  presentFullScreen: boolean;
-  run: (
-    arg0: unknown,
-    callback: () => void,
-    configuration: HookConfiguration
-  ) => void;
-  configuration: HookConfiguration;
-  isFlowBlocker: () => boolean;
-  skipHook: boolean;
-  setSkipHook: (skipHook: boolean) => void;
-  shouldSkipHook: () => boolean;
-  runInBackground: (
-    arg0: unknown,
-    callback: () => void,
-    hookPlugin: Hook,
-    presentUI: boolean
-  ) => void;
-}
-
-export type HookManagerArgs = {
-  rivers: Record<string, ZappRiver>;
-  plugins: ZappPlugin[];
-  targetScreen: ZappRiver;
-  startUpHooksData?: {
-    startUpHooks?: unknown[] | "in_process";
-    setStartUpHooks?: (arg0: string) => void;
-  };
-};
-
-export interface HookManager {
-  subscriber: SubscriberObj;
-  presentScreenHook: (
-    hook: Hook,
-    payload: unknown,
-    callback: (...any) => void
-  ) => void;
-  executeHook: (
-    hook: Hook,
-    payload: unknown,
-    callback: (...any) => void
-  ) => void;
-  handleHooks: (payload: unknown) => void;
-  runInBackground: (
-    hook: Hook,
-    payload: unknown,
-    callback: (...any) => void,
-    presentUI: boolean
-  ) => void;
-}
-
-export type HookIniObj = {
-  hook: HookModule & {
-    module: HookModule;
-    general: unknown;
-    screen_id?: string;
-    identifier?: string;
-    weight?: number | string;
-  };
-  hooks: Hook<any>[];
-  manager: HookManager;
-};
-
-export interface Hook<T extends HookModule = HookModule> {
-  manager: HookManager;
-  lastHook: boolean;
-  state: number;
-  module: T;
-  screen_id: string;
-  identifier: string;
-  configuration: T["configuration"];
-  setStateAndNotify(
-    event: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS],
-    opts: {
-      error?: typeof Error;
-      route?: string;
-      hookPlugin: Hook<T>;
-      payload: unknown;
-    }
-  );
-  general?: {
-    transition_type: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS];
-    allow_screen_plugin_presentation: boolean;
-    is_flow_blocker: boolean;
-  };
-}

package/appUtils/keyCodes/keys/index.ts

@@ -1,3 +0,0 @@
-export * from "./keys";
-
-export { keyEventMapper } from "./keyEventMapper";

package/appUtils/keyCodes/keys/keys.android.ts

@@ -1,18 +0,0 @@
-export const KEYS = {
-  Enter: { code: "Enter", keyCode: 13 },
-  EnterKeyboard: { code: "EnterKeyboard", keyCode: 66 },
-  Back: { code: "Back", keyCode: 8 },
-  Space: { code: "Space", keyCode: 32 },
-  m: { code: "m", keyCode: 77 },
-  ArrowLeft: { code: "ArrowLeft", keyCode: 37 },
-  ArrowUp: { code: "ArrowUp", keyCode: 38 },
-  ArrowRight: { code: "ArrowRight", keyCode: 39 },
-  ArrowDown: { code: "ArrowDown", keyCode: 40 },
-};
-
-export const ARROW_KEYS = [
-  KEYS.ArrowUp,
-  KEYS.ArrowLeft,
-  KEYS.ArrowDown,
-  KEYS.ArrowRight,
-];

package/appUtils/keyCodes/keys/keys.ios.ts

@@ -1,25 +0,0 @@
-export const KEYS = {
-  Enter: { code: "Enter", keyCode: 13 },
-  Space: { code: "Space", keyCode: 32 },
-  m: { code: "m", keyCode: 77 },
-  ArrowLeft: { code: "ArrowLeft", keyCode: 37 },
-  ArrowUp: { code: "ArrowUp", keyCode: 38 },
-  ArrowRight: { code: "ArrowRight", keyCode: 39 },
-  ArrowDown: { code: "ArrowDown", keyCode: 40 },
-  Back: { code: "Backspace", keyCode: 8 },
-  Play: { code: "PlayPause", keyCode: 179 },
-  Pause: { code: "Pause", keyCode: 179 },
-  Forward: { code: "Forward", keyCode: 176 },
-  Rewind: { code: "Rewind", keyCode: 177 },
-  VolumeUp: { code: "VolumeUp", keyCode: 175 },
-  VolumeDown: { code: "VolumeDown", keyCode: 174 },
-  ToggleMute: { code: "VolumeMute", keyCode: 173 },
-  Stop: { code: "Q", keyCode: 81 },
-};
-
-export const ARROW_KEYS = [
-  KEYS.ArrowUp,
-  KEYS.ArrowLeft,
-  KEYS.ArrowDown,
-  KEYS.ArrowRight,
-];

package/appUtils/keyCodes/keys/keys.ts

@@ -1,15 +0,0 @@
-// dummy file to make sure the folder structure is created
-export const KEYS: Record<string, { code: string; keyCode: number }> = {
-  ArrowLeft: { code: "ArrowLeft", keyCode: -1 },
-  ArrowUp: { code: "ArrowUp", keyCode: -1 },
-  ArrowRight: { code: "ArrowRight", keyCode: -1 },
-  ArrowDown: { code: "ArrowDown", keyCode: -1 },
-  Back: { code: "Back", keyCode: -1 },
-};
-
-export const ARROW_KEYS = [
-  KEYS.ArrowUp,
-  KEYS.ArrowLeft,
-  KEYS.ArrowDown,
-  KEYS.ArrowRight,
-];