@applicaster/zapp-react-native-utils 12.0.0-alpha.4536343143 → 12.0.0-alpha.4576271826

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "12.0.0-alpha.4536343143",
+  "version": "12.0.0-alpha.4576271826",
   "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.4536343143",
+    "@applicaster/applicaster-types": "12.0.0-alpha.4576271826",
     "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/pluginUtils/index.ts

@@ -245,3 +245,12 @@ export function generateManifest({ manifestConfig, version }) {
 
   return manifestConfig({ platform, version });
 }
+
+const getPluginType = R.pathOr("unknown_plugin_type", [
+  "state",
+  "screen",
+  "plugin_type",
+]);
+
+export const isPlayerPlugin = (routeState): boolean =>
+  getPluginType(routeState) === "player";

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/feed/__tests__/useFeedRefresh.test.tsx

@@ -1,9 +1,13 @@
 import { renderHook } from "@testing-library/react-hooks";
 
-import { useFeedRefresh, feedRefreshLogger } from "../";
-
 jest.useFakeTimers();
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
+  useIsScreenActive: () => true,
+}));
+
+const { useFeedRefresh, feedRefreshLogger } = require("..");
+
 describe("useFeedRefresh", () => {
   const reloadData = jest.fn();
 

package/reactHooks/feed/useFeedRefresh.tsx

@@ -1,7 +1,8 @@
 import * as React from "react";
-import * as R from "ramda";
+import { path, max } from "ramda";
 import { isTrue } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { toNumberWithDefault } from "@applicaster/zapp-react-native-utils/numberUtils";
+import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 
 import { reactHooksLogger } from "../logger";
 import { ReloadDataFunction } from "./useFeedLoader";
@@ -18,9 +19,8 @@ const minimumRefreshingInterval = 5;
 const defaultRefreshInterval = 60;
 
 export const useFeedRefresh = ({ reloadData, component }: Props): void => {
-  const enable_data_refreshing = R.path(
-    ["rules", "enable_data_refreshing"],
-    component
+  const isDataRefreshingEnabled = isTrue(
+    path(["rules", "enable_data_refreshing"], component)
   );
 
   const refreshing_interval = toNumberWithDefault(
@@ -29,10 +29,12 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
   );
 
   const refreshingIntervalInMilliseconds =
-    R.max(refreshing_interval, minimumRefreshingInterval) * 1000;
+    max(refreshing_interval, minimumRefreshingInterval) * 1000;
+
+  const isScreenActive = useIsScreenActive();
 
   React.useEffect(() => {
-    if (isTrue(enable_data_refreshing) && refreshing_interval) {
+    if (isDataRefreshingEnabled && refreshing_interval && isScreenActive) {
       if (refreshing_interval < minimumRefreshingInterval) {
         feedRefreshLogger.warning({
           message: `You set your feed refresh interval to ${refreshing_interval} when minimum value is ${minimumRefreshingInterval}seconds.Your feed will refresh after ${minimumRefreshingInterval}seconds.`,
@@ -59,5 +61,5 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
         clearInterval(refreshInterval);
       };
     }
-  }, [reloadData]);
+  }, [reloadData, isScreenActive]);
 };

package/reactHooks/layout/useDimensions/useDimensions.ts

@@ -95,6 +95,8 @@ export const useDimensions: UseDimensions = (
 
     const activeSubscription = Dimensions.addEventListener("change", handler);
 
+    handler({ [context]: Dimensions.get(context) });
+
     return () => {
       activeSubscription.remove();
     };

package/reactHooks/navigation/index.ts

@@ -31,7 +31,7 @@ import { platformSelect } from "../../reactUtils";
 import { useConnectionInfo } from "../connection";
 import { getTargetScreenData } from "../screen/useTargetScreenData";
 
-import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavbarState } from "../screen";
 import { useNavigation } from "./useNavigation";
 import { useModalStore } from "../../modalState";
@@ -78,6 +78,10 @@ export function isNavBarVisible(
     return false;
   }
 
+  if (screenData?.plugin_type === "login" && isTV()) {
+    return false;
+  }
+
   /* Match if screen is Hook */
   if (route.startsWith("/hooks/")) {
     const module = screenData?.module;
@@ -462,7 +466,13 @@ export const useUniqueRouteSuffix = (): Return => {
   const suffix = `currentRoute:${currentRoute}_pathname:${pathname}`;
 
   const withUniqueRouteSuffix = React.useCallback((prefix: string) => {
-    return `${prefix}___${suffix}`;
+    if (isWeb()) {
+      // we should use extended route prefix only on Web, where we have stack-navigator
+      return `${prefix}___${suffix}`;
+    }
+
+    // for other platforms use previous version
+    return prefix;
   }, []);
 
   return withUniqueRouteSuffix;

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

@@ -108,3 +108,107 @@ export const isAndroidPlatform = () => Platform.OS === "android";
 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
+ */
+export const PLATFORMS = {
+  webos: "Web0S",
+  tizen: "Tizen",
+  samsung: "SMART-TV",
+  mac: "Mac",
+  win: "Win",
+  linux: "Linux",
+  iphone: "iPhone",
+  android: "Android",
+  mobile: "Mobile",
+  vizio: "VIZIO",
+  smartcast: "SmartCast",
+  conjure: "Conjure",
+};
+
+/**
+ * Simple way of identifying if we have access to the tizen APIs
+ */
+export const hasTizen = typeof window?.tizen !== "undefined";
+
+/**
+ * Simple way of identifying if we have access to the webOS APIs
+ */
+export const hasWebOS = typeof window?.webOS !== "undefined";
+
+export const getUserAgent = () => window?.navigator?.userAgent;
+
+export const isLgPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  // Note: LG uses the number 0 in their userAgent, possibly because of Palm WebOS
+  return hasWebOS || userAgent.includes(PLATFORMS.webos);
+};
+
+export const isSamsungPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  return (
+    hasTizen ||
+    userAgent.includes(PLATFORMS.samsung) ||
+    userAgent.includes(PLATFORMS.tizen)
+  );
+};
+
+/**
+ * Checks if we are on the Vizio platform by using the userAgent string
+ *
+ * Use this method when you need to identify the platform on runtime
+ * before the VIZIO Companion Library has loaded
+ */
+export const isVizioPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  const isVizioAgent =
+    userAgent.includes(PLATFORMS.vizio) ||
+    userAgent.includes(PLATFORMS.smartcast) ||
+    userAgent.includes(PLATFORMS.conjure);
+
+  return isVizioAgent;
+};
+
+/**
+ * Checks if we are on the Vizio platform by checking for the global VIZIO object
+ * and the VIZIO Companion Library. This method does not use the userAgent string,
+ * because it mainly checks whether we have access to apis, which may not be available yet
+ */
+export const hasVizioAPIs = () => {
+  const hasAPIs =
+    typeof window.VIZIO !== "undefined" &&
+    window?.applicaster?.vizioLibraryDidLoad;
+
+  return hasAPIs;
+};

package/appUtils/focusManager/FocusableEvents.ts

@@ -1,8 +0,0 @@
-export const FOCUSABLE_EVENTS = {
-  IS_REGISTERED: "isRegistered",
-  WILL_RECEIVE_FOCUS: "willReceiveFocus",
-  HAS_RECEIVED_FOCUS: "hasReceivedFocus",
-  WILL_LOSE_FOCUS: "willLoseFocus",
-  HAS_LOST_FOCUS: "hasLostFocus",
-  WILL_UNREGISTER: "willUnregister",
-};