@applicaster/zapp-react-native-utils 15.1.0-rc.1 → 16.0.0-alpha.9803580571

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/__tests__/__snapshots__/focusManager.test.js.snap

@@ -71,6 +71,9 @@ exports[`focusManagerIOS should be defined 1`] = `
   "invokeHandler": [Function],
   "isChildOf": [Function],
   "isFocusOn": [Function],
+  "isFocusOnContent": [Function],
+  "isFocusOnMenu": [Function],
+  "isFocusOnTabsScreenContent": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],
   "on": [Function],

package/appUtils/focusManager/index.ios.ts

@@ -4,7 +4,11 @@ import * as R from "ramda";
 import {
   isCurrentFocusOn,
   isChildOf as isChildOfUtils,
-} from "../focusManagerAux/utils";
+  isPartOfMenu,
+  isPartOfContent,
+  isPartOfTabsScreenContent,
+} from "../focusManagerAux/utils/index.ios";
+
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
@@ -188,9 +192,15 @@ export const focusManager = (function () {
   function register({ id, component }) {
     const { isGroup = false } = component;
 
-    emitRegistered(id);
+    if (isGroup) {
+      registerGroup(id, component);
+    } else {
+      registerItem(id, component);
+    }
 
-    return isGroup ? registerGroup(id, component) : registerItem(id, component);
+    const groupId = component?.props?.groupId;
+
+    emitRegistered({ id, groupId, isGroup });
   }
 
   function unregister(id, { group = false } = {}) {
@@ -273,7 +283,9 @@ export const focusManager = (function () {
   function setFocus(
     id: string,
     direction?: FocusManager.IOS.Direction,
-    options?: Partial<{ groupFocusedChanged: boolean }>,
+    options?: Partial<{
+      groupFocusedChanged: boolean;
+    }>,
     callback?: any
   ) {
     blur(direction);
@@ -412,6 +424,30 @@ export const focusManager = (function () {
     return id && isCurrentFocusOn(id, currentFocusNode);
   }
 
+  function isFocusOnMenu(): boolean {
+    const currentFocusable = getCurrentFocus();
+
+    return isPartOfMenu(focusableTree, currentFocusable?.props?.id);
+  }
+
+  function isFocusOnContent(): boolean {
+    const currentFocusable = getCurrentFocus();
+
+    return isPartOfContent(focusableTree, currentFocusable?.props?.id);
+  }
+
+  function isFocusOnTabsScreenContent(
+    screenPickerContentContainerId: string
+  ): boolean {
+    const currentFocusable = getCurrentFocus();
+
+    return isPartOfTabsScreenContent(
+      focusableTree,
+      screenPickerContentContainerId,
+      currentFocusable?.props?.id
+    );
+  }
+
   function isChildOf(childId, parentId): boolean {
     return isChildOfUtils(focusableTree, childId, parentId);
   }
@@ -438,6 +474,9 @@ export const focusManager = (function () {
     isGroupItemFocused,
     getPreferredFocusChild,
     isFocusOn,
+    isFocusOnMenu,
+    isFocusOnContent,
+    isFocusOnTabsScreenContent,
     isChildOf,
   };
 })();

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/focusManagerAux/utils/index.ios.ts

@@ -0,0 +1,122 @@
+import { isNil, startsWith } from "@applicaster/zapp-react-native-utils/utils";
+
+import {
+  QUICK_BRICK_CONTENT,
+  QUICK_BRICK_NAVBAR,
+} from "@applicaster/quick-brick-core/const";
+
+const isNavBar = (node) => startsWith(QUICK_BRICK_NAVBAR, node?.id);
+const isContent = (node) => startsWith(QUICK_BRICK_CONTENT, node?.id);
+const isRoot = (node) => node?.id === "root";
+
+export const isPartOfTabsScreenContent = (
+  focusableTree,
+  screenPickerContentContainerId,
+  id
+) => {
+  const node = focusableTree.findInTree(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  if (node?.id === screenPickerContentContainerId) {
+    return true;
+  }
+
+  return isPartOfTabsScreenContent(
+    focusableTree,
+    screenPickerContentContainerId,
+    node.parent?.id
+  );
+};
+
+export const isPartOfMenu = (focusableTree, id): boolean => {
+  const node = focusableTree.findInTree(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return true;
+  }
+
+  if (isContent(node)) {
+    return false;
+  }
+
+  return isPartOfMenu(focusableTree, node.parent?.id);
+};
+
+export const isPartOfContent = (focusableTree, id) => {
+  const node = focusableTree.findInTree(id);
+
+  if (isNil(node)) {
+    return false;
+  }
+
+  if (isRoot(node)) {
+    return false;
+  }
+
+  if (isNavBar(node)) {
+    return false;
+  }
+
+  if (isContent(node)) {
+    return true;
+  }
+
+  return isPartOfContent(focusableTree, node.parent?.id);
+};
+
+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);
+};
+
+export const isChildOf = (focusableTree, childId, parentId) => {
+  if (isNil(childId) || isNil(parentId)) {
+    return false;
+  }
+
+  const childNode = focusableTree.findInTree(childId);
+
+  if (isNil(childNode)) {
+    return false;
+  }
+
+  if (childNode.parent?.id === parentId) {
+    return true;
+  }
+
+  return isChildOf(focusableTree, childNode.parent?.id, parentId);
+};

package/appUtils/focusManagerAux/utils/index.ts

@@ -100,7 +100,7 @@ export const getNavbarNode = (focusableTree) => {
 
 export const waitForContent = (focusableTree) => {
   const contentHasAnyChildren = (): boolean => {
-    const countOfChildren = pathOr(
+    const countOfChildren = pathOr<number>(
       0,
       ["children", "length"],
       getContentNode(focusableTree)
@@ -142,6 +142,10 @@ export const isTabsScreenOnContentFocused = (node) => {
 };
 
 export const isCurrentFocusOnMenu = (node) => {
+  if (isNil(node)) {
+    return false;
+  }
+
   if (isRoot(node)) {
     return false;
   }
@@ -154,10 +158,14 @@ export const isCurrentFocusOnMenu = (node) => {
     return false;
   }
 
-  return isCurrentFocusOnMenu(node.parent);
+  return isCurrentFocusOnMenu(node?.parent);
 };
 
 export const isCurrentFocusOnContent = (node) => {
+  if (isNil(node)) {
+    return false;
+  }
+
   if (isRoot(node)) {
     return false;
   }
@@ -170,7 +178,7 @@ export const isCurrentFocusOnContent = (node) => {
     return true;
   }
 
-  return isCurrentFocusOnContent(node.parent);
+  return isCurrentFocusOnContent(node?.parent);
 };
 
 export const isCurrentFocusOn = (id, node) => {