@applicaster/zapp-react-native-utils 14.0.0-alpha.2523527255 → 14.0.0-alpha.2893452677

package/actionsExecutor/ActionExecutorContext.tsx

@@ -120,7 +120,6 @@ const prepareDefaultActions = (actionExecutor) => {
         loadPipesData(dataSource, {
           silentRefresh: false,
           clearCache: true,
-          callback: (_data) => {},
           riverId: context?.screenData?.id,
         })
       );

package/actionsExecutor/ScreenActions.ts

@@ -7,10 +7,11 @@ import { get } from "lodash";
 import { onMaxTagsReached } from "./StorageActions";
 import { ScreenMultiSelectProvider } from "../storage/ScreenStateMultiSelectProvider";
 import { ScreenSingleValueProvider } from "../storage/ScreenSingleValueProvider";
+import { useScreenStateStore } from "../reactHooks/navigation/useScreenStateStore";
 
 export const screenSetVariable = async (
   screenRoute: string,
-  screenStateStore: ScreenStateStore,
+  screenStateStore: ReturnType<typeof useScreenStateStore>,
   context: Record<string, any>,
   action: ActionType
 ): Promise<ActionResult> => {
@@ -34,11 +35,11 @@ export const screenSetVariable = async (
     ? get(entry, action.options.selector)
     : (entry.extensions?.tag ?? entry.id);
 
-  const keyNamespace = action.options?.key;
+  const key = action.options?.key;
 
-  if (!keyNamespace) {
-    log_error("handleAction: screenSetVariable action missing key namespace", {
-      keyNamespace,
+  if (!key) {
+    log_error("handleAction: screenSetVariable action missing argument 'key'", {
+      key,
     });
 
     return ActionResult.Error;
@@ -55,7 +56,7 @@ export const screenSetVariable = async (
 
   try {
     const singleValueProvider = ScreenSingleValueProvider.getProvider(
-      keyNamespace,
+      key,
       screenRoute,
       screenStateStore
     );
@@ -63,19 +64,19 @@ export const screenSetVariable = async (
     const currentValue = await singleValueProvider.getValueAsync();
 
     log_info(
-      `handleAction: screenSetVariable setting value: ${tag} for keyNamespace: ${keyNamespace}, previous value: ${currentValue}`
+      `handleAction: screenSetVariable setting value: ${tag} for key: ${key}, previous value: ${currentValue}`
     );
 
     await singleValueProvider.setValue(String(tag));
 
     log_info(
-      `handleAction: screenSetVariable successfully set value: ${tag} for keyNamespace: ${keyNamespace}`
+      `handleAction: screenSetVariable successfully set value: ${tag} for key: ${key}`
     );
 
     return ActionResult.Success;
   } catch (error) {
     log_error("handleAction: screenSetVariable failed to set value", {
-      keyNamespace,
+      key,
       tag,
       error,
     });
@@ -86,7 +87,7 @@ export const screenSetVariable = async (
 
 export const screenToggleFlag = async (
   screenRoute: string,
-  screenStateStore: ScreenStateStore,
+  screenStateStore: ReturnType<typeof useScreenStateStore>,
   context: Record<string, any>,
   action: ActionType
 ) => {
@@ -110,11 +111,11 @@ export const screenToggleFlag = async (
     ? get(entry, action.options.selector)
     : (entry.extensions?.tag ?? entry.id);
 
-  const keyNamespace = action.options?.key;
+  const key = action.options?.key;
 
-  if (keyNamespace && tag) {
+  if (key && tag) {
     const multiSelectProvider = ScreenMultiSelectProvider.getProvider(
-      keyNamespace,
+      key,
       screenRoute,
       screenStateStore
     );
@@ -125,7 +126,7 @@ export const screenToggleFlag = async (
     log_info(
       `handleAction: screenToggleFlag event will ${
         isTagInSelectedItems ? "remove" : "add"
-      } tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`
+      } tag: ${tag} for key: ${key}, current selectedItems: ${selectedItems}`
     );
 
     if (selectedItems.includes(tag)) {
@@ -142,7 +143,7 @@ export const screenToggleFlag = async (
           selectedItems,
           maxItems,
           tag,
-          keyNamespace,
+          keyNamespace: key,
         });
 
         return ActionResult.Cancel;
@@ -151,10 +152,10 @@ export const screenToggleFlag = async (
       await multiSelectProvider.addItem(tag);
     }
   } else {
-    log_error(
-      "handleAction: screenToggleFlag event missing keyNamespace or tag",
-      { keyNamespace, tag }
-    );
+    log_error("handleAction: screenToggleFlag event missing key or tag", {
+      key,
+      tag,
+    });
 
     return ActionResult.Error;
   }

package/analyticsUtils/__tests__/analyticsUtils.test.js

@@ -8,17 +8,6 @@ jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
   ),
 }));
 
-jest.mock(
-  "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider",
-  () => ({
-    StorageMultiSelectProvider: {
-      getProvider: jest.fn(() => ({
-        getSelectedItems: jest.fn(() => []),
-      })),
-    },
-  })
-);
-
 const mock_postAnalyticEvent = jest.fn();
 const mock_startAnalyticsTimedEvent = jest.fn();
 const mock_endAnalyticsTimedEvent = jest.fn();

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,5 +1,7 @@
 import { ContextKeysManager } from "./index";
 import * as R from "ramda";
+import * as _ from "lodash";
+import { useScreenStateStore } from "../../reactHooks/navigation/useScreenStateStore";
 
 export interface IResolver {
   resolve: (string) => Promise<string | number | object>;
@@ -25,11 +27,21 @@ export class EntryResolver implements IResolver {
 // TODO: Move to proper place
 
 export class ScreenStateResolver implements IResolver {
-  constructor(private screenStateStore: ScreenStateStore) {}
+  constructor(
+    private screenStateStore: ReturnType<typeof useScreenStateStore>
+  ) {}
 
   async resolve(key: string) {
     const screenState = this.screenStateStore.getState().data;
 
+    if (!key || key.length === 0) {
+      return screenState;
+    }
+
+    if (key.includes(".")) {
+      return R.view(R.lensPath(key.split(".")), screenState);
+    }
+
     return screenState?.[key];
   }
 }
@@ -77,3 +89,19 @@ export const resolveObjectValues = async (
 
   return Object.fromEntries(resolvedEntries);
 };
+
+export const extractAtValues = _.memoize((input: any): string[] => {
+  return _.flatMapDeep(input, (value: any) => {
+    if (_.isString(value)) {
+      const matches = value.match(/@\{([^}]*)\}/g);
+
+      return matches ? matches.map((match) => match.slice(2, -1)) : [];
+    }
+
+    if (_.isObject(value)) {
+      return extractAtValues(_.values(value));
+    }
+
+    return [];
+  });
+});

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

@@ -6,6 +6,7 @@ exports[`focusManager should be defined 1`] = `
   "disableFocus": [Function],
   "enableFocus": [Function],
   "findPreferredFocusChild": [Function],
+  "focusTopNavigation": [Function],
   "focusableTree": Tree {
     "loadingCounter": 0,
     "root": {
@@ -24,6 +25,9 @@ exports[`focusManager should be defined 1`] = `
   "invokeHandler": [Function],
   "isCurrentFocusOnTheTopScreen": [Function],
   "isFocusDisabled": [Function],
+  "isFocusOn": [Function],
+  "isFocusOnContent": [Function],
+  "isFocusOnMenu": [Function],
   "isGroupItemFocused": [Function],
   "longPress": [Function],
   "moveFocus": [Function],
@@ -63,6 +67,7 @@ exports[`focusManagerIOS should be defined 1`] = `
   "getGroupRootById": [Function],
   "getPreferredFocusChild": [Function],
   "invokeHandler": [Function],
+  "isFocusOn": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],
   "on": [Function],

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

@@ -33,7 +33,7 @@ describe("focusManager", () => {
 
     expect(success).toBe(true);
     expect(mockSetFocus).toBeCalledTimes(1);
-    expect(mockSetFocus).toBeCalledWith(null);
+    expect(mockSetFocus).toBeCalledWith(null, undefined);
   });
 
   describe("register", () => {});

package/appUtils/focusManager/index.ios.ts

@@ -1,6 +1,7 @@
 import { NativeModules } from "react-native";
 import * as R from "ramda";
 
+import { isCurrentFocusOn } from "../focusManagerAux/utils";
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
@@ -391,6 +392,14 @@ export const focusManager = (function () {
     return node;
   }
 
+  function isFocusOn(id): boolean {
+    const currentFocusNode = focusableTree.findInTree(
+      getCurrentFocus()?.props?.id
+    );
+
+    return id && isCurrentFocusOn(id, currentFocusNode);
+  }
+
   return {
     on,
     invokeHandler,
@@ -412,5 +421,6 @@ export const focusManager = (function () {
     getGroupRootById,
     isGroupItemFocused,
     getPreferredFocusChild,
+    isFocusOn,
   };
 })();

package/appUtils/focusManager/index.ts

@@ -14,6 +14,15 @@ import { subscriber } from "../../functionUtils";
 import { coreLogger } from "../../logger";
 import { ACTION } from "./utils/enums";
 
+import {
+  findSelectedTabId,
+  findSelectedMenuId,
+  isTabsScreenContentFocused,
+  isCurrentFocusOnContent,
+  isCurrentFocusOnMenu,
+  isCurrentFocusOn,
+} from "../focusManagerAux/utils";
+
 const logger = coreLogger.addSubsystem("focusManager");
 
 const isFocusEnabled = (focusableItem): boolean => {
@@ -100,7 +109,7 @@ export const focusManager = (function () {
    * @private
    * @param {Object} direction of the navigation which led to this action
    */
-  function focus(direction) {
+  function focus(direction, context?: FocusManager.FocusContext) {
     const currentFocusable = getCurrentFocus();
 
     if (
@@ -108,7 +117,7 @@ export const focusManager = (function () {
       !currentFocusable.isGroup &&
       currentFocusable.isMounted()
     ) {
-      currentFocusable.setFocus(direction);
+      currentFocusable.setFocus(direction, context);
     }
   }
 
@@ -205,7 +214,7 @@ export const focusManager = (function () {
    * @param {Array<string>} ids - An array of node IDs to update.
    * @param {boolean} setFocus - A flag indicating whether to set focus (true) or blur (false) on the nodes.
    */
-  const updateNodeFocus = (ids, action) => {
+  const updateNodeFocus = (ids, action, context: FocusManager.FocusContext) => {
     if (!ids || ids.length === 0) {
       return; // Nothing to do
     }
@@ -222,11 +231,13 @@ export const focusManager = (function () {
 
     // Function to apply the action (focus or blur)
     const applyAction = (node) => {
+      const direction = undefined;
+
       if (node && node.component) {
         if (action === "focus") {
-          node.component.setFocus();
+          node.component.setFocus(direction, context);
         } else if (action === "blur") {
-          node.component.setBlur();
+          node.component.setBlur(direction, context);
         }
       }
     };
@@ -253,7 +264,11 @@ export const focusManager = (function () {
    * @param {Object} direction of the navigation, which led to this focus change
    * to another group or not. defaults to false
    */
-  function setFocus(id: string, direction?: FocusManager.Web.Direction) {
+  function setFocus(
+    id: string,
+    direction?: FocusManager.Web.Direction,
+    context?: FocusManager.FocusContext
+  ) {
     if (focusDisabled) return false;
 
     // due to optimisiation it's recommanded to set currentFocusNode before setFocus
@@ -266,21 +281,65 @@ export const focusManager = (function () {
       );
 
       // Set focus on current node parents and blur on previous node parents
-      updateNodeFocus(currentNodeParentsIDs, ACTION.FOCUS);
-      updateNodeFocus(previousNodeParentsIDs, ACTION.BLUR);
+      updateNodeFocus(currentNodeParentsIDs, ACTION.FOCUS, context);
+      updateNodeFocus(previousNodeParentsIDs, ACTION.BLUR, context);
 
       currentFocusNode = focusableTree.findInTree(id);
     }
 
     setLastFocusOnParentNode(currentFocusNode);
 
-    focus(direction);
+    focus(direction, context);
+  }
+
+  function isFocusOnContent() {
+    return isCurrentFocusOnContent(currentFocusNode);
+  }
+
+  function isFocusOnMenu() {
+    return isCurrentFocusOnMenu(currentFocusNode);
+  }
+
+  // Move focus to appropriate top navigation tab with context
+  function focusTopNavigation(isTabsScreen: boolean, item: ZappEntry) {
+    const landFocusTo = (id) => {
+      if (id) {
+        // set focus on selected menu item
+        const direction = undefined;
+
+        const context: FocusManager.FocusContext = {
+          source: "back",
+          preserveScroll: true,
+        };
+
+        logger.log({ message: "landFocusTo", data: { id } });
+
+        blur(direction);
+        setFocus(id, direction, context);
+      }
+    };
+
+    if (isTabsScreen && isTabsScreenContentFocused(currentFocusNode)) {
+      const selectedTabId = findSelectedTabId(item);
+
+      // Set focus with back button context to tabs-menu
+      landFocusTo(selectedTabId);
+
+      return;
+    }
+
+    const selectedMenuItemId = findSelectedMenuId(focusableTree);
+    // Set focus with back button context to top-menu
+    landFocusTo(selectedMenuItemId);
   }
 
   /**
    * sets the initial focus when the screen loads, or when focus is lost
    */
-  function setInitialFocus(lastAddedParentNode?: any) {
+  function setInitialFocus(
+    lastAddedParentNode?: any,
+    context?: FocusManager.FocusContext
+  ) {
     const preferredFocus = findPriorityItem(
       lastAddedParentNode?.children || focusableTree.root.children
     );
@@ -326,7 +385,7 @@ export const focusManager = (function () {
         },
       });
 
-      focusableItem && setFocus(focusCandidate.id, null);
+      focusableItem && setFocus(focusCandidate.id, null, context);
 
       return { success: true };
     }
@@ -546,6 +605,14 @@ export const focusManager = (function () {
     return preferredFocus[0];
   }
 
+  function isFocusOn(id): boolean {
+    return (
+      id &&
+      isCurrentFocusOnTheTopScreen() &&
+      isCurrentFocusOn(id, currentFocusNode)
+    );
+  }
+
   /**
    * this is the list of the functions available externally
    * when importing the focus manager
@@ -576,5 +643,9 @@ export const focusManager = (function () {
     recoverFocus,
     isCurrentFocusOnTheTopScreen,
     findPreferredFocusChild,
+    focusTopNavigation,
+    isFocusOnContent,
+    isFocusOnMenu,
+    isFocusOn,
   };
 })();

package/appUtils/focusManagerAux/utils/index.ts

@@ -1,14 +1,31 @@
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
-import { find, last, pathOr, startsWith } from "ramda";
+import {
+  isNil,
+  last,
+  startsWith,
+  find,
+  pathOr,
+} from "@applicaster/zapp-react-native-utils/utils";
+
 import {
   QUICK_BRICK_CONTENT,
   QUICK_BRICK_NAVBAR,
 } from "@applicaster/quick-brick-core/const";
 
+import {
+  getFocusableId,
+  SCREEN_PICKER_CONTAINER,
+} from "@applicaster/zapp-react-native-utils/screenPickerUtils";
+
 // 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
 
+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;
@@ -49,7 +66,7 @@ export const waitForActiveScreen = (currentRoute: string, focusableTree) => {
 
     const route = find((route) => route.id === currentRoute, routes);
 
-    return isNotNil(route);
+    return !isNil(route);
   };
 
   return waitUntil({
@@ -99,3 +116,89 @@ export const waitForContent = (focusableTree) => {
     conditionFn: contentHasAnyChildren,
   });
 };
+
+export const findSelectedTabId = (item: ZappEntry): string => {
+  const selectedTabId = getFocusableId(item.id);
+
+  return selectedTabId;
+};
+
+export const findSelectedMenuId = (focusableTree) => {
+  // Set focus with back button context
+  const navbar = getNavbarNode(focusableTree);
+
+  const selectedMenuItemId = find(
+    (child) => child.component.props.selected,
+    navbar.children
+  )?.id;
+
+  return selectedMenuItemId;
+};
+
+export const isTabsScreenContentFocused = (node) => {
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isTopMenu(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (isScrenPicker(node)) {
+    return true;
+  }
+
+  return isTabsScreenContentFocused(node.parent);
+};
+
+export const isCurrentFocusOnMenu = (node) => {
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isTopMenu(node)) {
+    return true;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  return isCurrentFocusOnMenu(node.parent);
+};
+
+export const isCurrentFocusOnContent = (node) => {
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isTopMenu(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return true;
+  }
+
+  return isCurrentFocusOnContent(node.parent);
+};
+
+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);
+};

package/configurationUtils/__tests__/manifestKeyParser.test.ts

@@ -1,6 +1,5 @@
 import { getAllSpecificStyles } from "../manifestKeyParser";
 
-// Mock the dependencies
 jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
   platformSelect: jest.fn((platforms) => platforms.samsung_tv), // Default to samsung for tests
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "14.0.0-alpha.2523527255",
+  "version": "14.0.0-alpha.2893452677",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "14.0.0-alpha.2523527255",
+    "@applicaster/applicaster-types": "14.0.0-alpha.2893452677",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",
@@ -38,7 +38,6 @@
   "peerDependencies": {
     "@applicaster/zapp-pipes-v2-client": "*",
     "@react-native-community/netinfo": "*",
-    "immer": "*",
     "react": "*",
     "react-native": "*",
     "uglify-js": "*",

package/reactHooks/cell-click/__tests__/index.test.js

@@ -26,6 +26,9 @@ jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils/", () => ({
 }));
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
+  ...jest.requireActual(
+    "@applicaster/zapp-react-native-utils/reactHooks/screen"
+  ),
   useTargetScreenData: jest.fn(() => ({})),
   useCurrentScreenData: jest.fn(() => ({})),
 }));

package/reactHooks/debugging/__tests__/index.test.js

@@ -12,7 +12,6 @@ describe("Debug utils", () => {
     // Clear the timers object
     Object.keys(timers).forEach((key) => delete timers[key]);
 
-    // Mock performance.now()
     // eslint-disable-next-line no-undef
     performanceNowMock = jest.spyOn(performance, "now");
     performanceNowMock.mockReturnValue(0); // Initial value

package/reactHooks/feed/__tests__/useBatchLoading.test.tsx

@@ -2,12 +2,16 @@ import { renderHook } from "@testing-library/react-hooks";
 import { allFeedsIsReady, useBatchLoading } from "../useBatchLoading";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { waitFor } from "@testing-library/react-native";
 
 jest.mock("../../navigation");
 
 jest.mock(
   "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext",
   () => ({
+    ...jest.requireActual(
+      "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext"
+    ),
     useScreenContext: jest.fn().mockReturnValue({ screen: {}, entry: {} }),
   })
 );
@@ -33,7 +37,7 @@ describe("useBatchLoading", () => {
     jest.clearAllMocks();
   });
 
-  it("loadPipesData start loading not started requests", () => {
+  it("loadPipesData start loading not started requests", async () => {
     const store = {
       zappPipes: {
         url1: {
@@ -65,7 +69,9 @@ describe("useBatchLoading", () => {
 
     const actions = (appStore.getStore() as any).getActions();
 
-    expect(actions).toHaveLength(2);
+    await waitFor(() => {
+      expect(actions).toHaveLength(2);
+    });
 
     expect(actions[0]).toMatchObject({
       type: "ZAPP_PIPES_REQUEST_START",