@applicaster/zapp-react-native-utils 15.0.0-alpha.3564377339 → 15.0.0-alpha.3634430569

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

@@ -71,6 +71,9 @@ exports[`focusManagerIOS should be defined 1`] = `
   "invokeHandler": [Function],
   "isChildOf": [Function],
   "isFocusOn": [Function],
+  "isFocusOnContent": [Function],
+  "isFocusOnMenu": [Function],
+  "isFocusOnTabsScreenContent": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],
   "on": [Function],

package/appUtils/focusManager/index.ios.ts

@@ -4,7 +4,11 @@ import * as R from "ramda";
 import {
   isCurrentFocusOn,
   isChildOf as isChildOfUtils,
-} from "../focusManagerAux/utils";
+  isPartOfMenu,
+  isPartOfContent,
+  isPartOfTabsScreenContent,
+} from "../focusManagerAux/utils/index.ios";
+
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
@@ -194,9 +198,9 @@ export const focusManager = (function () {
       registerItem(id, component);
     }
 
-    const parentId = component?.props?.groupId;
+    const groupId = component?.props?.groupId;
 
-    emitRegistered({ id, parentId, isGroup });
+    emitRegistered({ id, groupId, isGroup });
   }
 
   function unregister(id, { group = false } = {}) {
@@ -279,7 +283,9 @@ export const focusManager = (function () {
   function setFocus(
     id: string,
     direction?: FocusManager.IOS.Direction,
-    options?: Partial<{ groupFocusedChanged: boolean }>,
+    options?: Partial<{
+      groupFocusedChanged: boolean;
+    }>,
     callback?: any
   ) {
     blur(direction);
@@ -418,6 +424,30 @@ 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);
   }
@@ -444,6 +474,9 @@ export const focusManager = (function () {
     isGroupItemFocused,
     getPreferredFocusChild,
     isFocusOn,
+    isFocusOnMenu,
+    isFocusOnContent,
+    isFocusOnTabsScreenContent,
     isChildOf,
   };
 })();

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.ios.ts

@@ -0,0 +1,122 @@
+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);
+};
+
+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/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

@@ -1,7 +1,9 @@
 import { ReplaySubject, Subject } from "rxjs";
-import { filter, switchMap, take } from "rxjs/operators";
+import { filter, switchMap, take, withLatestFrom, map } from "rxjs/operators";
+
 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";
+import { isPartOfMenu, isPartOfContent } from "./index.ios";
 
 type FocusableID = string;
 type RegistrationEvent = {
@@ -11,13 +13,23 @@ type RegistrationEvent = {
 
 let focusableViewRegistrationSubject$ = new Subject<{
   id: FocusableID;
-  parentId: FocusableID;
+  groupId: FocusableID;
 }>();
 
 let focusableGroupRegistrationSubject$ = new ReplaySubject<{
   id: FocusableID;
 }>();
 
+let focusableNativeViewRegistrationSubject$ = new Subject<{
+  id: FocusableID;
+  groupId: FocusableID;
+}>();
+
+let focusableNativeGroupRegistrationSubject$ = new ReplaySubject<{
+  id: FocusableID;
+  groupId: FocusableID;
+}>();
+
 const isFocusableButton = (id: Option<FocusableID>): boolean =>
   id && id.includes?.(BUTTON_PREFIX);
 
@@ -41,35 +53,93 @@ export const resetFocusableRegistration = () => {
     focusableGroupRegistrationSubject$.complete();
   }
 
+  if (!focusableNativeViewRegistrationSubject$.closed) {
+    focusableNativeViewRegistrationSubject$.complete();
+  }
+
+  if (!focusableNativeGroupRegistrationSubject$.closed) {
+    focusableNativeGroupRegistrationSubject$.complete();
+  }
+
   focusableViewRegistrationSubject$ = new Subject<{
     id: FocusableID;
-    parentId: FocusableID;
+    groupId: FocusableID;
   }>();
 
   focusableGroupRegistrationSubject$ = new ReplaySubject<{
     id: FocusableID;
   }>();
+
+  focusableNativeViewRegistrationSubject$ = new Subject<{
+    id: FocusableID;
+    groupId: FocusableID;
+  }>();
+
+  focusableNativeGroupRegistrationSubject$ = new ReplaySubject<{
+    id: FocusableID;
+    groupId: FocusableID;
+  }>();
 };
 
-export const firstFocusableViewRegistrationFactory = () =>
+const focusableNativeViewRegistration = ({ focusableView, focusableGroup }) => {
+  return focusableNativeViewRegistrationSubject$.pipe(
+    filter(
+      (focusableNativeView) => focusableNativeView.id === focusableView.id
+    ),
+    take(1),
+    switchMap((focusableNativeView) =>
+      // start waiting registration of its parent FocusableNativeGroup
+      focusableNativeGroupRegistrationSubject$.pipe(
+        filter(
+          (focusableNativeGroup) =>
+            focusableNativeGroup.id === focusableNativeView.groupId
+        ),
+        take(1),
+        map((focusableNativeGroup) => ({
+          focusableNativeGroup,
+          focusableNativeView,
+          focusableView,
+          focusableGroup,
+        }))
+      )
+    )
+  );
+};
+
+export const firstFocusableViewInContentRegistrationFactory = () =>
   focusableViewRegistrationSubject$.pipe(
-    take(1), // we care about only first FocusableView registration
-    switchMap(({ parentId }) =>
-      // start waiting registration of its parent
+    switchMap((focusableView) =>
+      // start waiting registration of its parent FocusableGroup
       focusableGroupRegistrationSubject$.pipe(
-        filter(({ id }) => id === parentId)
+        filter((focusableGroup) => focusableGroup.id === focusableView.groupId),
+        take(1),
+        map((focusableGroup) => ({
+          focusableView,
+          focusableGroup,
+        }))
       )
     ),
-    take(1)
+    // start waiting registration for FocusableNativeView and its parent FocusableNativeGroup
+    switchMap(({ focusableView, focusableGroup }) =>
+      focusableNativeViewRegistration({
+        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)
 export const emitRegistered = ({
   id,
-  parentId,
+  groupId,
   isGroup,
 }: {
   id: Option<FocusableID>;
-  parentId: Option<FocusableID>;
+  groupId: Option<FocusableID>;
   isGroup: boolean;
 }): void => {
   if (isFocusableButton(id)) {
@@ -80,13 +150,85 @@ export const emitRegistered = ({
     focusableGroupRegistrationSubject$.next({ id });
   }
 
-  if (!isGroup && id && parentId) {
-    focusableViewRegistrationSubject$.next({ id, parentId });
+  if (!isGroup && id && groupId) {
+    focusableViewRegistrationSubject$.next({ id, groupId });
   }
 };
 
+// unregistration on RN level(into RN focusManager)
 export const emitUnregistered = (id: Option<FocusableID>): void => {
   if (isFocusableButton(id)) {
     registeredSubject$.next({ id, registered: false });
   }
 };
+
+// registration focusableNativeView and focusableNativeGroup
+export const emitNativeRegistered = ({
+  id,
+  groupId,
+  isGroup,
+}: {
+  id: Option<FocusableID>;
+  groupId: Option<FocusableID>;
+  isGroup: boolean;
+}): void => {
+  if (!isGroup && id && groupId) {
+    focusableNativeViewRegistrationSubject$.next({ id, groupId });
+  }
+
+  if (isGroup && id && groupId) {
+    focusableNativeGroupRegistrationSubject$.next({ id, groupId });
+  }
+};
+
+// /////
+
+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 createFocusableRegistry = () => {
+  const subject$ = new ReplaySubject<FocusableID | undefined>(1);
+
+  return {
+    observable$: subject$.asObservable(),
+    register: (id: FocusableID) => {
+      // save focusable_id on registration
+      subject$.next(id);
+    },
+    unregister: () => {
+      // reset focusable_id on unregistration
+      subject$.next(undefined);
+    },
+  };
+};
+
+/// HOME_TOP_MENU_ITEM
+export const HomeTopMenuItemRegistry = createFocusableRegistry();
+
+export const homeTopMenuItemFocused$ = topMenuItemFocused$.pipe(
+  withLatestFrom(HomeTopMenuItemRegistry.observable$),
+  filter(([id, homeId]) => id === homeId)
+);
+
+/// SCREEN_PICKER
+export const ScreenPickerContentContainerRegistry = createFocusableRegistry();
+
+/// SEARCH_INPUT
+export const SearchInputRegistry = createFocusableRegistry();

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;
 };