@applicaster/zapp-react-native-utils 12.0.0-alpha.4342066143 → 12.0.0-alpha.4354608902

package/analyticsUtils/AnalyticsEvents/index.ts

@@ -12,6 +12,11 @@ import {
   sendSearchExecutedEvent,
 } from "./searchEvents";
 
+import {
+  sendShareInitiatedEvent,
+  sendShareSuccessEvent,
+} from "./sendShareEvent";
+
 export {
   sendScreenEvent,
   sendOnClickEvent,
@@ -24,4 +29,6 @@ export {
   sendDownloadsEvent,
   sendSearchCanceledEvent,
   sendSearchExecutedEvent,
+  sendShareInitiatedEvent,
+  sendShareSuccessEvent,
 };

package/analyticsUtils/AnalyticsEvents/sendShareEvent.ts

@@ -0,0 +1,21 @@
+import { log_debug } from "../logger";
+import { postAnalyticEvent } from "../manager";
+import { ANALYTICS_CORE_EVENTS } from "../events";
+
+export const sendShareInitiatedEvent = (analyticsProps) => {
+  const eventName = ANALYTICS_CORE_EVENTS.SHARE_INITIATED;
+  postAnalyticEvent(eventName, analyticsProps);
+
+  log_debug(`sendShareInitiatedEvent: send event: ${eventName}`, {
+    analyticsProps,
+  });
+};
+
+export const sendShareSuccessEvent = (analyticsProps) => {
+  const eventName = ANALYTICS_CORE_EVENTS.SHARE_SUCCESS;
+  postAnalyticEvent(eventName, analyticsProps);
+
+  log_debug(`sendShareSuccessEvent: send event: ${eventName}`, {
+    analyticsProps,
+  });
+};

package/analyticsUtils/events.ts

@@ -28,11 +28,17 @@ export const SEARCH_EVENTS = {
   SEARCH_CANCELED: "search_canceled",
 };
 
+export const SHARE_EVENTS = {
+  SHARE_INITIATED: "share_initiated",
+  SHARE_SUCCESS: "share_success",
+};
+
 export const ANALYTICS_CORE_EVENTS = {
   ...LEGACY_EVENTS,
   ...SCREEN_VIEW_EVENTS,
   ...TAPPING_EVENTS,
   ...SEARCH_EVENTS,
+  ...SHARE_EVENTS,
 };
 
 export const WEBVIEW_EVENTS = {

package/analyticsUtils/index.tsx

@@ -20,6 +20,8 @@ import {
   sendScreenEvent,
   sendSearchCanceledEvent,
   sendSearchExecutedEvent,
+  sendShareInitiatedEvent,
+  sendShareSuccessEvent,
 } from "./AnalyticsEvents";
 
 import { postAnalyticEvent } from "./manager";
@@ -70,6 +72,8 @@ type AnalyticsFunctions = {
   }) => void;
   sendSearchCanceledEvent: (props: AnalyticsDefaultProperties) => void;
   sendSearchExecutedEvent: (props: AnalyticsDefaultProperties) => void;
+  sendShareInitiatedEvent: (props: AnalyticsDefaultProperties) => void;
+  sendShareSuccessEvent: (props: AnalyticsDefaultProperties) => void;
 };
 
 type GetAnalyticsFunctions = (
@@ -108,6 +112,8 @@ export function getAnalyticsFunctions({
     sendDownloadsEvent,
     sendSearchCanceledEvent,
     sendSearchExecutedEvent,
+    sendShareInitiatedEvent,
+    sendShareSuccessEvent,
   };
 }
 

package/appUtils/HooksManager/{Hook.js → Hook.ts}

@@ -4,6 +4,7 @@ import { isFunction } from "../../functionUtils";
 import { HOOKS_EVENTS, HOOKS_TRANSITION_TYPE } from "./constants";
 
 import { hooksManagerLogger } from "./logger";
+import type { Hook as HookInterface, HookIniObj } from "./types";
 
 const BASE_HOOK_PROPERTIES = ["screen_id", "identifier", "weight"];
 
@@ -14,7 +15,9 @@ const BASE_HOOK_PROPERTIES = ["screen_id", "identifier", "weight"];
  * @param {string} hookEventName
  * @returns {number} index
  */
-const hookState = R.indexOf(R.__, R.values(HOOKS_EVENTS));
+const hookState: (
+  arg0: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS]
+) => number = R.indexOf(R.__, R.values(HOOKS_EVENTS));
 
 /**
  * assigns property to a given context
@@ -28,17 +31,20 @@ function assignProp(context) {
 }
 
 /**
- * Representation of a hook plugin with full data
+ * Representation of a hook plugin
  */
-export class Hook {
-  /**
-   * constructs the hook
-   * @param {object} Options
-   * @param {object} Options.hook hook object
-   * @param {Array<Object>} Options.hooks array of hooks siblings in the current process
-   * @param {object} manager hook manager to process the hooks
-   */
-  constructor({ hook, hooks, manager }) {
+export class Hook implements HookInterface {
+  public manager: HookInterface["manager"];
+  public lastHook: HookInterface["lastHook"];
+  public state: HookInterface["state"];
+  public screen_id: HookInterface["screen_id"];
+  public identifier: HookInterface["identifier"];
+  public module: HookInterface["module"];
+  public general: HookInterface["general"];
+  public weight: number;
+  public configuration: HookInterface["configuration"];
+
+  constructor({ hook, hooks, manager }: HookIniObj) {
     R.forEachObjIndexed(assignProp(this), hook);
     this.manager = manager;
 
@@ -55,25 +61,28 @@ export class Hook {
    * @param {string} event name
    * @param {Array<Any>} args variadic arguments to invoke the handler with
    */
-  setStateAndNotify(event, ...args) {
+  setStateAndNotify(
+    event: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS],
+    ...args
+  ) {
     this.state = hookState(event);
-    this.manager.invokeHandler(event, ...args);
+    this.manager.subscriber.invokeHandler(event, ...args);
   }
 
   /**
    * returns react component of the the hook modal presenter
    * @returns {React.ComponentType<any>}
    */
-  getModalContainer() {
-    return this.module && this.module.ModalContainer;
+  getModalContainer(): HookInterface["module"]["ModalContainer"] | undefined {
+    return this.module ? this.module.ModalContainer : undefined;
   }
 
   /**
    * tells whether the hook should be presented as a screen
    * @returns {boolean}
    */
-  shouldPresentScreenHook() {
-    return (
+  shouldPresentScreenHook(): boolean {
+    return !!(
       (this.screen_id && this.general?.allow_screen_plugin_presentation) ||
       (this.module && this.module.presentFullScreen) ||
       (!this.module?.presentFullScreen &&
@@ -87,7 +96,7 @@ export class Hook {
    * tells whether the hook should be presented as a modal screen
    * @returns {boolean}
    */
-  isModalHook() {
+  isModalHook(): boolean {
     return (
       this.screen_id &&
       this.general?.transition_type === HOOKS_TRANSITION_TYPE.MODAL
@@ -99,7 +108,7 @@ export class Hook {
    * if it doesn't return success
    * @returns { boolean}
    */
-  isFlowBlocker() {
+  isFlowBlocker(): boolean {
     return (
       (this.general && this.general.is_flow_blocker) ||
       (this.module && this.module.isFlowBlocker && this.module.isFlowBlocker())
@@ -111,7 +120,7 @@ export class Hook {
    * @param {object} payload to pass to the hook
    * @returns { boolean}
    */
-  skipHook(payload) {
+  skipHook(payload: object): boolean {
     const _skipHook = R.compose(
       R.ifElse(isFunction, R.apply(R.__, [payload]), R.F),
       R.path(["module", "skipHook"])
@@ -133,7 +142,10 @@ export class Hook {
    * @param {object} payload to pass to the hook
    * @param {function} next callback to invoke for processing next hook
    */
-  execute(payload, next) {
+  execute<T extends object>(
+    payload: T,
+    next: (arg0: { payload: T; success?: boolean }) => void
+  ): void {
     if (this.skipHook(payload)) {
       next({ payload, success: true });
 
@@ -152,7 +164,7 @@ export class Hook {
 
         this.setStateAndNotify(HOOKS_EVENTS.START_BACKGROUND_HOOK, this);
 
-        this.manager.runInBackground(this, payload, next, (_payload) =>
+        this.manager.runInBackground(this, payload, next, (_payload: any) =>
           this.manager.presentScreenHook(this, _payload || payload, next)
         );
       } else if (this.shouldPresentScreenHook()) {
@@ -175,7 +187,7 @@ export class Hook {
    *  - AND next hook has the same weight as the current one
    * @returns {boolean}
    */
-  shouldStartNextHook(nextHook) {
+  shouldStartNextHook(nextHook: Hook): boolean {
     return (
       nextHook &&
       !this.shouldPresentScreenHook() &&

package/appUtils/HooksManager/{constants.js → constants.ts}

@@ -12,7 +12,7 @@ export const HOOKS_EVENTS = {
   CANCEL: "cancel",
   SUCCESS: "success",
   COMPLETE: "complete",
-};
+} as const;
 
 export const HOOKS_TRANSITION_TYPE = {
   PUSH: "push",

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

@@ -10,14 +10,72 @@ import { Hook } from "./Hook";
 import { HOOKS_EVENTS, HOOKS_TYPE } from "./constants";
 
 import { hooksManagerLogger } from "./logger";
+import { HookManager, HookManagerArgs } from "./types";
+
+/**
+ * orders the hooks according to their weight
+ * @param {Array<object>} hooks to sort out
+ * @returns {Array<object>} sorted hooks
+ */
+function orderHooksByWeight(hooks: Hook[]) {
+  return R.sortBy(R.compose(Number, R.prop("weight")), hooks);
+}
+
+function executeOnNextHook(
+  hooks: Hook[],
+  payload: object,
+  callback: (hookPlugin: Hook, restOfHooks: Hook[], payload: object) => void
+) {
+  const [nextHook, ...restOfHooks] = orderHooksByWeight(hooks);
+
+  if (nextHook) {
+    nextHook.execute(payload, callback(nextHook, restOfHooks, payload));
+  }
+}
+
+/**
+ * tells wether the current river is related to a player plugin, or the default player
+ * @param {Object} river
+ * @returns {boolean}
+ */
+function riverIsPlayer(river, plugins) {
+  const { screenType, plugin_type } = river;
+
+  if (screenType || plugin_type) {
+    return screenType === "playable" || plugin_type === "player";
+  }
+
+  const { type } = river;
+
+  return R.compose(
+    R.propEq("type", "player"),
+    R.defaultTo({}),
+    R.find(R.propEq("identifier", type))
+  )(plugins);
+}
+
+/**
+ * Injects the hooks for the player
+ * @param _hookType type of hook
+ * @param plugins plugins
+ * @returns {Array<Object>}
+ */
+function injectPlayerHooks(_hookType: string, plugins): Hook[] {
+  const playerhooks: Hook[] = R.compose(
+    R.sortBy(R.prop("weight")),
+    R.map((plugin) => ({
+      identifier: plugin.identifier,
+      weight: R.path(["module", "weight"], plugin) || 1,
+    })),
+    R.filter(R.pathEq(["module", "hasPlayerHook"], true))
+  )(plugins);
+
+  return playerhooks;
+}
 
 /**
  * creates a hooksManager object to handle the hooks process.
  * it is based on the `subscriber` object
- * @param {object} options
- * @param {object} rivers map of rivers in the app
- * @param {object} targetScreen rivers which we are navigating to
- * @param {Array<object>} plugins array of plugins in the app
  * @returns {object} hooksManager object - see Navigator for usage
  */
 export function HooksManager({
@@ -25,7 +83,7 @@ export function HooksManager({
   targetScreen,
   plugins,
   startUpHooksData = {},
-}) {
+}: HookManagerArgs): HookManager {
   hooksManagerLogger.addContext({ targetScreen });
 
   function logHookEvent(func, message, data) {
@@ -35,7 +93,8 @@ export function HooksManager({
     });
   }
 
-  const hooksManager = subscriber();
+  const hooksManager: Partial<HookManager> = {};
+  hooksManager.subscriber = subscriber();
 
   /**
    * attaches the screen data to the hook object if the hook
@@ -100,15 +159,6 @@ export function HooksManager({
     };
   }
 
-  /**
-   * orders the hooks according to their weight
-   * @param {Array<object>} hooks to sort out
-   * @returns {Array<object>} sorted hooks
-   */
-  function orderHooksByWeight(hooks) {
-    return R.sortBy(R.compose(Number, R.prop("weight")), hooks);
-  }
-
   /**
    * extracts the hooks form the target river. returns null if there are none
    * if there are hooks, gathers all required data and constructs a Hook object
@@ -117,10 +167,10 @@ export function HooksManager({
    * @returns {Array<Hooks>} list of hooks to go through
    */
   function getHooks(hookType, river) {
-    const playerhooks = [];
+    const playerhooks: Hook[] = [];
 
-    if (riverIsPlayer(river)) {
-      playerhooks.push(...injectPlayerHooks(hookType));
+    if (riverIsPlayer(river, plugins)) {
+      playerhooks.push(...injectPlayerHooks(hookType, plugins));
     }
 
     let hooks = R.concat(playerhooks, R.pathOr([], ["hooks", hookType], river));
@@ -130,8 +180,10 @@ export function HooksManager({
     const { startUpHooks, setStartUpHooks } = startUpHooksData;
 
     if (startUpHooks && startUpHooks !== "in_process") {
-      hooks.unshift(...startUpHooks);
-      setStartUpHooks("in_process");
+      if (Array.isArray(startUpHooks)) {
+        hooks.unshift(...startUpHooks);
+        setStartUpHooks("in_process");
+      }
     }
 
     if (!R.length(hooks)) {
@@ -158,45 +210,6 @@ export function HooksManager({
     )(hooks);
   }
 
-  /**
-   * tells wether the current river is related to a player plugin, or the default player
-   * @param {Object} river
-   * @returns {boolean}
-   */
-  function riverIsPlayer(river) {
-    const { screenType, plugin_type } = river;
-
-    if (screenType || plugin_type) {
-      return screenType === "playable" || plugin_type === "player";
-    }
-
-    const { type } = river;
-
-    return R.compose(
-      R.propEq("type", "player"),
-      R.defaultTo({}),
-      R.find(R.propEq("identifier", type))
-    )(plugins);
-  }
-
-  /**
-   * Injects the hooks for the player
-   * @param {String} hookType type of hook
-   * @returns {Array<Object>}
-   */
-  function injectPlayerHooks(_hookType) {
-    const playerhooks = R.compose(
-      R.sortBy(R.prop("weight")),
-      R.map((plugin) => ({
-        identifier: plugin.identifier,
-        weight: R.path(["module", "weight"], plugin) || 1,
-      })),
-      R.filter(R.pathEq(["module", "hasPlayerHook"], true))
-    )(plugins);
-
-    return playerhooks;
-  }
-
   /**
    * tells wether the given hook is the last one or not
    * @param {Hook} hookPlugin
@@ -209,6 +222,32 @@ export function HooksManager({
     return hookPlugin.lastHook;
   }
 
+  /**
+   * flags a hook as succeeded, and pass hook data along
+   * @param {Hook} hookPlugin
+   * @param {object} payload returned by the hook plugin
+   */
+  function completeHook(hookPlugin, payload, callback) {
+    logHookEvent(
+      hooksManagerLogger.info,
+      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
+      {
+        payload,
+        hook: hookPlugin,
+      }
+    );
+
+    // eslint-disable-next-line
+    // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
+    delete payload.getLoginProtocol;
+
+    hookPlugin.setStateAndNotify(HOOKS_EVENTS.COMPLETE, {
+      hookPlugin,
+      payload,
+      callback,
+    });
+  }
+
   /**
    * creates the callback to invoke in order to proceed to the next hook
    * covers the scenarios of failure & flow blocking
@@ -228,9 +267,11 @@ export function HooksManager({
       success,
       error,
       payload = initialPayload,
-      callback,
+      callback: callbackArg,
       cancelled,
     }) {
+      let callback = callbackArg;
+
       if (error) {
         logHookEvent(
           hooksManagerLogger.error,
@@ -301,6 +342,18 @@ export function HooksManager({
           }
         );
 
+        if (!callback) {
+          logHookEvent(
+            hooksManagerLogger.warn,
+            `hookCallback: ${hookPlugin["identifier"]} is missing \`callback\`, using hookCallback(default one)`,
+            {
+              hookPlugin,
+            }
+          );
+
+          callback = hookCallback;
+        }
+
         hookPlugin.setStateAndNotify(HOOKS_EVENTS.SUCCESS, {
           hookPlugin,
           payload,
@@ -309,37 +362,11 @@ export function HooksManager({
 
         isLastHook(hookPlugin, restOfHooks)
           ? completeHook(hookPlugin, payload, callback)
-          : handleNextHook(restOfHooks, payload);
+          : executeOnNextHook(restOfHooks, payload, callback);
       }
     };
   }
 
-  /**
-   * flags a hook as succeeded, and pass hook data along
-   * @param {Hook} hookPlugin
-   * @param {object} payload returned by the hook plugin
-   */
-  function completeHook(hookPlugin, payload, callback) {
-    logHookEvent(
-      hooksManagerLogger.info,
-      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
-      {
-        payload,
-        hook: hookPlugin,
-      }
-    );
-
-    // eslint-disable-next-line
-    // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
-    delete payload.getLoginProtocol;
-
-    hookPlugin.setStateAndNotify(HOOKS_EVENTS.COMPLETE, {
-      hookPlugin,
-      payload,
-      callback,
-    });
-  }
-
   /**
    * presents a screen hook by triggering an event invoking the handler with
    * the appropriate route & payload
@@ -376,9 +403,6 @@ export function HooksManager({
 
   /**
    * executes a headless hook
-   * @param {Hook} hookPlugin to present
-   * @param {object} payload to pass to the hook module
-   * @param {function} callback to invoke when the hook is successful
    */
   hooksManager.executeHook = function (hookPlugin, payload, callback) {
     logHookEvent(
@@ -444,30 +468,13 @@ export function HooksManager({
     }
   };
 
-  /**
-   * handles the next hook in the list of provided hooks, passing the payload along
-   * @param {Array<Hook>} hooks to process
-   * @param {object} payload to pass to the hook
-   */
-  function handleNextHook(hooks, payload) {
-    const [hookPlugin, ...restOfHooks] = orderHooksByWeight(hooks);
-
-    /**
-     * Commenting out part of the code which is trying to run the next hook
-     * in parallel - it's not in use, and it's creating unexpected side
-     * effects
-     * */
-
-    hookPlugin.execute(payload, hookCallback(hookPlugin, restOfHooks, payload));
-  }
-
   /**
    * function exposes on the hooks manager to trigger the handling of the hooks for
    * the given targetScreen
    * @param {object} payload to send to the hooks
    * @returns {object} returns the hooks manager so methods can be chained
    */
-  hooksManager.handleHooks = function (payload) {
+  hooksManager.handleHooks = function (payload: object) {
     const preloadHooks = getHooks(HOOKS_TYPE.PRELOAD, targetScreen);
 
     if (preloadHooks?.length) {
@@ -482,9 +489,9 @@ export function HooksManager({
         }
       );
 
-      handleNextHook(preloadHooks, payload);
+      executeOnNextHook(preloadHooks, payload, hookCallback);
     } else {
-      hooksManager.invokeHandler(HOOKS_EVENTS.COMPLETE, {
+      hooksManager.subscriber.invokeHandler(HOOKS_EVENTS.COMPLETE, {
         hookPlugin: { lastHook: true },
         payload,
       });
@@ -493,5 +500,5 @@ export function HooksManager({
     return hooksManager;
   };
 
-  return hooksManager;
+  return hooksManager as HookManager;
 }

package/appUtils/HooksManager/types.ts

@@ -0,0 +1,116 @@
+import { SubscriberObj } from "../../functionUtils";
+import { HOOKS_EVENTS } from "./constants";
+
+export interface HookConfiguration {}
+
+/* existing Hook Plugn props: sample */
+interface _HookModulePlugin {
+  Component:
+    | React.FC<HookPluginProps>
+    | React.Component<HookPluginProps, any>
+    | React.ReactNode;
+  ModalContainer?: React.FC<ModalProps> | React.Component<ModalProps, any>;
+  skipHook?: (payload: ZappRiver | ZappEntry) => boolean;
+  presentFullScreen: boolean;
+  showNavBar?: boolean;
+  isFlowBlocker: (() => boolean) | boolean; // narrow this
+  hasPlayerHook?: boolean;
+  name: string;
+  runInBackground?: (
+    item: HookPluginProps["payload"],
+    callback: hookCallback,
+    hookPlugin: HookScreenData,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => any;
+}
+
+//* Derived from usage */
+export interface HookModule {
+  ModalContainer?: React.ComponentType<any>;
+  Component: React.ComponentType<any>;
+  presentFullScreen: boolean;
+  run?: (
+    arg0: unknown,
+    callback: () => void,
+    configuration: HookConfiguration
+  ) => void; // not sure about optional parameter
+  hasPlayerHook?: boolean;
+  configuration?: HookConfiguration;
+  isFlowBlocker: () => boolean;
+  skipHook?: (payload?: ZappRiver | ZappEntry) => boolean;
+  runInBackground?: (
+    arg0: unknown,
+    callback: () => void,
+    hookPlugin: Hook,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => void;
+  name: string;
+  showNavBar?: boolean; // unsure
+}
+
+export type HookManagerArgs = {
+  rivers: Record<string, ZappRiver>;
+  plugins: ZappPlugin[];
+  targetScreen: ZappRiver;
+  startUpHooksData?: {
+    startUpHooks?: unknown[] | "in_process";
+    setStartUpHooks?: (arg0: string) => void;
+  };
+};
+
+export interface HookManager {
+  subscriber: SubscriberObj;
+  presentScreenHook: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void
+  ) => void;
+  executeHook: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void
+  ) => void;
+  handleHooks: (payload: unknown) => void;
+  runInBackground: (
+    hook: Hook,
+    payload: unknown,
+    callback: (...any) => void,
+    presentUI: (payload?: HookPluginProps["payload"]) => void
+  ) => void;
+}
+
+export type HookIniObj = {
+  hook: HookModule & {
+    module: HookModule;
+    general: unknown;
+    screen_id?: string;
+    identifier?: string;
+    weight?: number | string;
+  };
+  hooks: Hook<any>[];
+  manager: HookManager;
+};
+
+export interface Hook<T extends HookModule = HookModule> {
+  manager: HookManager;
+  lastHook: boolean;
+  state: number;
+  module: T;
+  screen_id: string;
+  identifier: string;
+  configuration: T["configuration"];
+  setStateAndNotify(
+    event: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS],
+    opts: {
+      error?: typeof Error;
+      route?: string;
+      hookPlugin: Hook<T>;
+      payload: unknown;
+    }
+  );
+  general?: {
+    transition_type: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS];
+    allow_screen_plugin_presentation: boolean;
+    is_flow_blocker: boolean;
+  };
+}