@applicaster/zapp-react-native-utils 13.0.0-alpha.5330008750 → 13.0.0-alpha.5335086935

package/README.md

@@ -376,16 +376,6 @@ useEffect(() => {
 }, []);
 ```
 
-### testUtils
-
-`@applicaster/zapp-react-native-utils/testUtils`
-
-- `testIDEquals: (testId: any) => boolean | { width: number, height: number }` - Function to be used in tandem with enzyme findWhere
-
-```javascript
-wrapper.findWhere(testIDEquals("text"));
-```
-
 ### appUtils - contextKeysManager
 
 `@applicaster/zapp-react-native-utils/appUtils/contextKeyManager`

package/analyticsUtils/currentScreenProperities.ts

@@ -72,12 +72,14 @@ const mappedScreenPropertiesScreen = (
   screenData
 ): AnalyticsScreenProperties => {
   return {
-    screen_name: screenData?.targetScreen?.name,
+    screen_name: screenData?.targetScreen?.name || screenData?.name,
     screen_entry_title: screenData?.title,
     screen_entry_id: R.isNil(screenData?.type) ? null : screenData?.id,
-    screen_layout_id: screenData?.targetScreen?.id,
-    screen_type: screenData?.targetScreen?.type,
-    home_screen: screenData?.targetScreen?.home,
+    screen_layout_id: screenData?.targetScreen?.id || screenData?.id,
+    screen_type: screenData?.targetScreen?.type || screenData?.type,
+    home_screen: !R.isNil(screenData?.targetScreen?.home)
+      ? screenData?.targetScreen?.home
+      : screenData?.home,
   };
 };
 

package/appUtils/contextKeysManager/index.ts

@@ -16,12 +16,12 @@ import {
 
 export { StorageLevel };
 
-type KeyNameObj = {
+export type KeyNameObj = {
   namespace: string;
   key: string;
 };
 
-type KeyName = string | KeyNameObj;
+export type KeyName = string | KeyNameObj;
 
 type ParsedKeyAndNamespace = {
   namespace?: string;

package/appUtils/contextKeysManager/utils/index.ts

@@ -1,10 +1,11 @@
 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) {
+export function getNamespaceAndKey(namespacedKey: KeyName): KeyNameObj {
   if (typeof namespacedKey !== "string") return namespacedKey;
 
   const namespacedKeyProps = namespacedKey.includes(".")

package/appUtils/focusManager/__tests__/__snapshots__/focusManager.test.js.snap

@@ -28,6 +28,7 @@ exports[`focusManager should be defined 1`] = `
   "moveFocus": [Function],
   "on": [Function],
   "press": [Function],
+  "pressIn": [Function],
   "pressOut": [Function],
   "recoverFocus": [Function],
   "register": [Function],

package/appUtils/focusManager/index.ts

@@ -345,6 +345,14 @@ export const focusManager = (function () {
     });
   }
 
+  function pressIn() {
+    const currentFocusable = getCurrentFocus();
+
+    if (currentFocusable) {
+      currentFocusable.pressIn(null);
+    }
+  }
+
   /**
    * calls the `press` method on the current focus component
    * @public
@@ -552,6 +560,7 @@ export const focusManager = (function () {
     invokeHandler,
     removeHandler,
     longPress,
+    pressIn,
     pressOut,
     enableFocus,
     setInitialFocus,

package/appUtils/platform/platformUtils.ts

@@ -77,13 +77,22 @@ export class ClosedCaptioningManager {
 
   private constructor() {
     this.initialize();
+
+    window["vizioDebug"] = {
+      setCCEnabled: (isCCEnabled: boolean) => {
+        this.ccState$.next(isCCEnabled);
+      },
+    };
   }
 
   static getInstance(): ClosedCaptioningManager {
     if (!ClosedCaptioningManager.ccManagerInstance) {
+      log_debug("ClosedCaptioningManager: Creating new instance");
       ClosedCaptioningManager.ccManagerInstance = new ClosedCaptioningManager();
     }
 
+    log_debug("ClosedCaptioningManager: Returning existing instance");
+
     return ClosedCaptioningManager.ccManagerInstance;
   }
 
@@ -92,23 +101,41 @@ export class ClosedCaptioningManager {
       PLATFORM_KEYS.deviceClosedCaptioningEnabled
     );
 
-    log_debug("Initializing closed captioning manager", { existingState });
-
     if (existingState !== null) {
+      log_debug(
+        `ClosedCaptioningManager: Setting initial state to ${existingState}`
+      );
+
       this.ccState$.next(existingState === "true" || existingState === true);
+    } else {
+      log_debug("ClosedCaptioningManager: No existing state found");
     }
 
     if (hasVizioAPIs()) {
+      log_debug("ClosedCaptioningManager: Setting closed captioning handler");
+
       window.VIZIO!.setClosedCaptionHandler((isCCEnabled) => {
-        log_debug("CC state changed", { isCCEnabled });
+        log_debug(
+          "ClosedCaptioningManager: There was a change in the CC state",
+          { isCCEnabled }
+        );
 
         sessionStorage.setItem(
           PLATFORM_KEYS.deviceClosedCaptioningEnabled,
           isCCEnabled
         );
 
+        log_debug(
+          "ClosedCaptioningManager: Saved CC state to session storage",
+          { isCCEnabled }
+        );
+
         this.ccState$.next(isCCEnabled);
       });
+    } else {
+      log_debug(
+        "ClosedCaptioningManager: Vizio APIs are not available, skipping setup"
+      );
     }
   }
 

package/appUtils/playerManager/index.ts

@@ -452,7 +452,7 @@ export class PlayerManager {
     if (this.castingReceiver) {
       this.castingReceiver.closeNativePlayer();
     } else {
-      this.getActivePlayer().closeNativePlayer();
+      this.getActivePlayer()?.closeNativePlayer();
       this.invokeHandler("close");
     }
   }

package/arrayUtils/index.ts

@@ -93,7 +93,7 @@ export const isIndexInRange = (index: number, length: number): boolean => {
 export const makeListOfIndexes = (size: number): number[] =>
   Array.from({ length: size }, (_, index) => index);
 
-export const makeListOf = (value: unknown, size: number): number[] => {
+export const makeListOf = <T>(value: T, size: number): T[] => {
   return Array(size).fill(value);
 };
 

package/componentsUtils/__tests__/isFirstComponentGallery.test.ts

@@ -0,0 +1,33 @@
+import { isFirstComponentGallery } from "../index";
+
+describe("isFirstComponentGallery", () => {
+  it("should return true if the first component is a gallery", () => {
+    const components = [
+      { component_type: "gallery-qb" },
+      { component_type: "other-component" },
+    ];
+
+    expect(isFirstComponentGallery(components)).toBe(true);
+  });
+
+  it("should return false if the first component is not a gallery", () => {
+    const components = [
+      { component_type: "other-component" },
+      { component_type: "gallery-qb" },
+    ];
+
+    expect(isFirstComponentGallery(components)).toBe(false);
+  });
+
+  it("should return false if the components array is empty", () => {
+    const components = [];
+
+    expect(isFirstComponentGallery(components)).toBe(false);
+  });
+
+  it("should return false if the components array is undefined", () => {
+    const components = undefined;
+
+    expect(isFirstComponentGallery(components)).toBe(false);
+  });
+});

package/componentsUtils/__tests__/isFirstComponentScreenPicker.test.ts

@@ -0,0 +1,33 @@
+import { isFirstComponentScreenPicker } from "..";
+
+describe("isFirstComponentScreenPicker", () => {
+  it("should return true if the first component screen-picker", () => {
+    const items = [{ component_type: "screen-picker-qb-tv" }];
+    expect(isFirstComponentScreenPicker(items)).toBe(true);
+  });
+
+  it("should return false if the first component type is not screen-picker", () => {
+    const items = [{ component_type: "other-component" }];
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the component type is undefined", () => {
+    const items = [{ component_type: undefined }];
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the item is null", () => {
+    const items = null;
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the item is undefined", () => {
+    const items = undefined;
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+
+  it("should return false if the item is an empty object", () => {
+    const items = {};
+    expect(isFirstComponentScreenPicker(items)).toBe(false);
+  });
+});

package/componentsUtils/__tests__/isGallery.test.ts

@@ -0,0 +1,33 @@
+import { isGallery } from "..";
+
+describe("isGallery", () => {
+  it("should return true if the component type is 'gallery-qb'", () => {
+    const item = { component_type: "gallery-qb" };
+    expect(isGallery(item)).toBe(true);
+  });
+
+  it("should return false if the component type is not 'gallery-qb'", () => {
+    const item = { component_type: "other-component" };
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the component type is undefined", () => {
+    const item = { component_type: undefined };
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the item is null", () => {
+    const item = null;
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the item is undefined", () => {
+    const item = undefined;
+    expect(isGallery(item)).toBe(false);
+  });
+
+  it("should return false if the item is an empty object", () => {
+    const item = {};
+    expect(isGallery(item)).toBe(false);
+  });
+});

package/componentsUtils/__tests__/isScreenPicker.test.ts

@@ -0,0 +1,33 @@
+import { isScreenPicker } from "..";
+
+describe("isScreenPicker", () => {
+  it("should return true if the component type is 'screen-picker-qb-tv'", () => {
+    const item = { component_type: "screen-picker-qb-tv" };
+    expect(isScreenPicker(item)).toBe(true);
+  });
+
+  it("should return false if the component type is not 'screen-picker-qb-tv'", () => {
+    const item = { component_type: "other-component" };
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the component type is undefined", () => {
+    const item = { component_type: undefined };
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the item is null", () => {
+    const item = null;
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the item is undefined", () => {
+    const item = undefined;
+    expect(isScreenPicker(item)).toBe(false);
+  });
+
+  it("should return false if the item is an empty object", () => {
+    const item = {};
+    expect(isScreenPicker(item)).toBe(false);
+  });
+});

package/componentsUtils/index.ts

@@ -0,0 +1,17 @@
+export const isGallery = (item): boolean =>
+  item?.component_type === "gallery-qb";
+
+export const isScreenPicker = (item): boolean =>
+  item?.component_type === "screen-picker-qb-tv";
+
+export const isFirstComponentScreenPicker = (
+  components: ZappUIComponent[]
+): boolean => {
+  return isScreenPicker(components?.[0]);
+};
+
+export const isFirstComponentGallery = (
+  components: ZappUIComponent[]
+): boolean => {
+  return isGallery(components?.[0]);
+};

package/equalUtils/__tests__/isEqual/combination.test.ts

@@ -0,0 +1,263 @@
+import { isEqual } from "../..";
+
+const array = [1, 2, 3];
+const sameProp = "sameProp";
+
+describe("isEqual - comprehensive tests", () => {
+  describe("all conditions together", () => {
+    it("all conditions checked and not equal", () => {
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "test",
+        extraProp1: 123,
+        extraProp2: sameProp,
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "different",
+        extraProp1: 456,
+        extraProp2: sameProp,
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+        compareRemainingKeysBySameValue: true,
+      })(prev, next);
+
+      expect(result).toBe(false);
+
+      expect(customComparator).toHaveBeenCalledWith(
+        prev.byComparatorProp,
+        next.byComparatorProp
+      );
+    });
+
+    it("all conditions pass with exact remaining keys check", () => {
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "test",
+        extraProp: sameProp,
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "test",
+        extraProp: sameProp,
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+        compareRemainingKeysBySameValue: true,
+      })(prev, next);
+
+      expect(result).toBe(true);
+
+      expect(customComparator).toHaveBeenCalledWith(
+        prev.byComparatorProp,
+        next.byComparatorProp
+      );
+    });
+
+    it("byReference check fails first (early return)", () => {
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: sameProp,
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: [1, 2, 3],
+        byComparatorProp: sameProp,
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+      })(prev, next);
+
+      expect(result).toBe(false);
+      expect(customComparator).not.toHaveBeenCalled();
+    });
+
+    it("byValue check fails after byReference passes", () => {
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: sameProp,
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 3 },
+        byRefProp: array,
+        byComparatorProp: sameProp,
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+      })(prev, next);
+
+      expect(result).toBe(false);
+      expect(customComparator).not.toHaveBeenCalled();
+    });
+
+    it("byComparator check fails after other checks pass", () => {
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "test",
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "different",
+      };
+
+      const customComparator = jest.fn().mockReturnValue(false);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+      })(prev, next);
+
+      expect(result).toBe(false);
+
+      expect(customComparator).toHaveBeenCalledWith(
+        prev.byComparatorProp,
+        next.byComparatorProp
+      );
+    });
+
+    it("remaining keys comparison fails", () => {
+      const sharedArray = [1, 2, 3];
+
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: sharedArray,
+        byComparatorProp: "test",
+        extraProp: "original",
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: sharedArray,
+        byComparatorProp: "different",
+        extraProp: "changed",
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+        compareRemainingKeysBySameValue: true,
+      })(prev, next);
+
+      expect(result).toBe(false);
+      expect(customComparator).toHaveBeenCalled();
+    });
+
+    it("with debug flag", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation();
+
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "test",
+        extraProp: sameProp,
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: array,
+        byComparatorProp: "different",
+        extraProp: sameProp,
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+        compareRemainingKeysBySameValue: true,
+        debug: true,
+      })(prev, next);
+
+      expect(result).toBe(true);
+      expect(consoleSpy).toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+
+    it("handles missing properties", () => {
+      const prev = {
+        byValueProp: { a: 1, b: 2 },
+        byRefProp: [1, 2, 3],
+      };
+
+      const next = {
+        byValueProp: { a: 1, b: 2 },
+        byComparatorProp: "test",
+      };
+
+      const customComparator = jest.fn().mockReturnValue(true);
+
+      const result = isEqual({
+        byValue: ["byValueProp"],
+        byReference: ["byRefProp"],
+        byComparator: {
+          comparator: customComparator,
+          keys: ["byComparatorProp"],
+        },
+      })(prev, next);
+
+      expect(result).toBe(false);
+      expect(customComparator).not.toHaveBeenCalled();
+    });
+  });
+});