react-native-notification-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,853 @@
+import { Platform, PermissionsAndroid, Linking } from 'react-native';
+import messaging, { AuthorizationStatus } from '@react-native-firebase/messaging';
+import notifee, { AndroidImportance, EventType, RepeatFrequency, TriggerType, AuthorizationStatus as AuthorizationStatus$1 } from '@notifee/react-native';
+
+class NotificationSDKError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NotificationSDKError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+class FirebaseInitializationError extends NotificationSDKError {
+    constructor() {
+        super("Firebase has not been initialized.");
+        this.name = "FirebaseInitializationError";
+    }
+}
+
+class SDKNotInitializedError extends NotificationSDKError {
+    constructor() {
+        super("Notification SDK must be initialized before calling this method.");
+        this.name = "SDKNotInitializedError";
+    }
+}
+
+class EventBus {
+    listeners = {};
+    on(event, listener) {
+        if (!this.listeners[event]) {
+            //@ts-ignore
+            this.listeners[event] = new Set();
+        }
+        this.listeners[event].add(listener);
+        return () => {
+            this.off(event, listener);
+        };
+    }
+    off(event, listener) {
+        this.listeners[event]?.delete(listener);
+    }
+    emit(event, payload) {
+        this.listeners[event]?.forEach((listener) => listener(payload));
+    }
+    removeAll() {
+        Object.values(this.listeners).forEach((set) => set?.clear());
+    }
+}
+
+class NotificationMapper {
+    /**
+     * Converts a Firebase RemoteMessage into the SDK NotificationPayload.
+     */
+    static fromRemoteMessage(remoteMessage) {
+        const rawData = remoteMessage.data ?? {};
+        const data = Object.keys(rawData).reduce((acc, key) => {
+            const value = rawData[key];
+            acc[key] =
+                typeof value === "string"
+                    ? value
+                    : value == null
+                        ? ""
+                        : JSON.stringify(value);
+            return acc;
+        }, {});
+        return {
+            id: remoteMessage.messageId ?? "",
+            title: remoteMessage.notification?.title ?? data.title,
+            body: remoteMessage.notification?.body ?? data.body,
+            data,
+        };
+    }
+    /**
+     * Converts NotificationPayload into DisplayNotification.
+     */
+    static toDisplayNotification(notification) {
+        return {
+            id: notification.id,
+            title: notification.title ?? "",
+            body: notification.body ?? "",
+            data: notification.data,
+        };
+    }
+}
+
+const SDK_VERSION = "0.0.1";
+
+class NotificationManager {
+    container;
+    eventBus;
+    constructor(container, eventBus) {
+        this.container = container;
+        this.eventBus = eventBus;
+    }
+    initialized = false;
+    async initializeFirebase() {
+        await this.container.firebaseService.initialize((token) => {
+            this.eventBus.emit("tokenRefresh", {
+                token,
+            });
+        });
+        this.container.firebaseListener.start();
+    }
+    registerListeners() {
+        this.container.firebaseListener.onMessage(async (notification) => {
+            this.eventBus.emit("notificationReceived", {
+                notification,
+            });
+            if (this.container.config.foreground?.displayNotifications) {
+                await this.container.notifeeService.displayNotification(NotificationMapper.toDisplayNotification(notification));
+            }
+        });
+        this.container.notifeeService.onNotificationPressed((notification) => {
+            this.container.logger.log("Local notification opened.");
+            this.eventBus.emit("notificationOpened", {
+                notification,
+            });
+        });
+        this.container.notifeeService.onNotificationDismissed((notification) => {
+            this.container.logger.log("Local notification dismissed.");
+            this.eventBus.emit("notificationDismissed", {
+                notification,
+            });
+        });
+        this.container.notifeeService.onNotificationActionPressed((notification, actionId, input) => {
+            this.eventBus.emit("notificationActionPressed", {
+                notification,
+                actionId,
+                input,
+            });
+        });
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.container.logger.log("Initializing SDK...");
+        this.registerListeners();
+        await this.container.notifeeService.initialize(this.container.config.channels);
+        if (this.container.config.ios?.requestPermissionOnLaunch) {
+            await this.requestPermission();
+        }
+        await this.initializeFirebase();
+        this.eventBus.emit("initialized", undefined);
+        this.container.logger.log("SDK initialized.");
+        this.initialized = true;
+    }
+    async requestPermission() {
+        const status = await this.container.permissionService.requestPermission();
+        const granted = this.container.permissionService.isGranted(status);
+        this.eventBus.emit("permissionChanged", {
+            status,
+            granted,
+        });
+        if (granted) {
+            await this.initializeFirebase();
+        }
+        return status;
+    }
+    async getPermissionStatus() {
+        return this.container.permissionService.getPermissionStatus();
+    }
+    async getToken() {
+        await this.initializeFirebase();
+        const token = await this.container.firebaseService.getToken();
+        this.eventBus.emit("tokenGenerated", { token });
+        return token;
+    }
+    async deleteToken() {
+        await this.container.firebaseService.deleteToken();
+    }
+    async displayNotification(notification) {
+        await this.container.notifeeService.displayNotification(notification);
+    }
+    async cancelNotification(id) {
+        await this.container.notifeeService.cancelNotification(id);
+    }
+    async cancelAllNotifications() {
+        await this.container.notifeeService.cancelAllNotifications();
+    }
+    destroy() {
+        this.container.logger.log("Destroying SDK...");
+        this.container.firebaseListener.destroy();
+        this.container.firebaseService.destroy();
+        this.initialized = false;
+    }
+    async scheduleNotification(notification) {
+        return this.container.notifeeService.scheduleNotification(notification);
+    }
+    async cancelScheduledNotification(id) {
+        await this.container.notifeeService.cancelScheduledNotification(id);
+    }
+    async cancelAllScheduledNotifications() {
+        await this.container.notifeeService.cancelAllScheduledNotifications();
+    }
+    async getScheduledNotifications() {
+        return this.container.notifeeService.getScheduledNotifications();
+    }
+    async getStatus() {
+        const permission = await this.container.permissionService.getPermissionStatus();
+        let tokenAvailable = false;
+        try {
+            const token = await this.container.firebaseService.getToken();
+            tokenAvailable = !!token;
+        }
+        catch {
+            tokenAvailable = false;
+        }
+        return {
+            initialized: this.initialized,
+            firebaseInitialized: this.container.firebaseService.isInitialized(),
+            notifeeInitialized: this.container.notifeeService.isInitialized(),
+            permission,
+            tokenAvailable,
+            platform: Platform.OS === "android" ? "android" : "ios",
+            sdkVersion: SDK_VERSION,
+        };
+    }
+    registerBackgroundHandler(handler) {
+        this.container.firebaseListener.registerBackgroundHandler(async (notification) => {
+            if (this.container.config.background?.displayNotifications !== false) {
+                await this.container.notifeeService.displayNotification(NotificationMapper.toDisplayNotification(notification));
+            }
+            await handler?.(notification);
+        });
+    }
+}
+
+class ConsoleLogger {
+    enabled;
+    constructor(enabled) {
+        this.enabled = enabled;
+    }
+    log(...args) {
+        if (!this.enabled)
+            return;
+        console.log("[NotificationSDK]", ...args);
+    }
+    warn(...args) {
+        if (!this.enabled)
+            return;
+        console.warn("[NotificationSDK]", ...args);
+    }
+    error(...args) {
+        if (!this.enabled)
+            return;
+        console.error("[NotificationSDK]", ...args);
+    }
+}
+
+class FirebaseService {
+    logger;
+    tokenRefreshUnsubscribe;
+    initialized = false;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Initializes Firebase Messaging and starts token refresh tracking.
+     */
+    async initialize(onTokenRefresh) {
+        if (this.initialized) {
+            this.logger.log("FirebaseService already initialized.");
+            return;
+        }
+        // iOS requires explicit registration with APNs
+        if (Platform.OS === "ios") {
+            const isRegistered = messaging().isDeviceRegisteredForRemoteMessages;
+            if (!isRegistered) {
+                this.logger.log("Registering device for remote messages...");
+                await messaging().registerDeviceForRemoteMessages();
+                this.logger.log("Device registered for remote messages.");
+            }
+        }
+        await messaging().setAutoInitEnabled(true);
+        this.tokenRefreshUnsubscribe = messaging().onTokenRefresh((token) => {
+            this.logger.log("Firebase token refreshed.");
+            onTokenRefresh(token);
+        });
+        this.initialized = true;
+        this.logger.log("FirebaseService initialized.");
+    }
+    /**
+     * Gets the current Firebase Cloud Messaging token.
+     */
+    async getToken() {
+        if (!this.initialized) {
+            throw new FirebaseInitializationError();
+        }
+        // Extra safety for iOS
+        if (Platform.OS === "ios") {
+            const registered = messaging().isDeviceRegisteredForRemoteMessages;
+            if (!registered) {
+                try {
+                    await messaging().registerDeviceForRemoteMessages();
+                }
+                catch (e) {
+                    this.logger.warn("Unable to register for remote messages.");
+                    throw e;
+                }
+            }
+        }
+        const token = await messaging().getToken();
+        this.logger.log("FCM token generated.");
+        return token;
+    }
+    /**
+     * Deletes the current Firebase Cloud Messaging token.
+     */
+    async deleteToken() {
+        await messaging().deleteToken();
+        this.logger.log("FCM token deleted.");
+    }
+    destroy() {
+        this.tokenRefreshUnsubscribe?.();
+        this.tokenRefreshUnsubscribe = undefined;
+        this.initialized = false;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}
+
+class PermissionService {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Requests notification permission.
+     */
+    async requestPermission() {
+        try {
+            this.logger.log("Requesting notification permission...");
+            // Android
+            if (Platform.OS === "android") {
+                if (Platform.Version >= 33) {
+                    const result = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+                    const status = result === PermissionsAndroid.RESULTS.GRANTED
+                        ? "authorized"
+                        : "denied";
+                    this.logger.log(`Permission status: ${status}`);
+                    return status;
+                }
+                this.logger.log("Android < 13 detected. Notification permission is granted by default.");
+                return "authorized";
+            }
+            // iOS
+            const authorizationStatus = await messaging().requestPermission();
+            const status = this.normalizeStatus(authorizationStatus);
+            this.logger.log(`Permission status: ${status}`);
+            if (this.isGranted(status) &&
+                !messaging().isDeviceRegisteredForRemoteMessages) {
+                this.logger.log("Registering device for remote messages...");
+                await messaging().registerDeviceForRemoteMessages();
+                this.logger.log("Device registered for remote messages.");
+            }
+            return status;
+        }
+        catch (error) {
+            this.logger.error("Failed to request notification permission.", error);
+            throw error;
+        }
+    }
+    /**
+     * Returns current notification permission status.
+     */
+    async getPermissionStatus() {
+        try {
+            // Android
+            if (Platform.OS === "android") {
+                if (Platform.Version < 33) {
+                    return "authorized";
+                }
+                const granted = await PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+                return granted ? "authorized" : "denied";
+            }
+            // iOS
+            const authorizationStatus = await messaging().hasPermission();
+            return this.normalizeStatus(authorizationStatus);
+        }
+        catch (error) {
+            this.logger.error("Failed to get notification permission status.", error);
+            throw error;
+        }
+    }
+    /**
+     * Opens the application settings.
+     */
+    async openSettings() {
+        this.logger.log("Opening application settings...");
+        await Linking.openSettings();
+    }
+    /**
+     * Returns true if permission is granted.
+     */
+    isGranted(status) {
+        return status === "authorized" || status === "provisional";
+    }
+    /**
+     * Registers device for remote messages (iOS only).
+     */
+    async registerForRemoteMessages() {
+        if (Platform.OS !== "ios") {
+            return;
+        }
+        if (messaging().isDeviceRegisteredForRemoteMessages) {
+            this.logger.log("Device already registered for remote messages.");
+            return;
+        }
+        this.logger.log("Registering device for remote messages...");
+        await messaging().registerDeviceForRemoteMessages();
+        this.logger.log("Device registered for remote messages.");
+    }
+    /**
+     * Unregisters device for remote messages (iOS only).
+     */
+    async unregisterForRemoteMessages() {
+        if (Platform.OS !== "ios") {
+            return;
+        }
+        if (!messaging().isDeviceRegisteredForRemoteMessages) {
+            return;
+        }
+        this.logger.log("Unregistering device for remote messages...");
+        await messaging().unregisterDeviceForRemoteMessages();
+        this.logger.log("Device unregistered.");
+    }
+    /**
+     * Converts Firebase authorization status.
+     */
+    normalizeStatus(status) {
+        switch (status) {
+            case AuthorizationStatus.AUTHORIZED:
+                return "authorized";
+            case AuthorizationStatus.PROVISIONAL:
+                return "provisional";
+            case AuthorizationStatus.DENIED:
+                return "denied";
+            case AuthorizationStatus.NOT_DETERMINED:
+                return "notDetermined";
+            default:
+                return "unknown";
+        }
+    }
+}
+
+class FirebaseListener {
+    logger;
+    foregroundUnsubscribe;
+    notificationOpenedUnsubscribe;
+    messageListener;
+    notificationOpenedListener;
+    initialNotificationListener;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Starts listening for foreground Firebase messages.
+     */
+    start() {
+        if (this.foregroundUnsubscribe || this.notificationOpenedUnsubscribe) {
+            return;
+        }
+        this.logger.log("Starting Firebase listeners...");
+        this.foregroundUnsubscribe = messaging().onMessage((remoteMessage) => {
+            this.logger.log("Foreground notification received.");
+            this.messageListener?.(NotificationMapper.fromRemoteMessage(remoteMessage));
+        });
+        this.notificationOpenedUnsubscribe = messaging().onNotificationOpenedApp((remoteMessage) => {
+            this.logger.log("Notification opened from background.");
+            this.notificationOpenedListener?.(NotificationMapper.fromRemoteMessage(remoteMessage));
+        });
+        void this.checkInitialNotification();
+    }
+    /**
+     * Stops all Firebase listeners.
+     */
+    destroy() {
+        this.foregroundUnsubscribe?.();
+        this.notificationOpenedUnsubscribe?.();
+        this.foregroundUnsubscribe = undefined;
+        this.notificationOpenedUnsubscribe = undefined;
+    }
+    onMessage(listener) {
+        this.messageListener = listener;
+    }
+    /**
+     * Maps Firebase RemoteMessage to SDK NotificationPayload.
+     */
+    async checkInitialNotification() {
+        try {
+            const remoteMessage = await messaging().getInitialNotification();
+            if (!remoteMessage) {
+                return;
+            }
+            this.logger.log("Notification opened from terminated state.");
+            this.initialNotificationListener?.(NotificationMapper.fromRemoteMessage(remoteMessage));
+        }
+        catch (error) {
+            this.logger.error("Failed to get initial notification.", error);
+        }
+    }
+    registerBackgroundHandler(handler) {
+        messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+            const notification = NotificationMapper.fromRemoteMessage(remoteMessage);
+            await handler(notification);
+        });
+    }
+}
+
+class NotifeeService {
+    logger;
+    defaultChannelId;
+    mapImportance(importance) {
+        switch (importance) {
+            case "none":
+                return AndroidImportance.NONE;
+            case "min":
+                return AndroidImportance.MIN;
+            case "low":
+                return AndroidImportance.LOW;
+            case "default":
+                return AndroidImportance.DEFAULT;
+            case "high":
+                return AndroidImportance.HIGH;
+            case "max":
+                return AndroidImportance.HIGH;
+            default:
+                return AndroidImportance.HIGH;
+        }
+    }
+    async createChannel(channel) {
+        return notifee.createChannel({
+            id: channel.id,
+            name: channel.name,
+            description: channel.description,
+            importance: this.mapImportance(channel.importance),
+        });
+    }
+    notificationPressedListener;
+    notificationDismissedListener;
+    handleForegroundEvent = ({ type, detail }) => {
+        if (!detail.notification) {
+            return;
+        }
+        const notification = this.mapNotification(detail.notification);
+        switch (type) {
+            case EventType.PRESS:
+                this.logger.log("Local notification pressed.");
+                this.notificationPressedListener?.(notification);
+                break;
+            case EventType.DISMISSED:
+                this.logger.log("Local notification dismissed.");
+                this.notificationDismissedListener?.(notification);
+                break;
+            case EventType.ACTION_PRESS:
+                this.logger.log("Notification action pressed.");
+                this.notificationActionPressedListener?.(notification, detail.pressAction?.id ?? "", detail.input);
+                break;
+        }
+    };
+    mapNotification(notification) {
+        return {
+            id: notification?.id ?? "",
+            title: notification?.title ?? "",
+            body: notification?.body ?? "",
+            data: (notification?.data ?? {}),
+        };
+    }
+    initialized = false;
+    unsubscribeForeground;
+    buildTrigger(notification) {
+        const trigger = notification.trigger;
+        switch (trigger.type) {
+            case "timestamp":
+                return {
+                    type: TriggerType.TIMESTAMP,
+                    timestamp: trigger.timestamp,
+                };
+            case "interval":
+                return {
+                    type: TriggerType.TIMESTAMP,
+                    timestamp: Date.now() + trigger.interval * 1000,
+                    repeatFrequency: trigger.repeat ? RepeatFrequency.DAILY : undefined,
+                };
+        }
+    }
+    buildAndroidNotification(notification) {
+        const android = {
+            channelId: notification.android?.channelId ?? this.defaultChannelId ?? "default",
+            autoCancel: notification.android?.autoCancel ?? true,
+            pressAction: {
+                id: notification.android?.pressActionId ?? "default",
+            },
+        };
+        if (notification.android?.smallIcon) {
+            android.smallIcon = notification.android.smallIcon;
+        }
+        if (notification.android?.largeIcon) {
+            android.largeIcon = notification.android.largeIcon;
+        }
+        if (notification.android?.color) {
+            android.color = notification.android.color;
+        }
+        if (notification.actions?.length) {
+            android.actions = notification.actions.map((action) => ({
+                title: action.title,
+                pressAction: {
+                    id: action.id,
+                    launchActivity: action.launchActivity === "default" ? "default" : undefined,
+                },
+                destructive: action.destructive,
+                input: action.allowInput ? true : undefined,
+            }));
+        }
+        return android;
+    }
+    buildIOSNotification(notification) {
+        const ios = {};
+        if (notification.ios?.badge !== undefined) {
+            ios.badgeCount = notification.ios.badge;
+        }
+        if (notification.ios?.sound) {
+            ios.sound = notification.ios.sound;
+        }
+        if (notification.ios?.categoryId) {
+            ios.categoryId = notification.ios.categoryId;
+        }
+        return ios;
+    }
+    buildNotification(notification) {
+        return {
+            title: notification.title,
+            subtitle: notification.subtitle,
+            body: notification.body,
+            data: notification.data,
+            android: Platform.OS === "android"
+                ? this.buildAndroidNotification(notification)
+                : undefined,
+            ios: Platform.OS === "ios"
+                ? this.buildIOSNotification(notification)
+                : undefined,
+        };
+    }
+    notificationActionPressedListener;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Initializes Notifee.
+     */
+    async initialize(channels) {
+        if (this.initialized) {
+            return;
+        }
+        this.unsubscribeForeground = notifee.onForegroundEvent(this.handleForegroundEvent);
+        if (Platform.OS === "android") {
+            if (!channels?.length) {
+                await this.createDefaultChannel();
+            }
+            else {
+                for (const channel of channels) {
+                    await this.createChannel(channel);
+                }
+            }
+        }
+        this.initialized = true;
+        this.logger.log("Notifee initialized.");
+    }
+    /**
+     * Creates the SDK default notification channel.
+     */
+    async createDefaultChannel() {
+        if (this.defaultChannelId) {
+            return this.defaultChannelId;
+        }
+        this.defaultChannelId = await notifee.createChannel({
+            id: "default",
+            name: "Default",
+            importance: AndroidImportance.HIGH,
+        });
+        this.logger.log(`Default notification channel created (${this.defaultChannelId})`);
+        return this.defaultChannelId;
+    }
+    /**
+     * Requests notification permission.
+     */
+    async requestPermission() {
+        if (Platform.OS === "android") {
+            return true;
+        }
+        const settings = await notifee.requestPermission();
+        return settings.authorizationStatus === AuthorizationStatus$1.AUTHORIZED;
+    }
+    /**
+     * Displays a local notification.
+     */
+    async displayNotification(notification) {
+        if (Platform.OS === "android" && !this.defaultChannelId) {
+            await this.createDefaultChannel();
+        }
+        await notifee.displayNotification(this.buildNotification(notification));
+        this.logger.log("Notification displayed.");
+    }
+    async cancelNotification(id) {
+        await notifee.cancelNotification(id);
+    }
+    async cancelAllNotifications() {
+        await notifee.cancelAllNotifications();
+    }
+    onNotificationPressed(listener) {
+        this.notificationPressedListener = listener;
+    }
+    onNotificationDismissed(listener) {
+        this.notificationDismissedListener = listener;
+    }
+    destroy() {
+        this.unsubscribeForeground?.();
+        this.unsubscribeForeground = undefined;
+        this.notificationPressedListener = undefined;
+        this.notificationDismissedListener = undefined;
+        this.initialized = false;
+        this.logger.log("Notifee destroyed.");
+    }
+    async scheduleNotification(notification) {
+        if (Platform.OS === "android" && !this.defaultChannelId) {
+            await this.createDefaultChannel();
+        }
+        const trigger = this.buildTrigger(notification);
+        const id = await notifee.createTriggerNotification(this.buildNotification(notification), trigger);
+        this.logger.log(`Notification scheduled (${id})`);
+        return id;
+    }
+    async cancelScheduledNotification(id) {
+        await notifee.cancelTriggerNotification(id);
+    }
+    async cancelAllScheduledNotifications() {
+        await notifee.cancelTriggerNotifications();
+    }
+    async getScheduledNotifications() {
+        return notifee.getTriggerNotifications();
+    }
+    onNotificationActionPressed(listener) {
+        this.notificationActionPressedListener = listener;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}
+
+class SDKContainer {
+    config;
+    logger;
+    permissionService;
+    firebaseService;
+    firebaseListener;
+    notifeeService;
+    // readonly deepLinkService: DeepLinkService;
+    constructor(config) {
+        this.config = Object.freeze({
+            ...config,
+        });
+        this.logger = new ConsoleLogger(config.debug ?? false);
+        this.permissionService = new PermissionService(this.logger);
+        this.firebaseService = new FirebaseService(this.logger);
+        this.firebaseListener = new FirebaseListener(this.logger);
+        this.notifeeService = new NotifeeService(this.logger);
+        // this.deepLinkService = new DeepLinkService(this.logger);
+    }
+}
+
+class NotificationSDK {
+    eventBus = new EventBus();
+    manager;
+    async initialize(config) {
+        if (this.manager) {
+            return;
+        }
+        const container = new SDKContainer(config);
+        this.manager = new NotificationManager(container, this.eventBus);
+        await this.manager.initialize();
+    }
+    on(event, listener) {
+        return this.eventBus.on(event, listener);
+    }
+    off(event, listener) {
+        this.eventBus.off(event, listener);
+    }
+    async requestPermission() {
+        return this.getManager().requestPermission();
+    }
+    async getPermissionStatus() {
+        return this.getManager().getPermissionStatus();
+    }
+    async getToken() {
+        return this.getManager().getToken();
+    }
+    async deleteToken() {
+        await this.getManager().deleteToken();
+    }
+    async displayNotification(notification) {
+        await this.getManager().displayNotification(notification);
+    }
+    async cancelNotification(id) {
+        await this.getManager().cancelNotification(id);
+    }
+    async cancelAllNotifications() {
+        await this.getManager().cancelAllNotifications();
+    }
+    async scheduleNotification(notification) {
+        return this.getManager().scheduleNotification(notification);
+    }
+    async cancelScheduledNotification(id) {
+        await this.getManager().cancelScheduledNotification(id);
+    }
+    async cancelAllScheduledNotifications() {
+        await this.getManager().cancelAllScheduledNotifications();
+    }
+    async getScheduledNotifications() {
+        return this.getManager().getScheduledNotifications();
+    }
+    destroy() {
+        this.manager?.destroy();
+        this.manager = undefined;
+        this.eventBus.removeAll();
+    }
+    async getStatus() {
+        return this.getManager().getStatus();
+    }
+    getManager() {
+        if (!this.manager) {
+            throw new SDKNotInitializedError();
+        }
+        return this.manager;
+    }
+}
+
+function registerBackgroundHandler(handler) {
+    messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+        const notification = NotificationMapper.fromRemoteMessage(remoteMessage);
+        const logger = new ConsoleLogger(false);
+        const notifee = new NotifeeService(logger);
+        await notifee.initialize();
+        await notifee.displayNotification(NotificationMapper.toDisplayNotification(notification));
+        await handler?.(notification);
+    });
+}
+
+const Notifications = new NotificationSDK();
+
+export { Notifications as default, registerBackgroundHandler };
+//# sourceMappingURL=index.js.map