@applicaster/zapp-react-native-utils 15.0.0-alpha.5412418016 → 15.0.0-alpha.5485312433

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/__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/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

@@ -102,7 +102,7 @@ export const getNavbarNode = (focusableTree) => {
 
 export const waitForContent = (focusableTree) => {
   const contentHasAnyChildren = (): boolean => {
-    const countOfChildren = pathOr(
+    const countOfChildren = pathOr<number>(
       0,
       ["children", "length"],
       getContentNode(focusableTree)

package/appUtils/focusManagerAux/utils/utils.ios.ts

@@ -1,7 +1,9 @@
-import { ReplaySubject } from "rxjs";
-import { filter } from "rxjs/operators";
+import { ReplaySubject, Subject } from "rxjs";
+import { filter, switchMap, take, withLatestFrom, map } from "rxjs/operators";
+
 import { BUTTON_PREFIX } from "@applicaster/zapp-react-native-ui-components/Components/MasterCell/DefaultComponents/tv/TvActionButtons/const";
 import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
+import { isPartOfMenu, isPartOfContent } from "./index.ios";
 
 type FocusableID = string;
 type RegistrationEvent = {
@@ -9,6 +11,25 @@ type RegistrationEvent = {
   registered: boolean;
 };
 
+let focusableViewRegistrationSubject$ = new Subject<{
+  id: FocusableID;
+  groupId: FocusableID;
+}>();
+
+let focusableGroupRegistrationSubject$ = new ReplaySubject<{
+  id: FocusableID;
+}>();
+
+let focusableNativeViewRegistrationSubject$ = new Subject<{
+  id: FocusableID;
+  groupId: FocusableID;
+}>();
+
+let focusableNativeGroupRegistrationSubject$ = new ReplaySubject<{
+  id: FocusableID;
+  groupId: FocusableID;
+}>();
+
 const isFocusableButton = (id: Option<FocusableID>): boolean =>
   id && id.includes?.(BUTTON_PREFIX);
 
@@ -22,14 +43,189 @@ export const focusableButtonsRegistration$ = (focusableGroupId: string) =>
     )
   );
 
-export const emitRegistered = (id: Option<FocusableID>): void => {
+export const resetFocusableRegistration = () => {
+  // complete the old subject so subscribers are notified and resources are freed
+  if (!focusableViewRegistrationSubject$.closed) {
+    focusableViewRegistrationSubject$.complete();
+  }
+
+  if (!focusableGroupRegistrationSubject$.closed) {
+    focusableGroupRegistrationSubject$.complete();
+  }
+
+  if (!focusableNativeViewRegistrationSubject$.closed) {
+    focusableNativeViewRegistrationSubject$.complete();
+  }
+
+  if (!focusableNativeGroupRegistrationSubject$.closed) {
+    focusableNativeGroupRegistrationSubject$.complete();
+  }
+
+  focusableViewRegistrationSubject$ = new Subject<{
+    id: FocusableID;
+    groupId: FocusableID;
+  }>();
+
+  focusableGroupRegistrationSubject$ = new ReplaySubject<{
+    id: FocusableID;
+  }>();
+
+  focusableNativeViewRegistrationSubject$ = new Subject<{
+    id: FocusableID;
+    groupId: FocusableID;
+  }>();
+
+  focusableNativeGroupRegistrationSubject$ = new ReplaySubject<{
+    id: FocusableID;
+    groupId: FocusableID;
+  }>();
+};
+
+const focusableNativeViewRegistration = ({ focusableView, focusableGroup }) => {
+  return focusableNativeViewRegistrationSubject$.pipe(
+    filter(
+      (focusableNativeView) => focusableNativeView.id === focusableView.id
+    ),
+    take(1),
+    switchMap((focusableNativeView) =>
+      // start waiting registration of its parent FocusableNativeGroup
+      focusableNativeGroupRegistrationSubject$.pipe(
+        filter(
+          (focusableNativeGroup) =>
+            focusableNativeGroup.id === focusableNativeView.groupId
+        ),
+        take(1),
+        map((focusableNativeGroup) => ({
+          focusableNativeGroup,
+          focusableNativeView,
+          focusableView,
+          focusableGroup,
+        }))
+      )
+    )
+  );
+};
+
+export const firstFocusableViewRegistrationFactory = () =>
+  focusableViewRegistrationSubject$.pipe(
+    take(1), // we care about only first FocusableView registration
+    switchMap((focusableView) =>
+      // start waiting registration of its parent FocusableGroup
+      focusableGroupRegistrationSubject$.pipe(
+        filter((focusableGroup) => focusableGroup.id === focusableView.groupId),
+        take(1),
+        map((focusableGroup) => ({
+          focusableView,
+          focusableGroup,
+        }))
+      )
+    ),
+    // start waiting registration for FocusableNativeView and its parent FocusableNativeGroup
+    switchMap(({ focusableView, focusableGroup }) =>
+      focusableNativeViewRegistration({
+        focusableView,
+        focusableGroup,
+      })
+    )
+  );
+
+// registration on RN level(into RN focusManager)
+export const emitRegistered = ({
+  id,
+  groupId,
+  isGroup,
+}: {
+  id: Option<FocusableID>;
+  groupId: Option<FocusableID>;
+  isGroup: boolean;
+}): void => {
   if (isFocusableButton(id)) {
     registeredSubject$.next({ id, registered: true });
   }
+
+  if (isGroup && id) {
+    focusableGroupRegistrationSubject$.next({ id });
+  }
+
+  if (!isGroup && id && groupId) {
+    focusableViewRegistrationSubject$.next({ id, groupId });
+  }
 };
 
+// unregistration on RN level(into RN focusManager)
 export const emitUnregistered = (id: Option<FocusableID>): void => {
   if (isFocusableButton(id)) {
     registeredSubject$.next({ id, registered: false });
   }
 };
+
+// registration focusableNativeView and focusableNativeGroup
+export const emitNativeRegistered = ({
+  id,
+  groupId,
+  isGroup,
+}: {
+  id: Option<FocusableID>;
+  groupId: Option<FocusableID>;
+  isGroup: boolean;
+}): void => {
+  if (!isGroup && id && groupId) {
+    focusableNativeViewRegistrationSubject$.next({ id, groupId });
+  }
+
+  if (isGroup && id && groupId) {
+    focusableNativeGroupRegistrationSubject$.next({ id, groupId });
+  }
+};
+
+// /////
+
+const focusedSubject$ = new Subject<FocusableID>();
+
+const focused$ = focusedSubject$.asObservable();
+
+export const emitFocused = (id: FocusableID): void => {
+  focusedSubject$.next(id);
+};
+
+export const topMenuItemFocused$ = focused$.pipe(
+  filter((id) => id && isPartOfMenu(focusManager.focusableTree, id))
+);
+
+export const contentFocused$ = focused$.pipe(
+  filter((id) => {
+    const isContent = isPartOfContent(focusManager.focusableTree, id);
+
+    return id && isContent;
+  })
+);
+
+const createFocusableRegistry = () => {
+  const subject$ = new ReplaySubject<FocusableID | undefined>(1);
+
+  return {
+    observable$: subject$.asObservable(),
+    register: (id: FocusableID) => {
+      // save focusable_id on registration
+      subject$.next(id);
+    },
+    unregister: () => {
+      // reset focusable_id on unregistration
+      subject$.next(undefined);
+    },
+  };
+};
+
+/// HOME_TOP_MENU_ITEM
+export const HomeTopMenuItemRegistry = createFocusableRegistry();
+
+export const homeTopMenuItemFocused$ = topMenuItemFocused$.pipe(
+  withLatestFrom(HomeTopMenuItemRegistry.observable$),
+  filter(([id, homeId]) => id === homeId)
+);
+
+/// SCREEN_PICKER
+export const ScreenPickerContentContainerRegistry = createFocusableRegistry();
+
+/// SEARCH_INPUT
+export const SearchInputRegistry = createFocusableRegistry();