@applicaster/zapp-react-native-utils 15.0.0-alpha.2210035610 → 15.0.0-alpha.2220425501

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

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/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 = () => {