@applicaster/zapp-react-native-utils 15.0.0-alpha.2239032089 → 15.0.0-alpha.2413435535

package/analyticsUtils/AnalyticPlayerListener.ts

@@ -35,8 +35,11 @@ export class AnalyticPlayerListener
     this.handleAnalyticEvent(PLAYBACK_EVENT.complete);
   };
 
-  onError = (err: Error) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.error, err); // TODO: Check error format
+  onError = (err: QuickBrickPlayer.PlayerErrorI) => {
+    this.handleAnalyticEvent(
+      PLAYBACK_EVENT.error,
+      err.toObject?.() || { message: err.message }
+    );
   };
 
   onPlayerPause = (event) => {

package/appUtils/RiverFocusManager/{index.ts → index.js}

@@ -1,31 +1,11 @@
-import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
-import { QUICK_BRICK_CONTENT } from "@applicaster/quick-brick-core/const";
-import { isNil, isEmpty } from "@applicaster/zapp-react-native-utils/utils";
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import * as R from "ramda";
+
+import { focusManager } from "../focusManager";
 
 let riverFocusData = {};
 let initialyPresentedScreenFocused = false;
 
 export const riverFocusManager = (function () {
-  /**
-   * Create unique key that will be used for save focused group data inside specific screen
-   * @param {{ screenId: string, isInsideContainer: boolean }}
-   * screenId Unique Id of the screen from layout.json
-   * isInsideContainer If this screen a screen picker child
-   *
-   */
-  function screenFocusableGroupId({
-    screenId,
-    isInsideContainer,
-  }: {
-    screenId: string;
-    isInsideContainer: Option<boolean>;
-  }) {
-    return `${QUICK_BRICK_CONTENT}-${screenId}${
-      isNil(isInsideContainer) ? "" : "-isInsideContainer"
-    }`;
-  }
-
   function setScreenFocusableData({
     screenFocusableGroupId,
     groupId,
@@ -98,8 +78,8 @@ export const riverFocusManager = (function () {
   }) {
     // Check if screen should be focused
     const shouldFocus =
-      (initialyPresentedScreenFocused === false && isEmpty(riverFocusData)) ||
-      isNotNil(riverFocusData[screenFocusableGroupId]) ||
+      (initialyPresentedScreenFocused === false && R.isEmpty(riverFocusData)) ||
+      R.compose(R.not, R.isNil)(riverFocusData[screenFocusableGroupId]) ||
       isDeepLink;
 
     // TODO: Uncommit it to start fixing bug where selection wrong item
@@ -138,6 +118,19 @@ export const riverFocusManager = (function () {
     }
   }
 
+  /**
+   * Create unique key that will be used for save focused group data inside specific screen
+   * @param {{ screenId: string, isInsideContainer: boolean }}
+   * screenId Unique Id of the screen from layout.json
+   * isInsideContainer If this screen a screen picker child
+   *
+   */
+  function screenFocusableGroupId({ screenId, isInsideContainer }) {
+    return `RiverFocusableGroup-${screenId}${
+      R.isNil(isInsideContainer) ? "" : "-isInsideContainer"
+    }`;
+  }
+
   return {
     setScreenFocusableData,
     clearAllScreensData,

package/appUtils/accessibilityManager/hooks.ts

@@ -17,6 +17,9 @@ export const useAccessibilityManager = (
     return AccessibilityManager.getInstance();
   }, []);
 
+  const [accessibilityManagerState, setAccessibilityManagerState] =
+    useState<AccessibilityState>(accessibilityManager.getState());
+
   useEffect(() => {
     if (pluginConfiguration) {
       accessibilityManager.updateLocalizations(pluginConfiguration);
@@ -25,18 +28,17 @@ export const useAccessibilityManager = (
 
   useEffect(() => {
     const subscription = accessibilityManager.getStateAsObservable().subscribe({
-      next: () => {
-        // TODO: handle accessibility states
-        // screenReaderEnabled: false
-        // reduceMotionEnabled: false
-        // boldTextEnabled: false
+      next: (newState) => {
+        setAccessibilityManagerState(newState);
       },
     });
 
     return () => subscription.unsubscribe();
   }, [accessibilityManager]);
 
-  return accessibilityManager;
+  return Object.assign(accessibilityManager, {
+    accessibilityManagerState,
+  });
 };
 
 export const useInitialAnnouncementReady = (

package/appUtils/accessibilityManager/index.ts

@@ -36,7 +36,20 @@ export class AccessibilityManager {
     false
   );
 
-  private constructor() {}
+  private constructor() {
+    this.ttsManager
+      .getScreenReaderEnabledAsObservable()
+      .subscribe((enabled) => {
+        const state = this.state$.getValue();
+
+        if (state.screenReaderEnabled !== enabled) {
+          this.state$.next({
+            ...state,
+            screenReaderEnabled: enabled,
+          });
+        }
+      });
+  }
 
   public static getInstance(): AccessibilityManager {
     if (!AccessibilityManager._instance) {
@@ -92,8 +105,15 @@ export class AccessibilityManager {
   /**
    * Adds a heading to the queue, headings will be read before the next text
    * Each heading will be read once and removed from the queue
+   * Does nothing if screen reader is not enabled
    */
   public addHeading(heading: string) {
+    const state = this.state$.getValue();
+
+    if (!state.screenReaderEnabled) {
+      return;
+    }
+
     if (!this.pendingFocusId) {
       this.pendingFocusId = Date.now().toString();
     }
@@ -108,6 +128,7 @@ export class AccessibilityManager {
    *
    * Implements a delay mechanism to reduce noise during rapid navigation.
    * Only the most recent announcement will be read after the delay period.
+   * Does nothing if screen reader is not enabled
    */
   public readText({
     text,
@@ -116,6 +137,12 @@ export class AccessibilityManager {
     text: string;
     keyOfLocalizedText?: string;
   }) {
+    const state = this.state$.getValue();
+
+    if (!state.screenReaderEnabled) {
+      return;
+    }
+
     let textToRead = text;
 
     if (keyOfLocalizedText) {

package/appUtils/accessibilityManager/utils.ts

@@ -12,13 +12,44 @@ export function calculateReadingTime(
   minimumPause: number = 500,
   announcementDelay: number = 700
 ): number {
-  const words = text
-    .trim()
+  const trimmed = text.trim();
+
+  // Count words (split on whitespace and punctuation, keep alnum boundaries)
+  const words = trimmed
     .split(/(?<=\d)(?=[a-zA-Z])|(?<=[a-zA-Z])(?=\d)|[^\w\s]+|\s+/)
     .filter(Boolean).length;
 
-  return (
-    Math.max(minimumPause, (words / wordsPerMinute) * 60 * 1000) +
-    announcementDelay
+  // Count spaces - multiple consecutive spaces add extra pause time
+  const spaceMatches: string[] = trimmed.match(/\s+/g) || [];
+
+  const totalSpaces = spaceMatches.reduce(
+    (sum: number, match: string) => sum + match.length,
+    0
   );
+
+  const extraSpaces = Math.max(0, totalSpaces - (words - 1)); // words-1 is normal spacing
+
+  // Heuristic: punctuation increases TTS duration beyond word-based WPM.
+  // Commas typically introduce short pauses, sentence terminators longer ones.
+  const commaCount = (trimmed.match(/,/g) || []).length;
+  const semicolonCount = (trimmed.match(/;/g) || []).length;
+  const colonCount = (trimmed.match(/:/g) || []).length;
+  const dashCount = (trimmed.match(/\u2013|\u2014|-/g) || []).length; // – — -
+  const sentenceEndCount = (trimmed.match(/[.!?](?!\d)/g) || []).length;
+
+  const commaPauseMs = 220; // short prosody pause for ","
+  const midPauseMs = 260; // for ";", ":", dashes
+  const sentenceEndPauseMs = 420; // for ".", "!", "?"
+  const extraSpacePauseMs = 50; // per extra space beyond normal spacing
+
+  const punctuationPause =
+    commaCount * commaPauseMs +
+    (semicolonCount + colonCount + dashCount) * midPauseMs +
+    sentenceEndCount * sentenceEndPauseMs +
+    extraSpaces * extraSpacePauseMs;
+
+  const baseByWordsMs = (words / wordsPerMinute) * 60 * 1000;
+  const estimatedMs = Math.max(minimumPause, baseByWordsMs + punctuationPause);
+
+  return estimatedMs + announcementDelay;
 }

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

@@ -69,10 +69,8 @@ exports[`focusManagerIOS should be defined 1`] = `
   "getGroupRootById": [Function],
   "getPreferredFocusChild": [Function],
   "invokeHandler": [Function],
+  "isChildOf": [Function],
   "isFocusOn": [Function],
-  "isFocusOnContent": [Function],
-  "isFocusOnMenu": [Function],
-  "isFocusOnTabsScreenContent": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],
   "on": [Function],

package/appUtils/focusManager/index.ios.ts

@@ -1,17 +1,19 @@
 import { NativeModules } from "react-native";
 import * as R from "ramda";
 
+import {
+  isCurrentFocusOn,
+  isChildOf as isChildOfUtils,
+} from "../focusManagerAux/utils";
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
 import { findChild } from "./utils";
 
 import {
-  isCurrentFocusOn,
-  isPartOfMenu,
-  isPartOfContent,
-  isPartOfTabsScreenContent,
-} from "../focusManagerAux/utils/index.ios";
+  emitRegistered,
+  emitUnregistered,
+} from "../focusManagerAux/utils/utils.ios";
 
 const { FocusableManagerModule } = NativeModules;
 
@@ -186,10 +188,14 @@ export const focusManager = (function () {
   function register({ id, component }) {
     const { isGroup = false } = component;
 
+    emitRegistered(id);
+
     return isGroup ? registerGroup(id, component) : registerItem(id, component);
   }
 
   function unregister(id, { group = false } = {}) {
+    emitUnregistered(id);
+
     group ? unregisterGroup(id) : unregisterItem(id);
   }
 
@@ -267,9 +273,7 @@ export const focusManager = (function () {
   function setFocus(
     id: string,
     direction?: FocusManager.IOS.Direction,
-    options?: Partial<{
-      groupFocusedChanged: boolean;
-    }>,
+    options?: Partial<{ groupFocusedChanged: boolean }>,
     callback?: any
   ) {
     blur(direction);
@@ -408,28 +412,8 @@ export const focusManager = (function () {
     return id && isCurrentFocusOn(id, currentFocusNode);
   }
 
-  function isFocusOnMenu(): boolean {
-    const currentFocusable = getCurrentFocus();
-
-    return isPartOfMenu(focusableTree, currentFocusable?.props?.id);
-  }
-
-  function isFocusOnContent(): boolean {
-    const currentFocusable = getCurrentFocus();
-
-    return isPartOfContent(focusableTree, currentFocusable?.props?.id);
-  }
-
-  function isFocusOnTabsScreenContent(
-    screenPickerContentContainerId: string
-  ): boolean {
-    const currentFocusable = getCurrentFocus();
-
-    return isPartOfTabsScreenContent(
-      focusableTree,
-      screenPickerContentContainerId,
-      currentFocusable?.props?.id
-    );
+  function isChildOf(childId, parentId): boolean {
+    return isChildOfUtils(focusableTree, childId, parentId);
   }
 
   return {
@@ -454,8 +438,6 @@ export const focusManager = (function () {
     isGroupItemFocused,
     getPreferredFocusChild,
     isFocusOn,
-    isFocusOnMenu,
-    isFocusOnContent,
-    isFocusOnTabsScreenContent,
+    isChildOf,
   };
 })();

package/appUtils/focusManagerAux/utils/index.ts

@@ -190,3 +190,21 @@ export const isCurrentFocusOn = (id, node) => {
 
   return isCurrentFocusOn(id, node.parent);
 };
+
+export const isChildOf = (focusableTree, childId, parentId) => {
+  if (isNil(childId) || isNil(parentId)) {
+    return false;
+  }
+
+  const childNode = focusableTree.findInTree(childId);
+
+  if (isNil(childNode)) {
+    return false;
+  }
+
+  if (childNode.parent?.id === parentId) {
+    return true;
+  }
+
+  return isChildOf(focusableTree, childNode.parent?.id, parentId);
+};

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

@@ -1,63 +1,35 @@
-import { Subject, ReplaySubject, withLatestFrom } from "rxjs";
+import { ReplaySubject } from "rxjs";
 import { filter } from "rxjs/operators";
-
-import { isPartOfMenu, isPartOfContent } from "./index.ios";
-
-import { focusManager } from "../../focusManager/index.ios";
+import { BUTTON_PREFIX } from "@applicaster/zapp-react-native-ui-components/Components/MasterCell/DefaultComponents/tv/TvActionButtons/const";
+import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
 
 type FocusableID = string;
-const focusedSubject$ = new Subject<FocusableID>();
-
-const focused$ = focusedSubject$.asObservable();
-
-export const emitFocused = (id: FocusableID): void => {
-  focusedSubject$.next(id);
+type RegistrationEvent = {
+  id: FocusableID;
+  registered: boolean;
 };
 
-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 isFocusableButton = (id: Option<FocusableID>): boolean =>
+  id && id.includes?.(BUTTON_PREFIX);
 
-const registeredScreenPickerContentContainerSubject$ =
-  new ReplaySubject<FocusableID>(1);
+const registeredSubject$ = new ReplaySubject<RegistrationEvent>(1);
 
-export const registeredScreenPickerContentContainer$ =
-  registeredScreenPickerContentContainerSubject$.asObservable();
+export const focusableButtonsRegistration$ = (focusableGroupId: string) =>
+  registeredSubject$.pipe(
+    filter(
+      (value) =>
+        value.registered && focusManager.isChildOf(value.id, focusableGroupId)
+    )
+  );
 
-export const emitScreenPickerContentContainerRegistered = (id) => {
-  // save screenPickerContentContainerId on registration
-  registeredScreenPickerContentContainerSubject$.next(id);
+export const emitRegistered = (id: Option<FocusableID>): void => {
+  if (isFocusableButton(id)) {
+    registeredSubject$.next({ id, registered: true });
+  }
 };
 
-export const emitScreenPickerContentContainerUnregistered = () => {
-  // reset screenPickerContentContainerId on unregistration
-  registeredScreenPickerContentContainerSubject$.next(undefined);
+export const emitUnregistered = (id: Option<FocusableID>): void => {
+  if (isFocusableButton(id)) {
+    registeredSubject$.next({ id, registered: false });
+  }
 };

package/appUtils/platform/platformUtils.ts

@@ -170,7 +170,9 @@ export const getClosedCaptionState = () => {
  */
 export class TTSManager {
   private ttsState$ = new BehaviorSubject<boolean>(false);
+  private screenReaderEnabled$ = new BehaviorSubject<boolean>(false);
   private static ttsManagerInstance: TTSManager;
+  private samsungListenerId: number | null = null;
 
   private constructor() {
     this.initialize();
@@ -185,23 +187,84 @@ export class TTSManager {
   }
 
   async initialize() {
-    if (!isVizioPlatform()) return;
+    if (isVizioPlatform()) {
+      document.addEventListener(
+        "VIZIO_TTS_ENABLED",
+        () => {
+          log_debug("Vizio screen reader enabled");
+          this.screenReaderEnabled$.next(true);
+        },
+        false
+      );
 
-    document.addEventListener(
-      "VIZIO_TTS_ENABLED",
-      () => {
-        this.ttsState$.next(true);
-      },
-      false
-    );
+      document.addEventListener(
+        "VIZIO_TTS_DISABLED",
+        () => {
+          log_debug("Vizio screen reader disabled");
+          this.screenReaderEnabled$.next(false);
+        },
+        false
+      );
+    }
 
-    document.addEventListener(
-      "VIZIO_TTS_DISABLED",
-      () => {
-        this.ttsState$.next(false);
-      },
-      false
-    );
+    if (isLgPlatform() && window.webOS?.service) {
+      try {
+        // https://webostv.developer.lge.com/develop/references/settings-service
+        window.webOS.service.request("luna://com.webos.settingsservice", {
+          method: "getSystemSettings",
+          parameters: {
+            category: "option",
+            keys: ["audioGuidance"],
+            subscribe: true, // Request a subscription to changes
+          },
+          onSuccess: (response: any) => {
+            const isEnabled = response?.settings?.audioGuidance === "on";
+
+            log_debug("LG Audio Guidance status changed", {
+              isEnabled,
+              response,
+            });
+
+            this.screenReaderEnabled$.next(isEnabled);
+          },
+          onFailure: (error: any) => {
+            log_debug("webOS settings subscription failed", { error });
+            this.screenReaderEnabled$.next(false);
+          },
+        });
+      } catch (error) {
+        log_debug("webOS settings service request error", { error });
+        this.screenReaderEnabled$.next(false);
+      }
+    }
+
+    if (isSamsungPlatform() && typeof window.tizen !== "undefined") {
+      try {
+        if (
+          window.tizen.accessibility &&
+          typeof window.tizen.accessibility
+            .addVoiceGuideStatusChangeListener === "function"
+        ) {
+          this.samsungListenerId =
+            window.tizen.accessibility.addVoiceGuideStatusChangeListener(
+              (enabled: boolean) => {
+                log_debug("Samsung Voice Guide status changed", { enabled });
+                this.screenReaderEnabled$.next(!!enabled);
+              }
+            );
+
+          log_debug("Samsung Voice Guide listener registered", {
+            listenerId: this.samsungListenerId,
+          });
+        } else {
+          log_debug("Samsung accessibility API not available");
+          this.screenReaderEnabled$.next(false);
+        }
+      } catch (error) {
+        log_debug("Samsung Voice Guide listener error", { error });
+        this.screenReaderEnabled$.next(false);
+      }
+    }
   }
 
   getCurrentState(): boolean {
@@ -212,31 +275,52 @@ export class TTSManager {
     return this.ttsState$.asObservable();
   }
 
+  getScreenReaderEnabledAsObservable() {
+    return this.screenReaderEnabled$.asObservable();
+  }
+
   readText(text: string) {
     this.ttsState$.next(true);
 
-    if (isSamsungPlatform() && window.speechSynthesis) {
-      const utterance = new SpeechSynthesisUtterance(text);
+    if (
+      isSamsungPlatform() &&
+      typeof window.tizen !== "undefined" &&
+      window.tizen.speech
+    ) {
+      try {
+        const successCallback = () => {
+          log_debug("Samsung TTS play started successfully");
+          // Estimate reading time and set inactive when done
+          this.scheduleTTSComplete(text);
+        };
 
-      window.speechSynthesis.cancel(); // Cancel previous speech before speaking new text
-      window.speechSynthesis.speak(utterance);
+        const errorCallback = (error: any) => {
+          log_debug("Samsung TTS error", { error: error?.message || error });
+          this.ttsState$.next(false);
+        };
 
-      // Estimate reading time and set inactive when done
-      this.scheduleTTSComplete(text);
+        // Clear any previous speech before speaking new text
+        window.tizen.speech.stop();
+
+        window.tizen.speech.speak(text, successCallback, errorCallback);
+      } catch (error) {
+        log_debug("Samsung TTS speak() error", { error });
+        this.ttsState$.next(false);
+      }
     }
 
     if (isLgPlatform() && window.webOS?.service) {
       try {
         window.webOS.service.request("luna://com.webos.service.tts", {
           method: "speak",
-          onFailure(error: any) {
+          onFailure: (error: any) => {
             log_debug("There was a failure setting up webOS TTS service", {
               error,
             });
 
             this.ttsState$.next(false);
           },
-          onSuccess(response: any) {
+          onSuccess: (response: any) => {
             log_debug("webOS TTS service is configured successfully", {
               response,
             });

package/appUtils/playerManager/conts.ts

@@ -2,6 +2,27 @@ export const userPreferencesNamespace = "user_preferences";
 
 export const skipActionType = "show_skip";
 
+export class PlayerError
+  extends Error
+  implements QuickBrickPlayer.PlayerErrorI
+{
+  description: string;
+
+  constructor(message: string, description: string) {
+    super(message);
+    this.description = description;
+
+    Object.setPrototypeOf(this, PlayerError.prototype);
+  }
+
+  toObject() {
+    return {
+      error: this.message,
+      message: this.description,
+    };
+  }
+}
+
 export enum SharedPlayerCallBacksKeys {
   OnPlayerResume = "onPlayerResume",
   OnPlayerPause = "onPlayerPause",

package/arrayUtils/__tests__/allTruthy.test.ts

@@ -0,0 +1,24 @@
+import { allTruthy } from "..";
+
+describe("allTruthy", () => {
+  it("should return true when all values are true", () => {
+    expect(allTruthy([true, true, true])).toBe(true);
+  });
+
+  it("should return false when at least one value is false", () => {
+    expect(allTruthy([true, false, true])).toBe(false);
+  });
+
+  it("should return false when all values are false", () => {
+    expect(allTruthy([false, false, false])).toBe(false);
+  });
+
+  it("should return false for an empty array", () => {
+    expect(allTruthy([])).toBe(false);
+  });
+
+  it("should handle single-element arrays correctly", () => {
+    expect(allTruthy([true])).toBe(true);
+    expect(allTruthy([false])).toBe(false);
+  });
+});