@applicaster/zapp-react-native-utils 13.0.0-alpha.7019824418 → 13.0.0-alpha.7048001189

package/actionsExecutor/ActionExecutorContext.tsx

@@ -1,6 +1,6 @@
 /// <reference types="@applicaster/applicaster-types" />
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
-import React, { createContext, useMemo } from "react";
+import React, { createContext, useEffect, useMemo } from "react";
 import {
   actionExecutor as _actionExecutor,
   ActionResult,
@@ -19,8 +19,15 @@ import {
   EntryResolver,
   resolveObjectValues,
 } from "../appUtils/contextKeysManager/contextResolver";
+import { useNavigation } from "../reactHooks";
+import { get } from "lodash";
 
-const { log_error, log_info } = createLogger({
+import {
+  useContentTypes,
+  usePickFromState,
+} from "@applicaster/zapp-react-native-redux/hooks";
+
+export const { log_error, log_info, log_debug } = createLogger({
   subsystem: "ActionExecutorContext",
   category: "General",
 });
@@ -51,6 +58,22 @@ type Props = {
   children: React.ReactNode;
 };
 
+function findParentComponent(
+  childId: string,
+  parent: ZappRiver | ZappUIComponent
+): ZappRiver | ZappUIComponent | null {
+  for (const child of parent.ui_components) {
+    if (child.id === childId) return parent;
+
+    if (child.ui_components) {
+      const found = findParentComponent(childId, child);
+      if (found) return found;
+    }
+  }
+
+  return null;
+}
+
 const prepareDefaultActions = (actionExecutor) => {
   actionExecutor.registerAction("localStorageSet", async (action) => {
     const namespaces = action.options.content;
@@ -65,11 +88,13 @@ const prepareDefaultActions = (actionExecutor) => {
     async (_action, context) => {
       const dispatch = appStore.getDispatch();
 
-      log_info("handleAction: refreshComponent event");
+      const dataSource =
+        context?.component?.data?.source ||
+        findParentComponent(context?.component.id, context?.screenData)?.data
+          ?.source;
 
-      const dataSource = context?.component?.data?.source;
+      log_info(`handleAction: refreshComponent for dataSource:${dataSource}`);
 
-      // TODO: Later we can pass component ids to do refresh instead of current one
       // TODO: In theory we should wait callback to complete, before completing the action, but now it's not needed
       // TODO: handle focused item removal
       dispatch(
@@ -169,8 +194,29 @@ const prepareDefaultActions = (actionExecutor) => {
       action: ActionType,
       context?: Record<string, any>
     ): Promise<ActionResult> => {
+      if (!context) {
+        log_error(
+          "handleAction: localStorageToggleFlag action missing context"
+        );
+
+        return ActionResult.Error;
+      }
+
+      const entry = context?.entry as ZappEntry;
+
+      if (!entry) {
+        log_error(
+          "handleAction: localStorageToggleFlag action missing entry. Entry is required to get the tag."
+        );
+
+        return ActionResult.Error;
+      }
+
+      const tag = action.options?.selector
+        ? get(entry, action.options.selector)
+        : (entry.extensions?.tag ?? entry.id);
+
       const keyNamespace = action.options?.key;
-      const tag = context?.entry?.extensions?.tag;
 
       if (keyNamespace && tag) {
         const multiSelectProvider =
@@ -188,6 +234,16 @@ const prepareDefaultActions = (actionExecutor) => {
         if (selectedItems.includes(tag)) {
           await multiSelectProvider.removeItem(tag);
         } else {
+          const maxItems = action.options?.max_items;
+
+          if (maxItems && selectedItems.length >= maxItems) {
+            log_info(
+              `handleAction: localStorageToggleFlag event reached max items limit: ${maxItems}, cannot add tag: ${tag}`
+            );
+
+            return ActionResult.Cancel;
+          }
+
           await multiSelectProvider.addItem(tag);
         }
       } else {
@@ -211,6 +267,10 @@ export function withActionExecutor(Component) {
   prepareDefaultActions(_actionExecutor);
 
   return function ActionExecutorComponent(props: Props) {
+    const navigator = useNavigation();
+    const { rivers } = usePickFromState(["rivers"]);
+    const contentTypes = useContentTypes();
+
     const handlers = useMemo(() => {
       return {
         unregisterAction: _actionExecutor.unregisterAction,
@@ -221,6 +281,44 @@ export function withActionExecutor(Component) {
       };
     }, []);
 
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        "navigateToScreen",
+        async (action: ActionType, context?: Record<string, any>) => {
+          const screenType = action.options?.typeMapping;
+
+          if (!screenType) {
+            log_error("navigateToScreen: typeMapping option is missing");
+
+            return ActionResult.Error;
+          }
+
+          const screenId = contentTypes?.[screenType]?.screen_id || null;
+
+          if (!screenId) {
+            log_error(
+              `navigateToScreen: can not resolve screen type mapping: ${screenType}`
+            );
+
+            return ActionResult.Error;
+          }
+
+          const river = rivers[screenId];
+
+          if (!river) {
+            log_error("navigateToScreen: can not resolve river");
+
+            return ActionResult.Error;
+          }
+
+          context?.callback?.({ success: false, error: null, abort: true });
+          navigator.replace(river);
+
+          return ActionResult.Success;
+        }
+      );
+    }, [navigator, rivers, contentTypes]);
+
     return (
       <ActionExecutorContext.Provider value={handlers}>
         <Component {...props} />

package/analyticsUtils/currentScreenProperities.ts

@@ -72,12 +72,14 @@ const mappedScreenPropertiesScreen = (
   screenData
 ): AnalyticsScreenProperties => {
   return {
-    screen_name: screenData?.targetScreen?.name,
+    screen_name: screenData?.targetScreen?.name || screenData?.name,
     screen_entry_title: screenData?.title,
     screen_entry_id: R.isNil(screenData?.type) ? null : screenData?.id,
-    screen_layout_id: screenData?.targetScreen?.id,
-    screen_type: screenData?.targetScreen?.type,
-    home_screen: screenData?.targetScreen?.home,
+    screen_layout_id: screenData?.targetScreen?.id || screenData?.id,
+    screen_type: screenData?.targetScreen?.type || screenData?.type,
+    home_screen: !R.isNil(screenData?.targetScreen?.home)
+      ? screenData?.targetScreen?.home
+      : screenData?.home,
   };
 };
 

package/appUtils/HooksManager/Hook.ts

@@ -65,6 +65,10 @@ export class Hook implements HookInterface {
     event: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS],
     ...args
   ) {
+    if (this.state === hookState(HOOKS_EVENTS.CANCEL)) {
+      return;
+    }
+
     this.state = hookState(event);
     this.manager.subscriber.invokeHandler(event, ...args);
   }

package/appUtils/HooksManager/index.ts

@@ -84,7 +84,7 @@ export function HooksManager({
   plugins,
   startUpHooksData = {},
 }: HookManagerArgs): HookManager {
-  hooksManagerLogger.addContext({ targetScreen });
+  hooksManagerLogger.addContext({ targetScreenId: targetScreen.id });
 
   function logHookEvent(func, message, data) {
     func({
@@ -269,6 +269,7 @@ export function HooksManager({
       payload = initialPayload,
       callback: callbackArg,
       cancelled,
+      abort,
     }) {
       let callback = callbackArg;
 
@@ -308,6 +309,7 @@ export function HooksManager({
         hookPlugin.setStateAndNotify(HOOKS_EVENTS.CANCEL, {
           hookPlugin,
           payload,
+          abort,
         });
 
         const isHookInHomescreen = payload?.home;

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,12 +1,6 @@
-import { createLogger } from "../../logger";
 import { ContextKeysManager } from "./index";
 import * as R from "ramda";
 
-const { log_error } = createLogger({
-  subsystem: "contextResolver",
-  category: "General",
-});
-
 interface IResolver {
   resolve: (string) => Promise<string | number | object>;
 }
@@ -64,12 +58,7 @@ export const resolveObjectValues = async (
         return [key, resolvedValue];
       }
 
-      log_error("resolveObjectValues: invalid context string", {
-        key,
-        value,
-      });
-
-      return [key, null];
+      return [key, value];
     })
   );
 

package/appUtils/focusManager/__tests__/__snapshots__/focusManager.test.js.snap

@@ -5,6 +5,7 @@ exports[`focusManager should be defined 1`] = `
   "blur": [Function],
   "disableFocus": [Function],
   "enableFocus": [Function],
+  "findPreferredFocusChild": [Function],
   "focusableTree": Tree {
     "loadingCounter": 0,
     "root": {
@@ -33,7 +34,6 @@ exports[`focusManager should be defined 1`] = `
   "recoverFocus": [Function],
   "register": [Function],
   "removeHandler": [Function],
-  "resetFocus": [Function],
   "setFocus": [Function],
   "setInitialFocus": [Function],
   "unregister": [Function],

package/appUtils/focusManager/__tests__/focusManager.test.js

@@ -1,6 +1,5 @@
 import { focusManager } from "../index.ts";
 import { focusManager as focusManagerIOS } from "../index.ios.ts";
-import { findFirstFocusableItem } from "../utils";
 
 describe("focusManagerIOS", () => {
   it("should be defined", () => {
@@ -9,67 +8,6 @@ describe("focusManagerIOS", () => {
   });
 });
 
-const focusableTree = {
-  root: {
-    children: [
-      {
-        children: [
-          {
-            children: [
-              {
-                children: [],
-                component: {
-                  isGroup: true,
-                },
-                id: "route/1/1",
-              },
-              {
-                children: [],
-                component: {
-                  isGroup: true,
-                },
-                id: "route/1/2",
-              },
-            ],
-            component: {
-              isGroup: true,
-            },
-            id: "route/1",
-          },
-          {
-            children: [
-              {
-                children: [],
-                component: {
-                  isGroup: true,
-                },
-                id: "route/2/1",
-              },
-              {
-                children: [],
-                component: {
-                  isGroup: false,
-                },
-                id: "route/2/2",
-              },
-            ],
-            component: {
-              isGroup: true,
-            },
-            id: "route/2",
-          },
-        ],
-        component: {
-          isGroup: true,
-        },
-        id: "/river/1234",
-      },
-    ],
-    component: null,
-    id: "root",
-  },
-};
-
 describe("focusManager", () => {
   it("should be defined", () => {
     expect(focusManager).toBeDefined();
@@ -107,24 +45,4 @@ describe("focusManager", () => {
   it("placeholder test", () => {
     expect(true).toBe(true);
   });
-
-  it("findFirstFocusableItem returns focusableItem", () => {
-    const expectedItemId =
-      focusableTree.root.children[0].children[1].children[1].id;
-
-    const focusableItem = findFirstFocusableItem(focusableTree.root.children);
-
-    expect(
-      focusableItem !== undefined && expectedItemId === focusableItem.id
-    ).toBe(true);
-  });
-
-  it("findFirstFocusableItem does not return focusableItem", () => {
-    focusableTree.root.children[0].children[1].children[1].component.isGroup =
-      true;
-
-    const focusableItem = findFirstFocusableItem(focusableTree.root.children);
-
-    expect(focusableItem === undefined).toBe(true);
-  });
 });

package/appUtils/focusManager/__tests__/index.test.ts

@@ -30,7 +30,6 @@ describe("focusManager", () => {
       "isGroupItemFocused",
       "recoverFocus",
       "isCurrentFocusOnTheTopScreen",
-      "resetFocus",
     ];
 
     expectedMethods.forEach((method) => {

package/appUtils/focusManager/index.ts

@@ -13,7 +13,6 @@ import {
 import { subscriber } from "../../functionUtils";
 import { coreLogger } from "../../logger";
 import { ACTION } from "./utils/enums";
-import { findFirstFocusableItem } from "./utils";
 
 const logger = coreLogger.addSubsystem("focusManager");
 
@@ -335,16 +334,7 @@ export const focusManager = (function () {
     return { success: false };
   }
 
-  function treeLoaded(val, node) {
-    logger.log({
-      message: "treeLoaded",
-      data: {
-        val,
-        node,
-        currentFocusNode,
-      },
-    });
-  }
+  function treeLoaded(_val, _node) {}
 
   function pressIn() {
     const currentFocusable = getCurrentFocus();
@@ -493,29 +483,20 @@ export const focusManager = (function () {
     return haveSameParentBeforeRoot(currentFocusNode, R.last(routes));
   }
 
-  function resetFocus() {
+  function recoverFocus() {
     if (!isCurrentFocusOnTheTopScreen()) {
-      // We've failed to set focused node on the new screen => run focus reset
+      // We've failed to set focused node on the new screen => run focus recovery
       setInitialFocus();
     }
   }
 
-  /**
-   * sets the focus on first focusable item
-   * @public
-   */
-  function recoverFocus() {
-    const focusableItem = findFirstFocusableItem(focusableTree.root.children);
-    focusableItem && setFocus(focusableItem.id);
-  }
-
   /**
    * moves the focus in a provided direction
    * @public
    * @param {Object} direction of the scroll
    */
   function moveFocus(direction) {
-    if (!isCurrentFocusOnTheTopScreen() && currentFocusNode) {
+    if (!isCurrentFocusOnTheTopScreen()) {
       // We are opening new screen. We need to ignore movement of focus.
       return false;
     }
@@ -538,8 +519,6 @@ export const focusManager = (function () {
       } else {
         currentFocusNode.component.failedLostFocus(currentFocusNode, direction);
       }
-    } else {
-      recoverFocus();
     }
   }
 
@@ -555,6 +534,18 @@ export const focusManager = (function () {
 
   const { on, invokeHandler, removeHandler } = eventHandler;
 
+  function findPreferredFocusChild(id) {
+    const node = getCurrentFocusNode(id);
+
+    const preferredFocus = findPriorityItem([node]);
+
+    if (isNilOrEmpty(preferredFocus)) {
+      return undefined;
+    }
+
+    return preferredFocus[0];
+  }
+
   /**
    * this is the list of the functions available externally
    * when importing the focus manager
@@ -584,6 +575,6 @@ export const focusManager = (function () {
     isGroupItemFocused,
     recoverFocus,
     isCurrentFocusOnTheTopScreen,
-    resetFocus,
+    findPreferredFocusChild,
   };
 })();

package/appUtils/focusManager/utils/index.ts

@@ -98,17 +98,3 @@ export const waitForContent = (focusableTree) => {
     conditionFn: contentHasAnyChildren,
   });
 };
-
-export const findFirstFocusableItem = (items) => {
-  for (const item of items) {
-    if (!item.component.isGroup) {
-      return item;
-    } else {
-      if (item.children) {
-        const focusableItem = findFirstFocusableItem(item.children);
-
-        if (focusableItem) return focusableItem;
-      }
-    }
-  }
-};

package/appUtils/focusManagerAux/index.ts

@@ -54,7 +54,7 @@ export async function setFocusOnContent(currentRoute: string) {
   // For doing it we have to wait registration of first focusable node into focusableTree
   // we wait until content node starts having children
 
-  const { setInitialFocus, focusableTree, getCurrentFocus } = focusManager;
+  const { setInitialFocus, focusableTree } = focusManager;
 
   try {
     await waitForActiveScreen(currentRoute, focusableTree);
@@ -71,6 +71,6 @@ export async function setFocusOnContent(currentRoute: string) {
       );
     }
   } catch (error) {
-    !getCurrentFocus() && setFocusOnContent(currentRoute);
+    setFocusOnContent(currentRoute);
   }
 }

package/appUtils/keyCodes/index.ts

@@ -1,5 +1,3 @@
-import * as R from "ramda";
-
 // more keys can be added here. Simply make sure
 // the key matches the code value
 
@@ -34,12 +32,18 @@ export function keyCode(key) {
   keyCode(keyEvent).matchesAny("Enter", "Backspace", KEYS.ArrowLeft, ...)
   */
 
-  const matches = R.compose(
-    R.either(R.eqProps("code", key), R.eqProps("keyCode", key)),
-    R.when(R.is(String), R.prop(R.__, KEYS))
-  );
+  const matches = (compareKey) => {
+    // If compareKey is a string, look it up in KEYS object
+    const keyToCompare =
+      typeof compareKey === "string" ? KEYS[compareKey] : compareKey;
+
+    // Compare either code or keyCode properties
+    return (
+      keyToCompare?.code === key.code || keyToCompare?.keyCode === key.keyCode
+    );
+  };
 
-  const matchesAny = (...args) => R.any(matches, args);
+  const matchesAny = (...args) => args.some(matches);
 
   const direction = () =>
     matchesAny(...ARROW_KEYS) ? directionHelper(key) : null;

package/appUtils/orientationHelper.ts

@@ -1,8 +1,8 @@
-/// <reference types="@types/react-native" />
 import * as ReactNative from "react-native";
-import { isTV, platformSelect } from "../reactUtils";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
-import { useIsTablet } from "@applicaster/zapp-react-native-utils/reactHooks/device/useIsTablet";
+
+import { isTV, platformSelect } from "../reactUtils";
+import { useIsTablet } from "../reactHooks";
 
 import {
   QUICK_BRICK_EVENTS,
@@ -121,8 +121,15 @@ export const removeOrientationChangeListener = (listener: any): void => {
  */
 export const isOrientationCompatible = ({
   orientation,
-  layoutData: { width, height },
+  layoutData: { width, height, isTablet, isTabletPortrait },
 }) => {
+  // We count portrait as compatible, because if default in zapp for mobile layout
+  // We count landscape as compatible, because if isTabletPortrait is false,
+  // it defaults for device
+  if (isTablet && !isTabletPortrait) {
+    return true;
+  }
+
   const isLandscape = width > height;
 
   if (
@@ -146,15 +153,6 @@ export const isOrientationCompatible = ({
   return true;
 };
 
-export const useIsOrientationCompatible = (orientation) => {
-  const { height, width } = ReactNative.useWindowDimensions();
-
-  return isOrientationCompatible({
-    orientation,
-    layoutData: { width, height },
-  });
-};
-
 /**
  * Determine final screen orientation based on device type,
  * settings and orientation value provided by screen data settings

package/appUtils/playerManager/index.ts

@@ -452,7 +452,7 @@ export class PlayerManager {
     if (this.castingReceiver) {
       this.castingReceiver.closeNativePlayer();
     } else {
-      this.getActivePlayer().closeNativePlayer();
+      this.getActivePlayer()?.closeNativePlayer();
       this.invokeHandler("close");
     }
   }

package/appUtils/playerManager/player.ts

@@ -97,7 +97,7 @@ export class Player {
     this.onVideoLoad = this.onVideoLoad.bind(this);
     this.isFullScreenSupported = this.isFullScreenSupported.bind(this);
     this.onPlayerSeekComplete = this.onPlayerSeekComplete.bind(this);
-
+    this.onAdBreakEnd = this.onAdBreakEnd.bind(this);
     this.entryObservable = null;
   }
 
@@ -201,17 +201,25 @@ export class Player {
         adPosition: currentTime,
       };
     } else {
-      if (!isEmptyOrNil(seekableDuration) && seekableDuration >= 0) {
-        this.playerState.seekableDuration = seekableDuration;
-      }
+      this.updateContentDuration({ seekableDuration, duration, currentTime });
+    }
+  };
 
-      if (!isEmptyOrNil(duration) && duration >= 0) {
-        this.playerState.contentDuration = duration;
-      }
+  protected updateContentDuration = ({
+    seekableDuration = null,
+    duration = null,
+    currentTime = null,
+  }) => {
+    if (!isEmptyOrNil(seekableDuration) && seekableDuration >= 0) {
+      this.playerState.seekableDuration = seekableDuration;
+    }
 
-      if (!isEmptyOrNil(currentTime) && currentTime >= 0) {
-        this.playerState.contentPosition = currentTime;
-      }
+    if (!isEmptyOrNil(duration) && duration >= 0) {
+      this.playerState.contentDuration = duration;
+    }
+
+    if (!isEmptyOrNil(currentTime) && currentTime >= 0) {
+      this.playerState.contentPosition = currentTime;
     }
   };
 
@@ -559,7 +567,7 @@ export class Player {
     });
   };
 
-  onAdBreakEnd = (event) => {
+  onAdBreakEnd(event) {
     this.playerState.adState = null;
     this.playerState.isInAdBreak = false;
 
@@ -567,7 +575,7 @@ export class Player {
       callbackName: SharedPlayerCallBacksKeys.OnAdBreakEnd,
       event,
     });
-  };
+  }
 
   onAdEnd = (event) => {
     this.playerState.adState = null;
@@ -736,6 +744,10 @@ export class Player {
     return null;
   };
 
+  public hasResumePosition() {
+    return false;
+  }
+
   public getConfig = () => this.config;
 
   // TODO: replace with enum of supported orientations