@applicaster/zapp-react-native-utils 15.0.0-alpha.3752284136 → 15.0.0-alpha.3842304615

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/contextKeysManager/__tests__/getKeys/failure.test.ts

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

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

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

package/appUtils/contextKeysManager/index.ts

@@ -1,4 +1,4 @@
-import * as R from "ramda";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
 
 import { StorageLevel, StorageType } from "./consts";
 import {
@@ -13,6 +13,7 @@ import {
   localStorage as LocalStorage,
   secureStorage as SecureStorage,
 } from "./storage";
+import { NativeModules } from "react-native";
 
 export { StorageLevel };
 
@@ -154,11 +155,65 @@ export class ContextKeysManager {
   }
 
   public async getKeys(
-    keys: Array<KeyName>
+    keys: Array<KeyName>,
+    contextObj?: { key: string; required?: boolean }[]
   ): Promise<Map<KeyName, ValueOrNothing>> {
-    const values = await Promise.all(keys.map((key) => this.getKey(key)));
+    if (NativeModules.ContextResolverBridge) {
+      const keysObj: Record<string, boolean> = {};
 
-    return new Map(R.zip(keys, values));
+      const requiredByKey = new Map(
+        contextObj?.map((item) => [item.key, item.required ?? false]) ?? []
+      );
+
+      let hasResolvableKeys = false;
+
+      const normalizedKeys: Array<{
+        original: KeyName;
+        normalized: string | null;
+      }> = [];
+
+      for (const key of keys) {
+        const {
+          isValid: isValidKey,
+          key: parsedKey,
+          namespace: parsedNamespace,
+        } = this.parseKey(key);
+
+        if (!isValidKey) {
+          normalizedKeys.push({ original: key, normalized: null });
+          continue;
+        }
+
+        const normalized = buildNamespaceKey(parsedKey, parsedNamespace);
+
+        keysObj[normalized] = requiredByKey.get(normalized) ?? false;
+        hasResolvableKeys = true;
+        normalizedKeys.push({ original: key, normalized });
+      }
+
+      if (!hasResolvableKeys) {
+        return new Map(
+          normalizedKeys.map(({ original }) => [original, NOTHING])
+        );
+      }
+
+      const res =
+        await NativeModules.ContextResolverBridge.resolveContextKeys(keysObj);
+
+      const resolved = res ?? {};
+
+      return new Map(
+        normalizedKeys.map(({ original, normalized }) => {
+          if (!normalized) return [original, NOTHING];
+
+          return [original, resolved[normalized] ?? NOTHING];
+        })
+      );
+    } else {
+      const values = await Promise.all(keys.map((key) => this.getKey(key)));
+
+      return new Map(keys.map((key, index) => [key, values[index]]));
+    }
   }
 
   public async getKey(key: KeyName): Promise<ValueOrNothing> {
@@ -181,7 +236,7 @@ export class ContextKeysManager {
       parsedNamespace
     );
 
-    if (!R.isNil(resultByReference)) {
+    if (!isNil(resultByReference)) {
       return resultByReference;
     }
 
@@ -192,7 +247,7 @@ export class ContextKeysManager {
         parsedNamespace
       );
 
-      if (!R.isNil(resultFromSessionStorage)) {
+      if (!isNil(resultFromSessionStorage)) {
         return resultFromSessionStorage;
       }
 
@@ -201,7 +256,7 @@ export class ContextKeysManager {
         parsedNamespace
       );
 
-      if (!R.isNil(resultFromLocalStorage)) {
+      if (!isNil(resultFromLocalStorage)) {
         return resultFromLocalStorage;
       }
 
@@ -210,7 +265,7 @@ export class ContextKeysManager {
         parsedNamespace
       );
 
-      if (!R.isNil(resultFromSecureStorage)) {
+      if (!isNil(resultFromSecureStorage)) {
         return resultFromSecureStorage;
       }
 
@@ -275,7 +330,7 @@ export class ContextKeysManager {
       keysProp.map((keyProp) => this.setKey(keyProp))
     );
 
-    return new Map(R.zip(keys, values));
+    return new Map(keys.map((key, index) => [key, values[index]]));
   }
 
   // when succeed saving - return true
@@ -384,7 +439,7 @@ export class ContextKeysManager {
   public async removeKeys(keys: KeyName[]): Promise<Map<KeyName, boolean>> {
     const values = await Promise.all(keys.map((key) => this.removeKey(key)));
 
-    return new Map(R.zip(keys, values));
+    return new Map(keys.map((key, index) => [key, values[index]]));
   }
   // REMOVE
 }

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