@applicaster/zapp-react-native-utils 12.0.0-alpha.4337072244 → 12.0.0-alpha.4354608902

package/appUtils/HooksManager/types.ts

@@ -0,0 +1,116 @@
+import { SubscriberObj } from "../../functionUtils";
+import { HOOKS_EVENTS } from "./constants";
+
+export interface HookConfiguration {}
+
+/* existing Hook Plugn props: sample */
+interface _HookModulePlugin {
+  Component:
+    | React.FC<HookPluginProps>
+    | React.Component<HookPluginProps, any>
+    | React.ReactNode;
+  ModalContainer?: React.FC<ModalProps> | React.Component<ModalProps, any>;
+  skipHook?: (payload: ZappRiver | ZappEntry) => boolean;
+  presentFullScreen: boolean;
+  showNavBar?: boolean;
+  isFlowBlocker: (() => boolean) | boolean; // narrow this
+  hasPlayerHook?: boolean;
+  name: string;
+  runInBackground?: (
+    item: HookPluginProps["payload"],
+    callback: hookCallback,
+    hookPlugin: HookScreenData,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => any;
+}
+
+//* Derived from usage */
+export interface HookModule {
+  ModalContainer?: React.ComponentType<any>;
+  Component: React.ComponentType<any>;
+  presentFullScreen: boolean;
+  run?: (
+    arg0: unknown,
+    callback: () => void,
+    configuration: HookConfiguration
+  ) => void; // not sure about optional parameter
+  hasPlayerHook?: boolean;
+  configuration?: HookConfiguration;
+  isFlowBlocker: () => boolean;
+  skipHook?: (payload?: ZappRiver | ZappEntry) => boolean;
+  runInBackground?: (
+    arg0: unknown,
+    callback: () => void,
+    hookPlugin: Hook,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => void;
+  name: string;
+  showNavBar?: boolean; // unsure
+}
+
+export type HookManagerArgs = {
+  rivers: Record<string, ZappRiver>;
+  plugins: ZappPlugin[];
+  targetScreen: ZappRiver;
+  startUpHooksData?: {
+    startUpHooks?: unknown[] | "in_process";
+    setStartUpHooks?: (arg0: string) => void;
+  };
+};
+
+export interface HookManager {
+  subscriber: SubscriberObj;
+  presentScreenHook: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void
+  ) => void;
+  executeHook: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void
+  ) => void;
+  handleHooks: (payload: unknown) => void;
+  runInBackground: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => void;
+}
+
+export type HookIniObj = {
+  hook: HookModule & {
+    module: HookModule;
+    general: unknown;
+    screen_id?: string;
+    identifier?: string;
+    weight?: number | string;
+  };
+  hooks: Hook<any>[];
+  manager: HookManager;
+};
+
+export interface Hook<T extends HookModule = HookModule> {
+  manager: HookManager;
+  lastHook: boolean;
+  state: number;
+  module: T;
+  screen_id: string;
+  identifier: string;
+  configuration: T["configuration"];
+  setStateAndNotify(
+    event: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS],
+    opts: {
+      error?: typeof Error;
+      route?: string;
+      hookPlugin: Hook<T>;
+      payload: unknown;
+    }
+  );
+  general?: {
+    transition_type: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS];
+    allow_screen_plugin_presentation: boolean;
+    is_flow_blocker: boolean;
+  };
+}

package/appUtils/RiverFocusManager/index.js

@@ -26,7 +26,7 @@ export const riverFocusManager = (function () {
   /**
    * Retrieve screen focus data by id
    *
-   * @param {String}  screenFocusableGroupId Id that was used to save screen data.
+   * @param {{screenFocusableGroupId: string}} screenFocusableGroupId Unique Id of the screen from layout.json
    *
    */
   function screenFocusableData({ screenFocusableGroupId }) {
@@ -36,8 +36,9 @@ export const riverFocusManager = (function () {
   /**
    * Clear screen data for specific screen
    *
-   * @param {String}  screenId Unique Id of the screen from layout.json
-   * @param {boolean} isInsideContainer If this screen a screen picker child
+   * @param {{ screenId: string, isInsideContainer: boolean }}
+   * screenId Unique Id of the screen from layout.json
+   * isInsideContainer If this screen a screen picker child
    *
    */
   function clearScreenData({ screenId, isInsideContainer }) {
@@ -60,9 +61,13 @@ export const riverFocusManager = (function () {
   /**
    * Focus on selected items
    *
-   * @param {String}  screenFocusableGroupId Top group id that was saved as screenn
-   * @param {String} screenFocusedOnItem focusable item to focus
-   * @param {object} history navigator history object
+   * @param {{
+   * screenFocusableGroupId: string,
+   * screenFocusedOnItem: () => void,
+   * previousAction: QuickBrickNavigationActionType,
+   * isDeepLink: boolean }} object contains data for focus
+   * - `screenFocusedOnItem` focusable item to focus
+   * - `previousActionhistory` navigator history object
    *
    */
   function focusOnSelectedItem({
@@ -115,15 +120,15 @@ export const riverFocusManager = (function () {
 
   /**
    * Create unique key that will be used for save focused group data inside specific screen
-   *
-   * @param {String}  screenId Unique Id of the screen from layout.json
-   * @param {boolean} isInsideContainer If this screen a screen picker child
+   * @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 R.isNil(isInsideContainer)
-      ? `RiverFocusableGroup-${screenId}`
-      : `RiverFocusableGroup-${screenId}-isInsideContainer`;
+    return `RiverFocusableGroup-${screenId}${
+      R.isNil(isInsideContainer) ? "" : "-isInsideContainer"
+    }`;
   }
 
   return {

package/appUtils/accessibilityManager/const.ts

@@ -0,0 +1,50 @@
+export const BUTTON_ACCESSIBILITY_KEYS = {
+  play: {
+    label: "accessibility_play_label",
+    hint: "accessibility_play_hint",
+    mini: {
+      label: "accessibility_play_mini_label",
+      hint: "accessibility_play_mini_hint",
+    },
+  },
+  pause: {
+    label: "accessibility_pause_label",
+    hint: "accessibility_pause_hint",
+    mini: {
+      label: "accessibility_pause_mini_label",
+      hint: "accessibility_pause_mini_hint",
+    },
+  },
+  rewind: {
+    label: "accessibility_rewind_label",
+    hint: "accessibility_rewind_hint",
+  },
+  forward: {
+    label: "accessibility_forward_label",
+    hint: "accessibility_forward_hint",
+  },
+  close: {
+    label: "accessibility_close_label",
+    hint: "accessibility_close_hint",
+    mini: {
+      label: "accessibility_close_mini_label",
+      hint: "accessibility_close_mini_hint",
+    },
+  },
+  maximize: {
+    label: "accessibility_maximize_label",
+    hint: "accessibility_maximize_hint",
+  },
+  subtitles: {
+    label: "accessibility_subtitle_label",
+    hint: "accessibility_subtitle_hint",
+  },
+  back: {
+    label: "accessibility_back_label",
+    hint: "accessibility_back_hint",
+  },
+  fullscreen: {
+    label: "accessibility_fullscreen_label",
+    hint: "accessibility_fullscreen_hint",
+  },
+} as const;

package/appUtils/accessibilityManager/hooks.ts

@@ -0,0 +1,31 @@
+import { useEffect, useMemo } from "react";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { AccessibilityManager } from "./index";
+
+export const useAccessibilityManager = () => {
+  const { remoteConfigurations } = usePickFromState(["remoteConfigurations"]);
+  const { localizations } = remoteConfigurations;
+
+  const accessibilityManager = useMemo(() => {
+    return AccessibilityManager.getInstance();
+  }, []);
+
+  useEffect(() => {
+    accessibilityManager.updateLocalizations(localizations);
+  }, [localizations]);
+
+  useEffect(() => {
+    const subscription = accessibilityManager.getStateAsObservable().subscribe({
+      next: () => {
+        // TODO: handle accessibility states
+        // screenReaderEnabled: false
+        // reduceMotionEnabled: false
+        // boldTextEnabled: false
+      },
+    });
+
+    return () => subscription.unsubscribe();
+  }, [accessibilityManager]);
+
+  return accessibilityManager;
+};

package/appUtils/accessibilityManager/index.ts

@@ -0,0 +1,150 @@
+import { BehaviorSubject } from "rxjs";
+import { accessibilityManagerLogger as logger } from "./logger";
+import { TTSManager } from "../platform/platformUtils";
+import { getLocalizations } from "../../localizationUtils";
+import { BUTTON_ACCESSIBILITY_KEYS } from "./const";
+
+export interface AccessibilityState {
+  screenReaderEnabled: boolean;
+  reduceMotionEnabled: boolean;
+  boldTextEnabled: boolean;
+}
+
+export interface AccessibilityProps {
+  accessibilityLabel?: string;
+  accessibilityHint?: string;
+  "aria-label"?: string;
+  "aria-description"?: string;
+}
+
+export class AccessibilityManager {
+  private static _instance: AccessibilityManager | null = null;
+  private state$ = new BehaviorSubject<AccessibilityState>({
+    screenReaderEnabled: false,
+    reduceMotionEnabled: false,
+    boldTextEnabled: false,
+  });
+
+  private announcements$ = new BehaviorSubject<{
+    message: string;
+    localizedMessage?: string | undefined;
+    timestamp: number;
+  } | null>(null);
+
+  private ttsManager = TTSManager.getInstance();
+  private localizations: { [key: string]: string };
+
+  private constructor(localizations?: { [key: string]: string }) {
+    if (localizations) {
+      this.localizations = getLocalizations({ localizations });
+    }
+  }
+
+  public static getInstance(): AccessibilityManager {
+    if (!AccessibilityManager._instance) {
+      AccessibilityManager._instance = new AccessibilityManager();
+    }
+
+    return AccessibilityManager._instance;
+  }
+
+  public updateLocalizations(localizations: { [key: string]: string }) {
+    this.localizations = getLocalizations({ localizations });
+  }
+
+  public getState(): AccessibilityState {
+    return this.state$.getValue();
+  }
+
+  public getStateAsObservable() {
+    return this.state$.asObservable();
+  }
+
+  /**
+   * text you want to be read, if you want to use localized text pass keyOfLocalizedText instead
+   * keyOfLocalizedText is the key to the localized text
+   */
+  public readText({
+    text,
+    keyOfLocalizedText,
+  }: {
+    text: string;
+    keyOfLocalizedText?: string;
+  }) {
+    logger.debug("Reading text", { text, keyOfLocalizedText });
+
+    if (keyOfLocalizedText) {
+      if (!this.localizations) {
+        logger.error(
+          "Attempting to use localized key without initialized localizations"
+        );
+
+        return;
+      }
+
+      const localizedMessage = this.getLocalizedMessage(keyOfLocalizedText);
+
+      if (!localizedMessage) {
+        logger.warn(`No localization found for key: ${keyOfLocalizedText}`);
+
+        return;
+      }
+
+      text = localizedMessage;
+    }
+
+    if (this.ttsManager) {
+      this.ttsManager.readText(text);
+    }
+
+    this.announcements$.next({
+      message: text,
+      localizedMessage: keyOfLocalizedText ? text : undefined,
+      timestamp: Date.now(),
+    });
+  }
+
+  public getButtonAccessibilityProps(buttonName: string): AccessibilityProps {
+    const buttonConfig = BUTTON_ACCESSIBILITY_KEYS[buttonName];
+
+    if (!buttonConfig) {
+      return {
+        accessibilityLabel: buttonName,
+        accessibilityHint: `Press button to perform action on ${buttonName}`,
+        "aria-label": buttonName,
+        "aria-description": `Press button to perform action on ${buttonName}`,
+      };
+    }
+
+    const labelKey = buttonConfig.label;
+    const hintKey = buttonConfig.hint;
+
+    const label = this.getLocalizedMessage(labelKey) || buttonName;
+
+    const hint =
+      this.getLocalizedMessage(hintKey) ||
+      `Press button to perform action on ${buttonName}`;
+
+    return {
+      accessibilityLabel: label,
+      accessibilityHint: hint,
+      "aria-label": label,
+      "aria-description": hint,
+    };
+  }
+
+  public getLocalizedMessage(key: string): string | void {
+    if (!key) return;
+
+    if (!this.localizations) {
+      logger.error(
+        "Attempting to use localized key without initialized localizations",
+        { key }
+      );
+
+      return;
+    }
+
+    return this.localizations[key];
+  }
+}

package/appUtils/accessibilityManager/logger.ts

@@ -0,0 +1,5 @@
+import { utilsLogger } from "../../logger";
+
+export const accessibilityManagerLogger = utilsLogger.addSubsystem(
+  "accessibilityManager"
+);

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

@@ -21,6 +21,7 @@ Object {
   "getGroupById": [Function],
   "getGroupRootById": [Function],
   "invokeHandler": [Function],
+  "isCurrentFocusOnTheTopScreen": [Function],
   "isFocusDisabled": [Function],
   "isGroupItemFocused": [Function],
   "longPress": [Function],
@@ -32,8 +33,6 @@ Object {
   "register": [Function],
   "removeHandler": [Function],
   "setFocus": [Function],
-  "setFocusOnContent": [Function],
-  "setFocusOnMenu": [Function],
   "setInitialFocus": [Function],
   "unregister": [Function],
 }

package/appUtils/focusManager/__tests__/index.test.ts

@@ -28,9 +28,8 @@ describe("focusManager", () => {
       "focusableTree",
       "getGroupRootById",
       "isGroupItemFocused",
-      "setFocusOnMenu",
-      "setFocusOnContent",
       "recoverFocus",
+      "isCurrentFocusOnTheTopScreen",
     ];
 
     expectedMethods.forEach((method) => {

package/appUtils/focusManager/index.ts

@@ -8,18 +8,11 @@ import { Tree } from "./treeDataStructure/Tree";
 import {
   findFocusableNode,
   findPriorityItem,
-  isTransitionHappening,
+  haveSameParentBeforeRoot,
 } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
 import * as FOCUS_EVENTS from "./events";
 import { coreLogger } from "../../logger";
-import {
-  waitForActiveScreen,
-  waitForContent,
-  getContentNode,
-  getNavbarNode,
-} from "./utils";
-
 const logger = coreLogger.addSubsystem("focusManager");
 
 const isFocusEnabled = (focusableItem): boolean => {
@@ -416,77 +409,19 @@ export const focusManager = (function () {
     group ? unregisterGroup(id) : unregisterItem(id);
   }
 
-  async function setFocusOnMenu(currentRoute: string) {
-    try {
-      await waitForActiveScreen(currentRoute, focusableTree);
-
-      const navbar = getNavbarNode(focusableTree);
-
-      const selectedMenuItemId = R.find(
-        (child) => child.component.props.selected,
-        navbar.children
-      )?.id;
-
-      if (selectedMenuItemId) {
-        // set focus on selected menu item
-        setFocus(selectedMenuItemId);
-
-        return;
-      }
-
-      const firstMenuItemId = R.path(["children", 0, "id"], navbar);
-
-      if (firstMenuItemId) {
-        // set focus on first menu item
-        setFocus(firstMenuItemId);
-      }
-    } catch (error) {
-      logger.log({
-        message: "setFocusOnMenu – failed to put focus on top-menu",
-        data: {
-          currentRoute,
-          error,
-        },
-      });
-    }
-  }
-
-  async function setFocusOnContent(currentRoute: string) {
-    // we need to put focus on content here
-    // For doing it we have to wait registration of first focusable node into focusableTree
-    // we wait until content node starts having children
-    try {
-      await waitForActiveScreen(currentRoute, focusableTree);
-      await waitForContent(focusableTree);
-
-      const content = getContentNode(focusableTree);
-
-      const { success } = setInitialFocus(content);
-
-      if (!success) {
-        // we've failed to put initial focus on content, re-run "setFocusOnContent" again as a fallback
-        throw Error(
-          "we've failed to put initial focus on content, re-run 'setFocusOnContent' again as a fallback"
-        );
-      }
-    } catch (error) {
-      setFocusOnContent(currentRoute);
-    }
-  }
-
-  function isTransitionInProgress() {
+  function isCurrentFocusOnTheTopScreen() {
     const routes = R.pathOr([], ["root", "children"], focusableTree);
 
     if (routes.length <= 1) {
       // there is only one or zero routes
-      return false;
+      return true;
     }
 
-    return isTransitionHappening(currentFocusNode, R.last(routes));
+    return haveSameParentBeforeRoot(currentFocusNode, R.last(routes));
   }
 
   function recoverFocus() {
-    if (isTransitionInProgress()) {
+    if (!isCurrentFocusOnTheTopScreen()) {
       // We've failed to set focused node on the new screen => run focus recovery
       setInitialFocus();
     }
@@ -498,7 +433,7 @@ export const focusManager = (function () {
    * @param {Object} direction of the scroll
    */
   function moveFocus(direction) {
-    if (isTransitionInProgress()) {
+    if (!isCurrentFocusOnTheTopScreen()) {
       // We are opening new screen. We need to ignore movement of focus.
       return false;
     }
@@ -600,8 +535,7 @@ export const focusManager = (function () {
     focusableTree,
     getGroupRootById,
     isGroupItemFocused,
-    setFocusOnMenu,
-    setFocusOnContent,
     recoverFocus,
+    isCurrentFocusOnTheTopScreen,
   };
 })();

package/appUtils/focusManager/treeDataStructure/Tree/index.js

@@ -59,7 +59,7 @@ export class Tree {
   /**
    * Update node with provided data from newNode
    * @private
-   * @param {Object} node to update
+   * @param {Object} currentNode to update
    * @param {Object} newNode node to take data from
    */
   updateNode(currentNode, newNode) {
@@ -175,7 +175,6 @@ export class Tree {
    * @private
    * @param {Object} node to check
    * @returns True if node has defined groupID
-   * @returns False if node has NOT defined groupID
    */
   hasGroupID(node) {
     return node.component && node.component.props.groupId;
@@ -191,7 +190,7 @@ export class Tree {
       const findChildNode = this.findInTree(node.component.props.groupId);
 
       if (findChildNode) {
-        this.root.children.pop(findChildNode);
+        this.root.children.pop();
         node.children.push(findChildNode);
       }
     }

package/appUtils/focusManager/treeDataStructure/Utils/index.js

@@ -1,6 +1,7 @@
 import { allPass, pathOr, startsWith, isNil } from "ramda";
 import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 import { isZero } from "@applicaster/zapp-react-native-utils/numberUtils";
+import { QUICK_BRICK_NAVBAR } from "@applicaster/quick-brick-core/const";
 
 import { rejectItemByPath } from "../../../../objectUtils";
 import {
@@ -154,10 +155,10 @@ const excludeFromFocusSearching = pathOr(false, [
   "excludeFromFocusSearching",
 ]);
 
-const isNavBar = (target) => startsWith("navbar", target?.id);
+const isNavBar = (target) => startsWith(QUICK_BRICK_NAVBAR, target?.id);
 
 const ignoreMenuIfMultipleTargets = (nodes) => {
-  if (nodes.length > 1 && nodes.map((n) => n?.target?.id).includes("navbar")) {
+  if (nodes.length > 1) {
     return nodes.filter((n) => !isNavBar(n?.target));
   }
 
@@ -190,7 +191,6 @@ const toDistance = ({ target, direction, comparisonRect }) => {
  * Get target in shortest distance in specified direction
  * @private
  * @param {Object} direction of the navigation, which led to this focus change
- * @param {Object} excludedNode node which should be excluded from target group
  * @param {Array} targetNodes array of input target nodes
  * @param {Object} comparisonRect rectangle to compare sides in direction.
  * @returns {Object} target in direction.
@@ -205,7 +205,7 @@ export function getTargetInDirection(
   const overrideTarget = currentNode?.component?.props[overridePropName];
 
   if (overrideTarget) {
-    const target = targetNodes.find((n) => n.id === overrideTarget);
+    const target = targetNodes.find((n) => n?.id === overrideTarget);
 
     if (target) return target;
   }
@@ -299,8 +299,7 @@ export function findFocusableNode(direction, currentFocusNode) {
  * @public
  * @param {Object} direction of the navigation, which led to this focus change
  * @param {Object} component - object to check props.prioritiseFocusOn
- * @returns {Boolean} TRUE if object has priority in direction.
- * @returns {Boolean} FALSE if object has NO priority in direction.
+ * @returns {Boolean} TRUE if object has priority in direction. FALSE if object has NO priority in direction.
  */
 export function hasPriorityInDirection(direction, component) {
   const { prioritiseFocusOn = 0 } = component.props;
@@ -333,9 +332,9 @@ export const getNodeBeforeRoot = (node) => {
   return getNodeBeforeRoot(node.parent);
 };
 
-export const isTransitionHappening = (currentNode, nextNode) => {
+export const haveSameParentBeforeRoot = (currentNode, nextNode) => {
   const routeForCurrentNode = getNodeBeforeRoot(currentNode);
   const routeForNextNode = getNodeBeforeRoot(nextNode);
 
-  return routeForCurrentNode?.id !== routeForNextNode?.id;
+  return routeForCurrentNode?.id === routeForNextNode?.id;
 };

package/appUtils/focusManager/utils/index.ts

@@ -1,5 +1,9 @@
 import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 import { find, last, startsWith, pathOr } from "ramda";
+import {
+  QUICK_BRICK_NAVBAR,
+  QUICK_BRICK_CONTENT,
+} from "@applicaster/quick-brick-core/const";
 
 // run check each 300 ms
 // run this check too often could lead to performance penalty on low-end devices
@@ -60,7 +64,9 @@ const getActiveScreenChildren = (focusableTree) => {
 
 export const getContentNode = (focusableTree) => {
   const content = find(
-    (child) => startsWith("content", child.id),
+    (child) =>
+      startsWith(QUICK_BRICK_CONTENT, child.id) ||
+      startsWith("player", child.id),
     getActiveScreenChildren(focusableTree)
   );
 
@@ -69,7 +75,7 @@ export const getContentNode = (focusableTree) => {
 
 export const getNavbarNode = (focusableTree) => {
   const navbar = find(
-    (child) => startsWith("navbar", child.id),
+    (child) => startsWith(QUICK_BRICK_NAVBAR, child.id),
     getActiveScreenChildren(focusableTree)
   );