@applicaster/zapp-react-native-utils 13.0.0-alpha.2322412833 → 13.0.0-alpha.3592223128

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

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

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

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`Hook Hook Properties has all the hook properties 1`] = `
+exports[`Hook Properties has all the hook properties 1`] = `
 Hook {
   "advertising": Object {},
   "general": Object {
@@ -13,10 +13,8 @@ Hook {
   "lastHook": true,
   "manager": Object {
     "executeHook": [MockFunction],
+    "invokeHandler": [MockFunction],
     "presentScreenHook": [MockFunction],
-    "subscriber": Object {
-      "invokeHandler": [MockFunction],
-    },
   },
   "name": "Hook Screen",
   "navigations": Array [],

package/appUtils/HooksManager/__tests__/hook.test.js

@@ -29,9 +29,7 @@ const hooks = (options, otherHook = null) =>
 const manager = {
   presentScreenHook: jest.fn(),
   executeHook: jest.fn(),
-  subscriber: {
-    invokeHandler: jest.fn(),
-  },
+  invokeHandler: jest.fn(),
 };
 
 const getHook = (options, otherHook) =>
@@ -44,267 +42,257 @@ const getHook = (options, otherHook) =>
 function clearMocks() {
   manager.presentScreenHook.mockClear();
   manager.executeHook.mockClear();
-  manager.subscriber.invokeHandler.mockClear();
+  manager.invokeHandler.mockClear();
 }
 
-describe("Hook", () => {
-  describe("Hook Properties", () => {
-    const hookPlugin = getHook({});
+describe("Hook Properties", () => {
+  const hookPlugin = getHook({});
 
-    beforeEach(clearMocks);
+  beforeEach(clearMocks);
 
-    it("has all the hook properties", () => {
-      expect(hookPlugin).toMatchSnapshot();
-    });
+  it("has all the hook properties", () => {
+    expect(hookPlugin).toMatchSnapshot();
   });
+});
 
-  describe("getModalContainer", () => {
-    it("returns ModalContainer", () => {
-      const ModalContainer = jest.fn();
-
-      const hookPlugin = getHook({
-        general: {},
-        module: { ModalContainer },
-      });
+describe("getModalContainer", () => {
+  it("returns ModalContainer", () => {
+    const ModalContainer = jest.fn();
 
-      expect(hookPlugin.getModalContainer()).toBe(ModalContainer);
+    const hookPlugin = getHook({
+      general: {},
+      module: { ModalContainer },
     });
+
+    expect(hookPlugin.getModalContainer()).toBe(ModalContainer);
   });
+});
 
-  describe("isFlowBlocker", () => {
-    it("returns true if the hook is flow blocker", () => {
-      const hookPlugin = getHook({ general: { is_flow_blocker: true } });
+describe("isFlowBlocker", () => {
+  it("returns true if the hook is flow blocker", () => {
+    const hookPlugin = getHook({ general: { is_flow_blocker: true } });
 
-      const hookWithoutScreen = getHook({
-        general: {},
-        module: { isFlowBlocker: () => true },
-      });
-
-      expect(hookPlugin.isFlowBlocker()).toBe(true);
-      expect(hookWithoutScreen.isFlowBlocker()).toBe(true);
+    const hookWithoutScreen = getHook({
+      general: {},
+      module: { isFlowBlocker: () => true },
     });
 
-    it("returns false otherwise", () => {
-      const hookPlugin = getHook({ general: { is_flow_blocker: false } });
+    expect(hookPlugin.isFlowBlocker()).toBe(true);
+    expect(hookWithoutScreen.isFlowBlocker()).toBe(true);
+  });
 
-      const hookWithoutScreen = getHook({
-        general: {},
-        module: { isFlowBlocker: () => false },
-      });
+  it("returns false otherwise", () => {
+    const hookPlugin = getHook({ general: { is_flow_blocker: false } });
 
-      expect(hookPlugin.isFlowBlocker()).toBeFalsy();
-      expect(hookWithoutScreen.isFlowBlocker()).toBeFalsy();
+    const hookWithoutScreen = getHook({
+      general: {},
+      module: { isFlowBlocker: () => false },
     });
+
+    expect(hookPlugin.isFlowBlocker()).toBeFalsy();
+    expect(hookWithoutScreen.isFlowBlocker()).toBeFalsy();
   });
+});
 
-  describe("skipHook", () => {
-    it("returns true if the hooks module skipHook method returns true", () => {
-      const hookPlugin = getHook({ module: { skipHook: () => true } });
+describe("skipHook", () => {
+  it("returns true if the hooks module skipHook method returns true", () => {
+    const hookPlugin = getHook({ module: { skipHook: () => true } });
 
-      expect(hookPlugin.skipHook()).toBe(true);
-    });
+    expect(hookPlugin.skipHook()).toBe(true);
+  });
 
-    it("returns false otherwise", () => {
-      const hookPlugin = getHook({ module: { skipHook: false } });
-      const hookPluginWithUndefinedSkipHook = getHook({ module: {} });
+  it("returns false otherwise", () => {
+    const hookPlugin = getHook({ module: { skipHook: false } });
+    const hookPluginWithUndefinedSkipHook = getHook({ module: {} });
 
-      expect(hookPlugin.skipHook()).toBeFalsy();
-      expect(hookPluginWithUndefinedSkipHook.skipHook()).toBeFalsy();
-    });
+    expect(hookPlugin.skipHook()).toBeFalsy();
+    expect(hookPluginWithUndefinedSkipHook.skipHook()).toBeFalsy();
   });
+});
 
-  describe("lastHook", () => {
-    it("returns true if the current hook is the last one", () => {
-      const hookPlugin = getHook({});
-      expect(hookPlugin.lastHook).toBe(true);
-    });
-
-    it("returns false otherwise", () => {
-      const hookPlugin = getHook(
-        {},
-        {
-          screen_id: "B4567",
-          type: "general",
-          identifier: "some_hook",
-          weight: 2,
-        }
-      );
+describe("lastHook", () => {
+  it("returns true if the current hook is the last one", () => {
+    const hookPlugin = getHook({});
+    expect(hookPlugin.lastHook).toBe(true);
+  });
 
-      expect(hookPlugin.lastHook).toBe(false);
-    });
+  it("returns false otherwise", () => {
+    const hookPlugin = getHook(
+      {},
+      {
+        screen_id: "B4567",
+        type: "general",
+        identifier: "some_hook",
+        weight: 2,
+      }
+    );
+
+    expect(hookPlugin.lastHook).toBe(false);
   });
+});
 
-  describe("setStateAndNotify", () => {
-    let hookPlugin;
-    const args = ["foo", { bar: 42 }];
+describe("setStateAndNotify", () => {
+  let hookPlugin;
+  const args = ["foo", { bar: 42 }];
 
-    beforeEach(() => {
-      clearMocks();
-      hookPlugin = getHook({});
-    });
+  beforeEach(() => {
+    clearMocks();
+    hookPlugin = getHook({});
+  });
 
-    it("changes the hook's state", () => {
-      hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
-      expect(hookPlugin.state).toEqual(1);
-    });
+  it("changes the hook's state", () => {
+    hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
+    expect(hookPlugin.state).toEqual(1);
+  });
 
-    it("calls invokes the handler on the hook manager", () => {
-      hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
+  it("calls invokes the handler on the hook manager", () => {
+    hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
 
-      expect(manager.subscriber.invokeHandler).toHaveBeenCalledWith(
-        HOOKS_EVENTS.START,
-        ...args
-      );
-    });
+    expect(manager.invokeHandler).toHaveBeenCalledWith(
+      HOOKS_EVENTS.START,
+      ...args
+    );
   });
+});
 
-  describe("shouldPresentScreenHook", () => {
-    it("returns true if the hook has a screenId and allows screen presentation", () => {
-      const hookPlugin = getHook({});
-
-      const hookWithoutRiver = getHook({
-        screen_id: undefined,
-        module: { presentFullScreen: true },
-      });
+describe("shouldPresentScreenHook", () => {
+  it("returns true if the hook has a screenId and allows screen presentation", () => {
+    const hookPlugin = getHook({});
 
-      expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
-      expect(hookWithoutRiver.shouldPresentScreenHook()).toBe(true);
+    const hookWithoutRiver = getHook({
+      screen_id: undefined,
+      module: { presentFullScreen: true },
     });
 
-    it("returns true if the hook is modal presentation", () => {
-      const hookPlugin = getHook({
-        general: { transition_type: HOOKS_TRANSITION_TYPE.MODAL },
-      });
+    expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
+    expect(hookWithoutRiver.shouldPresentScreenHook()).toBe(true);
+  });
 
-      expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
+  it("returns true if the hook is modal presentation", () => {
+    const hookPlugin = getHook({
+      general: { transition_type: HOOKS_TRANSITION_TYPE.MODAL },
     });
 
-    it("returns false otherwise", () => {
-      const hookWithoutScreen = getHook({ screen_id: undefined });
+    expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
+  });
 
-      const hookWithoutRiver = getHook({
-        screen_id: undefined,
-        module: { presentFullScreen: false },
-      });
+  it("returns false otherwise", () => {
+    const hookWithoutScreen = getHook({ screen_id: undefined });
 
-      const hookWithoutAllowScreen = getHook({
-        general: { allow_screen_plugin_presentation: false },
-      });
+    const hookWithoutRiver = getHook({
+      screen_id: undefined,
+      module: { presentFullScreen: false },
+    });
 
-      const hookWithoutScreenAndAllow = getHook({
-        general: { allow_screen_plugin_presentation: false },
-        screen_id: null,
-      });
+    const hookWithoutAllowScreen = getHook({
+      general: { allow_screen_plugin_presentation: false },
+    });
 
-      expect(hookWithoutScreen.shouldPresentScreenHook()).toBeFalsy();
-      expect(hookWithoutAllowScreen.shouldPresentScreenHook()).toBeFalsy();
-      expect(hookWithoutScreenAndAllow.shouldPresentScreenHook()).toBeFalsy();
-      expect(hookWithoutRiver.shouldPresentScreenHook()).toBeFalsy();
+    const hookWithoutScreenAndAllow = getHook({
+      general: { allow_screen_plugin_presentation: false },
+      screen_id: null,
     });
+
+    expect(hookWithoutScreen.shouldPresentScreenHook()).toBeFalsy();
+    expect(hookWithoutAllowScreen.shouldPresentScreenHook()).toBeFalsy();
+    expect(hookWithoutScreenAndAllow.shouldPresentScreenHook()).toBeFalsy();
+    expect(hookWithoutRiver.shouldPresentScreenHook()).toBeFalsy();
   });
+});
 
-  describe("shouldStartNexHook", () => {
-    const hookPlugin = getHook({});
-    const hookWithoutScreen = getHook({ screen_id: undefined });
+describe("shouldStartNexHook", () => {
+  const hookPlugin = getHook({});
+  const hookWithoutScreen = getHook({ screen_id: undefined });
 
-    it("returns true if the nextHook has the same weight and is not a screen", () => {
-      expect(
-        hookWithoutScreen.shouldStartNextHook({
-          weight: hookWithoutScreen.weight,
-        })
-      ).toBe(true);
-    });
+  it("returns true if the nextHook has the same weight and is not a screen", () => {
+    expect(
+      hookWithoutScreen.shouldStartNextHook({
+        weight: hookWithoutScreen.weight,
+      })
+    ).toBe(true);
+  });
 
-    it("returns false otherwise", () => {
-      // even if weight if the same, since hookPlugin should present a screen,
-      // it cannot run in parallel
-      expect(
-        hookPlugin.shouldStartNextHook({ weight: hookPlugin })
-      ).toBeFalsy();
-
-      expect(
-        hookWithoutScreen.shouldStartNextHook({
-          weight: hookWithoutScreen.weight + 1,
-        })
-      ).toBeFalsy();
-    });
+  it("returns false otherwise", () => {
+    // even if weight if the same, since hookPlugin should present a screen,
+    // it cannot run in parallel
+    expect(hookPlugin.shouldStartNextHook({ weight: hookPlugin })).toBeFalsy();
+
+    expect(
+      hookWithoutScreen.shouldStartNextHook({
+        weight: hookWithoutScreen.weight + 1,
+      })
+    ).toBeFalsy();
   });
+});
 
-  describe("execute", () => {
-    const payload = { foo: "bar" };
-    const next = jest.fn();
+describe("execute", () => {
+  const payload = { foo: "bar" };
+  const next = jest.fn();
 
-    beforeEach(clearMocks);
+  beforeEach(clearMocks);
 
-    describe("when the hook execution should be skipped", () => {
-      it("doesn't execute the hook, and goes to the next", () => {
-        const hookPlugin = getHook({ module: { skipHook: () => true } });
-        hookPlugin.execute(payload, next);
+  describe("when the hook execution should be skipped", () => {
+    it("doesn't execute the hook, and goes to the next", () => {
+      const hookPlugin = getHook({ module: { skipHook: () => true } });
+      hookPlugin.execute(payload, next);
 
-        expect(manager.presentScreenHook).not.toHaveBeenCalled();
-        expect(manager.executeHook).not.toHaveBeenCalled();
-        expect(next).toHaveBeenCalledWith({ payload, success: true });
-      });
+      expect(manager.presentScreenHook).not.toHaveBeenCalled();
+      expect(manager.executeHook).not.toHaveBeenCalled();
+      expect(next).toHaveBeenCalledWith({ payload, success: true });
     });
+  });
 
-    describe("when the hook is not in pending state", () => {
-      it("doesn't execute the hook, and goes to the next", () => {
-        const hookPlugin = getHook({});
-        hookPlugin.setStateAndNotify(HOOKS_EVENTS.START);
-        hookPlugin.execute(payload, next);
+  describe("when the hook is not in pending state", () => {
+    it("doesn't execute the hook, and goes to the next", () => {
+      const hookPlugin = getHook({});
+      hookPlugin.setStateAndNotify(HOOKS_EVENTS.START);
+      hookPlugin.execute(payload, next);
 
-        const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
+      const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
 
-        expect(hookStateSpy).not.toHaveBeenCalled();
-        expect(manager.presentScreenHook).not.toHaveBeenCalled();
-        expect(manager.executeHook).not.toHaveBeenCalled();
-        expect(next).toHaveBeenCalledWith({ payload });
+      expect(hookStateSpy).not.toHaveBeenCalled();
+      expect(manager.presentScreenHook).not.toHaveBeenCalled();
+      expect(manager.executeHook).not.toHaveBeenCalled();
+      expect(next).toHaveBeenCalledWith({ payload });
 
-        hookStateSpy.mockRestore();
-      });
+      hookStateSpy.mockRestore();
     });
+  });
 
-    describe("when the screen should be presented", () => {
-      it("executes the hook", () => {
-        const hookPlugin = getHook({});
-        const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
+  describe("when the screen should be presented", () => {
+    it("executes the hook", () => {
+      const hookPlugin = getHook({});
+      const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
 
-        hookPlugin.execute(payload, next);
+      hookPlugin.execute(payload, next);
 
-        expect(hookStateSpy).toHaveBeenCalledWith(
-          HOOKS_EVENTS.START,
-          hookPlugin
-        );
+      expect(hookStateSpy).toHaveBeenCalledWith(HOOKS_EVENTS.START, hookPlugin);
 
-        expect(manager.presentScreenHook).toHaveBeenCalledWith(
-          hookPlugin,
-          payload,
-          next
-        );
-      });
+      expect(manager.presentScreenHook).toHaveBeenCalledWith(
+        hookPlugin,
+        payload,
+        next
+      );
     });
+  });
 
-    describe("when the hook is headless", () => {
-      it("executes the hook", () => {
-        const hookPlugin = getHook({
-          general: { allow_screen_plugin_presentation: false },
-        });
+  describe("when the hook is headless", () => {
+    it("executes the hook", () => {
+      const hookPlugin = getHook({
+        general: { allow_screen_plugin_presentation: false },
+      });
 
-        const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
+      const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
 
-        hookPlugin.execute(payload, next);
+      hookPlugin.execute(payload, next);
 
-        expect(hookStateSpy).toHaveBeenCalledWith(
-          HOOKS_EVENTS.START,
-          hookPlugin
-        );
+      expect(hookStateSpy).toHaveBeenCalledWith(HOOKS_EVENTS.START, hookPlugin);
 
-        expect(manager.executeHook).toHaveBeenCalledWith(
-          hookPlugin,
-          payload,
-          next
-        );
-      });
+      expect(manager.executeHook).toHaveBeenCalledWith(
+        hookPlugin,
+        payload,
+        next
+      );
     });
   });
 });