@applicaster/zapp-react-native-utils 15.0.0-alpha.1257410812 → 15.0.0-alpha.1305114721

package/appUtils/HooksManager/__tests__/__snapshots__/hooksManager.test.js.snap

@@ -1,193 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`HooksManager when target route is playable executes the player hook 1`] = `
-[
-  {
-    "callback": [Function],
-    "hookPlugin": Hook {
-      "configuration": {
-        "config_field": "bar",
-      },
-      "identifier": "headless_player_hook",
-      "lastHook": true,
-      "manager": {
-        "executeHook": [Function],
-        "handleHooks": [Function],
-        "presentScreenHook": [Function],
-        "runInBackground": [Function],
-        "subscriber": {
-          "handlers": {
-            "complete": [
-              [MockFunction] {
-                "calls": [
-                  [
-                    {
-                      "callback": [Function],
-                      "hookPlugin": [Circular],
-                      "payload": {
-                        "foo": "bar",
-                      },
-                    },
-                    [Function],
-                  ],
-                ],
-                "results": [
-                  {
-                    "type": "return",
-                    "value": undefined,
-                  },
-                ],
-              },
-            ],
-            "presentScreenHook": [
-              [MockFunction],
-            ],
-            "success": [
-              [MockFunction] {
-                "calls": [
-                  [Circular],
-                ],
-                "results": [
-                  {
-                    "type": "return",
-                    "value": undefined,
-                  },
-                ],
-              },
-            ],
-          },
-          "invokeHandler": [Function],
-          "on": [Function],
-          "removeHandler": [Function],
-        },
-      },
-      "module": {
-        "hasPlayerHook": true,
-        "run": [MockFunction] {
-          "calls": [
-            [
-              {
-                "foo": "bar",
-              },
-              [Function],
-              {
-                "config_field": "bar",
-              },
-            ],
-          ],
-          "results": [
-            {
-              "type": "return",
-              "value": undefined,
-            },
-          ],
-        },
-      },
-      "state": 7,
-      "weight": 1,
-    },
-    "payload": {
-      "foo": "bar",
-    },
-  },
-  [Function],
-]
-`;
-
-exports[`HooksManager when target route is playable executes the player hook 2`] = `
-[
-  {
-    "callback": [Function],
-    "hookPlugin": Hook {
-      "configuration": {
-        "config_field": "bar",
-      },
-      "identifier": "headless_player_hook",
-      "lastHook": true,
-      "manager": {
-        "executeHook": [Function],
-        "handleHooks": [Function],
-        "presentScreenHook": [Function],
-        "runInBackground": [Function],
-        "subscriber": {
-          "handlers": {
-            "complete": [
-              [MockFunction] {
-                "calls": [
-                  [Circular],
-                ],
-                "results": [
-                  {
-                    "type": "return",
-                    "value": undefined,
-                  },
-                ],
-              },
-            ],
-            "presentScreenHook": [
-              [MockFunction],
-            ],
-            "success": [
-              [MockFunction] {
-                "calls": [
-                  [
-                    {
-                      "callback": [Function],
-                      "hookPlugin": [Circular],
-                      "payload": {
-                        "foo": "bar",
-                      },
-                    },
-                    [Function],
-                  ],
-                ],
-                "results": [
-                  {
-                    "type": "return",
-                    "value": undefined,
-                  },
-                ],
-              },
-            ],
-          },
-          "invokeHandler": [Function],
-          "on": [Function],
-          "removeHandler": [Function],
-        },
-      },
-      "module": {
-        "hasPlayerHook": true,
-        "run": [MockFunction] {
-          "calls": [
-            [
-              {
-                "foo": "bar",
-              },
-              [Function],
-              {
-                "config_field": "bar",
-              },
-            ],
-          ],
-          "results": [
-            {
-              "type": "return",
-              "value": undefined,
-            },
-          ],
-        },
-      },
-      "state": 7,
-      "weight": 1,
-    },
-    "payload": {
-      "foo": "bar",
-    },
-  },
-  [Function],
-]
-`;
-
 exports[`HooksManager when there are preload hooks hook with screen: executes 1`] = `
 [
   {

package/appUtils/HooksManager/__tests__/hooksManager.test.js

@@ -116,9 +116,23 @@ describe("HooksManager", () => {
         headlessPlayerHook.configuration
       );
 
-      expect(successHandler.mock.calls[0]).toMatchSnapshot();
+      expect(successHandler).toHaveBeenCalledTimes(1);
+      expect(successHandler.mock.calls[0][0].payload).toEqual(payload);
 
-      expect(completeHandler.mock.calls[0]).toMatchSnapshot();
+      expect(successHandler.mock.calls[0][0].hookPlugin.identifier).toBe(
+        "headless_player_hook"
+      );
+
+      expect(typeof successHandler.mock.calls[0][1]).toBe("function");
+
+      expect(completeHandler).toHaveBeenCalledTimes(1);
+      expect(completeHandler.mock.calls[0][0].payload).toEqual(payload);
+
+      expect(completeHandler.mock.calls[0][0].hookPlugin.identifier).toBe(
+        "headless_player_hook"
+      );
+
+      expect(typeof completeHandler.mock.calls[0][1]).toBe("function");
     });
   });
 

package/appUtils/HooksManager/index.ts

@@ -11,6 +11,10 @@ import { HOOKS_EVENTS, HOOKS_TYPE } from "./constants";
 
 import { hooksManagerLogger } from "./logger";
 import { HookManager, HookManagerArgs } from "./types";
+import {
+  actionExecutor,
+  ActionResult,
+} from "../../actionsExecutor/ActionExecutor";
 
 /**
  * orders the hooks according to their weight
@@ -280,6 +284,8 @@ export function HooksManager({
           {}
         );
 
+        actionExecutor.unregisterAction("finishHook");
+
         return;
       }
 
@@ -294,6 +300,8 @@ export function HooksManager({
           }
         );
 
+        actionExecutor.unregisterAction("finishHook");
+
         return hookPlugin.setStateAndNotify(HOOKS_EVENTS.ERROR, {
           error,
           hookPlugin,
@@ -316,6 +324,8 @@ export function HooksManager({
         // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
         delete payload.getLoginProtocol;
 
+        actionExecutor.unregisterAction("finishHook");
+
         hookPlugin.setStateAndNotify(HOOKS_EVENTS.CANCEL, {
           hookPlugin,
           payload,
@@ -381,6 +391,27 @@ export function HooksManager({
     };
   }
 
+  function registerFinishHookAction(payload, callback) {
+    // Ensure no stale finishHook remains (e.g. presentUI re-entry from runInBackground)
+    actionExecutor.unregisterAction("finishHook");
+
+    actionExecutor.registerAction("finishHook", async (action: ActionType) => {
+      const { success, errorMessage, abort } = action.options;
+
+      actionExecutor.unregisterAction("finishHook");
+
+      if (errorMessage) {
+        callback({ success, error: new Error(errorMessage), payload, abort });
+      } else {
+        callback({ success, error: null, payload, abort });
+      }
+
+      hooksManagerLogger.info("finishHook action executed, finishing flow");
+
+      return ActionResult.Success;
+    });
+  }
+
   /**
    * presents a screen hook by triggering an event invoking the handler with
    * the appropriate route & payload
@@ -408,6 +439,8 @@ export function HooksManager({
       }
     );
 
+    registerFinishHookAction(payload, callback);
+
     hookPlugin.setStateAndNotify(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, {
       hookPlugin,
       route: targetScreenRoute,
@@ -467,6 +500,8 @@ export function HooksManager({
         }
       );
 
+      registerFinishHookAction(payload, callback);
+
       hookPlugin.module.runInBackground(
         payload,
         callback,

package/appUtils/focusManager/treeDataStructure/Tree/__tests__/Tree.test.js

@@ -373,3 +373,49 @@ describe("addNode", () => {
     checkParents(tree.root);
   });
 });
+
+describe("findInTree", () => {
+  function createNode(id, children) {
+    return {
+      id,
+      children,
+    };
+  }
+
+  it("returns a direct child match from root children", () => {
+    const tree = new Tree(treeLoaded);
+    const direct = createNode("direct-node");
+
+    tree.root.children = [direct];
+
+    expect(tree.findInTree("direct-node")).toEqual(direct);
+  });
+
+  it("returns a nested descendant match", () => {
+    const tree = new Tree(treeLoaded);
+    const nested = createNode("nested-node");
+    const intermediate = createNode("intermediate-node", [nested]);
+    const rootNode = createNode("root-node", [intermediate]);
+
+    tree.root.children = [rootNode];
+
+    expect(tree.findInTree("nested-node")).toEqual(nested);
+  });
+
+  it("returns null when node id does not exist", () => {
+    const tree = new Tree(treeLoaded);
+    const leaf = createNode("leaf-node");
+    const rootNode = createNode("root-node", [leaf]);
+
+    tree.root.children = [rootNode];
+
+    expect(tree.findInTree("missing-node")).toEqual(null);
+  });
+
+  it("returns null when tree has no children", () => {
+    const tree = new Tree(treeLoaded);
+    tree.root.children = null;
+
+    expect(tree.findInTree("any-node")).toEqual(null);
+  });
+});

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

@@ -205,31 +205,31 @@ export class Tree {
    * @returns founded node or null
    */
   findInTree(id) {
-    const retVal = null;
-
-    return this.findInArray(id, this.root.children, retVal);
+    return this.findInArray(id, this.root.children);
   }
 
-  findInArray(id, children, retVal) {
-    if (!retVal && children) {
-      retVal = children.find((obj) => obj.id === id);
+  findInArray(id, children) {
+    if (!children) {
+      return null;
+    }
 
-      if (!retVal) {
-        children.forEach((child) => {
-          if (child.children) {
-            retVal = this.findInArray(id, child.children, retVal);
+    const directMatch = children.find((obj) => obj.id === id);
 
-            if (retVal) {
-              return retVal;
-            }
-          }
-        });
-      } else {
-        return retVal;
+    if (directMatch) {
+      return directMatch;
+    }
+
+    for (const child of children) {
+      if (child.children) {
+        const nestedMatch = this.findInArray(id, child.children);
+
+        if (nestedMatch) {
+          return nestedMatch;
+        }
       }
     }
 
-    return retVal;
+    return null;
   }
 
   /**

package/appUtils/focusManagerAux/utils/index.ts

@@ -13,7 +13,7 @@ import {
 
 import {
   getFocusableId,
-  SCREEN_PICKER_CONTAINER,
+  isTabsScreenContentContainerId,
 } from "@applicaster/zapp-react-native-utils/screenPickerUtils";
 
 // run check each 300 ms
@@ -24,8 +24,6 @@ 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;
@@ -136,7 +134,7 @@ export const isTabsScreenOnContentFocused = (node) => {
     return false;
   }
 
-  if (isScrenPicker(node)) {
+  if (isTabsScreenContentContainerId(node?.id)) {
     return true;
   }
 

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

@@ -106,9 +106,8 @@ const focusableNativeViewRegistration = ({ focusableView, focusableGroup }) => {
   );
 };
 
-export const firstFocusableViewRegistrationFactory = () =>
+export const firstFocusableViewInContentRegistrationFactory = () =>
   focusableViewRegistrationSubject$.pipe(
-    take(1), // we care about only first FocusableView registration
     switchMap((focusableView) =>
       // start waiting registration of its parent FocusableGroup
       focusableGroupRegistrationSubject$.pipe(
@@ -126,7 +125,11 @@ export const firstFocusableViewRegistrationFactory = () =>
         focusableView,
         focusableGroup,
       })
-    )
+    ),
+    filter(({ focusableView }) =>
+      isPartOfContent(focusManager.focusableTree, focusableView.id)
+    ),
+    take(1) // we care about only first FocusableView registration
   );
 
 // registration on RN level(into RN focusManager)

package/appUtils/localizationsHelper.ts

@@ -85,6 +85,10 @@ export const toDayJSLocaleMap = (code) => {
     tt: null,
     "es-LA": "es",
     "en-UK": "en-gb",
+    "en-ZA": null,
+    "en-NG": null,
+    "en-ZW": null,
+    "en-ZM": null,
   };
 
   if (map[code] === null) {

package/appUtils/playerManager/index.ts

@@ -33,6 +33,7 @@ function deprecationWarning(method) {
 export interface PlayerLifecycleListener {
   onRegistered?: (player: Player) => void;
   onUnRegistered?: (player: Player) => void;
+  onCastingChanged?: (isCasting: boolean) => void;
 }
 
 type PlayersMap = {
@@ -253,10 +254,18 @@ export class PlayerManager {
 
   public registerCastingReceiver(receiver: Player) {
     this.castingReceiver = receiver;
+
+    this.lifecycleListeners.forEach((listener) => {
+      listener.onCastingChanged?.(true);
+    });
   }
 
   public unregisterCastingReceiver() {
     this.castingReceiver = null;
+
+    this.lifecycleListeners.forEach((listener) => {
+      listener.onCastingChanged?.(false);
+    });
   }
 
   /**

package/appUtils/playerManager/player.ts

@@ -258,7 +258,7 @@ export class Player {
   };
 
   isAd = () => {
-    return !!this.playerState.adState || this.playerState.isInAdBreak;
+    return !!this.playerState.adState || !!this.playerState.isInAdBreak;
   };
 
   isSeeking = () => {

package/appUtils/playerManager/playerNative.ts

@@ -229,8 +229,9 @@ export class PlayerNative extends Player {
   };
 
   closeNativePlayer = () => {
-    // TODO: Delete does not work
+    // TODO: Delete, does not work (component is null)
     this.currentPlayerComponent()?.closeNativePlayer?.();
+    this.getPlayerModule()?.stopBackgroundPlayback?.();
   };
 
   togglePlayPause = () => {

package/appUtils/playerManager/usePlayer.tsx

@@ -22,7 +22,6 @@ export const usePlayer = (playerId?: string): Player => {
 
   const isCasting = playerManager.isCasting();
 
-  // TODO: We need to prerender when we start/stop casting, fix this
   const getPlayer = (playerId, isCasting) =>
     getControlledPlayer(playerId, isCasting);
 
@@ -46,7 +45,7 @@ export const usePlayer = (playerId?: string): Player => {
     return playerManager.addLifecycleListener({
       onRegistered: (player) => {
         if (playerIdToUse === player.playerId) {
-          setPlayer(getPlayer(playerIdToUse, isCasting));
+          setPlayer(getPlayer(playerIdToUse, playerManager.isCasting()));
         }
       },
       onUnRegistered: (player) => {
@@ -54,8 +53,11 @@ export const usePlayer = (playerId?: string): Player => {
           setPlayer(null);
         }
       },
+      onCastingChanged: () => {
+        setPlayer(getPlayer(playerIdToUse, playerManager.isCasting()));
+      },
     } as PlayerLifecycleListener);
-  }, [playerIdToUse, isCasting]);
+  }, [playerIdToUse]);
 
   return player;
 };