@imatis/react-native-notifications 4.3.3-imatis.11 → 4.3.3-imatis.13

package/lib/dist/commands/Commands.test.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts_mockito_1 = require("ts-mockito");
+const Commands_1 = require("./Commands");
+const NativeCommandsSender_1 = require("../adapters/NativeCommandsSender");
+const Notification_1 = require("../DTO/Notification");
+const UniqueIdProvider_1 = require("../adapters/UniqueIdProvider");
+const NotificationFactory_1 = require("../DTO/NotificationFactory");
+const NotificationAndroid_1 = require("../DTO/NotificationAndroid");
+const react_native_1 = require("react-native");
+const NotificationIOS_1 = require("../DTO/NotificationIOS");
+describe('Commands', () => {
+    let uut;
+    let mockedNativeCommandsSender;
+    let mockedUniqueIdProvider;
+    let notificationFactory;
+    beforeEach(() => {
+        notificationFactory = new NotificationFactory_1.NotificationFactory();
+        mockedNativeCommandsSender = (0, ts_mockito_1.mock)(NativeCommandsSender_1.NativeCommandsSender);
+        mockedUniqueIdProvider = (0, ts_mockito_1.mock)(UniqueIdProvider_1.UniqueIdProvider);
+        (0, ts_mockito_1.when)(mockedUniqueIdProvider.generate()).thenCall(() => 12);
+        uut = new Commands_1.Commands((0, ts_mockito_1.instance)(mockedNativeCommandsSender), (0, ts_mockito_1.instance)(mockedUniqueIdProvider), notificationFactory);
+    });
+    describe('getInitialNotification', () => {
+        it('sends to native', () => {
+            uut.getInitialNotification();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.getInitialNotification()).called();
+        });
+        it('Android - returns a promise with the initial notification', async () => {
+            react_native_1.Platform.OS = 'android';
+            const expectedNotification = new NotificationAndroid_1.NotificationAndroid({ 'google.message_id': 'id' });
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.getInitialNotification()).thenResolve({ 'google.message_id': 'id' });
+            const result = await uut.getInitialNotification();
+            expect(result).toEqual(expectedNotification);
+        });
+        it('Should return undefined initial notification', async () => {
+            react_native_1.Platform.OS = 'android';
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.getInitialNotification()).thenResolve();
+            const result = await uut.getInitialNotification();
+            expect(result).toEqual(undefined);
+        });
+        it('iOS - returns a promise with the initial notification', async () => {
+            react_native_1.Platform.OS = 'ios';
+            const expectedNotification = new NotificationIOS_1.NotificationIOS({ identifier: 'id' });
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.getInitialNotification()).thenResolve({ identifier: 'id' });
+            const result = await uut.getInitialNotification();
+            expect(result).toEqual(expectedNotification);
+        });
+    });
+    describe('requestPermissions', () => {
+        it('sends to native', () => {
+            const opts = {};
+            uut.requestPermissions(opts);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.requestPermissions(opts)).called();
+        });
+        it('sends to native with options', () => {
+            const opts = { criticalAlert: true };
+            uut.requestPermissions(opts);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.requestPermissions(opts)).called();
+        });
+    });
+    describe('registerPushKit', () => {
+        it('sends to native', () => {
+            uut.registerPushKit();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.registerPushKit()).called();
+        });
+    });
+    describe('setCategories', () => {
+        it('sends to native', () => {
+            const emptyCategoriesArray = [];
+            uut.setCategories(emptyCategoriesArray);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.setCategories(emptyCategoriesArray)).called();
+        });
+        it('sends to native with categories', () => {
+            const category = { identifier: 'id', actions: [] };
+            const categoriesArray = [category];
+            uut.setCategories(categoriesArray);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.setCategories(categoriesArray)).called();
+        });
+    });
+    describe('abandonPermissions', () => {
+        it('sends to native', () => {
+            uut.abandonPermissions();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.abandonPermissions()).called();
+        });
+    });
+    describe('postLocalNotification', () => {
+        it('sends to native', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            uut.postLocalNotification(notification);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.postLocalNotification(notification, (0, ts_mockito_1.anyNumber)())).called();
+        });
+        it('generates unique identifier', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            uut.postLocalNotification(notification);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.postLocalNotification(notification, (0, ts_mockito_1.anyNumber)())).called();
+        });
+        it('use passed notification id', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            const passedId = 2;
+            uut.postLocalNotification(notification, passedId);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.postLocalNotification(notification, passedId)).called();
+        });
+        it('return notification id', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            const notificationId = 2;
+            const response = uut.postLocalNotification(notification, notificationId);
+            expect(response).toEqual(notificationId);
+        });
+    });
+    describe('getBadgeCount', () => {
+        it('sends to native', () => {
+            uut.getBadgeCount();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.getBadgeCount()).called();
+        });
+    });
+    describe('setBadgeCount', () => {
+        it('sends to native', () => {
+            uut.setBadgeCount(10);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.setBadgeCount(10)).called();
+        });
+    });
+    describe('cancelLocalNotification', () => {
+        it('sends to native', () => {
+            const notificationId = 1;
+            uut.cancelLocalNotification(notificationId);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.cancelLocalNotification(notificationId)).called();
+        });
+    });
+    describe('cancelAllLocalNotifications', () => {
+        it('sends to native', () => {
+            uut.cancelAllLocalNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.cancelAllLocalNotifications()).called();
+        });
+    });
+    describe('isRegisteredForRemoteNotifications', () => {
+        it('sends to native', () => {
+            uut.isRegisteredForRemoteNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).called();
+        });
+        it('return positive response from native', async () => {
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).thenResolve(true);
+            const isRegistered = await uut.isRegisteredForRemoteNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).called();
+            expect(isRegistered).toEqual(true);
+        });
+        it('return negative response from native', async () => {
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).thenResolve(false);
+            const isRegistered = await uut.isRegisteredForRemoteNotifications();
+            expect(isRegistered).toEqual(false);
+        });
+    });
+    describe('checkPermissions', () => {
+        it('sends to native', () => {
+            uut.checkPermissions();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.checkPermissions()).called();
+        });
+        it('return negative response from native', async () => {
+            const expectedPermissions = {
+                badge: false,
+                alert: true,
+                sound: false,
+                carPlay: false,
+                criticalAlert: false,
+                providesAppNotificationSettings: false,
+                provisional: false,
+                announcement: false,
+                notificationCenter: true,
+                lockScreen: false,
+            };
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.checkPermissions()).thenResolve(expectedPermissions);
+            const permissions = await uut.checkPermissions();
+            expect(permissions).toEqual(expectedPermissions);
+        });
+    });
+    describe('removeAllDeliveredNotifications', () => {
+        it('sends to native', () => {
+            uut.removeAllDeliveredNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.removeAllDeliveredNotifications()).called();
+        });
+    });
+    describe('removeDeliveredNotifications', () => {
+        it('sends to native', () => {
+            const identifiers = ["id1", "id2"];
+            uut.removeDeliveredNotifications(identifiers);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.removeDeliveredNotifications(identifiers)).called();
+        });
+    });
+    describe('getDeliveredNotifications', () => {
+        it('sends to native', () => {
+            uut.getDeliveredNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.getDeliveredNotifications()).called();
+        });
+    });
+    describe('refreshToken', () => {
+        it('sends to native', () => {
+            uut.refreshToken();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.refreshToken()).called();
+        });
+    });
+});

package/lib/dist/events/EventsRegistry.d.ts

@@ -0,0 +1,18 @@
+import { EmitterSubscription } from 'react-native';
+import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver';
+import { Registered, RegistrationError } from '../interfaces/NotificationEvents';
+import { NotificationActionResponse } from '../interfaces/NotificationActionResponse';
+import { CompletionCallbackWrapper } from '../adapters/CompletionCallbackWrapper';
+import { Notification } from '../DTO/Notification';
+import { NotificationCompletion, NotificationBackgroundFetchResult } from '../interfaces/NotificationCompletion';
+export declare class EventsRegistry {
+    private nativeEventsReceiver;
+    private completionCallbackWrapper;
+    constructor(nativeEventsReceiver: NativeEventsReceiver, completionCallbackWrapper: CompletionCallbackWrapper);
+    registerRemoteNotificationsRegistered(callback: (event: Registered) => void): EmitterSubscription;
+    registerNotificationReceivedForeground(callback: (notification: Notification, completion: (response: NotificationCompletion) => void) => void): EmitterSubscription;
+    registerNotificationReceivedBackground(callback: (notification: Notification, completion: (response: NotificationBackgroundFetchResult) => void) => void): EmitterSubscription;
+    registerNotificationOpened(callback: (notification: Notification, completion: () => void, actionResponse?: NotificationActionResponse) => void): EmitterSubscription;
+    registerRemoteNotificationsRegistrationFailed(callback: (event: RegistrationError) => void): EmitterSubscription;
+    registerRemoteNotificationsRegistrationDenied(callback: () => void): EmitterSubscription;
+}

package/lib/dist/events/EventsRegistry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsRegistry = void 0;
+class EventsRegistry {
+    nativeEventsReceiver;
+    completionCallbackWrapper;
+    constructor(nativeEventsReceiver, completionCallbackWrapper) {
+        this.nativeEventsReceiver = nativeEventsReceiver;
+        this.completionCallbackWrapper = completionCallbackWrapper;
+    }
+    registerRemoteNotificationsRegistered(callback) {
+        return this.nativeEventsReceiver.registerRemoteNotificationsRegistered(callback);
+    }
+    registerNotificationReceivedForeground(callback) {
+        return this.nativeEventsReceiver.registerNotificationReceived(this.completionCallbackWrapper.wrapReceivedForegroundCallback(callback));
+    }
+    registerNotificationReceivedBackground(callback) {
+        return this.nativeEventsReceiver.registerNotificationReceivedBackground(this.completionCallbackWrapper.wrapReceivedBackgroundCallback(callback));
+    }
+    registerNotificationOpened(callback) {
+        return this.nativeEventsReceiver.registerNotificationOpened(this.completionCallbackWrapper.wrapOpenedCallback(callback));
+    }
+    registerRemoteNotificationsRegistrationFailed(callback) {
+        return this.nativeEventsReceiver.registerRemoteNotificationsRegistrationFailed(callback);
+    }
+    registerRemoteNotificationsRegistrationDenied(callback) {
+        return this.nativeEventsReceiver.registerRemoteNotificationsRegistrationDenied(callback);
+    }
+}
+exports.EventsRegistry = EventsRegistry;

package/lib/dist/events/EventsRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/events/EventsRegistry.test.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const Notification_1 = require("../DTO/Notification");
+const CompletionCallbackWrapper_1 = require("../adapters/CompletionCallbackWrapper");
+const NativeCommandsSender_1 = require("../adapters/NativeCommandsSender");
+const NativeEventsReceiver_1 = require("../adapters/NativeEventsReceiver");
+const NotificationCompletion_1 = require("../interfaces/NotificationCompletion");
+const EventsRegistry_1 = require("./EventsRegistry");
+jest.mock('../adapters/NativeCommandsSender');
+jest.mock('../adapters/NativeEventsReceiver');
+describe('EventsRegistry', () => {
+    let uut;
+    const mockNativeEventsReceiver = new NativeEventsReceiver_1.NativeEventsReceiver();
+    const mockNativeCommandsSender = new NativeCommandsSender_1.NativeCommandsSender();
+    const completionCallbackWrapper = new CompletionCallbackWrapper_1.CompletionCallbackWrapper(mockNativeCommandsSender);
+    beforeEach(() => {
+        uut = new EventsRegistry_1.EventsRegistry(mockNativeEventsReceiver, completionCallbackWrapper);
+    });
+    describe('registerRemoteNotificationsReceivedForeground', () => {
+        beforeEach(() => {
+            react_native_1.AppState.currentState = 'active';
+        });
+        it('delegates to nativeEventsReceiver', () => {
+            const cb = jest.fn();
+            uut.registerNotificationReceivedForeground(cb);
+            expect(mockNativeEventsReceiver.registerNotificationReceived).toHaveBeenCalledTimes(1);
+            expect(mockNativeEventsReceiver.registerNotificationReceived).toHaveBeenCalledWith(expect.any(Function));
+        });
+        it('should wrap callback with completion block', () => {
+            const wrappedCallback = jest.fn();
+            const notification = new Notification_1.Notification({ identifier: 'identifier' });
+            uut.registerNotificationReceivedForeground(wrappedCallback);
+            const call = mockNativeEventsReceiver.registerNotificationReceived.mock.calls[0][0];
+            call(notification);
+            expect(wrappedCallback).toBeCalledWith(notification, expect.any(Function));
+            expect(wrappedCallback).toBeCalledTimes(1);
+        });
+        it('should wrap callback with completion block', () => {
+            const expectedNotification = new Notification_1.Notification({ identifier: 'identifier' });
+            uut.registerNotificationReceivedForeground((notification) => {
+                expect(notification).toEqual(expectedNotification);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationReceived.mock.calls[0][0];
+            call(expectedNotification);
+        });
+        it('should invoke finishPresentingNotification', () => {
+            const notification = new Notification_1.Notification({ identifier: 'notificationId' });
+            const response = { alert: true };
+            uut.registerNotificationReceivedForeground((notification, completion) => {
+                completion(response);
+                expect(mockNativeCommandsSender.finishPresentingNotification).toBeCalledWith(notification.identifier, response);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationReceived.mock.calls[0][0];
+            call(notification);
+        });
+        it('should not invoke finishPresentingNotification on Android', () => {
+            react_native_1.Platform.OS = 'android';
+            const expectedNotification = new Notification_1.Notification({ identifier: 'notificationId' });
+            const response = { alert: true };
+            uut.registerNotificationReceivedForeground((notification, completion) => {
+                completion(response);
+                expect(expectedNotification).toEqual(notification);
+                expect(mockNativeCommandsSender.finishPresentingNotification).toBeCalledTimes(0);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationReceived.mock.calls[0][0];
+            call(expectedNotification);
+        });
+    });
+    describe('registerRemoteNotificationsReceivedBackground', () => {
+        beforeEach(() => {
+            react_native_1.AppState.currentState = 'background';
+        });
+        it('delegates to nativeEventsReceiver', () => {
+            const cb = jest.fn();
+            uut.registerNotificationReceivedBackground(cb);
+            expect(mockNativeEventsReceiver.registerNotificationReceivedBackground).toHaveBeenCalledTimes(1);
+            expect(mockNativeEventsReceiver.registerNotificationReceivedBackground).toHaveBeenCalledWith(expect.any(Function));
+        });
+        it('should wrap callback with completion block', () => {
+            const wrappedCallback = jest.fn();
+            const notification = new Notification_1.Notification({ identifier: 'identifier' });
+            uut.registerNotificationReceivedBackground(wrappedCallback);
+            const call = mockNativeEventsReceiver.registerNotificationReceivedBackground.mock.calls[0][0];
+            call(notification);
+            expect(wrappedCallback).toBeCalledWith(notification, expect.any(Function));
+            expect(wrappedCallback).toBeCalledTimes(1);
+        });
+        it('should wrap callback with completion block', () => {
+            const expectedNotification = new Notification_1.Notification({ identifier: 'identifier' });
+            uut.registerNotificationReceivedBackground((notification) => {
+                expect(notification).toEqual(expectedNotification);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationReceivedBackground.mock.calls[0][0];
+            call(expectedNotification);
+        });
+        it('should invoke finishHandlingBackgroundAction', () => {
+            const notification = new Notification_1.Notification({ identifier: 'notificationId' });
+            const response = NotificationCompletion_1.NotificationBackgroundFetchResult.NO_DATA;
+            uut.registerNotificationReceivedBackground((notification, completion) => {
+                completion(response);
+                expect(mockNativeCommandsSender.finishHandlingBackgroundAction).toBeCalledWith(notification.identifier, response);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationReceivedBackground.mock.calls[0][0];
+            call(notification);
+        });
+        it('should not invoke finishHandlingBackgroundAction on Android', () => {
+            react_native_1.Platform.OS = 'android';
+            const expectedNotification = new Notification_1.Notification({ identifier: 'notificationId' });
+            const response = NotificationCompletion_1.NotificationBackgroundFetchResult.NO_DATA;
+            uut.registerNotificationReceivedBackground((notification, completion) => {
+                completion(response);
+                expect(expectedNotification).toEqual(notification);
+                expect(mockNativeCommandsSender.finishHandlingBackgroundAction).toBeCalledTimes(0);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationReceivedBackground.mock.calls[0][0];
+            call(expectedNotification);
+        });
+    });
+    describe('', () => {
+        it('delegates to nativeEventsReceiver', () => {
+            const cb = jest.fn();
+            uut.registerNotificationOpened(cb);
+            expect(mockNativeEventsReceiver.registerNotificationOpened).toHaveBeenCalledTimes(1);
+            expect(mockNativeEventsReceiver.registerNotificationOpened).toHaveBeenCalledWith(expect.any(Function));
+        });
+        it('should wrap callback with completion block', () => {
+            const wrappedCallback = jest.fn();
+            const notification = new Notification_1.Notification({ identifier: 'identifier' });
+            const response = {
+                notification,
+                identifier: 'responseId',
+                action: { identifier: 'actionIdentifier', text: 'userText' },
+            };
+            uut.registerNotificationOpened(wrappedCallback);
+            const call = mockNativeEventsReceiver.registerNotificationOpened.mock.calls[0][0];
+            call(response.notification, response.action);
+            expect(wrappedCallback).toBeCalledWith(response.notification, expect.any(Function), response.action);
+            expect(wrappedCallback).toBeCalledTimes(1);
+        });
+        it('should wrap callback with completion block', () => {
+            const notification = new Notification_1.Notification({ identifier: 'identifier' });
+            uut.registerNotificationOpened((response) => {
+                expect(response).toEqual(notification);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationOpened.mock.calls[0][0];
+            call(notification);
+        });
+        it('calling completion should invoke finishHandlingAction', () => {
+            const expectedNotification = new Notification_1.Notification({ identifier: 'notificationId' });
+            uut.registerNotificationOpened((notification, completion) => {
+                completion();
+                expect(expectedNotification).toEqual(notification);
+                expect(mockNativeCommandsSender.finishHandlingAction).toBeCalledWith(notification.identifier);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationOpened.mock.calls[0][0];
+            call(expectedNotification);
+        });
+        it('should not invoke finishHandlingAction on Android', () => {
+            react_native_1.Platform.OS = 'android';
+            const expectedNotification = new Notification_1.Notification({ identifier: 'notificationId' });
+            uut.registerNotificationOpened((notification, completion) => {
+                completion();
+                expect(expectedNotification).toEqual(notification);
+                expect(mockNativeCommandsSender.finishHandlingAction).toBeCalledTimes(0);
+            });
+            const call = mockNativeEventsReceiver.registerNotificationOpened.mock.calls[0][0];
+            call(expectedNotification);
+        });
+    });
+    it('delegates registerRemoteNotificationsRegistered to nativeEventsReceiver', () => {
+        const cb = jest.fn();
+        uut.registerRemoteNotificationsRegistered(cb);
+        expect(mockNativeEventsReceiver.registerRemoteNotificationsRegistered).toHaveBeenCalledTimes(1);
+        expect(mockNativeEventsReceiver.registerRemoteNotificationsRegistered).toHaveBeenCalledWith(cb);
+    });
+    it('delegates registerRemoteNotificationsRegistrationFailed to nativeEventsReceiver', () => {
+        const cb = jest.fn();
+        uut.registerRemoteNotificationsRegistrationFailed(cb);
+        expect(mockNativeEventsReceiver.registerRemoteNotificationsRegistrationFailed).toHaveBeenCalledTimes(1);
+        expect(mockNativeEventsReceiver.registerRemoteNotificationsRegistrationFailed).toHaveBeenCalledWith(cb);
+    });
+});

package/lib/dist/events/EventsRegistryIOS.d.ts

@@ -0,0 +1,12 @@
+import { EmitterSubscription } from 'react-native';
+import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver';
+import { RegisteredPushKit } from '../interfaces/NotificationEvents';
+import { CompletionCallbackWrapper } from '../adapters/CompletionCallbackWrapper';
+export declare class EventsRegistryIOS {
+    private nativeEventsReceiver;
+    private completionCallbackWrapper;
+    constructor(nativeEventsReceiver: NativeEventsReceiver, completionCallbackWrapper: CompletionCallbackWrapper);
+    registerPushKitRegistered(callback: (event: RegisteredPushKit) => void): EmitterSubscription;
+    registerPushKitNotificationReceived(callback: (event: object, completion: () => void) => void): EmitterSubscription;
+    appNotificationSettingsLinked(callback: () => void): EmitterSubscription;
+}

package/lib/dist/events/EventsRegistryIOS.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsRegistryIOS = void 0;
+class EventsRegistryIOS {
+    nativeEventsReceiver;
+    completionCallbackWrapper;
+    constructor(nativeEventsReceiver, completionCallbackWrapper) {
+        this.nativeEventsReceiver = nativeEventsReceiver;
+        this.completionCallbackWrapper = completionCallbackWrapper;
+    }
+    registerPushKitRegistered(callback) {
+        return this.nativeEventsReceiver.registerPushKitRegistered(callback);
+    }
+    registerPushKitNotificationReceived(callback) {
+        return this.nativeEventsReceiver.registerPushKitNotificationReceived(this.completionCallbackWrapper.wrapOpenedCallback(callback));
+    }
+    appNotificationSettingsLinked(callback) {
+        return this.nativeEventsReceiver.appNotificationSettingsLinked(callback);
+    }
+}
+exports.EventsRegistryIOS = EventsRegistryIOS;

package/lib/dist/events/EventsRegistryIOS.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/events/EventsRegistryIOS.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const EventsRegistryIOS_1 = require("./EventsRegistryIOS");
+const CompletionCallbackWrapper_1 = require("../adapters/CompletionCallbackWrapper");
+const NativeCommandsSender_1 = require("../adapters/NativeCommandsSender");
+const NativeEventsReceiver_1 = require("../adapters/NativeEventsReceiver");
+jest.mock('../adapters/NativeCommandsSender');
+jest.mock('../adapters/NativeEventsReceiver');
+describe('EventsRegistryIOS', () => {
+    let uut;
+    const mockNativeEventsReceiver = new NativeEventsReceiver_1.NativeEventsReceiver();
+    const mockNativeCommandsSender = new NativeCommandsSender_1.NativeCommandsSender();
+    const completionCallbackWrapper = new CompletionCallbackWrapper_1.CompletionCallbackWrapper(mockNativeCommandsSender);
+    beforeEach(() => {
+        uut = new EventsRegistryIOS_1.EventsRegistryIOS(mockNativeEventsReceiver, completionCallbackWrapper);
+    });
+    it('delegates registerPushKitRegistered to nativeEventsReceiver', () => {
+        const cb = jest.fn();
+        uut.registerPushKitRegistered(cb);
+        expect(mockNativeEventsReceiver.registerPushKitRegistered).toHaveBeenCalledTimes(1);
+        expect(mockNativeEventsReceiver.registerPushKitRegistered).toHaveBeenCalledWith(cb);
+    });
+    it('delegates registerPushKitNotificationReceived to nativeEventsReceiver', () => {
+        const cb = jest.fn();
+        uut.registerPushKitNotificationReceived(cb);
+        expect(mockNativeEventsReceiver.registerPushKitNotificationReceived).toHaveBeenCalledTimes(1);
+        expect(mockNativeEventsReceiver.registerPushKitNotificationReceived).toHaveBeenCalledWith(expect.any(Function));
+    });
+    it('should wrap callback with completion block', () => {
+        const expectedNotification = { identifier: 'notificationId' };
+        uut.registerPushKitNotificationReceived((notification) => {
+            expect(notification).toEqual(expectedNotification);
+        });
+        const call = mockNativeEventsReceiver.registerPushKitNotificationReceived.mock.calls[0][0];
+        call(expectedNotification);
+    });
+    it('should invoke finishPresentingNotification', () => {
+        const expectedNotification = { identifier: 'notificationId' };
+        uut.registerPushKitNotificationReceived((notification, completion) => {
+            completion();
+            expect(notification).toEqual(expectedNotification);
+            expect(mockNativeCommandsSender.finishHandlingAction).toBeCalledWith('notificationId');
+        });
+        const call = mockNativeEventsReceiver.registerPushKitNotificationReceived.mock.calls[0][0];
+        call(expectedNotification);
+    });
+    it('delegates appNotificationSettingsLinked to nativeEventsReceiver', () => {
+        const cb = jest.fn();
+        uut.appNotificationSettingsLinked(cb);
+        expect(mockNativeEventsReceiver.appNotificationSettingsLinked).toHaveBeenCalledTimes(1);
+        expect(mockNativeEventsReceiver.appNotificationSettingsLinked).toHaveBeenCalledWith(cb);
+    });
+});

package/lib/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { NotificationsRoot } from './Notifications';
+export declare const Notifications: NotificationsRoot;
+export * from './interfaces/EventSubscription';
+export * from './DTO/Notification';
+export * from './interfaces/NotificationEvents';
+export * from './interfaces/NotificationCategory';
+export * from './interfaces/NotificationCompletion';

package/lib/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifications = void 0;
+const tslib_1 = require("tslib");
+const Notifications_1 = require("./Notifications");
+const notificationsSingleton = new Notifications_1.NotificationsRoot();
+exports.Notifications = notificationsSingleton;
+tslib_1.__exportStar(require("./interfaces/EventSubscription"), exports);
+tslib_1.__exportStar(require("./DTO/Notification"), exports);
+tslib_1.__exportStar(require("./interfaces/NotificationEvents"), exports);
+tslib_1.__exportStar(require("./interfaces/NotificationCategory"), exports);
+tslib_1.__exportStar(require("./interfaces/NotificationCompletion"), exports);

package/lib/dist/interfaces/EventSubscription.d.ts

@@ -0,0 +1,3 @@
+export interface EventSubscription {
+    remove(): void;
+}

package/lib/dist/interfaces/EventSubscription.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dist/interfaces/NotificationActionResponse.d.ts

@@ -0,0 +1,5 @@
+export declare class NotificationActionResponse {
+    identifier: string;
+    text?: string;
+    constructor(response: any);
+}

package/lib/dist/interfaces/NotificationActionResponse.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationActionResponse = void 0;
+class NotificationActionResponse {
+    identifier;
+    text;
+    constructor(response) {
+        this.identifier = response.identifier;
+        this.text = response.text;
+    }
+}
+exports.NotificationActionResponse = NotificationActionResponse;

package/lib/dist/interfaces/NotificationCategory.d.ts

@@ -0,0 +1,18 @@
+export declare class NotificationCategory {
+    identifier: string;
+    actions?: NotificationAction[];
+    constructor(identifier: string, actions?: NotificationAction[]);
+}
+export interface NotificationTextInput {
+    buttonTitle: string;
+    placeholder: string;
+}
+export type ActivationMode = 'background' | 'foreground' | 'authenticationRequired' | 'destructive';
+export declare class NotificationAction {
+    identifier: string;
+    activationMode: ActivationMode;
+    title: string;
+    authenticationRequired: boolean;
+    textInput?: NotificationTextInput;
+    constructor(identifier: string, activationMode: ActivationMode, title: string, authenticationRequired: boolean, textInput?: NotificationTextInput);
+}

package/lib/dist/interfaces/NotificationCategory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationAction = exports.NotificationCategory = void 0;
+class NotificationCategory {
+    identifier;
+    actions;
+    constructor(identifier, actions) {
+        this.identifier = identifier;
+        this.actions = actions;
+    }
+}
+exports.NotificationCategory = NotificationCategory;
+class NotificationAction {
+    identifier;
+    activationMode;
+    title;
+    authenticationRequired;
+    textInput;
+    constructor(identifier, activationMode, title, authenticationRequired, textInput) {
+        this.identifier = identifier;
+        this.activationMode = activationMode;
+        this.title = title;
+        this.authenticationRequired = authenticationRequired;
+        this.textInput = textInput;
+    }
+}
+exports.NotificationAction = NotificationAction;

package/lib/dist/interfaces/NotificationChannel.d.ts

@@ -0,0 +1,14 @@
+export interface NotificationChannel {
+    channelId: string;
+    name: string;
+    importance: -1000 | 0 | 1 | 2 | 3 | 4 | 5;
+    description?: string;
+    enableLights?: boolean;
+    enableVibration?: boolean;
+    groupId?: string;
+    groupName?: string;
+    lightColor?: string;
+    showBadge?: boolean;
+    soundFile?: string;
+    vibrationPattern?: number[];
+}

package/lib/dist/interfaces/NotificationChannel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });