@applicaster/zapp-react-native-utils 13.0.0-alpha.5004843012 → 13.0.0-alpha.5049772260

package/appUtils/playerManager/playerNative.ts

@@ -54,6 +54,10 @@ export class PlayerNative extends Player {
     });
   }
 
+  public hasResumePosition() {
+    return true;
+  }
+
   getContentPosition = () => {
     return this.playerState.contentPosition;
   };
@@ -221,11 +225,13 @@ export class PlayerNative extends Player {
   };
 
   onVideoLoad = (event) => {
-    if (this.startPosition) {
-      this.seekTo(this.startPosition);
-      this.startPosition = null;
+    this.updateContentDuration(event);
 
+    if (this.startPosition && !this.playerState.isInAdBreak) {
       super.onVideoLoad({ ...event, ignoreContinueWatching: true });
+
+      this.seekTo(this.startPosition);
+      this.startPosition = null;
     } else {
       super.onVideoLoad(event);
     }
@@ -249,6 +255,15 @@ export class PlayerNative extends Player {
     }
   };
 
+  onAdBreakEnd = (event) => {
+    super.onAdBreakEnd(event);
+
+    if (this.startPosition) {
+      this.seekTo(this.startPosition);
+      this.startPosition = null;
+    }
+  };
+
   // This function is called when native player used directly without wrapped component,
   // Since event from native comes with wrapped in NativeEvent property
   getNativeViewListener = (): QuickBrickPlayer.SharedPlayerCallBacks => {

package/appUtils/playerManager/usePlayerTitleSummaryOverlay.tsx

@@ -3,12 +3,18 @@ import { OverlaysObserver } from "./OverlayObserver/OverlaysObserver";
 import { useFeedLoader } from "../../reactHooks";
 import { usePlayer } from "./usePlayer";
 
+const getLiveUrl = (url: string) => {
+  // Use the replace method with a regular expression to replace all instances of subClass with livePage
+  return url.replace(new RegExp("subClass", "g"), "livePage");
+};
+
 export const useTitleSummaryOverlay = (
-  feedUrl,
   entry,
   isLive = false,
   interval: number
 ) => {
+  // TODO: Have generic place for live url from configuration. Currently its hardcoded for client.
+  const feedUrl = getLiveUrl(entry?.extensions?.live?.channel_src ?? "");
   const player = usePlayer();
   const [title, setTitle] = useState<string | number>(entry?.title || "");
   const [summary, setSummary] = useState<string | number>(entry?.summary || "");

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,32 @@
+const GROUP = "group-qb";
+const GROUP_INFO = "group-info-qb";
+const EMPTY_GROUP_COMPONENT = "empty_group_component";
+
+const GALLERY = "gallery-qb";
+
+const SCREEN_PICKER = "screen-picker-qb-tv";
+
+export const isGallery = (item): boolean => item?.component_type === GALLERY;
+
+export const isScreenPicker = (item): boolean =>
+  item?.component_type === SCREEN_PICKER;
+
+export const isFirstComponentScreenPicker = (
+  components: ZappUIComponent[]
+): boolean => {
+  return isScreenPicker(components?.[0]);
+};
+
+export const isFirstComponentGallery = (
+  components: ZappUIComponent[]
+): boolean => {
+  return isGallery(components?.[0]);
+};
+
+export const isGroup = (item): boolean => item?.component_type === GROUP;
+
+export const isEmptyGroup = (item): boolean =>
+  item?.component_type === EMPTY_GROUP_COMPONENT;
+
+export const isGroupInfo = (item): boolean =>
+  item?.component_type === GROUP_INFO;

package/dateUtils/index.ts

@@ -2,10 +2,29 @@ import dayjs from "dayjs";
 import utc from "dayjs/plugin/utc";
 import timezone from "dayjs/plugin/timezone";
 import isoWeek from "dayjs/plugin/isoWeek";
+import duration from "dayjs/plugin/duration";
+import relativeTime from "dayjs/plugin/relativeTime";
 
 // Extend dayjs with plugins
 dayjs.extend(utc);
 dayjs.extend(timezone);
 dayjs.extend(isoWeek);
+dayjs.extend(duration);
+
+dayjs.extend(relativeTime, {
+  thresholds: [
+    { l: "s", r: 1 },
+    { l: "m", r: 1 },
+    { l: "mm", r: 59, d: "minute" },
+    { l: "h", r: 1 },
+    { l: "hh", r: 23, d: "hour" },
+    { l: "d", r: 1 },
+    { l: "dd", r: 29, d: "day" },
+    { l: "M", r: 1 },
+    { l: "MM", r: 11, d: "month" },
+    { l: "y", r: 1 },
+    { l: "yy", d: "year" },
+  ],
+});
 
 export { dayjs };

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();
+    });
+  });
+});

package/equalUtils/index.ts

@@ -1,6 +1,8 @@
 /* eslint no-console: off */
 
-import * as R from "ramda";
+import { equals } from "ramda";
+
+const alwaysTrue = () => true;
 
 export const isParentFocusEqual = (
   prevParentFocus: ParentFocus,
@@ -18,7 +20,7 @@ export const isEqual =
   ({
     byValue = [],
     byReference = [],
-    byComparator = { comparator: R.always(true), keys: [] },
+    byComparator = { comparator: alwaysTrue, keys: [] },
     debug = false,
     compareRemainingKeysBySameValue = false,
   }: {
@@ -29,42 +31,59 @@ export const isEqual =
     compareRemainingKeysBySameValue?: boolean;
   }) =>
   (prev, next) => {
-    const isEqualByValue = R.isEmpty(byValue)
-      ? true
-      : R.all((key) => R.equals(prev[key], next[key]), byValue);
+    for (const key of byReference) {
+      if (prev[key] !== next[key]) {
+        if (debug) console.log({ isEqualByReference: false });
 
-    const isEqualByReference = R.isEmpty(byReference)
-      ? true
-      : R.all((key) => prev[key] === next[key], byReference);
+        return false;
+      }
+    }
 
-    const isEqualByComparator = R.isEmpty(byComparator.keys)
-      ? true
-      : R.all(
-          (key) => byComparator.comparator(prev[key], next[key]),
-          byComparator.keys
-        );
+    for (const key of byValue) {
+      if (!equals(prev[key], next[key])) {
+        if (debug) console.log({ isEqualByValue: false });
 
-    if (debug) {
-      console.log({ isEqualByValue, isEqualByReference, isEqualByComparator });
+        return false;
+      }
+    }
+
+    for (const key of byComparator.keys) {
+      if (!byComparator.comparator(prev[key], next[key])) {
+        if (debug) console.log({ isEqualByComparator: false });
+
+        return false;
+      }
     }
 
     if (compareRemainingKeysBySameValue) {
-      const undeclaredKeys = R.difference(
-        [...byValue, ...byReference, byComparator.keys],
-        Object.keys(prev)
-      );
+      const allKeys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+
+      const declaredKeys = new Set([
+        ...byValue,
+        ...byReference,
+        ...byComparator.keys,
+      ]);
 
-      const isRestKeysEqualAllBySameValue = undeclaredKeys.every((key) =>
-        Object.is(prev[key], next[key])
-      );
+      for (const key of Array.from(allKeys)) {
+        if (!declaredKeys.has(key) && !Object.is(prev[key], next[key])) {
+          if (debug) console.log({ isRestKeysEqualAllBySameValue: false });
 
-      return (
-        isEqualByValue &&
-        isEqualByReference &&
-        isEqualByComparator &&
-        isRestKeysEqualAllBySameValue
-      );
+          return false;
+        }
+      }
+    }
+
+    // if we made it here, everything matched
+    if (debug) {
+      console.log({
+        isEqualByValue: true,
+        isEqualByReference: true,
+        isEqualByComparator: true,
+        isRestKeysEqualAllBySameValue: compareRemainingKeysBySameValue
+          ? true
+          : undefined,
+      });
     }
 
-    return isEqualByValue && isEqualByReference && isEqualByComparator;
+    return true;
   };

package/focusManager/FocusManager.ts

@@ -227,7 +227,9 @@ class FocusManager {
 
       const nextNextFocus = FocusManager.getNextFocusable(direction, nextFocus);
 
-      FocusManager.instance.setFocus(nextNextFocus, options);
+      if (nextNextFocus) {
+        FocusManager.instance.setFocus(nextNextFocus, options);
+      }
     } else {
       FocusManager.instance.setFocusLocal(nextFocus);
 
@@ -250,7 +252,17 @@ class FocusManager {
   }
 
   onDisableFocusChange = (id) => {
-    if (FocusManager.instance.isFocused(id)) {
+    const isFocused = FocusManager.instance.isFocused(id);
+
+    const isDescendantFocused = (() => {
+      try {
+        return FocusManager.instance.isAnyDescendantFocused(id);
+      } catch (_e) {
+        return false;
+      }
+    })();
+
+    if (isFocused || isDescendantFocused) {
       // Move focus to next one
       const nextFocus = FocusManager.instance.focused?.props
         ?.nextFocusDown as string;