@applicaster/zapp-react-native-utils 15.0.0-rc.99 → 15.1.0-alpha.2915689988

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

@@ -1,5 +1,193 @@
 // 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,23 +116,9 @@ describe("HooksManager", () => {
         headlessPlayerHook.configuration
       );
 
-      expect(successHandler).toHaveBeenCalledTimes(1);
-      expect(successHandler.mock.calls[0][0].payload).toEqual(payload);
-
-      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(successHandler.mock.calls[0]).toMatchSnapshot();
 
-      expect(typeof completeHandler.mock.calls[0][1]).toBe("function");
+      expect(completeHandler.mock.calls[0]).toMatchSnapshot();
     });
   });
 

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
@@ -86,7 +90,7 @@ export function HooksManager({
 }: HookManagerArgs): HookManager {
   hooksManagerLogger.addContext({ targetScreenId: targetScreen.id });
 
-  function logHookEvent(func, message, data) {
+  function logHookEvent(func, message, data = {}) {
     func({
       message,
       data: __DEV__ ? data : null,
@@ -230,7 +234,7 @@ export function HooksManager({
   function completeHook(hookPlugin, payload, callback) {
     logHookEvent(
       hooksManagerLogger.info,
-      `completeHook: hook sequence completed successfully: ${hookPlugin.identifier}`,
+      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
       {
         payload,
         hook: hookPlugin,
@@ -276,10 +280,12 @@ export function HooksManager({
       if (hookPlugin.isCancelled()) {
         logHookEvent(
           hooksManagerLogger.info,
-          `hookCallback: hook was cancelled: ${hookPlugin.identifier}`,
+          `hookCallback: hook was cancelled: ${hookPlugin["identifier"]}`,
           {}
         );
 
+        actionExecutor.unregisterAction("finishHook");
+
         return;
       }
 
@@ -294,6 +300,8 @@ export function HooksManager({
           }
         );
 
+        actionExecutor.unregisterAction("finishHook");
+
         return hookPlugin.setStateAndNotify(HOOKS_EVENTS.ERROR, {
           error,
           hookPlugin,
@@ -305,7 +313,7 @@ export function HooksManager({
       if (!success) {
         logHookEvent(
           hooksManagerLogger.info,
-          `hookCallback: hook was cancelled: ${hookPlugin.identifier}`,
+          `hookCallback: hook was cancelled: ${hookPlugin["identifier"]}`,
           {
             payload,
             hook: 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,
@@ -334,10 +344,9 @@ export function HooksManager({
         if (isHookInHomescreen && isHookFlowBlocker && cancelled) {
           logHookEvent(
             hooksManagerLogger.info,
-            `hookCallback: send app to background, cancelled flow blocker hook  ${hookPlugin.identifier} on home screen`,
+            `hookCallback: send app to background, cancelled flow blocker hook  ${hookPlugin["identifier"]} on home screen`,
             {
               payload,
-              hook: hookPlugin,
             }
           );
 
@@ -349,20 +358,16 @@ export function HooksManager({
       } else {
         logHookEvent(
           hooksManagerLogger.info,
-          `hookCallback: hook successfully finished: ${hookPlugin.identifier}`,
+          `hookCallback: hook successfully finished: ${hookPlugin["identifier"]}`,
           {
             payload,
-            hook: hookPlugin,
           }
         );
 
         if (!callback) {
           logHookEvent(
-            hooksManagerLogger.warn,
-            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`,
-            {
-              hookPlugin,
-            }
+            hooksManagerLogger.debug,
+            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`
           );
 
           callback = hookCallback;
@@ -381,6 +386,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
@@ -401,13 +427,15 @@ export function HooksManager({
 
     logHookEvent(
       hooksManagerLogger.info,
-      `presentScreenHook: Presenting screen hook: ${hookPlugin.identifier}`,
+      `presentScreenHook: Presenting screen hook: ${hookPlugin["identifier"]}`,
       {
         hook: hookPlugin,
         payload,
       }
     );
 
+    registerFinishHookAction(payload, callback);
+
     hookPlugin.setStateAndNotify(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, {
       hookPlugin,
       route: targetScreenRoute,
@@ -421,7 +449,7 @@ export function HooksManager({
   hooksManager.executeHook = function (hookPlugin, payload, callback) {
     logHookEvent(
       hooksManagerLogger.info,
-      `executeHook: ${hookPlugin.identifier}`,
+      `executeHook: ${hookPlugin["identifier"]}`,
       {
         hook: hookPlugin,
         payload,
@@ -433,7 +461,7 @@ export function HooksManager({
     } catch (error) {
       logHookEvent(
         hooksManagerLogger.error,
-        `executeHook: error executing hook: ${hookPlugin.identifier} error: ${error.message}`,
+        `executeHook: error executing hook: ${hookPlugin["identifier"]} error: ${error.message}`,
         {
           hook: hookPlugin,
           payload,
@@ -460,13 +488,15 @@ export function HooksManager({
     try {
       logHookEvent(
         hooksManagerLogger.info,
-        `runInBackground: Executing hook: ${hookPlugin.identifier}`,
+        `runInBackground: Executing hook: ${hookPlugin["identifier"]}`,
         {
           hook: hookPlugin,
           payload,
         }
       );
 
+      registerFinishHookAction(payload, callback);
+
       hookPlugin.module.runInBackground(
         payload,
         callback,

package/appUtils/RiverFocusManager/{index.ts → index.js}

@@ -1,31 +1,11 @@
-import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
-import { QUICK_BRICK_CONTENT } from "@applicaster/quick-brick-core/const";
-import { isNil, isEmpty } from "@applicaster/zapp-react-native-utils/utils";
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import * as R from "ramda";
+
+import { focusManager } from "../focusManager";
 
 let riverFocusData = {};
 let initialyPresentedScreenFocused = false;
 
 export const riverFocusManager = (function () {
-  /**
-   * Create unique key that will be used for save focused group data inside specific screen
-   * @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,
-  }: {
-    screenId: string;
-    isInsideContainer: Option<boolean>;
-  }) {
-    return `${QUICK_BRICK_CONTENT}-${screenId}${
-      isNil(isInsideContainer) ? "" : "-isInsideContainer"
-    }`;
-  }
-
   function setScreenFocusableData({
     screenFocusableGroupId,
     groupId,
@@ -98,8 +78,8 @@ export const riverFocusManager = (function () {
   }) {
     // Check if screen should be focused
     const shouldFocus =
-      (initialyPresentedScreenFocused === false && isEmpty(riverFocusData)) ||
-      isNotNil(riverFocusData[screenFocusableGroupId]) ||
+      (initialyPresentedScreenFocused === false && R.isEmpty(riverFocusData)) ||
+      R.compose(R.not, R.isNil)(riverFocusData[screenFocusableGroupId]) ||
       isDeepLink;
 
     // TODO: Uncommit it to start fixing bug where selection wrong item
@@ -138,6 +118,19 @@ export const riverFocusManager = (function () {
     }
   }
 
+  /**
+   * Create unique key that will be used for save focused group data inside specific screen
+   * @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 `RiverFocusableGroup-${screenId}${
+      R.isNil(isInsideContainer) ? "" : "-isInsideContainer"
+    }`;
+  }
+
   return {
     setScreenFocusableData,
     clearAllScreensData,

package/appUtils/accessibilityManager/const.ts

@@ -31,10 +31,6 @@ export const BUTTON_ACCESSIBILITY_KEYS = {
       hint: "accessibility_close_mini_hint",
     },
   },
-  back_to_live: {
-    label: "back_to_live_label",
-    hint: "",
-  },
   maximize: {
     label: "accessibility_maximize_label",
     hint: "accessibility_maximize_hint",

package/appUtils/accessibilityManager/utils.ts

@@ -35,6 +35,7 @@ export function calculateReadingTime(
     return 0;
   }
 
+  // Count words (split on whitespace and punctuation, keep alnum boundaries)
   const words = trimmed
     .split(/(?<=\d)(?=[a-zA-Z])|(?<=[a-zA-Z])(?=\d)|[^\w\s]+|\s+/)
     .filter(Boolean).length;

package/appUtils/contextKeysManager/__tests__/getKeys/failure.test.ts

@@ -1,12 +1,7 @@
-import { NativeModules } from "react-native";
 import { ContextKeysManager } from "../..";
 
 describe("Context Keys Manager - getKeys", () => {
-  beforeEach(() => {
-    delete NativeModules.ContextResolverBridge;
-  });
-
-  it("returns null if all keys are invalid 1", async () => {
+  it("returns null if all keys are invalid", async () => {
     // setup
     const keys = [null];
 
@@ -29,7 +24,7 @@ describe("Context Keys Manager - getKeys", () => {
     expect(getKey.mock.calls).toEqual([[null]]);
   });
 
-  it("returns null if all keys are invalid 2", async () => {
+  it("returns null if all keys are invalid", async () => {
     // setup
     const keys = [null, undefined];
 

package/appUtils/contextKeysManager/__tests__/getKeys/success.test.ts

@@ -1,11 +1,6 @@
-import { NativeModules } from "react-native";
 import { ContextKeysManager } from "../..";
 
 describe("Context Keys Manager - getKeys", () => {
-  beforeEach(() => {
-    delete NativeModules.ContextResolverBridge;
-  });
-
   it("returns value if found by getKey", async () => {
     // setup
     const keys = ["namespace.key"];
@@ -170,47 +165,4 @@ describe("Context Keys Manager - getKeys", () => {
     expect(getKey).toHaveBeenCalledTimes(2);
     expect(getKey.mock.calls).toEqual([[keys[0]], [keys[1]]]);
   });
-
-  it("returns values from native bridge when available", async () => {
-    // setup
-    const keys = ["namespace.key1", "namespace.key2"];
-
-    const contextObj = [
-      { key: keys[0], required: true },
-      { key: keys[1], required: false },
-    ];
-
-    const resolved = {
-      [keys[0]]: "value1",
-      [keys[1]]: "value2",
-    };
-
-    const reactNative = require("react-native");
-
-    const bridgeMock = {
-      resolveContextKeys: jest.fn().mockResolvedValue(resolved),
-    };
-
-    reactNative.__setContextResolverBridgeMock(bridgeMock);
-
-    const contextManager = new ContextKeysManager({});
-    const getKey = jest.spyOn(contextManager, "getKey");
-
-    // run
-    const result = await contextManager.getKeys(keys, contextObj);
-
-    // verify
-    const map = new Map();
-    map.set(keys[0], "value1");
-    map.set(keys[1], "value2");
-
-    expect(result).toEqual(map);
-
-    expect(bridgeMock.resolveContextKeys).toHaveBeenCalledWith({
-      [keys[0]]: true,
-      [keys[1]]: false,
-    });
-
-    expect(getKey).not.toHaveBeenCalled();
-  });
 });

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,10 +1,8 @@
 import { ContextKeysManager } from "./index";
-import { get, values } from "@applicaster/zapp-react-native-utils/utils";
+import * as R from "ramda";
+import * as _ from "lodash";
 import { useScreenStateStore } from "../../reactHooks/navigation/useScreenStateStore";
 
-const contextKeyPattern = /@{([^/]+)\/([^}]*)}/;
-const contextVariablePattern = /@\{([^}]*)\}/g;
-
 export interface IResolver {
   resolve: (string) => Promise<string | number | object>;
 }
@@ -22,7 +20,7 @@ export class EntryResolver implements IResolver {
       return this.entry;
     }
 
-    return get(this.entry, key.split("."));
+    return R.view(R.lensPath(key.split(".")), this.entry);
   }
 }
 
@@ -41,7 +39,7 @@ export class ScreenStateResolver implements IResolver {
     }
 
     if (key.includes(".")) {
-      return get(screenState, key.split("."));
+      return R.view(R.lensPath(key.split(".")), screenState);
     }
 
     return screenState?.[key];
@@ -63,16 +61,21 @@ export const resolveObjectValues = async (
 
   const resolvedEntries = await Promise.all(
     entries.map(async ([key, value]) => {
-      if (typeof value !== "string" || !value.startsWith("@")) {
+      if (typeof value !== "string") {
         return [key, value];
       }
 
-      const regex = contextKeyPattern;
+      if (!value.startsWith("@")) {
+        return [key, value];
+      }
+
+      const regex = /@{([^/]+)\/([^}]*)}/;
 
       const match = (value as string).match(regex);
 
       if (match) {
-        const [_, contextResolverName, compositeKey] = match;
+        const contextResolverName = match[1];
+        const compositeKey = match[2];
 
         const resolver = exResolvers[contextResolverName] || exResolvers.ctx;
         const resolvedValue = await resolver.resolve(compositeKey);
@@ -87,50 +90,18 @@ export const resolveObjectValues = async (
   return Object.fromEntries(resolvedEntries);
 };
 
-// Simple memoization cache
-const extractAtValuesCache = new Map<any, string[]>();
-
-const flatMapDeep = <T, U>(arr: T[], fn: (value: T) => U | U[]): U[] => {
-  const result: U[] = [];
+export const extractAtValues = _.memoize((input: any): string[] => {
+  return _.flatMapDeep(input, (value: any) => {
+    if (_.isString(value)) {
+      const matches = value.match(/@\{([^}]*)\}/g);
 
-  const flatten = (items: any) => {
-    for (const item of items) {
-      if (Array.isArray(item)) {
-        flatten(item);
-      } else {
-        result.push(item);
-      }
+      return matches ? matches.map((match) => match.slice(2, -1)) : [];
     }
-  };
-
-  flatten(arr.map(fn));
 
-  return result;
-};
-
-export const extractAtValues = (input: any): string[] => {
-  if (extractAtValuesCache.has(input)) {
-    return extractAtValuesCache.get(input)!;
-  }
-
-  const result = flatMapDeep(
-    Array.isArray(input) ? input : [input],
-    (value: any) => {
-      if (typeof value === "string") {
-        const matches = value.match(contextVariablePattern);
-
-        return matches ? matches.map((match) => match.slice(2, -1)) : [];
-      }
-
-      if (typeof value === "object" && value !== null) {
-        return extractAtValues(values(value));
-      }
-
-      return [];
+    if (_.isObject(value)) {
+      return extractAtValues(_.values(value));
     }
-  );
 
-  extractAtValuesCache.set(input, result);
-
-  return result;
-};
+    return [];
+  });
+});