@nolag/feed 0.1.0

package/dist/index.mjs

@@ -0,0 +1,684 @@
+import { NoLag } from '@nolag/js-sdk';
+
+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 post cache ordered by timestamp.
+ */
+class PostStore {
+    constructor(maxSize) {
+        this._posts = [];
+        this._ids = new Set();
+        this._maxSize = maxSize;
+    }
+    /**
+     * Add a post. Returns true if the post was new (not a duplicate).
+     */
+    add(post) {
+        if (this._ids.has(post.id)) {
+            return false;
+        }
+        this._ids.add(post.id);
+        this._posts.push(post);
+        // Keep sorted by timestamp (newest last)
+        if (this._posts.length > 1 &&
+            post.timestamp < this._posts[this._posts.length - 2].timestamp) {
+            this._posts.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        // Trim if over capacity (remove oldest)
+        while (this._posts.length > this._maxSize) {
+            const removed = this._posts.shift();
+            this._ids.delete(removed.id);
+        }
+        return true;
+    }
+    /**
+     * Get a post by ID.
+     */
+    get(id) {
+        return this._posts.find((p) => p.id === id);
+    }
+    /**
+     * Get all posts in timestamp order (oldest first).
+     */
+    getAll() {
+        return [...this._posts];
+    }
+    /**
+     * Update the like count (and likedByMe flag) for a post in-place.
+     */
+    updateLikeCount(postId, count, likedByMe) {
+        const post = this._posts.find((p) => p.id === postId);
+        if (post) {
+            post.likeCount = count;
+            post.likedByMe = likedByMe;
+        }
+    }
+    /**
+     * Increment the comment count for a post in-place.
+     */
+    incrementCommentCount(postId) {
+        const post = this._posts.find((p) => p.id === postId);
+        if (post) {
+            post.commentCount++;
+        }
+    }
+    /**
+     * Check if a post ID exists.
+     */
+    has(id) {
+        return this._ids.has(id);
+    }
+    /**
+     * Get post count.
+     */
+    get size() {
+        return this._posts.length;
+    }
+    /**
+     * Clear all posts.
+     */
+    clear() {
+        this._posts = [];
+        this._ids.clear();
+    }
+}
+
+/**
+ * Tracks like/unlike state per post with per-user deduplication.
+ *
+ * Internal: Map<postId, Set<userId>>
+ */
+class ReactionManager {
+    constructor() {
+        this._likes = new Map();
+    }
+    /**
+     * Record a like from userId on postId.
+     * Returns the updated likeCount and whether this was a new like.
+     */
+    like(postId, userId) {
+        if (!this._likes.has(postId)) {
+            this._likes.set(postId, new Set());
+        }
+        const likers = this._likes.get(postId);
+        const isNew = !likers.has(userId);
+        likers.add(userId);
+        return { postId, likeCount: likers.size, isNew };
+    }
+    /**
+     * Record an unlike from userId on postId.
+     * Returns the updated likeCount and whether the like was removed.
+     */
+    unlike(postId, userId) {
+        const likers = this._likes.get(postId);
+        if (!likers) {
+            return { postId, likeCount: 0, wasLiked: false };
+        }
+        const wasLiked = likers.has(userId);
+        likers.delete(userId);
+        return { postId, likeCount: likers.size, wasLiked };
+    }
+    /**
+     * Check if a userId has liked a postId.
+     */
+    isLikedBy(postId, userId) {
+        return this._likes.get(postId)?.has(userId) ?? false;
+    }
+    /**
+     * Get the total like count for a post.
+     */
+    getLikeCount(postId) {
+        return this._likes.get(postId)?.size ?? 0;
+    }
+    /**
+     * Clear all reaction state.
+     */
+    clear() {
+        this._likes.clear();
+    }
+}
+
+/**
+ * Maps actorTokenId <-> FeedUser, filtering self.
+ */
+class PresenceManager {
+    constructor(localActorId) {
+        this._users = new Map();
+        this._actorToUserId = new Map();
+        this._localActorId = localActorId;
+    }
+    /**
+     * Add or update a user from presence data.
+     * Returns the FeedUser if it is a remote user, null if it is self.
+     */
+    addFromPresence(actorTokenId, presence, joinedAt) {
+        const isLocal = actorTokenId === this._localActorId;
+        // Skip self
+        if (isLocal)
+            return null;
+        const existing = this._actorToUserId.get(actorTokenId);
+        const userId = presence.userId || existing || actorTokenId;
+        const user = {
+            userId,
+            actorTokenId,
+            username: presence.username,
+            avatar: presence.avatar,
+            metadata: presence.metadata,
+            joinedAt: joinedAt || Date.now(),
+            isLocal: false,
+        };
+        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 / is self.
+     */
+    removeByActorId(actorTokenId) {
+        if (actorTokenId === this._localActorId)
+            return null;
+        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 remote users.
+     */
+    getAll() {
+        return Array.from(this._users.values());
+    }
+    /**
+     * Get the users Map (readonly view).
+     */
+    get users() {
+        return this._users;
+    }
+    /**
+     * Clear all tracked users.
+     */
+    clear() {
+        this._users.clear();
+        this._actorToUserId.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); };
+}
+
+const DEFAULT_APP_NAME = 'feed';
+const DEFAULT_MAX_POST_CACHE = 200;
+const DEFAULT_MAX_COMMENT_CACHE = 100;
+const TOPIC_POSTS = 'posts';
+const TOPIC_REACTIONS = 'reactions';
+const TOPIC_COMMENTS = 'comments';
+const LOBBY_ID = 'online';
+
+class FeedChannel extends EventEmitter {
+    constructor(name, roomContext, localUser, options, log) {
+        super();
+        this._comments = new Map();
+        this._unreadCount = 0;
+        this._active = false;
+        this.name = name;
+        this._roomContext = roomContext;
+        this._localUser = localUser;
+        this._options = options;
+        this._log = log;
+        this._presenceManager = new PresenceManager(localUser.actorTokenId);
+        this._postStore = new PostStore(options.maxPostCache);
+        this._reactionManager = new ReactionManager();
+    }
+    get posts() { return this._postStore.getAll(); }
+    get unreadCount() { return this._unreadCount; }
+    get active() { return this._active; }
+    createPost(opts) {
+        const post = {
+            id: generateId(), userId: this._localUser.userId, username: this._localUser.username,
+            avatar: this._localUser.avatar, content: opts.content, media: opts.media, data: opts.data,
+            likeCount: 0, commentCount: 0, likedByMe: false, timestamp: Date.now(), status: 'sending', isReplay: false,
+        };
+        this._postStore.add(post);
+        this.emit('postSent', post);
+        this._roomContext.emit(TOPIC_POSTS, {
+            id: post.id, userId: post.userId, username: post.username, avatar: post.avatar,
+            content: post.content, media: post.media, data: post.data, timestamp: post.timestamp,
+        }, { echo: false });
+        post.status = 'sent';
+        return post;
+    }
+    getPosts() { return this._postStore.getAll(); }
+    likePost(postId) {
+        const { likeCount, isNew } = this._reactionManager.like(postId, this._localUser.userId);
+        if (isNew) {
+            this._postStore.updateLikeCount(postId, likeCount, true);
+            this._roomContext.emit(TOPIC_REACTIONS, { postId, userId: this._localUser.userId, type: 'like', timestamp: Date.now() }, { echo: false });
+            this.emit('postLiked', { postId, userId: this._localUser.userId, likeCount });
+        }
+    }
+    unlikePost(postId) {
+        const { likeCount, wasLiked } = this._reactionManager.unlike(postId, this._localUser.userId);
+        if (wasLiked) {
+            this._postStore.updateLikeCount(postId, likeCount, false);
+            this._roomContext.emit(TOPIC_REACTIONS, { postId, userId: this._localUser.userId, type: 'unlike', timestamp: Date.now() }, { echo: false });
+            this.emit('postUnliked', { postId, userId: this._localUser.userId, likeCount });
+        }
+    }
+    addComment(postId, text) {
+        const comment = {
+            id: generateId(), postId, userId: this._localUser.userId, username: this._localUser.username,
+            avatar: this._localUser.avatar, text, timestamp: Date.now(), isReplay: false,
+        };
+        if (!this._comments.has(postId))
+            this._comments.set(postId, []);
+        this._comments.get(postId).push(comment);
+        this._postStore.incrementCommentCount(postId);
+        this.emit('commentSent', comment);
+        this._roomContext.emit(TOPIC_COMMENTS, {
+            id: comment.id, postId, userId: comment.userId, username: comment.username,
+            avatar: comment.avatar, text: comment.text, timestamp: comment.timestamp,
+        }, { echo: false });
+        return comment;
+    }
+    getComments(postId) {
+        return this._comments.get(postId) ?? [];
+    }
+    markRead() {
+        if (this._unreadCount !== 0) {
+            this._unreadCount = 0;
+            this.emit('unreadChanged', { channel: this.name, count: 0 });
+        }
+    }
+    getUsers() { return this._presenceManager.getAll(); }
+    _subscribe() {
+        this._roomContext.subscribe(TOPIC_POSTS);
+        this._roomContext.subscribe(TOPIC_REACTIONS);
+        this._roomContext.subscribe(TOPIC_COMMENTS);
+        this._roomContext.on(TOPIC_POSTS, (data, meta) => this._handleIncomingPost(data, meta));
+        this._roomContext.on(TOPIC_REACTIONS, (data) => this._handleIncomingReaction(data));
+        this._roomContext.on(TOPIC_COMMENTS, (data, meta) => this._handleIncomingComment(data, meta));
+    }
+    _activate() {
+        this._active = true;
+        this._markRead();
+        this._setPresence();
+        this._roomContext.fetchPresence().then((actors) => {
+            for (const actor of actors) {
+                if (actor.presence) {
+                    const user = this._presenceManager.addFromPresence(actor.actorTokenId, actor.presence, actor.joinedAt);
+                    if (user)
+                        this.emit('subscriberJoined', user);
+                }
+            }
+        }).catch(() => { });
+    }
+    _deactivate() { this._active = false; this._presenceManager.clear(); }
+    _handlePresenceJoin(actorTokenId, presenceData) {
+        const user = this._presenceManager.addFromPresence(actorTokenId, presenceData);
+        if (user)
+            this.emit('subscriberJoined', user);
+    }
+    _handlePresenceLeave(actorTokenId) {
+        const user = this._presenceManager.removeByActorId(actorTokenId);
+        if (user)
+            this.emit('subscriberLeft', user);
+    }
+    _handlePresenceUpdate(actorTokenId, presenceData) {
+        this._presenceManager.addFromPresence(actorTokenId, presenceData);
+    }
+    _handleReplayStart(count) { this.emit('replayStart', { count }); }
+    _handleReplayEnd(replayed) { this.emit('replayEnd', { replayed }); }
+    _updateLocalPresence() { this._setPresence(); }
+    _cleanup() {
+        this._roomContext.unsubscribe(TOPIC_POSTS);
+        this._roomContext.unsubscribe(TOPIC_REACTIONS);
+        this._roomContext.unsubscribe(TOPIC_COMMENTS);
+        this._roomContext.off(TOPIC_POSTS);
+        this._roomContext.off(TOPIC_REACTIONS);
+        this._roomContext.off(TOPIC_COMMENTS);
+        this._postStore.clear();
+        this._reactionManager.clear();
+        this._comments.clear();
+        this._presenceManager.clear();
+        this.removeAllListeners();
+    }
+    _handleIncomingPost(data, meta) {
+        const raw = data;
+        const post = {
+            id: raw.id, userId: raw.userId, username: raw.username,
+            avatar: raw.avatar, content: raw.content,
+            media: raw.media, data: raw.data,
+            likeCount: 0, commentCount: 0, likedByMe: false,
+            timestamp: raw.timestamp, status: 'delivered', isReplay: meta.isReplay ?? false,
+        };
+        if (this._postStore.add(post)) {
+            this.emit('postCreated', post);
+            if (!this._active && !post.isReplay) {
+                this._unreadCount++;
+                this.emit('unreadChanged', { channel: this.name, count: this._unreadCount });
+            }
+        }
+    }
+    _handleIncomingReaction(data) {
+        const raw = data;
+        if (raw.type === 'like') {
+            const { likeCount } = this._reactionManager.like(raw.postId, raw.userId);
+            const likedByMe = this._reactionManager.isLikedBy(raw.postId, this._localUser.userId);
+            this._postStore.updateLikeCount(raw.postId, likeCount, likedByMe);
+            this.emit('postLiked', { postId: raw.postId, userId: raw.userId, likeCount });
+        }
+        else if (raw.type === 'unlike') {
+            const { likeCount } = this._reactionManager.unlike(raw.postId, raw.userId);
+            const likedByMe = this._reactionManager.isLikedBy(raw.postId, this._localUser.userId);
+            this._postStore.updateLikeCount(raw.postId, likeCount, likedByMe);
+            this.emit('postUnliked', { postId: raw.postId, userId: raw.userId, likeCount });
+        }
+    }
+    _handleIncomingComment(data, meta) {
+        const raw = data;
+        const comment = {
+            id: raw.id, postId: raw.postId, userId: raw.userId,
+            username: raw.username, avatar: raw.avatar,
+            text: raw.text, timestamp: raw.timestamp, isReplay: meta.isReplay ?? false,
+        };
+        if (!this._comments.has(comment.postId))
+            this._comments.set(comment.postId, []);
+        this._comments.get(comment.postId).push(comment);
+        this._postStore.incrementCommentCount(comment.postId);
+        this.emit('commentAdded', comment);
+    }
+    _markRead() {
+        if (this._unreadCount !== 0) {
+            this._unreadCount = 0;
+            this.emit('unreadChanged', { channel: this.name, count: 0 });
+        }
+    }
+    _setPresence() {
+        this._roomContext.setPresence({
+            userId: this._localUser.userId, username: this._localUser.username,
+            avatar: this._localUser.avatar, metadata: this._localUser.metadata,
+        });
+    }
+}
+
+class NoLagFeed extends EventEmitter {
+    constructor(token, options) {
+        super();
+        this._client = null;
+        this._localUser = null;
+        this._channels = new Map();
+        this._lobby = null;
+        this._onlineUsers = new Map();
+        this._actorToUserId = new Map();
+        this._activeChannel = null;
+        this._token = token;
+        this._userId = generateId();
+        this._options = {
+            username: options.username, avatar: options.avatar, metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME, url: options.url,
+            maxPostCache: options.maxPostCache ?? DEFAULT_MAX_POST_CACHE,
+            maxCommentCache: options.maxCommentCache ?? DEFAULT_MAX_COMMENT_CACHE,
+            debug: options.debug ?? false, reconnect: options.reconnect ?? true, channels: options.channels ?? [],
+        };
+        this._log = createLogger('NoLagFeed', this._options.debug);
+    }
+    get connected() { return this._client?.connected ?? false; }
+    get localUser() { return this._localUser; }
+    get channels() { return this._channels; }
+    async connect() {
+        const clientOptions = { debug: this._options.debug, reconnect: this._options.reconnect };
+        if (this._options.url)
+            clientOptions.url = this._options.url;
+        this._client = NoLag(this._token, clientOptions);
+        this._client.on('connect', () => { if (this._channels.size > 0) {
+            this._restoreChannels();
+            this.emit('reconnected');
+        } });
+        this._client.on('disconnect', (reason) => this.emit('disconnected', reason));
+        this._client.on('reconnect', () => { });
+        this._client.on('error', (error) => this.emit('error', error));
+        this._client.on('replay:start', (data) => { for (const ch of this._channels.values())
+            ch._handleReplayStart(data.count); });
+        this._client.on('replay:end', (data) => { for (const ch of this._channels.values())
+            ch._handleReplayEnd(data.replayed); });
+        await this._client.connect();
+        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._localUser = {
+            userId: this._userId, actorTokenId: this._client.actorId, username: this._options.username,
+            avatar: this._options.avatar, metadata: this._options.metadata, joinedAt: Date.now(), isLocal: true,
+        };
+        await this._setupLobby();
+        for (const name of this._options.channels)
+            this._subscribeChannel(name);
+        this.emit('connected');
+        setTimeout(() => { if (this._lobby && this._client?.connected)
+            this._lobby.fetchPresence().then((s) => this._hydrateOnlineUsers(s)).catch(() => { }); }, 2000);
+    }
+    disconnect() {
+        for (const name of [...this._channels.keys()])
+            this.leaveChannel(name);
+        this._lobby?.unsubscribe();
+        this._lobby = null;
+        this._client?.disconnect();
+        this._client = null;
+        this._onlineUsers.clear();
+        this._actorToUserId.clear();
+        this._localUser = null;
+    }
+    joinChannel(name) {
+        if (!this._client || !this._localUser)
+            throw new Error('Not connected — call connect() first');
+        if (this._activeChannel && this._activeChannel !== name) {
+            this._channels.get(this._activeChannel)?._deactivate();
+        }
+        let ch = this._channels.get(name);
+        if (!ch)
+            ch = this._subscribeChannel(name);
+        this._activeChannel = name;
+        ch._activate();
+        return ch;
+    }
+    leaveChannel(name) {
+        const ch = this._channels.get(name);
+        if (!ch)
+            return;
+        ch._cleanup();
+        this._channels.delete(name);
+        if (this._activeChannel === name)
+            this._activeChannel = null;
+    }
+    getOnlineUsers() { return Array.from(this._onlineUsers.values()); }
+    _subscribeChannel(name) {
+        if (!this._client || !this._localUser)
+            throw new Error('Not connected');
+        const roomContext = this._client.setApp(this._options.appName).setRoom(name);
+        const ch = new FeedChannel(name, roomContext, this._localUser, this._options, createLogger(`FeedChannel:${name}`, this._options.debug));
+        this._channels.set(name, ch);
+        ch._subscribe();
+        return ch;
+    }
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        const pd = data.presence;
+        if (!pd?.userId)
+            return;
+        const user = this._presenceToUser(data.actorTokenId, pd);
+        this._actorToUserId.set(data.actorTokenId, user.userId);
+        if (!this._onlineUsers.has(user.userId)) {
+            this._onlineUsers.set(user.userId, user);
+            this.emit('userOnline', user);
+        }
+        const room = this._activeChannel ? this._channels.get(this._activeChannel) : undefined;
+        if (room)
+            room._handlePresenceJoin(data.actorTokenId, pd);
+    }
+    _handleRoomPresenceLeave(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        const room = this._activeChannel ? this._channels.get(this._activeChannel) : undefined;
+        if (room)
+            room._handlePresenceLeave(data.actorTokenId);
+    }
+    _handleRoomPresenceUpdate(data) {
+        if (data.actorTokenId === this._localUser?.actorTokenId)
+            return;
+        const pd = data.presence;
+        if (!pd?.userId)
+            return;
+        const room = this._activeChannel ? this._channels.get(this._activeChannel) : undefined;
+        if (room)
+            room._handlePresenceUpdate(data.actorTokenId, pd);
+    }
+    async _setupLobby() {
+        if (!this._client)
+            return;
+        this._lobby = this._client.setApp(this._options.appName).setLobby(LOBBY_ID);
+        const lh = (type) => (data) => {
+            const e = data;
+            if (type === 'join')
+                this._handleLobbyJoin(e);
+            else if (type === 'leave')
+                this._handleLobbyLeave(e);
+        };
+        this._client.on('lobbyPresence:join', lh('join'));
+        this._client.on('lobbyPresence:leave', lh('leave'));
+        this._client.on('lobbyPresence:update', lh('update'));
+        try {
+            const s = await this._lobby.subscribe();
+            this._hydrateOnlineUsers(s);
+        }
+        catch { }
+    }
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localUser?.actorTokenId)
+            return;
+        const pd = data;
+        if (!pd.userId)
+            return;
+        const user = this._presenceToUser(actorId, pd);
+        this._actorToUserId.set(actorId, user.userId);
+        if (!this._onlineUsers.has(user.userId)) {
+            this._onlineUsers.set(user.userId, user);
+            this.emit('userOnline', user);
+        }
+    }
+    _handleLobbyLeave(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localUser?.actorTokenId)
+            return;
+        const pd = data;
+        const userId = pd?.userId || this._actorToUserId.get(actorId);
+        if (userId) {
+            const user = this._onlineUsers.get(userId);
+            if (user) {
+                this._onlineUsers.delete(userId);
+                this._actorToUserId.delete(actorId);
+                this.emit('userOffline', user);
+            }
+        }
+    }
+    _hydrateOnlineUsers(state) {
+        for (const roomId of Object.keys(state)) {
+            for (const actorId of Object.keys(state[roomId])) {
+                if (actorId === this._localUser?.actorTokenId)
+                    continue;
+                const raw = state[roomId][actorId];
+                const pd = (raw?.presence ?? raw);
+                if (pd?.userId) {
+                    const user = this._presenceToUser(actorId, pd);
+                    this._actorToUserId.set(actorId, user.userId);
+                    if (!this._onlineUsers.has(user.userId)) {
+                        this._onlineUsers.set(user.userId, user);
+                        this.emit('userOnline', user);
+                    }
+                }
+            }
+        }
+    }
+    _presenceToUser(actorTokenId, data) {
+        return { userId: data.userId, actorTokenId, username: data.username, avatar: data.avatar, metadata: data.metadata, joinedAt: Date.now(), isLocal: false };
+    }
+    _restoreChannels() {
+        if (this._activeChannel) {
+            const ch = this._channels.get(this._activeChannel);
+            if (ch)
+                ch._updateLocalPresence();
+        }
+        this._lobby?.fetchPresence().then((s) => { this._onlineUsers.clear(); this._actorToUserId.clear(); this._hydrateOnlineUsers(s); }).catch(() => { });
+    }
+}
+
+export { EventEmitter, FeedChannel, NoLagFeed };
+//# sourceMappingURL=index.mjs.map