@applicaster/zapp-react-native-utils 14.0.0-alpha.2482261241 → 14.0.0-alpha.2802628909

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,36 +213,65 @@ 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) {
       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,
             });
+
+            // 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/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);
+  });
+});

package/arrayUtils/__tests__/anyThruthy.test.ts

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

package/arrayUtils/index.ts

@@ -116,3 +116,8 @@ export const sample = (xs: unknown[]): unknown => {
 
   return xs[index];
 };
+
+export const allTruthy = (xs: boolean[]) =>
+  isFilledArray(xs) && xs.every(Boolean);
+
+export const anyTruthy = (xs: boolean[]) => xs.some(Boolean);

package/configurationUtils/index.ts

@@ -399,7 +399,7 @@ export const populateConfigurationValues =
       flattenAndPopulateFields(fields, configuration, skipDefaults)
   );
 
-export const getAccesabilityProps = (item: ZappEntry) => ({
+export const getAccessibilityProps = (item: ZappEntry) => ({
   accessible: item?.extensions?.accessibility,
   accessibilityLabel: item?.extensions?.accessibility?.label || item?.title,
   accessibilityHint: item?.extensions?.accessibility?.hint,

package/focusManager/FocusManager.ts

@@ -2,11 +2,24 @@ import { path } from "ramda";
 import { isString } from "@applicaster/zapp-react-native-utils/stringUtils";
 import * as FOCUS_EVENTS from "@applicaster/zapp-react-native-utils/appUtils/focusManager/events";
 
+import {
+  QUICK_BRICK_CONTENT,
+  QUICK_BRICK_NAVBAR,
+} from "@applicaster/quick-brick-core/const";
+
 import { logger } from "./logger";
 import { TreeNode } from "./TreeNode";
 import { Tree } from "./Tree";
 import { subscriber } from "../functionUtils";
 import { getFocusableId, toFocusDirection } from "./utils";
+import {
+  findSelectedMenuId,
+  isTabsScreenContentFocused,
+  findSelectedTabId,
+  contextWithoutScrolling,
+} from "./aux";
+
+export { contextWithoutScrolling } from "./aux";
 
 export {
   toFocusDirection,
@@ -221,7 +234,8 @@ class FocusManager {
 
   private setNextFocus(
     nextFocus: FocusManager.TouchableReactRef,
-    options?: FocusManager.Android.CallbackOptions
+    options?: FocusManager.Android.CallbackOptions,
+    context?: FocusManager.FocusContext
   ) {
     if (nextFocus?.current?.props?.blockFocus) {
       return;
@@ -250,7 +264,7 @@ class FocusManager {
 
       FocusManager.instance.setPreviousNavigationDirection(options ?? null);
 
-      nextFocus?.current?.onFocus?.(nextFocus.current, options ?? {});
+      nextFocus?.current?.onFocus?.(nextFocus.current, options ?? {}, context);
     }
   }
 
@@ -291,7 +305,8 @@ class FocusManager {
 
   setFocus(
     newFocus: FocusManager.TouchableReactRef | string,
-    options?: FocusManager.Android.CallbackOptions
+    options?: FocusManager.Android.CallbackOptions,
+    context?: FocusManager.FocusContext
   ) {
     // Checks if element is focusable
     const { isFocusable, error } = FocusManager.isFocusable(newFocus);
@@ -316,7 +331,7 @@ class FocusManager {
       }
 
       if (newFocusRef) {
-        FocusManager.instance.setNextFocus(newFocusRef, options);
+        FocusManager.instance.setNextFocus(newFocusRef, options, context);
       }
     }
   }
@@ -351,6 +366,11 @@ class FocusManager {
       FocusManager.instance.focused.onBlur(FocusManager.instance.focused, {});
     }
 
+    // send reset event to some handler to reset their internal state, before real reset happens
+    this.eventHandler?.invokeHandler?.(FOCUS_EVENTS.RESET, {
+      focusedId: FocusManager.instance.focusedId,
+    });
+
     FocusManager.instance.setFocusLocal({ current: null });
   }
 
@@ -417,6 +437,60 @@ class FocusManager {
       throw new Error(`Group with id ${id} not found`);
     }
   }
+
+  isFocusOnMenu(): boolean {
+    return this.isFocusableChildOf(
+      FocusManager.instance.focusedId,
+      QUICK_BRICK_NAVBAR
+    );
+  }
+
+  isFocusOnContent(): boolean {
+    return this.isFocusableChildOf(
+      FocusManager.instance.focusedId,
+      QUICK_BRICK_CONTENT
+    );
+  }
+
+  private landFocusToWithoutScrolling = (id) => {
+    if (id) {
+      // set focus on selected menu item
+      const direction = undefined;
+
+      const context: FocusManager.FocusContext =
+        contextWithoutScrolling("back");
+
+      logger.log({ message: "landFocusToWithoutScrolling", data: { id } });
+
+      this.setFocus(id, direction, context);
+    }
+  };
+
+  // Move focus to appropriate top navigation tab with context
+  focusOnSelectedTab(index: number): void {
+    const selectedTabId = findSelectedTabId(this.tree, index);
+
+    // Set focus with back button context to tabs-menu
+    this.landFocusToWithoutScrolling(selectedTabId);
+  }
+
+  // Move focus to appropriate top navigation tab with context
+  focusOnSelectedTopMenuItem(index: number, sectionKey: string): void {
+    const selectedMenuItemId = findSelectedMenuId(this.tree, {
+      index,
+      sectionKey,
+    });
+
+    // Set focus with back button context to top-menu
+    this.landFocusToWithoutScrolling(selectedMenuItemId);
+  }
+
+  isTabsScreenContentFocused(): boolean {
+    return isTabsScreenContentFocused(
+      this.tree,
+      FocusManager.instance.focusedId
+    );
+  }
 }
 
 export const focusManager = FocusManager.getInstance();

package/focusManager/aux/index.ts

@@ -0,0 +1,98 @@
+import { isNil, pathOr } from "@applicaster/zapp-react-native-utils/utils";
+
+import {
+  QUICK_BRICK_CONTENT,
+  QUICK_BRICK_NAVBAR,
+  QUICK_BRICK_NAVBAR_SECTIONS,
+} from "@applicaster/quick-brick-core/const";
+
+const isNavBar = (node) => QUICK_BRICK_NAVBAR === node?.id;
+const isContent = (node) => QUICK_BRICK_CONTENT === node?.id;
+
+// SCREEN_PICKER_SELECTOR_CONTAINER(we assume there is only one SCREEN_PICKER)
+let screenPickerSelectorContainerId;
+
+export const onRegisterScreenPickerSelectorContainer = (id) => {
+  screenPickerSelectorContainerId = id;
+};
+
+export const onUnregisterScreenPickerSelectorContainer = (id) => {
+  // reset screenSelectorId on unregistration
+  if (screenPickerSelectorContainerId === id) {
+    screenPickerSelectorContainerId = undefined;
+  }
+};
+// SCREEN_PICKER_SELECTOR_CONTAINER
+
+// SCREEN_PICKER_CONTENT_CONTAINER(we assume there is only one SCREEN_PICKER)
+let screenPickerContentContainerId;
+
+export const onRegisterScreenPickerContentContainer = (id) => {
+  screenPickerContentContainerId = id;
+};
+
+export const onUnregisterScreenPickerContentContainer = (id) => {
+  // reset screenSelectorId on unregistration
+  if (screenPickerContentContainerId === id) {
+    screenPickerContentContainerId = undefined;
+  }
+};
+
+const isScreenPickerContentContainer = (node) =>
+  screenPickerContentContainerId === node?.id;
+
+// SCREEN_PICKER_CONTENT_CONTAINER
+
+export const findSelectedMenuId = (
+  focusableTree,
+  { index, sectionKey }: { index: number; sectionKey: string }
+) => {
+  const sectionName = QUICK_BRICK_NAVBAR_SECTIONS[sectionKey];
+
+  return pathOr(
+    undefined,
+    ["children", index, "id"],
+    focusableTree.find(sectionName)
+  );
+};
+
+export const findSelectedTabId = (focusableTree, index: number): string => {
+  const screenSelectorContainerNode = focusableTree.find(
+    screenPickerSelectorContainerId
+  );
+
+  const selectedTabId = screenSelectorContainerNode.children[index]?.id;
+
+  return selectedTabId;
+};
+
+export const isTabsScreenContentFocused = (focusableTree, id) => {
+  const node = focusableTree.find(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (isScreenPickerContentContainer(node)) {
+    return true;
+  }
+
+  return isTabsScreenContentFocused(focusableTree, node.parentId);
+};
+
+export const contextWithoutScrolling = (
+  source: FocusManager.FocusContext["source"]
+): FocusManager.FocusContext => {
+  return {
+    source,
+    preserveScroll: true,
+  };
+};

package/focusManager/utils.ts

@@ -4,11 +4,11 @@ import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/he
 
 export const getFocusableId = (ref) => ref?.current?.props.id;
 
-type Direction = "up" | "down" | "left" | "right";
-
 const normalizeDirection = (direction) => direction.toLowerCase();
 
-const checkDirection = (direction: Direction) => {
+const checkDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   invariant(!isNilOrEmpty(direction), "direction should not be empty");
 
   invariant(
@@ -17,19 +17,25 @@ const checkDirection = (direction: Direction) => {
   );
 };
 
-export const toFocusDirection = (direction: Direction) => {
+export const toFocusDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   checkDirection(direction);
 
   return `nextFocus${capitalize(normalizeDirection(direction))}`;
 };
 
-export const isHorizontalDirection = (direction: Direction) => {
+export const isHorizontalDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   checkDirection(direction);
 
   return ["left", "right"].includes(normalizeDirection(direction));
 };
 
-export const isVerticalDirection = (direction: Direction) => {
+export const isVerticalDirection = (
+  direction: FocusManager.Android.FocusNavigationDirections
+) => {
   checkDirection(direction);
 
   return ["up", "down"].includes(normalizeDirection(direction));

package/index.d.ts

@@ -69,7 +69,7 @@ declare type ExtraProps = ZappUIComponentProps & {
 };
 
 declare type WebConfirmationDialog = {
-  message: string;
+  message?: string;
   confirmCompletion?: () => void;
   cancelCompletion?: () => void;
 };