@applicaster/zapp-react-native-utils 15.0.0-rc.99 → 15.1.0-rc.1

package/actionsExecutor/ActionExecutorContext.tsx

@@ -23,9 +23,12 @@ import {
   EntryResolver,
   resolveObjectValues,
 } from "../appUtils/contextKeysManager/contextResolver";
-import { useNavigation, useRivers } from "../reactHooks";
+import { useNavigation } from "../reactHooks";
 
-import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  useContentTypes,
+  usePickFromState,
+} from "@applicaster/zapp-react-native-redux/hooks";
 import { useSubscriberFor } from "../reactHooks/useSubscriberFor";
 import { APP_EVENTS } from "../appUtils/events";
 import {
@@ -164,7 +167,7 @@ const prepareDefaultActions = (actionExecutor) => {
 
       const entry = context?.entry || {};
       const entryResolver = new EntryResolver(entry);
-      const screenData = context?.screenStateStore.getState().data || {};
+      const screenData = context?.screenStateStore?.getState().data || {};
       const screenResolver = new EntryResolver(screenData || {});
 
       const data =
@@ -275,7 +278,7 @@ export function withActionExecutor(Component) {
 
   return function ActionExecutorComponent(props: Props) {
     const navigator = useNavigation();
-    const rivers = useRivers();
+    const { rivers } = usePickFromState(["rivers"]);
     const contentTypes = useContentTypes();
 
     const handlers = useMemo(() => {
@@ -315,6 +318,44 @@ export function withActionExecutor(Component) {
             return ActionResult.Error;
           }
 
+          const navigationAction = action.options?.navigationAction;
+          const entrySource = action.options?.entry;
+
+          const entry = entrySource
+            ? entrySource === "@{entry/}"
+              ? context?.entry
+              : entrySource
+            : null;
+
+          if (entry) {
+            if (typeof entry !== "object") {
+              log_error(
+                `navigateToScreen: entry option is not an object, entry: ${entry}`
+              );
+
+              return ActionResult.Error;
+            }
+
+            log_info(
+              `navigateToScreen: navigating to screen type: ${screenType} with entry id: ${entry.id}`
+            );
+
+            const overriddenEntry = {
+              ...entry,
+              type: {
+                value: screenType,
+              },
+            };
+
+            if (navigationAction === "push") {
+              navigator.push(overriddenEntry);
+            } else {
+              navigator.replace(overriddenEntry);
+            }
+
+            return ActionResult.Success;
+          }
+
           const screenId = contentTypes?.[screenType]?.screen_id || null;
 
           if (!screenId) {
@@ -334,7 +375,12 @@ export function withActionExecutor(Component) {
           }
 
           context?.callback?.({ success: false, error: null, abort: true });
-          navigator.replace(river);
+
+          if (navigationAction === "push") {
+            navigator.push(river);
+          } else {
+            navigator.replace(river);
+          }
 
           return ActionResult.Success;
         }

package/actionsExecutor/feedDecorator.ts

@@ -27,7 +27,7 @@ function makeMultiSelect(feed: ZappFeed, key, decoratedFeed) {
   );
 
   const behavior = {
-    ...feed.extensions?.behavior,
+    ...feed.extensions?.["behavior"],
     select_mode: "multi",
     current_selection: `@{${scope}/${key}}`,
   };
@@ -75,7 +75,7 @@ function makeSingleSelect(feed: ZappFeed, key, decoratedFeed) {
   );
 
   const behavior = {
-    ...feed.extensions?.behavior,
+    ...feed.extensions?.["behavior"],
     select_mode: "single",
     current_selection: `@{${scope}/${key}}`,
   };
@@ -141,11 +141,11 @@ function makeSingleSelect(feed: ZappFeed, key, decoratedFeed) {
 }
 
 export const decorateFeed = (feed: ZappFeed) => {
-  if (!(feed.extensions?.role === "preference_editor")) {
+  if (!(feed.extensions?.["role"] === "preference_editor")) {
     return feed;
   }
 
-  const key = feed.extensions?.preference_editor_options?.key;
+  const key = feed.extensions?.["preference_editor_options"]?.["key"];
 
   if (!key) {
     log_error(
@@ -160,8 +160,8 @@ export const decorateFeed = (feed: ZappFeed) => {
   const decoratedFeed = R.clone(feed);
 
   const isSingleSelect =
-    (feed.extensions?.preference_editor_options?.select_mode ||
-      feed.extensions?.behavior?.select_mode) === "single";
+    (feed.extensions?.["preference_editor_options"]?.select_mode ||
+      feed.extensions?.["behavior"]?.select_mode) === "single";
 
   if (isSingleSelect) {
     return makeSingleSelect(feed, key, decoratedFeed);

package/adsUtils/index.ts

@@ -33,10 +33,10 @@ function convertOffset(offset: any): string {
 }
 
 function createAdBreak(ad: AdMap): string {
-  const offset = ad.offset;
+  const offset = ad["offset"];
   const id = offset.toString();
   const timestamp = convertOffset(offset);
-  const url = ad.ad_url.toString().trim();
+  const url = ad["ad_url"].toString().trim();
 
   return `
     <vmap:AdBreak timeOffset="${timestamp}" breakType="linear" breakId="break-${id}">

package/analyticsUtils/README.md

@@ -388,7 +388,7 @@ export function AnalyticsProvider(props: ComponentWithChildrenProps) {
 
 ```ts
 export function useAnalytics(props: any): any {
-  const appData = useAppData();
+  const { appData } = usePickFromState(["appData"]);
   const getAnalyticsFunctions = React.useContext(AnalyticsContext);
 
   const analyticsFunctions = React.useMemo(

package/appUtils/HooksManager/__tests__/__snapshots__/hooksManager.test.js.snap

@@ -1,5 +1,193 @@
 // 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,23 +116,9 @@ describe("HooksManager", () => {
         headlessPlayerHook.configuration
       );
 
-      expect(successHandler).toHaveBeenCalledTimes(1);
-      expect(successHandler.mock.calls[0][0].payload).toEqual(payload);
-
-      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(successHandler.mock.calls[0]).toMatchSnapshot();
 
-      expect(typeof completeHandler.mock.calls[0][1]).toBe("function");
+      expect(completeHandler.mock.calls[0]).toMatchSnapshot();
     });
   });
 

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
@@ -230,7 +234,7 @@ export function HooksManager({
   function completeHook(hookPlugin, payload, callback) {
     logHookEvent(
       hooksManagerLogger.info,
-      `completeHook: hook sequence completed successfully: ${hookPlugin.identifier}`,
+      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
       {
         payload,
         hook: hookPlugin,
@@ -276,10 +280,12 @@ export function HooksManager({
       if (hookPlugin.isCancelled()) {
         logHookEvent(
           hooksManagerLogger.info,
-          `hookCallback: hook was cancelled: ${hookPlugin.identifier}`,
+          `hookCallback: hook was cancelled: ${hookPlugin["identifier"]}`,
           {}
         );
 
+        actionExecutor.unregisterAction("finishHook");
+
         return;
       }
 
@@ -294,6 +300,8 @@ export function HooksManager({
           }
         );
 
+        actionExecutor.unregisterAction("finishHook");
+
         return hookPlugin.setStateAndNotify(HOOKS_EVENTS.ERROR, {
           error,
           hookPlugin,
@@ -305,7 +313,7 @@ export function HooksManager({
       if (!success) {
         logHookEvent(
           hooksManagerLogger.info,
-          `hookCallback: hook was cancelled: ${hookPlugin.identifier}`,
+          `hookCallback: hook was cancelled: ${hookPlugin["identifier"]}`,
           {
             payload,
             hook: 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,
@@ -334,7 +344,7 @@ export function HooksManager({
         if (isHookInHomescreen && isHookFlowBlocker && cancelled) {
           logHookEvent(
             hooksManagerLogger.info,
-            `hookCallback: send app to background, cancelled flow blocker hook  ${hookPlugin.identifier} on home screen`,
+            `hookCallback: send app to background, cancelled flow blocker hook  ${hookPlugin["identifier"]} on home screen`,
             {
               payload,
               hook: hookPlugin,
@@ -349,7 +359,7 @@ export function HooksManager({
       } else {
         logHookEvent(
           hooksManagerLogger.info,
-          `hookCallback: hook successfully finished: ${hookPlugin.identifier}`,
+          `hookCallback: hook successfully finished: ${hookPlugin["identifier"]}`,
           {
             payload,
             hook: hookPlugin,
@@ -359,7 +369,7 @@ export function HooksManager({
         if (!callback) {
           logHookEvent(
             hooksManagerLogger.warn,
-            `hookCallback: ${hookPlugin.identifier} is missing \`callback\`, using hookCallback(default one)`,
+            `hookCallback: ${hookPlugin["identifier"]} is missing \`callback\`, using hookCallback(default one)`,
             {
               hookPlugin,
             }
@@ -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
@@ -401,13 +432,15 @@ export function HooksManager({
 
     logHookEvent(
       hooksManagerLogger.info,
-      `presentScreenHook: Presenting screen hook: ${hookPlugin.identifier}`,
+      `presentScreenHook: Presenting screen hook: ${hookPlugin["identifier"]}`,
       {
         hook: hookPlugin,
         payload,
       }
     );
 
+    registerFinishHookAction(payload, callback);
+
     hookPlugin.setStateAndNotify(HOOKS_EVENTS.PRESENT_SCREEN_HOOK, {
       hookPlugin,
       route: targetScreenRoute,
@@ -421,7 +454,7 @@ export function HooksManager({
   hooksManager.executeHook = function (hookPlugin, payload, callback) {
     logHookEvent(
       hooksManagerLogger.info,
-      `executeHook: ${hookPlugin.identifier}`,
+      `executeHook: ${hookPlugin["identifier"]}`,
       {
         hook: hookPlugin,
         payload,
@@ -433,7 +466,7 @@ export function HooksManager({
     } catch (error) {
       logHookEvent(
         hooksManagerLogger.error,
-        `executeHook: error executing hook: ${hookPlugin.identifier} error: ${error.message}`,
+        `executeHook: error executing hook: ${hookPlugin["identifier"]} error: ${error.message}`,
         {
           hook: hookPlugin,
           payload,
@@ -460,13 +493,15 @@ export function HooksManager({
     try {
       logHookEvent(
         hooksManagerLogger.info,
-        `runInBackground: Executing hook: ${hookPlugin.identifier}`,
+        `runInBackground: Executing hook: ${hookPlugin["identifier"]}`,
         {
           hook: hookPlugin,
           payload,
         }
       );
 
+      registerFinishHookAction(payload, callback);
+
       hookPlugin.module.runInBackground(
         payload,
         callback,

package/appUtils/RiverFocusManager/{index.ts → index.js}

@@ -1,31 +1,11 @@
-import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
-import { QUICK_BRICK_CONTENT } from "@applicaster/quick-brick-core/const";
-import { isNil, isEmpty } from "@applicaster/zapp-react-native-utils/utils";
-import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import * as R from "ramda";
+
+import { focusManager } from "../focusManager";
 
 let riverFocusData = {};
 let initialyPresentedScreenFocused = false;
 
 export const riverFocusManager = (function () {
-  /**
-   * Create unique key that will be used for save focused group data inside specific screen
-   * @param {{ screenId: string, isInsideContainer: boolean }}
-   * screenId Unique Id of the screen from layout.json
-   * isInsideContainer If this screen a screen picker child
-   *
-   */
-  function screenFocusableGroupId({
-    screenId,
-    isInsideContainer,
-  }: {
-    screenId: string;
-    isInsideContainer: Option<boolean>;
-  }) {
-    return `${QUICK_BRICK_CONTENT}-${screenId}${
-      isNil(isInsideContainer) ? "" : "-isInsideContainer"
-    }`;
-  }
-
   function setScreenFocusableData({
     screenFocusableGroupId,
     groupId,
@@ -98,8 +78,8 @@ export const riverFocusManager = (function () {
   }) {
     // Check if screen should be focused
     const shouldFocus =
-      (initialyPresentedScreenFocused === false && isEmpty(riverFocusData)) ||
-      isNotNil(riverFocusData[screenFocusableGroupId]) ||
+      (initialyPresentedScreenFocused === false && R.isEmpty(riverFocusData)) ||
+      R.compose(R.not, R.isNil)(riverFocusData[screenFocusableGroupId]) ||
       isDeepLink;
 
     // TODO: Uncommit it to start fixing bug where selection wrong item
@@ -138,6 +118,19 @@ export const riverFocusManager = (function () {
     }
   }
 
+  /**
+   * Create unique key that will be used for save focused group data inside specific screen
+   * @param {{ screenId: string, isInsideContainer: boolean }}
+   * screenId Unique Id of the screen from layout.json
+   * isInsideContainer If this screen a screen picker child
+   *
+   */
+  function screenFocusableGroupId({ screenId, isInsideContainer }) {
+    return `RiverFocusableGroup-${screenId}${
+      R.isNil(isInsideContainer) ? "" : "-isInsideContainer"
+    }`;
+  }
+
   return {
     setScreenFocusableData,
     clearAllScreensData,

package/appUtils/accessibilityManager/const.ts

@@ -31,10 +31,6 @@ export const BUTTON_ACCESSIBILITY_KEYS = {
       hint: "accessibility_close_mini_hint",
     },
   },
-  back_to_live: {
-    label: "back_to_live_label",
-    hint: "",
-  },
   maximize: {
     label: "accessibility_maximize_label",
     hint: "accessibility_maximize_hint",

package/appUtils/accessibilityManager/utils.ts

@@ -35,6 +35,7 @@ export function calculateReadingTime(
     return 0;
   }
 
+  // Count words (split on whitespace and punctuation, keep alnum boundaries)
   const words = trimmed
     .split(/(?<=\d)(?=[a-zA-Z])|(?<=[a-zA-Z])(?=\d)|[^\w\s]+|\s+/)
     .filter(Boolean).length;

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

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