@nolag/notify 0.1.0

package/dist/index.cjs

@@ -0,0 +1,767 @@
+'use strict';
+
+var jsSdk = require('@nolag/js-sdk');
+
+/**
+ * Tiny typed event emitter — framework-agnostic base for NoLag SDKs.
+ */
+class EventEmitter {
+    constructor() {
+        this._handlers = new Map();
+    }
+    on(event, handler) {
+        if (!this._handlers.has(event)) {
+            this._handlers.set(event, new Set());
+        }
+        this._handlers.get(event).add(handler);
+        return this;
+    }
+    off(event, handler) {
+        if (handler) {
+            this._handlers.get(event)?.delete(handler);
+        }
+        else {
+            this._handlers.delete(event);
+        }
+        return this;
+    }
+    removeAllListeners() {
+        this._handlers.clear();
+        return this;
+    }
+    emit(event, ...args) {
+        const handlers = this._handlers.get(event);
+        if (!handlers)
+            return;
+        for (const handler of handlers) {
+            try {
+                handler(...args);
+            }
+            catch (e) {
+                console.error(`Error in ${String(event)} handler:`, e);
+            }
+        }
+    }
+    listenerCount(event) {
+        return this._handlers.get(event)?.size ?? 0;
+    }
+}
+
+/**
+ * Bounded, deduplicated notification cache ordered by timestamp,
+ * with read/unread tracking.
+ */
+class NotificationStore {
+    constructor(maxSize) {
+        this._notifications = [];
+        this._ids = new Set();
+        this._maxSize = maxSize;
+    }
+    /**
+     * Add a notification. Returns true if the notification was new (not a duplicate).
+     */
+    add(notification) {
+        if (this._ids.has(notification.id)) {
+            return false;
+        }
+        this._ids.add(notification.id);
+        this._notifications.push(notification);
+        // Keep sorted by timestamp
+        if (this._notifications.length > 1 &&
+            notification.timestamp < this._notifications[this._notifications.length - 2].timestamp) {
+            this._notifications.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        // Trim if over capacity
+        while (this._notifications.length > this._maxSize) {
+            const removed = this._notifications.shift();
+            this._ids.delete(removed.id);
+        }
+        return true;
+    }
+    /**
+     * Mark a notification as read by id.
+     * Returns true if the notification was found.
+     */
+    markRead(id) {
+        const notification = this._notifications.find((n) => n.id === id);
+        if (!notification)
+            return false;
+        notification.read = true;
+        return true;
+    }
+    /**
+     * Mark all notifications as read.
+     */
+    markAllRead() {
+        for (const notification of this._notifications) {
+            notification.read = true;
+        }
+    }
+    /**
+     * Get all notifications in timestamp order.
+     */
+    getAll() {
+        return [...this._notifications];
+    }
+    /**
+     * Get all unread notifications.
+     */
+    getUnread() {
+        return this._notifications.filter((n) => !n.read);
+    }
+    /**
+     * Get the number of unread notifications.
+     */
+    get unreadCount() {
+        return this._notifications.filter((n) => !n.read).length;
+    }
+    /**
+     * Get notification count.
+     */
+    get size() {
+        return this._notifications.length;
+    }
+    /**
+     * Check if a notification ID exists.
+     */
+    has(id) {
+        return this._ids.has(id);
+    }
+    /**
+     * Clear all notifications.
+     */
+    clear() {
+        this._notifications = [];
+        this._ids.clear();
+    }
+}
+
+function generateId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return 'xxxx-xxxx-xxxx-xxxx'.replace(/x/g, () => Math.floor(Math.random() * 16).toString(16));
+}
+function createLogger(prefix, enabled) {
+    if (!enabled) {
+        return (..._args) => { };
+    }
+    return (...args) => {
+        console.log(`[${prefix}]`, ...args);
+    };
+}
+
+/** Default app name for channel topic prefixes */
+const DEFAULT_APP_NAME = 'notify';
+/** Default max notifications kept per channel */
+const DEFAULT_MAX_NOTIFICATION_CACHE = 500;
+/** Topic name for notifications within a channel */
+const TOPIC_NOTIFICATIONS = 'notifications';
+/** Topic name for read receipts within a channel */
+const TOPIC_READ = '_read';
+/** Lobby ID for global online presence */
+const LOBBY_ID = 'online';
+
+/**
+ * NotifyChannel — a single notification channel with read/unread tracking.
+ *
+ * Created via `NoLagNotify.subscribe(name)`. Do not instantiate directly.
+ */
+class NotifyChannel extends EventEmitter {
+    /** @internal */
+    constructor(name, roomContext, options, log) {
+        super();
+        this._active = false;
+        this.name = name;
+        this._roomContext = roomContext;
+        this._options = options;
+        this._store = new NotificationStore(options.maxNotificationCache);
+        this._log = log;
+    }
+    // ============ Public Properties ============
+    /** All notifications in this channel (timestamp order) */
+    get notifications() {
+        return this._store.getAll();
+    }
+    /** Number of unread notifications */
+    get unreadCount() {
+        return this._store.unreadCount;
+    }
+    /** Whether this channel is currently active */
+    get active() {
+        return this._active;
+    }
+    // ============ Sending ============
+    /**
+     * Send a notification to this channel.
+     */
+    send(title, opts) {
+        const notification = {
+            id: generateId(),
+            channel: this.name,
+            title,
+            body: opts?.body,
+            icon: opts?.icon,
+            data: opts?.data,
+            timestamp: Date.now()};
+        this._roomContext.emit(TOPIC_NOTIFICATIONS, {
+            id: notification.id,
+            channel: notification.channel,
+            title: notification.title,
+            body: notification.body,
+            icon: notification.icon,
+            data: notification.data,
+            timestamp: notification.timestamp,
+        });
+    }
+    // ============ Read Tracking ============
+    /**
+     * Mark a single notification as read by id.
+     * Emits the read receipt to the _read topic for cross-tab sync.
+     */
+    markRead(id) {
+        if (this._store.markRead(id)) {
+            this._log('Mark read:', id);
+            this._roomContext.emit(TOPIC_READ, { id, channel: this.name });
+            this.emit('read', id);
+        }
+    }
+    /**
+     * Mark all notifications in this channel as read.
+     */
+    markAllRead() {
+        this._store.markAllRead();
+        this._log('Mark all read:', this.name);
+        this._roomContext.emit(TOPIC_READ, { all: true, channel: this.name });
+        this.emit('readAll');
+    }
+    /**
+     * Get all notifications (alias for the notifications getter).
+     */
+    getNotifications() {
+        return this._store.getAll();
+    }
+    /**
+     * Get all unread notifications.
+     */
+    getUnread() {
+        return this._store.getUnread();
+    }
+    // ============ Internal (called by NoLagNotify) ============
+    /** @internal Subscribe to notifications and _read topics */
+    _subscribe() {
+        this._log('Channel subscribe:', this.name);
+        this._roomContext.subscribe(TOPIC_NOTIFICATIONS);
+        this._roomContext.subscribe(TOPIC_READ);
+        this._roomContext.on(TOPIC_NOTIFICATIONS, (data, meta) => {
+            this._handleIncomingNotification(data, meta);
+        });
+        this._roomContext.on(TOPIC_READ, (data) => {
+            this._handleIncomingRead(data);
+        });
+    }
+    /** @internal Activate this channel (mark as visible/active) */
+    _activate() {
+        this._log('Channel activate:', this.name);
+        this._active = true;
+    }
+    /** @internal Deactivate this channel */
+    _deactivate() {
+        this._log('Channel deactivate:', this.name);
+        this._active = false;
+    }
+    /** @internal Handle replay start event */
+    _handleReplayStart(count) {
+        this.emit('replayStart', { count });
+    }
+    /** @internal Handle replay end event */
+    _handleReplayEnd(replayed) {
+        this.emit('replayEnd', { replayed });
+    }
+    /** @internal Unsubscribe and clean up */
+    _cleanup() {
+        this._log('Channel cleanup:', this.name);
+        this._roomContext.unsubscribe(TOPIC_NOTIFICATIONS);
+        this._roomContext.unsubscribe(TOPIC_READ);
+        this._roomContext.off(TOPIC_NOTIFICATIONS);
+        this._roomContext.off(TOPIC_READ);
+        this._store.clear();
+        this.removeAllListeners();
+    }
+    // ============ Private ============
+    _handleIncomingNotification(data, meta) {
+        const raw = data;
+        const notification = {
+            id: raw.id || generateId(),
+            channel: this.name,
+            title: raw.title,
+            body: raw.body,
+            icon: raw.icon,
+            data: raw.data,
+            timestamp: raw.timestamp || Date.now(),
+            read: false,
+            isReplay: meta.isReplay ?? false,
+        };
+        if (this._store.add(notification)) {
+            this._log('Notification received:', notification.id, notification.title);
+            this.emit('notification', notification);
+        }
+    }
+    _handleIncomingRead(data) {
+        const raw = data;
+        if (raw.all === true) {
+            this._store.markAllRead();
+            this.emit('readAll');
+        }
+        else if (typeof raw.id === 'string') {
+            if (this._store.markRead(raw.id)) {
+                this.emit('read', raw.id);
+            }
+        }
+    }
+}
+
+/**
+ * Aggregates unread notification counts across channels.
+ */
+class BadgeManager {
+    constructor() {
+        this._counts = new Map();
+    }
+    /**
+     * Update the unread count for a channel.
+     */
+    update(channel, unreadCount) {
+        this._counts.set(channel, unreadCount);
+    }
+    /**
+     * Get the unread count for a specific channel.
+     */
+    get(channel) {
+        return this._counts.get(channel) ?? 0;
+    }
+    /**
+     * Get all badge counts — total and per-channel breakdown.
+     */
+    getAll() {
+        const byChannel = {};
+        let total = 0;
+        for (const [channel, count] of this._counts) {
+            byChannel[channel] = count;
+            total += count;
+        }
+        return { total, byChannel };
+    }
+    /**
+     * Clear all counts.
+     */
+    clear() {
+        this._counts.clear();
+    }
+}
+
+/**
+ * Maps actorTokenId to NotifyUser for global presence tracking.
+ */
+class PresenceManager {
+    constructor() {
+        this._users = new Map();
+        this._actorToUserId = new Map();
+    }
+    /**
+     * Add or update a user from presence data.
+     * Returns the NotifyUser, or null if presence data is invalid.
+     */
+    addFromPresence(actorTokenId, presenceData, joinedAt) {
+        if (!presenceData?.userId)
+            return null;
+        const existing = this._actorToUserId.get(actorTokenId);
+        const userId = presenceData.userId || existing || actorTokenId;
+        const user = {
+            userId,
+            actorTokenId,
+            metadata: presenceData.metadata,
+            joinedAt: joinedAt || Date.now(),
+        };
+        this._users.set(userId, user);
+        this._actorToUserId.set(actorTokenId, userId);
+        return user;
+    }
+    /**
+     * Remove a user by actorTokenId.
+     * Returns the removed user, or null if not found.
+     */
+    removeByActorId(actorTokenId) {
+        const userId = this._actorToUserId.get(actorTokenId);
+        if (!userId)
+            return null;
+        const user = this._users.get(userId) || null;
+        this._users.delete(userId);
+        this._actorToUserId.delete(actorTokenId);
+        return user;
+    }
+    /**
+     * Get a user by userId.
+     */
+    getUser(userId) {
+        return this._users.get(userId);
+    }
+    /**
+     * Get a user by actorTokenId.
+     */
+    getUserByActorId(actorTokenId) {
+        const userId = this._actorToUserId.get(actorTokenId);
+        return userId ? this._users.get(userId) : undefined;
+    }
+    /**
+     * Get all tracked users.
+     */
+    getAll() {
+        return Array.from(this._users.values());
+    }
+    /**
+     * Clear all tracked users.
+     */
+    clear() {
+        this._users.clear();
+        this._actorToUserId.clear();
+    }
+}
+
+/**
+ * NoLagNotify — high-level notifications SDK built on @nolag/js-sdk.
+ *
+ * Provides multi-channel notifications, read/unread tracking, badge counts,
+ * message replay, and global presence — all framework-agnostic via events.
+ *
+ * @example
+ * ```typescript
+ * import { NoLagNotify } from '@nolag/notify';
+ *
+ * const notify = new NoLagNotify(token);
+ *
+ * notify.on('connected', () => console.log('Connected!'));
+ * notify.on('notification', (n) => console.log('New notification:', n.title));
+ *
+ * await notify.connect();
+ *
+ * const alerts = notify.subscribe('alerts');
+ * alerts.on('notification', (n) => console.log(n.title));
+ * ```
+ */
+class NoLagNotify extends EventEmitter {
+    constructor(token, options = {}) {
+        super();
+        this._client = null;
+        this._channels = new Map();
+        this._lobby = null;
+        this._badgeManager = new BadgeManager();
+        this._presenceManager = new PresenceManager();
+        this._actorToUserId = new Map();
+        this._token = token;
+        this._userId = generateId();
+        this._options = {
+            metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME,
+            url: options.url,
+            maxNotificationCache: options.maxNotificationCache ?? DEFAULT_MAX_NOTIFICATION_CACHE,
+            debug: options.debug ?? false,
+            reconnect: options.reconnect ?? true,
+            channels: options.channels ?? [],
+        };
+        this._log = createLogger('NoLagNotify', this._options.debug);
+    }
+    // ============ Public Properties ============
+    /** Whether the underlying connection is established */
+    get connected() {
+        return this._client?.connected ?? false;
+    }
+    /** All currently subscribed channels */
+    get channels() {
+        return this._channels;
+    }
+    // ============ Lifecycle ============
+    /**
+     * Connect to NoLag and set up global presence.
+     */
+    async connect() {
+        this._log('Connecting...');
+        const clientOptions = {
+            debug: this._options.debug,
+            reconnect: this._options.reconnect,
+        };
+        if (this._options.url) {
+            clientOptions.url = this._options.url;
+        }
+        this._client = jsSdk.NoLag(this._token, clientOptions);
+        // Wire client lifecycle events
+        this._client.on('connect', () => {
+            this._log('Connected');
+            if (this._channels.size > 0) {
+                this._log('Reconnected — restoring channels...');
+                this._restoreChannels();
+                this.emit('reconnected');
+            }
+        });
+        this._client.on('disconnect', (reason) => {
+            this._log('Disconnected:', reason);
+            this.emit('disconnected', reason);
+        });
+        this._client.on('reconnect', () => {
+            this._log('Reconnecting...');
+        });
+        this._client.on('error', (error) => {
+            this._log('Error:', error);
+            this.emit('error', error);
+        });
+        // Wire replay events
+        this._client.on('replay:start', (data) => {
+            const event = data;
+            for (const channel of this._channels.values()) {
+                channel._handleReplayStart(event.count);
+            }
+        });
+        this._client.on('replay:end', (data) => {
+            const event = data;
+            for (const channel of this._channels.values()) {
+                channel._handleReplayEnd(event.replayed);
+            }
+        });
+        // Connect
+        await this._client.connect();
+        // Wire room-level presence events
+        this._client.on('presence:join', (data) => {
+            this._handleRoomPresenceJoin(data);
+        });
+        this._client.on('presence:leave', (data) => {
+            this._handleRoomPresenceLeave(data);
+        });
+        this._client.on('presence:update', (data) => {
+            this._handleRoomPresenceUpdate(data);
+        });
+        this._log('Local userId:', this._userId, '→ actorId:', this._client.actorId);
+        // Set up lobby for global presence
+        await this._setupLobby();
+        // Pre-subscribe to all configured channels
+        for (const channelName of this._options.channels) {
+            this._subscribeChannel(channelName);
+        }
+        // Emit connected now that lobby is ready
+        this.emit('connected');
+        // Deferred lobby refetch to catch late-joining users
+        setTimeout(() => {
+            if (this._lobby && this._client?.connected) {
+                this._lobby.fetchPresence().then((state) => {
+                    this._hydratePresence(state);
+                }).catch(() => { });
+            }
+        }, 2000);
+    }
+    /**
+     * Disconnect from NoLag and clean up all channels.
+     */
+    disconnect() {
+        this._log('Disconnecting...');
+        for (const name of [...this._channels.keys()]) {
+            this.unsubscribe(name);
+        }
+        this._lobby?.unsubscribe();
+        this._lobby = null;
+        this._client?.disconnect();
+        this._client = null;
+        this._badgeManager.clear();
+        this._presenceManager.clear();
+        this._actorToUserId.clear();
+    }
+    // ============ Channel Management ============
+    /**
+     * Subscribe to a notification channel (idempotent).
+     * Returns the NotifyChannel instance.
+     */
+    subscribe(channelName) {
+        if (!this._client) {
+            throw new Error('Not connected — call connect() first');
+        }
+        const existing = this._channels.get(channelName);
+        if (existing)
+            return existing;
+        const channel = this._subscribeChannel(channelName);
+        channel._activate();
+        return channel;
+    }
+    /**
+     * Unsubscribe from a notification channel.
+     */
+    unsubscribe(channelName) {
+        const channel = this._channels.get(channelName);
+        if (!channel)
+            return;
+        this._log('Unsubscribing channel:', channelName);
+        channel._cleanup();
+        this._channels.delete(channelName);
+        this._badgeManager.update(channelName, 0);
+        this._emitBadgeUpdated();
+    }
+    // ============ Badge Counts ============
+    /**
+     * Get the current badge counts across all channels.
+     */
+    getBadgeCounts() {
+        return this._badgeManager.getAll();
+    }
+    // ============ Read Tracking ============
+    /**
+     * Mark all notifications as read across all channels.
+     */
+    markAllRead() {
+        for (const channel of this._channels.values()) {
+            channel.markAllRead();
+        }
+    }
+    // ============ Private: Channel Setup ============
+    _subscribeChannel(name) {
+        if (!this._client) {
+            throw new Error('Not connected — call connect() first');
+        }
+        this._log('Subscribing channel:', name);
+        const roomContext = this._client.setApp(this._options.appName).setRoom(name);
+        const channel = new NotifyChannel(name, roomContext, this._options, createLogger(`NotifyChannel:${name}`, this._options.debug));
+        this._channels.set(name, channel);
+        channel._subscribe();
+        // Relay notifications up to the main client and update badges
+        channel.on('notification', (notification) => {
+            this._badgeManager.update(name, channel.unreadCount);
+            this._emitBadgeUpdated();
+            this.emit('notification', notification);
+        });
+        channel.on('read', () => {
+            this._badgeManager.update(name, channel.unreadCount);
+            this._emitBadgeUpdated();
+        });
+        channel.on('readAll', () => {
+            this._badgeManager.update(name, 0);
+            this._emitBadgeUpdated();
+        });
+        return channel;
+    }
+    _emitBadgeUpdated() {
+        this.emit('badgeUpdated', this._badgeManager.getAll());
+    }
+    // ============ Private: Room Presence ============
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._client?.actorId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.userId)
+            return;
+        const user = this._presenceManager.addFromPresence(data.actorTokenId, presenceData);
+        if (user) {
+            this._actorToUserId.set(data.actorTokenId, user.userId);
+        }
+    }
+    _handleRoomPresenceLeave(data) {
+        if (data.actorTokenId === this._client?.actorId)
+            return;
+        this._presenceManager.removeByActorId(data.actorTokenId);
+    }
+    _handleRoomPresenceUpdate(data) {
+        if (data.actorTokenId === this._client?.actorId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.userId)
+            return;
+        this._presenceManager.addFromPresence(data.actorTokenId, presenceData);
+    }
+    // ============ Private: Lobby ============
+    async _setupLobby() {
+        if (!this._client)
+            return;
+        this._lobby = this._client.setApp(this._options.appName).setLobby(LOBBY_ID);
+        // Set local presence in the lobby
+        const presenceData = {
+            userId: this._userId,
+            metadata: this._options.metadata,
+        };
+        this._lobby.setPresence?.(presenceData);
+        const lobbyHandler = (type) => (data) => {
+            const event = data;
+            if (type === 'join')
+                this._handleLobbyJoin(event);
+            else if (type === 'leave')
+                this._handleLobbyLeave(event);
+            else
+                this._handleLobbyUpdate(event);
+        };
+        this._client.on('lobbyPresence:join', lobbyHandler('join'));
+        this._client.on('lobbyPresence:leave', lobbyHandler('leave'));
+        this._client.on('lobbyPresence:update', lobbyHandler('update'));
+        try {
+            const initialState = await this._lobby.subscribe();
+            this._hydratePresence(initialState);
+            this._log('Lobby subscribed');
+        }
+        catch (err) {
+            this._log('Lobby subscription failed:', err);
+        }
+    }
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._client?.actorId)
+            return;
+        const presenceData = data;
+        if (!presenceData?.userId)
+            return;
+        const user = this._presenceManager.addFromPresence(actorId, presenceData);
+        if (user) {
+            this._actorToUserId.set(actorId, user.userId);
+        }
+    }
+    _handleLobbyLeave(event) {
+        const { actorId } = event;
+        if (actorId === this._client?.actorId)
+            return;
+        this._presenceManager.removeByActorId(actorId);
+        this._actorToUserId.delete(actorId);
+    }
+    _handleLobbyUpdate(event) {
+        const { actorId, data } = event;
+        if (actorId === this._client?.actorId)
+            return;
+        const presenceData = data;
+        if (!presenceData?.userId)
+            return;
+        this._presenceManager.addFromPresence(actorId, presenceData);
+    }
+    _hydratePresence(state) {
+        for (const roomId of Object.keys(state)) {
+            const roomPresence = state[roomId];
+            for (const actorId of Object.keys(roomPresence)) {
+                if (actorId === this._client?.actorId)
+                    continue;
+                const raw = roomPresence[actorId];
+                const presenceData = (raw?.presence ?? raw);
+                if (presenceData?.userId) {
+                    const user = this._presenceManager.addFromPresence(actorId, presenceData);
+                    if (user) {
+                        this._actorToUserId.set(actorId, user.userId);
+                    }
+                }
+            }
+        }
+    }
+    // ============ Private: Reconnect ============
+    _restoreChannels() {
+        this._lobby?.fetchPresence().then((state) => {
+            this._presenceManager.clear();
+            this._actorToUserId.clear();
+            this._hydratePresence(state);
+        }).catch((err) => {
+            this._log('Failed to re-fetch lobby presence:', err);
+        });
+    }
+}
+
+exports.EventEmitter = EventEmitter;
+exports.NoLagNotify = NoLagNotify;
+exports.NotifyChannel = NotifyChannel;
+//# sourceMappingURL=index.cjs.map