@applicaster/zapp-react-native-utils 12.0.0-alpha.5135101838 → 12.0.0-alpha.5208030571

package/appUtils/focusManager/index.ts

@@ -1,9 +1,20 @@
 import * as R from "ramda";
+import {
+  isNilOrEmpty,
+  isNotNil,
+} from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode, findPriorityItem } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
 import * as FOCUS_EVENTS from "./events";
 import { coreLogger } from "../../logger";
+import {
+  waitForActiveScreen,
+  waitForContent,
+  getContentNode,
+  getActiveScreen,
+} from "./utils";
 
 const logger = coreLogger.addSubsystem("focusManager");
 
@@ -46,7 +57,7 @@ export const focusManager = (function () {
   let lastFocusedId = null;
   let initialFocusOnContent = null;
   let focusDisabled = false;
-  let focusAutoEnabled = true;
+  let focusAutoEnabled = false;
   const eventHandler = subscriber();
 
   function disableAutomaticFocus() {
@@ -93,7 +104,7 @@ export const focusManager = (function () {
       !currentFocusable.isGroup &&
       currentFocusable.isMounted()
     ) {
-      currentFocusable.blur(currentFocusable, direction);
+      currentFocusable.blur(direction);
       currentFocusable.hasLostFocus(getCurrentFocus(), direction);
     }
   }
@@ -219,38 +230,55 @@ export const focusManager = (function () {
   /**
    * sets the initial focus when the screen loads, or when focus is lost
    */
-  function setInitialFocus(lastAddedParentNode?: any) {
+  function setInitialFocus(lastAddedParentNode?: any, fallback?: () => void) {
     const preferredFocus = findPriorityItem(
       lastAddedParentNode?.children || focusableTree.root.children
     );
 
     logger.log({ message: "setInitialFocus", data: { preferredFocus } });
 
-    if (preferredFocus && preferredFocus.length > 0) {
-      const focusCandidate = preferredFocus[0];
-      const focusableItem = focusCandidate.component;
-
-      if (
-        focusableItem &&
-        !focusableItem.isGroup &&
-        isFocusEnabled(focusableItem)
-      ) {
-        if (initialFocusOnContent) {
-          blur();
-          initialFocusOnContent = false;
-        }
+    if (isNilOrEmpty(preferredFocus)) {
+      fallback?.();
+      return;
+    }
 
-        logger.log({
-          message: "setInitialFocus – currentFocusNode",
-          data: {
-            focusableItem,
-          },
-        });
+    const focusCandidate = preferredFocus[0];
+    const focusableItem = focusCandidate.component;
 
-        currentFocusNode = focusCandidate;
-        focusableItem.willReceiveFocus(focusableItem, null);
-        focusableItem && setFocus(focusCandidate.id, null);
+    const currentFocusedId = R.path(["props", "id"], getCurrentFocus());
+    const nextFocusedId = R.path(["props", "id"], focusableItem);
+
+    if (currentFocusedId === nextFocusedId) {
+      // we are going to move focus to the same node(already focused) -> nothing to do
+      return;
+    }
+
+    if (preferredFocus.length === 1 && focusableItem && focusableItem.isGroup) {
+      // we've found only one FocusableGroup as a candidate to focus, try to use fallback
+      fallback?.();
+      return;
+    }
+
+    if (
+      focusableItem &&
+      !focusableItem.isGroup &&
+      isFocusEnabled(focusableItem)
+    ) {
+      if (initialFocusOnContent) {
+        blur();
+        initialFocusOnContent = false;
       }
+
+      logger.log({
+        message: "setInitialFocus – currentFocusNode",
+        data: {
+          focusableItem,
+        },
+      });
+
+      currentFocusNode = focusCandidate;
+      focusableItem.willReceiveFocus(focusableItem, null);
+      focusableItem && setFocus(focusCandidate.id, null);
     }
   }
 
@@ -323,6 +351,8 @@ export const focusManager = (function () {
    * @returns {React.Component} the registered component
    */
   function registerGroup(id, component) {
+    // console.log("debug_2", "FM registerGroup", { id, component });
+
     focusableTree.addNode({ id, component });
 
     return component;
@@ -338,6 +368,8 @@ export const focusManager = (function () {
    * @returns {React.Component} the registered component
    */
   function registerItem(id, component) {
+    // console.log("debug_2", "FM registerItem", { id, component });
+
     focusableTree.addNode({ id, component });
 
     if (!currentFocusNode && id === lastFocusedId && !id.includes("menu")) {
@@ -354,6 +386,8 @@ export const focusManager = (function () {
    * @param {String} id of the group to unregister
    */
   function unregisterGroup(id) {
+    // console.log("debug_2", "FM unregisterGroup", { id });
+
     focusableTree.findAndRemoveNode(id);
   }
 
@@ -365,6 +399,8 @@ export const focusManager = (function () {
    * @param {String} id of the Focusable to unregister
    */
   function unregisterItem(id) {
+    // console.log("debug_2", "FM unregisterItem", { id });
+
     focusableTree.findAndRemoveNode(id);
 
     if (currentFocusNode && currentFocusNode.id === id) {
@@ -403,6 +439,8 @@ export const focusManager = (function () {
   }
 
   function setupInitialFocus(id: string, focusOnContent?: boolean) {
+    console.log("debug_2", "FM - setupInitialFocus", { id, focusOnContent });
+
     if (focusOnContent) {
       initialFocusOnContent = focusOnContent;
     } else {
@@ -410,6 +448,58 @@ export const focusManager = (function () {
     }
   }
 
+  async function setFocusOnMenu(currentRoute: string) {
+    try {
+      await waitForActiveScreen(currentRoute, focusableTree);
+
+      const navbar = R.find(
+        (child) => R.startsWith("navbar", child.id),
+        getActiveScreen(focusableTree).children
+      );
+
+      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) {
+      // failed to put focus on top-menu => log it
+    }
+  }
+
+  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
+    // this is the temporary hack with waiting until content node starts having children
+    try {
+      await waitForActiveScreen(currentRoute, focusableTree);
+      await waitForContent(focusableTree);
+
+      const content = getContentNode(focusableTree);
+
+      const fallback = () => {
+        throw Error("Failed to land focus on content");
+      };
+
+      setInitialFocus(content, fallback);
+    } catch (e) {
+      // we've failed to put initial focus on content, put focus on menu as a last chance
+      setFocusOnMenu(currentRoute);
+    }
+  }
+
   /**
    * moves the focus in a provided direction
    * @public
@@ -422,6 +512,13 @@ export const focusManager = (function () {
       currentFocusNode.component.willLoseFocus(currentFocusNode, direction);
       const nextFocusable = findFocusableNode(direction, currentFocusNode);
 
+      // console.log("debug_2", "FM moveFocus", {
+      //   direction: direction?.value,
+      //   currentFocusNode,
+      //   focusableTree,
+      //   nextFocusable,
+      // });
+
       if (nextFocusable?.component?.isMounted?.()) {
         const nextRect = nextFocusable.component.getRect();
 
@@ -518,5 +615,7 @@ export const focusManager = (function () {
     enableAutomaticFocus,
     getGroupRootById,
     isGroupItemFocused,
+    setFocusOnMenu,
+    setFocusOnContent,
   };
 })();

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

@@ -1,4 +1,4 @@
-import * as R from "ramda";
+import { allPass, pathOr, startsWith, isNil } from "ramda";
 import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 
 import { rejectItemByPath } from "../../../../objectUtils";
@@ -143,7 +143,49 @@ const hasChildren = (target) =>
 
 const hasComponent = (target) => !!target?.component;
 
-const hasComponentAndChildren = R.allPass([hasComponent, hasChildren]);
+const hasComponentAndChildren = allPass([hasComponent, hasChildren]);
+
+const positiveOrZero = (value) => value >= 0;
+
+const excludeFromFocusSearching = pathOr(false, [
+  "component",
+  "props",
+  "excludeFromFocusSearching",
+]);
+
+// const isAllScreens = all(excludeFromFocusSearching);
+
+const isNavBar = (target) => startsWith("navbar", target?.id);
+
+const ignoreMenuIfMultipleTargets = (nodes) => {
+  if (nodes.length > 1 && nodes.map((n) => n?.target?.id).includes("navbar")) {
+    return nodes.filter((n) => !isNavBar(n?.target));
+  }
+
+  return nodes;
+};
+
+const toDistance = ({ target, direction, comparisonRect }) => {
+  const componentRect = target.component?.getRect();
+
+  const orientationDistance = measureDistance(
+    direction,
+    comparisonRect,
+    componentRect
+  );
+
+  if (orientationDistance === -1) {
+    // ignores offscreen targets when moving up/down
+    return null;
+  }
+
+  const euclidDistance = measureEuclidianDistanceToCenter(
+    comparisonRect,
+    componentRect
+  );
+
+  return orientationDistance > 0 ? euclidDistance : orientationDistance;
+};
 
 /**
  * Get target in shortest distance in specified direction
@@ -173,52 +215,32 @@ export function getTargetInDirection(
 
   const distances = targets
     .filter(hasComponentAndChildren)
-    .map((target) => {
-      const componentRect = target.component?.getRect();
-
-      const distance = measureDistance(
-        direction,
-        comparisonRect,
-        componentRect
-      );
-
-      if (distance === -1) {
-        // ignores offscreen targets when moving up/down
-        return null;
-      }
+    .filter((target) => !excludeFromFocusSearching(target))
+    .map((target) => ({
+      distance: toDistance({ target, direction, comparisonRect }),
+      target,
+    }))
+    .filter(({ distance }) => positiveOrZero(distance));
 
-      const orientationDistance = measureDistance(
-        direction,
-        comparisonRect,
-        componentRect
-      );
-
-      const euclidDistance = measureEuclidianDistanceToCenter(
-        comparisonRect,
-        componentRect
-      );
-
-      return {
-        distance:
-          orientationDistance > 0 ? euclidDistance : orientationDistance,
-        target,
-      };
-    })
-    .filter((obj) => obj && obj.distance >= 0);
+  // if (isAllScreens(targets)) {
+  //   return last(targets);
+  // }
 
   const match = distances
     .sort((a, b) => a.distance - b.distance) // sorts the distances
     .filter(ignoreMenuIfMultipleTargets)[0]; // filters out multiple targets if necessary // gets the first element
 
-  return distances && distances.length > 0 ? match.target : null;
-}
-
-function ignoreMenuIfMultipleTargets(nodes) {
-  if (nodes.length > 1 && nodes.map((n) => n?.target?.id).includes("navbar")) {
-    return nodes.filter((n) => n?.target?.id !== "navbar");
-  }
-
-  return nodes;
+  // console.log("debug_2", "FM getTargetInDirection", {
+  //   direction: direction?.value,
+  //   currentNode,
+  //   targetNodes,
+  //   targets,
+  //   comparisonRect,
+  //   distances,
+  //   match,
+  // });
+
+  return match?.target;
 }
 
 /**
@@ -309,3 +331,36 @@ export function hasPriorityInDirection(direction, component) {
 
   return (prioritiseFocusOn & mappedDirection) > 0;
 }
+
+export const getNodeBeforeRoot = (node) => {
+  if (isNil(node)) {
+    return undefined;
+  }
+
+  if (node.parent.id === "root") {
+    return node;
+  }
+
+  return getNodeBeforeRoot(node.parent);
+};
+
+export const isAllowedToMoveTo = (currentNode, nextNode) => {
+  const screenForCurrentNode = getNodeBeforeRoot(currentNode);
+  const screenForNextNode = getNodeBeforeRoot(nextNode);
+
+  return screenForCurrentNode.id === screenForNextNode.id;
+
+  // console.log("debug_2", "isAllowedToMoveTo", {
+  //   nodeBeforeRoot,
+  // });
+
+  // if (nodeBeforeRoot?.id === "navbar") {
+  //   return true;
+  // }
+
+  // if (nodeBeforeRoot?.component?.props?.isActive) {
+  //   return true;
+  // }
+
+  // return false;
+};

package/appUtils/focusManager/utils/index.ts

@@ -0,0 +1,65 @@
+import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { find, last, startsWith } from "ramda";
+
+// run check each 300 ms
+// run this check too often could lead to performance penalty on low-end devices
+const HOW_OFTEN_TO_CHECK_CONDITION = 300; //ms
+
+type Props = {
+  maxTimeout: number;
+  conditionFn: () => boolean;
+};
+
+export const waitUntil = ({ maxTimeout, conditionFn }: Props) => {
+  let interval;
+  return new Promise((resolve, reject) => {
+    interval = setInterval(() => {
+      if (conditionFn()) {
+        clearInterval(interval);
+        resolve(undefined);
+      }
+    }, HOW_OFTEN_TO_CHECK_CONDITION);
+
+    setTimeout(() => {
+      reject();
+    }, maxTimeout);
+  });
+};
+
+export const waitForActiveScreen = (currentRoute: string, focusableTree) => {
+  const isActiveScreenAvailableToFocus = (): boolean => {
+    const routes = focusableTree.root.children;
+
+    const route = find((route) => route.id === currentRoute, routes);
+    return isNotNil(route);
+  };
+
+  return waitUntil({
+    maxTimeout: 2500, //ms
+    conditionFn: isActiveScreenAvailableToFocus,
+  });
+};
+
+export const getActiveScreen = (focusableTree) => {
+  return last(focusableTree.root.children);
+};
+
+export const getContentNode = (focusableTree) => {
+  const content = find(
+    (child) => startsWith("content", child.id),
+    getActiveScreen(focusableTree)?.children
+  );
+
+  return content;
+};
+
+export const waitForContent = (focusableTree) => {
+  const contentHasAnyChildren = (): boolean => {
+    return getContentNode(focusableTree)?.children.length > 0;
+  };
+
+  return waitUntil({
+    maxTimeout: 1000, //ms
+    conditionFn: contentHasAnyChildren,
+  });
+};

package/appUtils/playerManager/playerNative.ts

@@ -296,5 +296,8 @@ export class PlayerNative extends Player {
   supportsNativeControls = (): boolean =>
     toBooleanWithDefaultFalse(this.getConfig()?.["supports_native_controls"]);
 
-  supportNativeCast = (): boolean => toBooleanWithDefaultFalse(this.playerPluginId === "quick-brick-player-brightcove");
+  supportNativeCast = (): boolean =>
+    toBooleanWithDefaultFalse(
+      this.playerPluginId === "quick-brick-player-brightcove"
+    );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "12.0.0-alpha.5135101838",
+  "version": "12.0.0-alpha.5208030571",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "12.0.0-alpha.5135101838",
+    "@applicaster/applicaster-types": "12.0.0-alpha.5208030571",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

package/reactHooks/navigation/__mocks__/index.ts

@@ -15,8 +15,21 @@ export const mockMenu: ZappNavigation = {
   // preset_id?: null | unknown;
 };
 
+export const useRoute = jest.fn(() => ({
+  screenData: {
+    name: "someName",
+  },
+  pathname: "someRoute",
+}));
+
 export const useNavigation = jest.fn(() => ({
   data: {},
+  screenData: {
+    name: "someName",
+  },
+  activeRiver: {
+    id: "someId",
+  },
   currentRoute: "someRoute",
 }));
 

package/reactHooks/navigation/__mocks__/useNavigation.ts

@@ -1,4 +1,7 @@
 export const useNavigation = jest.fn(() => ({
   data: {},
+  screenData: {
+    name: "someName",
+  },
   currentRoute: "someRoute",
 }));

package/reactHooks/navigation/index.ts

@@ -496,3 +496,18 @@ export const useIsScreenActive = () => {
 
   return pathname === currentRoute;
 };
+
+type Return = (prefix: string) => string;
+
+export const useUniqueRouteSuffix = (): Return => {
+  const pathname = usePathname();
+  const { currentRoute } = useNavigation();
+
+  const suffix = `currentRoute:${currentRoute}_pathname:${pathname}`;
+
+  const withUniqueRouteSuffix = React.useCallback((prefix: string) => {
+    return `${prefix}___${suffix}`;
+  }, []);
+
+  return withUniqueRouteSuffix;
+};

package/reactHooks/screen/useScreenContext.ts

@@ -5,8 +5,9 @@ import { useNestedNavigationContext } from "@applicaster/zapp-react-native-ui-co
 import { useNavigation } from "../navigation/useNavigation";
 
 import { ScreenContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenContext";
+import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Components/Layout/TV";
 
-function useScreenContextV2() {
+export function useScreenContextV2() {
   return useContext(ScreenContext);
 }
 
@@ -45,8 +46,8 @@ export function useSetNavbarState() {
 export function useScreenContext(): NavigationScreenData {
   const navigator = useNavigation();
 
-  const screenKey = useMemo(() => navigator?.key, [navigator]);
-  const screenData = useMemo(() => navigator?.data, [screenKey]);
+  const screenData = useContext(ScreenDataContext);
+
   const modalScreenData = navigator?.modalData;
 
   const isModal = useModalNavigationContext();

package/reactUtils/helpers.tsx

@@ -7,7 +7,7 @@ export const isAnyNil = R.any(R.isNil);
 
 export const isNilOrEmpty = R.either(R.isNil, R.isEmpty);
 
-export const isNotEmpty = R.complement(R.isEmpty);
+export const isNotEmpty = R.both(isNotNil, R.complement(R.isEmpty));
 
 export const withoutNil = R.reject(R.isNil);
 

package/screenState/index.ts

@@ -49,11 +49,3 @@ export function useScreenState(
     setSelectedEntry: (entryId) => setSelectedEntry(screenId, entryId),
   };
 }
-
-export const useScreenScrollStore = create<{
-  scrollPosition: number;
-  scrollingVelocity: number;
-}>(() => ({
-  scrollPosition: 0,
-  scrollingVelocity: 0,
-}));

package/stringUtils/index.ts

@@ -152,3 +152,8 @@ export function objectToCamelCase(obj) {
 export function isString(value: unknown): value is string {
   return typeof value === "string" || value instanceof String;
 }
+
+/** Checks if a value is a non-empty string */
+export function isNotEmptyString(value: unknown): value is string {
+  return isString(value) && value.length > 0;
+}

package/testUtils/getByTestId.ts

@@ -0,0 +1,14 @@
+export const getByTestId = (wrapper, testId) => {
+  try {
+    if (wrapper?.getByTestId) {
+      return wrapper?.queryAllByTestId(testId)?.[0] ?? undefined;
+    } else if (wrapper?.root?.findByProps) {
+      return wrapper.root.findAllByProps({ testID: testId })?.[0] ?? undefined;
+    }
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.log("getByTestId E:", e);
+
+    return undefined;
+  }
+};

package/testUtils/index.tsx

@@ -1,6 +1,6 @@
 import * as R from "ramda";
 
-import React from "react";
+import React, { PropsWithChildren } from "react";
 import { View } from "react-native";
 
 import { Provider } from "react-redux";
@@ -11,6 +11,8 @@ import { SafeAreaProvider } from "react-native-safe-area-context";
 import { render } from "@testing-library/react-native";
 import { AnalyticsProvider } from "../analyticsUtils";
 
+export { getByTestId } from "./getByTestId";
+
 /**
  * Function to be used in tandem with enzyme findWhere(node => node.prop('testID') === 'yourID')
  * Example:
@@ -21,17 +23,6 @@ import { AnalyticsProvider } from "../analyticsUtils";
 export const testIDEquals = (testId: any): boolean =>
   R.compose(R.equals(testId), R.invoker(1, "prop")("testID"));
 
-export const getByTestId = (wrapper, testId) => {
-  try {
-    return wrapper?.queryAllByTestId(testId)?.[0] ?? undefined;
-  } catch (e) {
-    // eslint-disable-next-line no-console
-    console.log("getByTestId E:", e);
-
-    return undefined;
-  }
-};
-
 /** Helper function for react-test-renderer, accepts type and renderer
  * * @param {*} type React Component type instance  or name of component
  * * @param {*} renderer renderer instance
@@ -47,11 +38,11 @@ export const findByType = (type, renderer) => {
 export function createComponentMock(mockName, hasChildren = false) {
   return hasChildren
     ? jest.fn(({ children }) => (
-        <View comp={mockName} testID={mockName}>
+        <View testID={mockName}>
           {typeof children === "function" ? children() : children}
         </View>
       ))
-    : jest.fn(() => <View comp={mockName} testID={mockName} />);
+    : jest.fn(() => <View testID={mockName} />);
 }
 
 const initialState = {
@@ -64,14 +55,21 @@ const initialState = {
     AppContainer: createComponentMock("appContainer", true),
     DisplayError: createComponentMock("displayError"),
   },
-  rivers: [{ id: "A1234", home: true }],
+  rivers: { id: "A1234", home: true },
   appSettings: {},
   plugins: [],
-  appState: { appReady: true },
+  appState: { appReady: true, appLaunched: true },
+  appData: { layoutVersion: "v1" },
+  contentTypes: null,
 };
 
-export const WrappedWithProviders = ({ children, store = {} }: any) => {
-  const _store = configureStore([thunk])({ ...initialState, ...store });
+export const WrappedWithProviders = ({
+  children,
+  store: storeObj = {},
+}: any) => {
+  const _store = configureStore([thunk])(
+    R.mergeDeepWith(R.concat, { ...initialState }, storeObj)
+  );
 
   return (
     <SafeAreaProvider
@@ -93,8 +91,12 @@ export const WrappedWithProviders = ({ children, store = {} }: any) => {
  * @param store optional store to pass to the provider
  * @returns
  */
-export const renderWithProviders = (component, store?: unknown) => {
-  return render(
-    <WrappedWithProviders store={store}>{component}</WrappedWithProviders>
-  );
+export const renderWithProviders = (component, storeObj?: unknown) => {
+  return render(component, {
+    wrapper: function TestWrapper({ children }: PropsWithChildren<any>) {
+      return (
+        <WrappedWithProviders store={storeObj}>{children}</WrappedWithProviders>
+      );
+    },
+  });
 };