improve typings for event manager

Author: fadi-george

src/events/EventManager.test.ts

@@ -12,20 +12,22 @@ import {
   SUBSCRIPTION_CHANGED,
   USER_STATE_CHANGED,
 } from '../constants/events';
+import OSNotification from '../OSNotification';
+import type { NotificationClickEvent } from '../types/notificationEvents';
 import type { PushSubscriptionChangedState } from '../types/subscription';
 import type { UserChangedState } from '../types/user';
-import EventManager, { type EventListenerMap } from './EventManager';
+import EventManager, { type RawEventListenerMap } from './EventManager';
 import NotificationWillDisplayEvent from './NotificationWillDisplayEvent';
 
 describe('EventManager', () => {
   let eventManager: EventManager;
   let mockNativeModule: any;
   let eventCallbacks: Map<string, (payload: any) => void>;
 
-  const getCallback = <K extends keyof EventListenerMap>(
+  const getCallback = <K extends keyof RawEventListenerMap>(
     eventName: K,
-  ): ((payload: Parameters<EventListenerMap[K]>[0]) => void) | undefined => {
-    return eventCallbacks.get(eventName) as any;
+  ): RawEventListenerMap[K] | undefined => {
+    return eventCallbacks.get(eventName) as RawEventListenerMap[K] | undefined;
   };
 
   beforeEach(() => {
@@ -210,14 +212,7 @@ describe('EventManager', () => {
       eventManager.addEventListener(NOTIFICATION_WILL_DISPLAY, handler);
 
       const callback = getCallback(NOTIFICATION_WILL_DISPLAY);
-
-      const notificationPayload = {
-        notificationId: 'test-id',
-        body: 'test-body',
-        rawPayload: {},
-      };
-
-      callback!(notificationPayload);
+      callback!(rawWillDisplayPayload);
 
       expect(handler).toHaveBeenCalled();
       const receivedEvent = handler.mock.calls[0][0];
@@ -228,33 +223,22 @@ describe('EventManager', () => {
       const handler = vi.fn();
       eventManager.addEventListener(PERMISSION_CHANGED, handler);
 
+      const payload = getRawPermissionChangedPayload(true);
       const callback = getCallback(PERMISSION_CHANGED);
-      callback!({ permission: true });
+      callback!(payload);
 
       expect(handler).toHaveBeenCalledWith(true);
     });
 
     test('should handle generic events with object payload', () => {
       const handler = vi.fn();
-      const payload = {
-        previous: {
-          id: 'previous-id',
-          token: 'previous-token',
-          optedIn: false,
-        },
-        current: {
-          id: 'current-id',
-          token: 'current-token',
-          optedIn: true,
-        },
-      } satisfies PushSubscriptionChangedState;
 
       eventManager.addEventListener(SUBSCRIPTION_CHANGED, handler);
 
       const callback = getCallback(SUBSCRIPTION_CHANGED);
-      callback!(payload);
+      callback!(pushChangedPayload);
 
-      expect(handler).toHaveBeenCalledWith(payload);
+      expect(handler).toHaveBeenCalledWith(pushChangedPayload);
     });
 
     test('should call all handlers for an event', () => {
@@ -350,7 +334,14 @@ describe('EventManager', () => {
 
     test('should handle NOTIFICATION_CLICKED events', () => {
       const handler = vi.fn();
-      const payload = { notificationId: 'notif-123', action: 'clicked' };
+      const payload = {
+        result: { actionId: 'action-1' },
+        notification: new OSNotification({
+          notificationId: 'test-id',
+          body: 'test-body',
+          rawPayload: {},
+        }),
+      } satisfies NotificationClickEvent;
 
       eventManager.addEventListener(NOTIFICATION_CLICKED, handler);
 
@@ -372,7 +363,8 @@ describe('EventManager', () => {
 
       // Trigger event
       const callback = getCallback(PERMISSION_CHANGED);
-      callback!({ permission: true });
+      const payload = getRawPermissionChangedPayload(true);
+      callback!(payload);
 
       expect(handler1).toHaveBeenCalledWith(true);
       expect(handler2).toHaveBeenCalledWith(true);
@@ -385,7 +377,7 @@ describe('EventManager', () => {
       handler2.mockClear();
 
       // Trigger event again
-      callback!({ permission: false });
+      callback!(getRawPermissionChangedPayload(false));
 
       expect(handler1).not.toHaveBeenCalled();
       expect(handler2).toHaveBeenCalledWith(false);
@@ -409,17 +401,16 @@ describe('EventManager', () => {
       const notificationCallback = getCallback(NOTIFICATION_WILL_DISPLAY);
 
       // Trigger different event types
-      permissionCallback!({ permission: true });
-      subscriptionCallback!({ id: 'sub-123' });
-      notificationCallback!({
-        notificationId: 'notif-123',
-        body: 'test',
-        rawPayload: {},
-      });
+      const permissionPayload = getRawPermissionChangedPayload(true);
+      permissionCallback!(permissionPayload);
+      subscriptionCallback!(pushChangedPayload);
+      notificationCallback!(rawWillDisplayPayload);
 
       expect(permissionHandler).toHaveBeenCalledWith(true);
-      expect(subscriptionHandler).toHaveBeenCalledWith({ id: 'sub-123' });
-      expect(notificationWillDisplayHandler).toHaveBeenCalled();
+      expect(subscriptionHandler).toHaveBeenCalledWith(pushChangedPayload);
+      expect(notificationWillDisplayHandler).toHaveBeenCalledWith(
+        new NotificationWillDisplayEvent(rawWillDisplayPayload),
+      );
     });
 
     test('should maintain separate handler arrays for different events', () => {
@@ -455,20 +446,44 @@ describe('EventManager', () => {
 
       const callback = getCallback(SUBSCRIPTION_CHANGED);
 
-      callback!({ id: '1' });
-      expect(handler1).toHaveBeenCalledWith({ id: '1' });
-      expect(handler2).toHaveBeenCalledWith({ id: '1' });
-      expect(handler3).toHaveBeenCalledWith({ id: '1' });
+      callback!(pushChangedPayload);
+      expect(handler1).toHaveBeenCalledWith(pushChangedPayload);
+      expect(handler2).toHaveBeenCalledWith(pushChangedPayload);
+      expect(handler3).toHaveBeenCalledWith(pushChangedPayload);
 
       eventManager.removeEventListener(SUBSCRIPTION_CHANGED, handler2);
       handler1.mockClear();
       handler2.mockClear();
       handler3.mockClear();
 
-      callback!({ id: '2' });
-      expect(handler1).toHaveBeenCalledWith({ id: '2' });
+      callback!(pushChangedPayload);
+      expect(handler1).toHaveBeenCalledWith(pushChangedPayload);
       expect(handler2).not.toHaveBeenCalled();
-      expect(handler3).toHaveBeenCalledWith({ id: '2' });
+      expect(handler3).toHaveBeenCalledWith(pushChangedPayload);
     });
   });
 });
+
+// helper payloads
+const getRawPermissionChangedPayload = (permission: boolean) => ({
+  permission: permission,
+});
+
+const rawWillDisplayPayload = new OSNotification({
+  notificationId: 'test-id',
+  body: 'test-body',
+  rawPayload: {},
+});
+
+const pushChangedPayload = {
+  previous: {
+    id: 'previous-id',
+    token: 'previous-token',
+    optedIn: false,
+  },
+  current: {
+    id: 'current-id',
+    token: 'current-token',
+    optedIn: true,
+  },
+} satisfies PushSubscriptionChangedState;

src/events/EventManager.ts

@@ -29,7 +29,7 @@ import type { UserChangedState } from '../types/user';
 import NotificationWillDisplayEvent from './NotificationWillDisplayEvent';
 
 export interface EventListenerMap {
-  [PERMISSION_CHANGED]: (event: { permission: boolean }) => void;
+  [PERMISSION_CHANGED]: (event: boolean) => void;
   [SUBSCRIPTION_CHANGED]: (event: PushSubscriptionChangedState) => void;
   [USER_STATE_CHANGED]: (event: UserChangedState) => void;
   [NOTIFICATION_WILL_DISPLAY]: (event: NotificationWillDisplayEvent) => void;
@@ -41,6 +41,16 @@ export interface EventListenerMap {
   [IN_APP_MESSAGE_DID_DISPLAY]: (event: InAppMessageDidDisplayEvent) => void;
 }
 
+type RawNotificationOverrides = {
+  [PERMISSION_CHANGED]: (payload: { permission: boolean }) => void;
+  [NOTIFICATION_WILL_DISPLAY]: (payload: OSNotification) => void;
+};
+export type RawEventListenerMap = Omit<
+  EventListenerMap,
+  keyof RawNotificationOverrides
+> &
+  RawNotificationOverrides;
+
 const eventList = [
   PERMISSION_CHANGED,
   SUBSCRIPTION_CHANGED,
@@ -120,10 +130,10 @@ export default class EventManager {
   }
 
   // returns an event listener with the js to native mapping
-  generateEventListener<K extends keyof EventListenerMap>(
+  generateEventListener<K extends keyof RawEventListenerMap>(
     eventName: K,
   ): EmitterSubscription {
-    const addListenerCallback = (payload: unknown) => {
+    const addListenerCallback: RawEventListenerMap[K] = (payload: unknown) => {
       let handlerArray = this.eventListenerArrayMap.get(eventName);
       if (handlerArray) {
         if (eventName === NOTIFICATION_WILL_DISPLAY) {

src/index.test.ts

@@ -12,7 +12,7 @@ import {
   SUBSCRIPTION_CHANGED,
   USER_STATE_CHANGED,
 } from './constants/events';
-import EventManager from './events/EventManager';
+import EventManager, { type EventListenerMap } from './events/EventManager';
 import * as helpers from './helpers';
 import { LogLevel, OneSignal, OSNotificationPermission } from './index';
 
@@ -38,10 +38,12 @@ const removeEventManagerListenerSpy = vi.spyOn(
   'removeEventListener',
 );
 
-const filterEventListener = (eventName: string) => {
+const filterEventListener = <K extends keyof EventListenerMap>(
+  eventName: K,
+): EventListenerMap[K] => {
   return addEventManagerListenerSpy.mock.calls.filter(
     (call) => call[0] === eventName,
-  )[0][1];
+  )[0][1] as EventListenerMap[K];
 };
 
 describe('OneSignal', () => {
@@ -78,20 +80,29 @@ describe('OneSignal', () => {
       expect(permission).toBe(true);
 
       // test push subscription change listener
-      const subscriptionChangeFn = filterEventListener(SUBSCRIPTION_CHANGED);
-      subscriptionChangeFn({
+      const pushData = {
+        previous: {
+          id: '',
+          token: '',
+          optedIn: false,
+        },
         current: {
           id: 'subscription-id',
           token: 'push-token',
           optedIn: true,
         },
-      });
+      };
+      const subscriptionChangeFn = filterEventListener(SUBSCRIPTION_CHANGED);
+      subscriptionChangeFn(pushData);
       const pushSubscription =
         OneSignal.User.pushSubscription.getPushSubscriptionId();
       expect(pushSubscription).toBe('subscription-id');
 
       // reset push subscription
-      subscriptionChangeFn({ current: {} });
+      subscriptionChangeFn({
+        ...pushData,
+        current: { id: '', token: '', optedIn: false },
+      });
     });
 
     test('should not initialize if native module is not loaded', () => {