svelte-firekit 0.1.9 → 0.2.0

package/dist/services/in-app-messaging.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Reactive Firebase In-App Messaging service.
+ *
+ * In-App Messaging displays contextual messages to users while they are actively
+ * using your app. Messages are configured in the Firebase console and triggered
+ * by Analytics events. This service lets you control whether messages are shown.
+ *
+ * @example
+ * ```ts
+ * import { firekitInAppMessaging } from 'svelte-firekit';
+ *
+ * // Suppress messages during a critical flow (e.g. checkout)
+ * firekitInAppMessaging.suppress();
+ *
+ * // Re-enable after the flow completes
+ * firekitInAppMessaging.unsuppress();
+ * ```
+ */
+declare class FirekitInAppMessaging {
+    private static instance;
+    private _suppressed;
+    private _supported;
+    private _initialized;
+    private _iam;
+    private constructor();
+    static getInstance(): FirekitInAppMessaging;
+    get suppressed(): boolean;
+    get supported(): boolean;
+    get initialized(): boolean;
+    private _init;
+    /**
+     * Suppresses all In-App Messaging messages.
+     * Useful during critical flows such as checkout or sensitive forms.
+     */
+    suppress(): void;
+    /**
+     * Re-enables In-App Messaging after suppression.
+     */
+    unsuppress(): void;
+    /**
+     * Toggles suppression state.
+     */
+    toggleSuppression(): void;
+}
+export declare const firekitInAppMessaging: FirekitInAppMessaging;
+export {};

package/dist/services/in-app-messaging.js

@@ -0,0 +1,88 @@
+import { getInAppMessaging, setMessagesDisplaySuppressed, isSupported } from 'firebase/in-app-messaging';
+import { firebaseService } from '../firebase.js';
+function getApp() {
+    const app = firebaseService.getFirebaseApp();
+    if (!app)
+        throw new Error('Firebase app is not initialized.');
+    return app;
+}
+/**
+ * Reactive Firebase In-App Messaging service.
+ *
+ * In-App Messaging displays contextual messages to users while they are actively
+ * using your app. Messages are configured in the Firebase console and triggered
+ * by Analytics events. This service lets you control whether messages are shown.
+ *
+ * @example
+ * ```ts
+ * import { firekitInAppMessaging } from 'svelte-firekit';
+ *
+ * // Suppress messages during a critical flow (e.g. checkout)
+ * firekitInAppMessaging.suppress();
+ *
+ * // Re-enable after the flow completes
+ * firekitInAppMessaging.unsuppress();
+ * ```
+ */
+class FirekitInAppMessaging {
+    static instance;
+    _suppressed = $state(false);
+    _supported = $state(false);
+    _initialized = $state(false);
+    _iam = null;
+    constructor() {
+        this._init();
+    }
+    static getInstance() {
+        if (!FirekitInAppMessaging.instance) {
+            FirekitInAppMessaging.instance = new FirekitInAppMessaging();
+        }
+        return FirekitInAppMessaging.instance;
+    }
+    get suppressed() { return this._suppressed; }
+    get supported() { return this._supported; }
+    get initialized() { return this._initialized; }
+    async _init() {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            const supported = await isSupported();
+            this._supported = supported;
+            if (!supported)
+                return;
+            this._iam = getInAppMessaging(getApp());
+            // messagesDisplaySuppressed is a property on the InAppMessaging instance
+            this._suppressed = this._iam.messagesDisplaySuppressed;
+            this._initialized = true;
+        }
+        catch {
+            // In-App Messaging is optional — failures are non-fatal
+        }
+    }
+    /**
+     * Suppresses all In-App Messaging messages.
+     * Useful during critical flows such as checkout or sensitive forms.
+     */
+    suppress() {
+        if (!this._iam)
+            return;
+        setMessagesDisplaySuppressed(this._iam, true);
+        this._suppressed = true;
+    }
+    /**
+     * Re-enables In-App Messaging after suppression.
+     */
+    unsuppress() {
+        if (!this._iam)
+            return;
+        setMessagesDisplaySuppressed(this._iam, false);
+        this._suppressed = false;
+    }
+    /**
+     * Toggles suppression state.
+     */
+    toggleSuppression() {
+        this._suppressed ? this.unsuppress() : this.suppress();
+    }
+}
+export const firekitInAppMessaging = FirekitInAppMessaging.getInstance();

package/dist/services/messaging.svelte.d.ts

@@ -0,0 +1,75 @@
+import { type MessagePayload } from 'firebase/messaging';
+/**
+ * Reactive Firebase Cloud Messaging service.
+ *
+ * Handles FCM token registration, foreground message listening,
+ * and notification permission requests.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { firekitMessaging } from 'svelte-firekit';
+ *   await firekitMessaging.requestPermission('YOUR_VAPID_KEY');
+ * </script>
+ * {#if firekitMessaging.token}
+ *   FCM token: {firekitMessaging.token}
+ * {/if}
+ * {#if firekitMessaging.lastMessage}
+ *   New: {firekitMessaging.lastMessage.notification?.title}
+ * {/if}
+ * ```
+ */
+declare class FirekitMessaging {
+    private static instance;
+    private _token;
+    private _loading;
+    private _error;
+    private _permission;
+    private _lastMessage;
+    private _messages;
+    private _supported;
+    readonly hasToken: boolean;
+    readonly isGranted: boolean;
+    private _messaging;
+    private _unsubscribeMessage;
+    private _requesting;
+    private constructor();
+    static getInstance(): FirekitMessaging;
+    get token(): string | null;
+    get loading(): boolean;
+    get error(): Error | null;
+    get permission(): NotificationPermission;
+    get lastMessage(): MessagePayload | null;
+    get messages(): MessagePayload[];
+    get supported(): boolean;
+    private _initPermissionState;
+    private _getMessaging;
+    /**
+     * Requests notification permission, registers the FCM token,
+     * and starts listening for foreground messages.
+     *
+     * @param vapidKey - Your VAPID public key from the Firebase console.
+     * @param serviceWorkerRegistration - Optional custom service worker registration.
+     */
+    requestPermission(vapidKey: string, serviceWorkerRegistration?: ServiceWorkerRegistration): Promise<string | null>;
+    /**
+     * Refreshes the FCM token.
+     * Call this after deleting or if your token may have rotated.
+     */
+    refreshToken(vapidKey: string, serviceWorkerRegistration?: ServiceWorkerRegistration): Promise<string | null>;
+    /**
+     * Deletes the current FCM token and unregisters from push notifications.
+     */
+    deleteToken(): Promise<boolean>;
+    private _listenForMessages;
+    /**
+     * Registers a callback for foreground messages.
+     * Returns an unsubscribe function.
+     */
+    onMessage(handler: (payload: MessagePayload) => void): Promise<() => void>;
+    /** Clears the accumulated foreground message list. */
+    clearMessages(): void;
+    dispose(): void;
+}
+export declare const firekitMessaging: FirekitMessaging;
+export type { MessagePayload };

package/dist/services/messaging.svelte.js

@@ -0,0 +1,190 @@
+import { getMessaging, getToken, deleteToken, onMessage, isSupported } from 'firebase/messaging';
+import { firebaseService } from '../firebase.js';
+function getApp() {
+    const app = firebaseService.getFirebaseApp();
+    if (!app)
+        throw new Error('Firebase app is not initialized.');
+    return app;
+}
+/**
+ * Reactive Firebase Cloud Messaging service.
+ *
+ * Handles FCM token registration, foreground message listening,
+ * and notification permission requests.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { firekitMessaging } from 'svelte-firekit';
+ *   await firekitMessaging.requestPermission('YOUR_VAPID_KEY');
+ * </script>
+ * {#if firekitMessaging.token}
+ *   FCM token: {firekitMessaging.token}
+ * {/if}
+ * {#if firekitMessaging.lastMessage}
+ *   New: {firekitMessaging.lastMessage.notification?.title}
+ * {/if}
+ * ```
+ */
+class FirekitMessaging {
+    static instance;
+    _token = $state(null);
+    _loading = $state(false);
+    _error = $state(null);
+    _permission = $state('default');
+    _lastMessage = $state(null);
+    _messages = $state([]);
+    _supported = $state(false);
+    hasToken = $derived(this._token !== null);
+    isGranted = $derived(this._permission === 'granted');
+    _messaging = null;
+    _unsubscribeMessage = null;
+    _requesting = false;
+    constructor() {
+        this._initPermissionState();
+    }
+    static getInstance() {
+        if (!FirekitMessaging.instance) {
+            FirekitMessaging.instance = new FirekitMessaging();
+        }
+        return FirekitMessaging.instance;
+    }
+    get token() { return this._token; }
+    get loading() { return this._loading; }
+    get error() { return this._error; }
+    get permission() { return this._permission; }
+    get lastMessage() { return this._lastMessage; }
+    get messages() { return this._messages; }
+    get supported() { return this._supported; }
+    _initPermissionState() {
+        if (typeof window === 'undefined' || !('Notification' in window))
+            return;
+        this._permission = Notification.permission;
+    }
+    async _getMessaging() {
+        if (this._messaging)
+            return this._messaging;
+        if (typeof window === 'undefined')
+            return null;
+        const supported = await isSupported();
+        this._supported = supported;
+        if (!supported)
+            return null;
+        const app = getApp();
+        this._messaging = getMessaging(app);
+        return this._messaging;
+    }
+    // ── Permission & token ────────────────────────────────────────────────────
+    /**
+     * Requests notification permission, registers the FCM token,
+     * and starts listening for foreground messages.
+     *
+     * @param vapidKey - Your VAPID public key from the Firebase console.
+     * @param serviceWorkerRegistration - Optional custom service worker registration.
+     */
+    async requestPermission(vapidKey, serviceWorkerRegistration) {
+        if (this._requesting)
+            return this._token;
+        this._requesting = true;
+        this._loading = true;
+        this._error = null;
+        try {
+            const msg = await this._getMessaging();
+            if (!msg) {
+                this._error = new Error('Firebase Messaging is not supported in this browser.');
+                return null;
+            }
+            const permission = await Notification.requestPermission();
+            this._permission = permission;
+            if (permission !== 'granted')
+                return null;
+            const tokenOptions = { vapidKey };
+            if (serviceWorkerRegistration) {
+                tokenOptions.serviceWorkerRegistration = serviceWorkerRegistration;
+            }
+            this._token = await getToken(msg, tokenOptions);
+            this._listenForMessages(msg);
+            return this._token;
+        }
+        catch (err) {
+            this._error = err instanceof Error ? err : new Error(String(err));
+            return null;
+        }
+        finally {
+            this._loading = false;
+            this._requesting = false;
+        }
+    }
+    /**
+     * Refreshes the FCM token.
+     * Call this after deleting or if your token may have rotated.
+     */
+    async refreshToken(vapidKey, serviceWorkerRegistration) {
+        this._loading = true;
+        this._error = null;
+        try {
+            const msg = await this._getMessaging();
+            if (!msg)
+                return null;
+            const tokenOptions = { vapidKey };
+            if (serviceWorkerRegistration) {
+                tokenOptions.serviceWorkerRegistration = serviceWorkerRegistration;
+            }
+            this._token = await getToken(msg, tokenOptions);
+            return this._token;
+        }
+        catch (err) {
+            this._error = err instanceof Error ? err : new Error(String(err));
+            return null;
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    /**
+     * Deletes the current FCM token and unregisters from push notifications.
+     */
+    async deleteToken() {
+        const msg = await this._getMessaging();
+        if (!msg)
+            return false;
+        try {
+            const deleted = await deleteToken(msg);
+            if (deleted)
+                this._token = null;
+            return deleted;
+        }
+        catch (err) {
+            this._error = err instanceof Error ? err : new Error(String(err));
+            return false;
+        }
+    }
+    // ── Foreground messages ───────────────────────────────────────────────────
+    _listenForMessages(msg) {
+        this._unsubscribeMessage?.();
+        this._unsubscribeMessage = onMessage(msg, (payload) => {
+            this._lastMessage = payload;
+            this._messages = [...this._messages, payload];
+        });
+    }
+    /**
+     * Registers a callback for foreground messages.
+     * Returns an unsubscribe function.
+     */
+    async onMessage(handler) {
+        const msg = await this._getMessaging();
+        if (!msg)
+            return () => { };
+        return onMessage(msg, handler);
+    }
+    /** Clears the accumulated foreground message list. */
+    clearMessages() {
+        this._messages = [];
+        this._lastMessage = null;
+    }
+    dispose() {
+        this._unsubscribeMessage?.();
+        this._unsubscribeMessage = null;
+    }
+}
+export const firekitMessaging = FirekitMessaging.getInstance();