@applicaster/zapp-react-native-utils 14.0.0-rc.9 → 15.0.0-alpha.2239032089

package/appUtils/focusManagerAux/utils/index.ios.ts

@@ -0,0 +1,104 @@
+import { isNil, startsWith } from "@applicaster/zapp-react-native-utils/utils";
+
+import {
+  QUICK_BRICK_CONTENT,
+  QUICK_BRICK_NAVBAR,
+} from "@applicaster/quick-brick-core/const";
+
+const isNavBar = (node) => startsWith(QUICK_BRICK_NAVBAR, node?.id);
+const isContent = (node) => startsWith(QUICK_BRICK_CONTENT, node?.id);
+const isRoot = (node) => node?.id === "root";
+
+export const isPartOfTabsScreenContent = (
+  focusableTree,
+  screenPickerContentContainerId,
+  id
+) => {
+  const node = focusableTree.findInTree(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (node?.id === screenPickerContentContainerId) {
+    return true;
+  }
+
+  return isPartOfTabsScreenContent(
+    focusableTree,
+    screenPickerContentContainerId,
+    node.parent?.id
+  );
+};
+
+export const isPartOfMenu = (focusableTree, id): boolean => {
+  const node = focusableTree.findInTree(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return true;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  return isPartOfMenu(focusableTree, node.parent.id);
+};
+
+export const isPartOfContent = (focusableTree, id) => {
+  const node = focusableTree.findInTree(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return true;
+  }
+
+  return isPartOfContent(focusableTree, node.parent?.id);
+};
+
+export const isCurrentFocusOn = (id, node) => {
+  if (!node) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (node?.id === id) {
+    return true;
+  }
+
+  return isCurrentFocusOn(id, node.parent);
+};

package/appUtils/focusManagerAux/utils/index.ts

@@ -1,14 +1,31 @@
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
-import { find, last, pathOr, startsWith } from "ramda";
+import {
+  isNil,
+  last,
+  startsWith,
+  find,
+  pathOr,
+} from "@applicaster/zapp-react-native-utils/utils";
+
 import {
   QUICK_BRICK_CONTENT,
   QUICK_BRICK_NAVBAR,
 } from "@applicaster/quick-brick-core/const";
 
+import {
+  getFocusableId,
+  SCREEN_PICKER_CONTAINER,
+} from "@applicaster/zapp-react-native-utils/screenPickerUtils";
+
 // run check each 300 ms
 // run this check too often could lead to performance penalty on low-end devices
 const HOW_OFTEN_TO_CHECK_CONDITION = 300; // ms
 
+const isTopMenu = (node) => startsWith(QUICK_BRICK_NAVBAR, node?.id);
+const isContent = (node) => startsWith(QUICK_BRICK_CONTENT, node?.id);
+const isRoot = (node) => node?.id === "root";
+
+const isScrenPicker = (node) => startsWith(SCREEN_PICKER_CONTAINER, node?.id);
+
 type Props = {
   maxTimeout: number;
   conditionFn: () => boolean;
@@ -49,7 +66,7 @@ export const waitForActiveScreen = (currentRoute: string, focusableTree) => {
 
     const route = find((route) => route.id === currentRoute, routes);
 
-    return isNotNil(route);
+    return !isNil(route);
   };
 
   return waitUntil({
@@ -99,3 +116,77 @@ export const waitForContent = (focusableTree) => {
     conditionFn: contentHasAnyChildren,
   });
 };
+
+export const findSelectedTabId = (item: ZappEntry): string => {
+  const selectedTabId = getFocusableId(item.id);
+
+  return selectedTabId;
+};
+
+export const isTabsScreenOnContentFocused = (node) => {
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isTopMenu(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (isScrenPicker(node)) {
+    return true;
+  }
+
+  return isTabsScreenOnContentFocused(node.parent);
+};
+
+export const isCurrentFocusOnMenu = (node) => {
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isTopMenu(node)) {
+    return true;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  return isCurrentFocusOnMenu(node.parent);
+};
+
+export const isCurrentFocusOnContent = (node) => {
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isTopMenu(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return true;
+  }
+
+  return isCurrentFocusOnContent(node.parent);
+};
+
+export const isCurrentFocusOn = (id, node) => {
+  if (!node) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (node?.id === id) {
+    return true;
+  }
+
+  return isCurrentFocusOn(id, node.parent);
+};

package/appUtils/focusManagerAux/utils/utils.ios.ts

@@ -0,0 +1,63 @@
+import { Subject, ReplaySubject, withLatestFrom } from "rxjs";
+import { filter } from "rxjs/operators";
+
+import { isPartOfMenu, isPartOfContent } from "./index.ios";
+
+import { focusManager } from "../../focusManager/index.ios";
+
+type FocusableID = string;
+const focusedSubject$ = new Subject<FocusableID>();
+
+const focused$ = focusedSubject$.asObservable();
+
+export const emitFocused = (id: FocusableID): void => {
+  focusedSubject$.next(id);
+};
+
+export const topMenuItemFocused$ = focused$.pipe(
+  filter((id) => id && isPartOfMenu(focusManager.focusableTree, id))
+);
+
+export const contentFocused$ = focused$.pipe(
+  filter((id) => {
+    const isContent = isPartOfContent(focusManager.focusableTree, id);
+
+    return id && isContent;
+  })
+);
+
+const registeredHomeTopMenuItemSubject$ = new ReplaySubject<FocusableID>(1);
+
+export const registeredHomeTopMenuItem$ =
+  registeredHomeTopMenuItemSubject$.asObservable();
+
+export const homeTopMenuItemFocused$ = topMenuItemFocused$.pipe(
+  withLatestFrom(registeredHomeTopMenuItem$),
+  filter(([id, homeId]) => id === homeId)
+);
+
+export const emitHomeTopMenuItemRegistered = (id) => {
+  // save homeId on registration
+  registeredHomeTopMenuItemSubject$.next(id);
+};
+
+export const emitHomeTopMenuItemUnregistered = () => {
+  // reset homeId on unregistration
+  registeredHomeTopMenuItemSubject$.next(undefined);
+};
+
+const registeredScreenPickerContentContainerSubject$ =
+  new ReplaySubject<FocusableID>(1);
+
+export const registeredScreenPickerContentContainer$ =
+  registeredScreenPickerContentContainerSubject$.asObservable();
+
+export const emitScreenPickerContentContainerRegistered = (id) => {
+  // save screenPickerContentContainerId on registration
+  registeredScreenPickerContentContainerSubject$.next(id);
+};
+
+export const emitScreenPickerContentContainerUnregistered = () => {
+  // reset screenPickerContentContainerId on unregistration
+  registeredScreenPickerContentContainerSubject$.next(undefined);
+};

package/appUtils/platform/platformUtils.ts

@@ -10,6 +10,7 @@ import { PLATFORM_KEYS, PLATFORMS, ZappPlatform } from "./const";
 import { createLogger, utilsLogger } from "../../logger";
 import { getPlatform } from "../../reactUtils";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { calculateReadingTime } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager/utils";
 
 const { log_debug } = createLogger({
   category: "General",
@@ -212,9 +213,16 @@ export class TTSManager {
   }
 
   readText(text: string) {
+    this.ttsState$.next(true);
+
     if (isSamsungPlatform() && window.speechSynthesis) {
       const utterance = new SpeechSynthesisUtterance(text);
+
+      window.speechSynthesis.cancel(); // Cancel previous speech before speaking new text
       window.speechSynthesis.speak(utterance);
+
+      // Estimate reading time and set inactive when done
+      this.scheduleTTSComplete(text);
     }
 
     if (isLgPlatform() && window.webOS?.service) {
@@ -225,23 +233,45 @@ export class TTSManager {
             log_debug("There was a failure setting up webOS TTS service", {
               error,
             });
+
+            this.ttsState$.next(false);
           },
           onSuccess(response: any) {
             log_debug("webOS TTS service is configured successfully", {
               response,
             });
+
+            // Estimate reading time and set inactive when done
+            this.scheduleTTSComplete(text);
           },
           parameters: {
             text,
+            clear: true, // Clear any previous speech before speaking new text
           },
         });
       } catch (error) {
         log_debug("webOS TTS service error", { error });
+        this.ttsState$.next(false);
       }
     }
 
-    if (!window.VIZIO?.Chromevox) return;
+    if (!window.VIZIO?.Chromevox) {
+      // For platforms without TTS, estimate reading time
+      this.scheduleTTSComplete(text);
+
+      return;
+    }
 
     window.VIZIO.Chromevox.play(text);
+    // Estimate reading time and set inactive when done
+    this.scheduleTTSComplete(text);
+  }
+
+  private scheduleTTSComplete(text: string) {
+    const readingTime = calculateReadingTime(text);
+
+    setTimeout(() => {
+      this.ttsState$.next(false);
+    }, readingTime);
   }
 }

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -18,13 +18,6 @@ export const { log_verbose, log_debug, log_info, log_error } = createLogger({
   parent: utilsLogger,
 });
 
-type ActionChapter = {
-  type: string;
-  options?: {
-    title: string;
-  };
-};
-
 type ChapterMarkerOriginal = {
   id: string;
   title: string;
@@ -33,14 +26,6 @@ type ChapterMarkerOriginal = {
   actions: ActionChapter[];
 };
 
-export type ChapterMarkerEvent = {
-  id: string;
-  title: string;
-  start_time: number;
-  end_time: number;
-  actions: ActionChapter[];
-};
-
 export type TitleSummaryEvent = {
   title: string | number;
   summary: string | number;

package/appUtils/playerManager/useChapterMarker.tsx

@@ -1,4 +1,3 @@
-import { ChapterMarkerEvent } from "./OverlayObserver/OverlaysObserver";
 import { usePlayer } from "./usePlayer";
 import * as React from "react";
 

package/appUtils/playerManager/usePlayerControllerSetup.tsx

@@ -5,6 +5,9 @@ import { playerManager } from "./index";
 import { useValidatePlayerConfig } from "../../playerUtils/useValidatePlayerConfig";
 import { PlayerRole } from "./conts";
 import { isAppleTV } from "@applicaster/zapp-react-native-ui-components/Helpers/Platform";
+import { TVSeekController } from "../../reactHooks/player/TVSeekControlller/TVSeekController";
+import { KeyInputHandler } from "../keyInputHandler/KeyInputHandler";
+import { isTV } from "../../reactUtils";
 
 // TODO: Rename to ControllerType
 export const usePlayerControllerSetup = ({
@@ -76,5 +79,18 @@ export const usePlayerControllerSetup = ({
     };
   }, [playerId, playerController]);
 
+  useEffect(() => {
+    if (!isTV()) {
+      return;
+    }
+
+    if (playerController) {
+      const seekController = new TVSeekController(playerController);
+      playerController.seekController = seekController;
+
+      return KeyInputHandler.getInstance().addListener(seekController);
+    }
+  }, [playerController]);
+
   return playerController;
 };

package/arrayUtils/__tests__/isEmptyArray.test.ts

@@ -0,0 +1,63 @@
+import { isEmptyArray } from "..";
+
+describe("isEmptyArray", () => {
+  it("non-empty array is not empty", () => {
+    const value = [1, 2, 3];
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty array is empty", () => {
+    const value = [];
+
+    expect(isEmptyArray(value)).toBe(true);
+  });
+
+  it("number is not array", () => {
+    const value = 123;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("string is not array", () => {
+    const value = "vfnjdk";
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty string is not array", () => {
+    const value = "";
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("NaN is not array", () => {
+    const value = NaN;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("object is not array", () => {
+    const value = { test: 1 };
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty object is not array", () => {
+    const value = {};
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("undefined is not array", () => {
+    const value = undefined;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("null is not array", () => {
+    const value = null;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+});

package/arrayUtils/__tests__/isFilledArray.test.ts

@@ -32,7 +32,7 @@ describe("isFilledArray", () => {
   });
 
   it("NaN is not array", () => {
-    const value = "";
+    const value = NaN;
 
     expect(isFilledArray(value)).toBe(false);
   });

package/arrayUtils/index.ts

@@ -93,18 +93,23 @@ 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);
 };
 
 /** Checks if a value is a non-empty array */
 export function isFilledArray(value: unknown): boolean {
-  return R.is(Array, value) && R.length(value) > 0;
+  return Array.isArray(value) && value.length > 0;
+}
+
+/** Checks if a value is a empty array */
+export function isEmptyArray(value: unknown): boolean {
+  return Array.isArray(value) && value.length === 0;
 }
 
 // get random item from the list
 export const sample = (xs: unknown[]): unknown => {
-  invariant(R.is(Array, xs), `input value is not a array: ${xs}`);
+  invariant(Array.isArray(xs), `input value is not an array: ${xs}`);
   invariant(isFilledArray(xs), `input array is empty: ${xs}`);
 
   const index = Math.floor(Math.random() * xs.length);

package/audioPlayerUtils/__tests__/getArtworkImage.test.ts

@@ -0,0 +1,144 @@
+import { getArtworkImage } from "..";
+import { DEFAULT_IMAGE } from "../assets";
+
+describe("getArtworkImage", () => {
+  const entryWithImage = {
+    media_group: [
+      {
+        type: "image",
+        media_item: [
+          { key: "artwork_key", src: "image_from_entry" },
+          { key: "other_key", src: "other_image" },
+        ],
+      },
+    ],
+    extensions: {
+      artwork_key: "artwork_key",
+    },
+  };
+
+  const entryWithoutImage = {
+    media_group: [
+      {
+        type: "image",
+        media_item: [{ key: "other_key", src: "other_image" }],
+      },
+    ],
+    extensions: {
+      artwork_key: "artwork_key",
+    },
+  };
+
+  const pluginConfigWithImage = {
+    artwork_key: "plugin_artwork_key",
+  };
+
+  it("returns image from entry extensions key", () => {
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryWithImage,
+      plugin_configuration: {},
+    });
+
+    expect(result).toBe("image_from_entry");
+  });
+
+  it("returns image from plugin configuration key if not in entry", () => {
+    const entryNoMatch = {
+      ...entryWithoutImage,
+      extensions: { artwork_key: "not_found_key" },
+    };
+
+    const pluginConfig = {
+      artwork_key: "plugin_artwork_key",
+    };
+
+    const entryWithPluginImage = {
+      ...entryNoMatch,
+      media_group: [
+        {
+          type: "image",
+          media_item: [{ key: "plugin_artwork_key", src: "image_from_plugin" }],
+        },
+      ],
+    };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryWithPluginImage,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe("image_from_plugin");
+  });
+
+  it("returns DEFAULT_IMAGE if neither entry nor plugin configuration has image", () => {
+    const entryNoImage = {
+      media_group: [
+        {
+          type: "image",
+          media_item: [{ key: "other_key", src: "other_image" }],
+        },
+      ],
+      extensions: { artwork_key: "not_found_key" },
+    };
+
+    const pluginConfig = { artwork_key: "not_found_key" };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryNoImage,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles undefined key gracefully", () => {
+    const result = getArtworkImage({
+      key: undefined,
+      entry: entryWithImage,
+      plugin_configuration: pluginConfigWithImage,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles missing entry or plugin_configuration gracefully", () => {
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: undefined,
+      plugin_configuration: undefined,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles empty media_group", () => {
+    const entryEmptyMedia = {
+      media_group: [],
+      extensions: { artwork_key: "artwork_key" },
+    };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryEmptyMedia,
+      plugin_configuration: pluginConfigWithImage,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles missing extensions/config keys", () => {
+    const entryNoExt = { media_group: [], extensions: {} };
+    const pluginConfig = {};
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryNoExt,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+});