polfan-server-js-client 0.2.105 → 0.2.106

package/build/types/IndexedObjectCollection.d.ts

@@ -51,6 +51,14 @@ export declare class ObservableIndexedObjectCollection<ItemT, EventMapT extends
     set(...items: ItemT[]): void;
     delete(...ids: string[]): void;
     deleteAll(): void;
+    /**
+     * Bring the collection to exactly match the provided items: upsert every
+     * provided item and remove any existing item whose id is not present in the
+     * provided set. Emits at most a single `change` event describing both the
+     * set and the deleted ids, so bound consumers can update in place without
+     * ever observing an intermediate empty state (unlike deleteAll + set).
+     */
+    reconcile(...items: ItemT[]): void;
     createMirror(): ObservableIndexedObjectCollection<ItemT, EventMapT>;
     on<EventName extends keyof EventMapT & string>(eventName: EventName, handler: EventHandler<EventMapT[EventName]>): this;
     once<EventName extends keyof EventMapT & string>(eventName: EventName, handler: EventHandler<EventMapT[EventName]>): this;

package/build/types/state-tracker/FollowedTopicsManager.d.ts

@@ -11,6 +11,11 @@ export declare class FollowedTopicsManager extends EventTarget<EventMap> {
     private readonly followedTopicsPromises;
     private readonly deferredSession;
     private readonly summariesCache;
+    /**
+     * Rooms whose cached followed-topics are stale after a reconnect and must
+     * be refetched (and reconciled in place) the next time they are accessed.
+     */
+    private readonly staleRooms;
     constructor(tracker: ChatStateTracker);
     /**
      * Cache followed topics for all joined rooms in a space and fetch them in bulk if necessary.
@@ -58,6 +63,19 @@ export declare class FollowedTopicsManager extends EventTarget<EventMap> {
     private invalidateUnreadSummaries;
     private invalidateUnreadSummariesForRooms;
     private updateLocallyFollowedTopicOnNewMessage;
+    /**
+     * Reconcile the followed-topics collection for a single room to exactly
+     * match the provided list (upsert present, drop absent) without emitting an
+     * intermediate empty state, and clear its stale marker. Does not touch the
+     * unread summaries cache - callers decide how to invalidate it.
+     */
+    private applyRoomFollowedTopics;
+    /**
+     * Reconcile a batch of rooms from a single bulk GetFollowedTopics response.
+     * Rooms with no followed topics in the response are reconciled to empty, so
+     * topics unfollowed/removed during the downtime are correctly dropped.
+     */
+    private reconcileRoomsFollowedTopics;
     private setFollowedTopicsArray;
     private clearRoomFollowedTopicsStructures;
 }

package/build/types/state-tracker/RoomMessagesHistory.d.ts

@@ -13,6 +13,18 @@ export declare class RoomMessagesHistory {
      * @param peek If true, do not create a cache for this topic and do not allow it to collect new messages.
      */
     getMessagesWindow(topicId: string, peek?: boolean): Promise<TopicHistoryWindow | undefined>;
+    /**
+     * Re-synchronise this room's history after a reconnect without discarding
+     * the existing window objects (which would blank the UI and, for ephemeral
+     * rooms, permanently drop live-only history).
+     *
+     * The window bindings are preserved; only windows that the application had
+     * actually pulled to the latest page (state === LATEST) are refreshed, with
+     * a single resetToLatest instead of a chain of catch-up requests. Windows
+     * that were never pulled (LIVE) or belong to an ephemeral room are left
+     * untouched so their in-memory context survives the reconnect.
+     */
+    resync(room: Room): Promise<void>;
     private handleRoomUpdated;
     private handleNewTopic;
     private handleTopicDeleted;

package/build/types/state-tracker/TopicHistoryWindow.d.ts

@@ -64,7 +64,7 @@ export declare abstract class TraversableRemoteCollection<ItemT, EventMapT exten
     get hasLatest(): boolean;
     get hasOldest(): boolean;
     abstract createMirror(): TraversableRemoteCollection<ItemT, EventMapT>;
-    resetToLatest(): Promise<void>;
+    resetToLatest(force?: boolean): Promise<void>;
     fetchPrevious(): Promise<void>;
     fetchNext(): Promise<void>;
     jumpTo(id: string): Promise<void>;
@@ -99,7 +99,7 @@ export declare class TopicHistoryWindow extends TraversableRemoteCollection<Mess
     createMirror(): TopicHistoryWindow;
     get isTraverseLocked(): boolean;
     setTraverseLock(lock: boolean): Promise<void>;
-    resetToLatest(): Promise<void>;
+    resetToLatest(force?: boolean): Promise<void>;
     fetchNext(): Promise<void>;
     fetchPrevious(): Promise<void>;
     jumpTo(id: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polfan-server-js-client",
-  "version": "0.2.105",
+  "version": "0.2.106",
   "description": "JavaScript client library for handling communication with Polfan chat server.",
   "author": "Jarosław Żak",
   "license": "MIT",

package/src/IndexedObjectCollection.ts

@@ -226,6 +226,37 @@ export class ObservableIndexedObjectCollection<
         }
     }
 
+    /**
+     * Bring the collection to exactly match the provided items: upsert every
+     * provided item and remove any existing item whose id is not present in the
+     * provided set. Emits at most a single `change` event describing both the
+     * set and the deleted ids, so bound consumers can update in place without
+     * ever observing an intermediate empty state (unlike deleteAll + set).
+     */
+    public reconcile(...items: ItemT[]) {
+        const incomingIds = new Set(items.map(item => this.getId(item)));
+        const deletedItems: string[] = [];
+
+        for (const existing of this.items) {
+            const id = this.getId(existing);
+            if (! incomingIds.has(id)) {
+                deletedItems.push(id);
+            }
+        }
+
+        if (! items.length && ! deletedItems.length) {
+            return;
+        }
+
+        this._items.delete(...deletedItems);
+        super.set(...items);
+
+        this.eventTarget.emit('change', {
+            setItems: items.map(item => this.getId(item)),
+            deletedItems,
+        });
+    }
+
     public createMirror(): ObservableIndexedObjectCollection<ItemT, EventMapT> {
         const copy = new ObservableIndexedObjectCollection<ItemT, EventMapT>(this.id);
         copy.eventTarget = this.eventTarget;

package/src/state-tracker/EmoticonsManager.ts

@@ -1,69 +1,73 @@
-import {ChatStateTracker} from "./ChatStateTracker";
-import {
-    IndexedCollection,
-    ObservableIndexedObjectCollection
-} from "../IndexedObjectCollection";
-import {Emoticon, EmoticonDeleted, Emoticons, NewEmoticon, SpaceDeleted} from "../types/src";
-import {PromiseRegistry} from "./AsyncUtils";
-
-const GLOBAL_KEY = 'global';
-
-export class EmoticonsManager {
-    private list: IndexedCollection<string, ObservableIndexedObjectCollection<Emoticon>> = new IndexedCollection();
-    private emoticonsPromises = new PromiseRegistry();
-    
-    public constructor(private tracker: ChatStateTracker) {
-        this.tracker.client.on('Emoticons', ev => this.handleEmoticons(ev));
-        this.tracker.client.on('NewEmoticon', ev => this.handleNewEmoticon(ev));
-        this.tracker.client.on('EmoticonDeleted', ev => this.handleEmoticonDeleted(ev));
-        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
-        this.tracker.client.on('Session', () => this.handleSession());
-    }
-
-    public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
-        const key = spaceId ?? GLOBAL_KEY;
-
-        if (this.emoticonsPromises.notExist(key)) {
-            this.emoticonsPromises.registerByFunction(async () => {
-                const result = await this.tracker.client.send('GetEmoticons', {spaceId});
-                if (result.error) {
-                    throw result.error;
-                }
-                this.handleEmoticons(result.data);
-            }, key);
-        }
-
-        await this.emoticonsPromises.get(key);
-        return this.list.get(key);
-    }
-
-    private handleEmoticons(event: Emoticons): void {
-        const spaceId = event.location.spaceId ?? GLOBAL_KEY;
-
-        if (!this.list.has(spaceId)) {
-            this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
-        }
-
-        const collection = this.list.get(spaceId);
-        collection.set(...event.emoticons);
-    }
-
-    private handleNewEmoticon(ev: NewEmoticon): void {
-        const collection = this.list.get(ev.emoticon.spaceId ?? GLOBAL_KEY);
-        collection?.set(ev.emoticon);
-    }
-
-    private handleEmoticonDeleted(ev: EmoticonDeleted): void {
-        const collection = this.list.get(ev.spaceId ?? GLOBAL_KEY);
-        collection?.delete(ev.emoticonId);
-    }
-
-    private handleSpaceDeleted(event: SpaceDeleted): void {
-        this.list.delete(event.id);
-    }
-
-    private handleSession(): void {
-        this.list.deleteAll();
-        this.emoticonsPromises.forgetAll();
-    }
+import {ChatStateTracker} from "./ChatStateTracker";
+import {
+    IndexedCollection,
+    ObservableIndexedObjectCollection
+} from "../IndexedObjectCollection";
+import {Emoticon, EmoticonDeleted, Emoticons, NewEmoticon, SpaceDeleted} from "../types/src";
+import {PromiseRegistry} from "./AsyncUtils";
+
+const GLOBAL_KEY = 'global';
+
+export class EmoticonsManager {
+    private list: IndexedCollection<string, ObservableIndexedObjectCollection<Emoticon>> = new IndexedCollection();
+    private emoticonsPromises = new PromiseRegistry();
+    
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('Emoticons', ev => this.handleEmoticons(ev));
+        this.tracker.client.on('NewEmoticon', ev => this.handleNewEmoticon(ev));
+        this.tracker.client.on('EmoticonDeleted', ev => this.handleEmoticonDeleted(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('Session', () => this.handleSession());
+    }
+
+    public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
+        const key = spaceId ?? GLOBAL_KEY;
+
+        if (this.emoticonsPromises.notExist(key)) {
+            this.emoticonsPromises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetEmoticons', {spaceId});
+                if (result.error) {
+                    throw result.error;
+                }
+                this.handleEmoticons(result.data);
+            }, key);
+        }
+
+        await this.emoticonsPromises.get(key);
+        return this.list.get(key);
+    }
+
+    private handleEmoticons(event: Emoticons): void {
+        const spaceId = event.location.spaceId ?? GLOBAL_KEY;
+
+        if (!this.list.has(spaceId)) {
+            this.list.set([spaceId, new ObservableIndexedObjectCollection<Emoticon>('id')]);
+        }
+
+        // handleEmoticons always carries the full list for a location, so
+        // reconcile in place: a reconnect refetch drops removed emoticons and
+        // adds new ones without blanking a bound (visible) collection.
+        this.list.get(spaceId).reconcile(...event.emoticons);
+    }
+
+    private handleNewEmoticon(ev: NewEmoticon): void {
+        const collection = this.list.get(ev.emoticon.spaceId ?? GLOBAL_KEY);
+        collection?.set(ev.emoticon);
+    }
+
+    private handleEmoticonDeleted(ev: EmoticonDeleted): void {
+        const collection = this.list.get(ev.spaceId ?? GLOBAL_KEY);
+        collection?.delete(ev.emoticonId);
+    }
+
+    private handleSpaceDeleted(event: SpaceDeleted): void {
+        this.list.delete(event.id);
+    }
+
+    private handleSession(): void {
+        // Keep cached emoticon collections (they may be bound to visible
+        // pickers); just drop the fetch guards so the next access refetches and
+        // reconciles them in place.
+        this.emoticonsPromises.forgetAll();
+    }
 }

package/src/state-tracker/FollowedTopicsManager.ts

@@ -23,6 +23,12 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     private readonly deferredSession = new DeferredTask();
     private readonly summariesCache = new Map<string, { mentionCount: number, isUnread: boolean }>();
 
+    /**
+     * Rooms whose cached followed-topics are stale after a reconnect and must
+     * be refetched (and reconciled in place) the next time they are accessed.
+     */
+    private readonly staleRooms = new Set<string>();
+
     public constructor(private tracker: ChatStateTracker) {
         super();
 
@@ -57,8 +63,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return;
         }
 
-        const isAlreadyCached = roomIds.every(roomId => this.followedTopics.has(roomId));
-        if (isAlreadyCached) {
+        const needsFetch = roomIds.some(roomId => ! this.followedTopics.has(roomId) || this.staleRooms.has(roomId));
+        if (! needsFetch) {
             return;
         }
 
@@ -69,7 +75,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                 const result = await this.tracker.client.send('GetFollowedTopics', {location: {spaceId}});
                 if (result.error) throw result.error;
 
-                this.setFollowedTopicsArray(roomIds, result.data.followedTopics);
+                this.reconcileRoomsFollowedTopics(roomIds, result.data.followedTopics);
             }, spaceRegistryKey);
         }
 
@@ -85,7 +91,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
             return undefined;
         }
 
-        if (! this.followedTopics.has(roomId)) {
+        if (! this.followedTopics.has(roomId) || this.staleRooms.has(roomId)) {
             if (this.followedTopicsPromises.notExist(roomId)) {
                 this.followedTopicsPromises.registerByFunction(async () => {
                     const result = await this.tracker.client.send('GetFollowedTopics', {location: {roomId}});
@@ -94,7 +100,8 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
                         throw result.error;
                     }
 
-                    this.setFollowedTopicsArray([roomId], result.data.followedTopics);
+                    this.applyRoomFollowedTopics(roomId, result.data.followedTopics);
+                    this.invalidateUnreadSummaries(roomId);
                 }, roomId);
             }
 
@@ -199,7 +206,13 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     }
 
     private handleSession(ev: Session): void {
-        this.followedTopics.deleteAll();
+        // Keep cached followed-topic collections (they drive unread indicators
+        // that would otherwise blank on reconnect), but mark them stale and drop
+        // the fetch guards so the next access/caching refetches and reconciles
+        // them in place.
+        for (const roomId of this.followedTopics.items.keys()) {
+            this.staleRooms.add(roomId);
+        }
         this.followedTopicsPromises.forgetAll();
         this.invalidateUnreadSummaries();
         this.deferredSession.resolve();
@@ -351,6 +364,40 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
         this.invalidateUnreadSummaries(ev.message.location.roomId, ev.message.location.topicId);
     }
 
+    /**
+     * Reconcile the followed-topics collection for a single room to exactly
+     * match the provided list (upsert present, drop absent) without emitting an
+     * intermediate empty state, and clear its stale marker. Does not touch the
+     * unread summaries cache - callers decide how to invalidate it.
+     */
+    private applyRoomFollowedTopics(roomId: string, followedTopics: FollowedTopic[]): void {
+        if (! this.followedTopics.has(roomId)) {
+            this.followedTopics.set([roomId, new ObservableIndexedObjectCollection<FollowedTopic>(
+                followedTopic => followedTopic.location.topicId
+            )]);
+        }
+
+        this.followedTopics.get(roomId).reconcile(...followedTopics);
+        this.staleRooms.delete(roomId);
+    }
+
+    /**
+     * Reconcile a batch of rooms from a single bulk GetFollowedTopics response.
+     * Rooms with no followed topics in the response are reconciled to empty, so
+     * topics unfollowed/removed during the downtime are correctly dropped.
+     */
+    private reconcileRoomsFollowedTopics(roomIds: string[], followedTopics: FollowedTopic[]): void {
+        const roomToTopics: {[roomId: string]: FollowedTopic[]} = {};
+
+        followedTopics.forEach(followedTopic => {
+            (roomToTopics[followedTopic.location.roomId] ??= []).push(followedTopic);
+        });
+
+        roomIds.forEach(roomId => this.applyRoomFollowedTopics(roomId, roomToTopics[roomId] ?? []));
+
+        this.invalidateUnreadSummariesForRooms(roomIds);
+    }
+
     private setFollowedTopicsArray(roomIds: string[], followedTopics: FollowedTopic[]): void {
         const roomToTopics: {[roomId: string]: FollowedTopic[]} = {};
 
@@ -378,6 +425,7 @@ export class FollowedTopicsManager extends EventTarget<EventMap> {
     private clearRoomFollowedTopicsStructures(roomId: string): void {
         this.followedTopics.delete(roomId);
         this.followedTopicsPromises.forget(roomId);
+        this.staleRooms.delete(roomId);
         this.invalidateUnreadSummaries(roomId);
     }
 }

package/src/state-tracker/MessagesManager.ts

@@ -71,8 +71,27 @@ export class MessagesManager {
     }
 
     private handleSession(ev: Session): void {
-        this.roomHistories.deleteAll();
-        ev.state.rooms.forEach(room => this.createHistoryForNewRoom(room));
+        const stateRoomIds = new Set(ev.state.rooms.map(room => room.id));
+
+        // Drop histories only for rooms that no longer exist server-side.
+        for (const roomId of Array.from(this.roomHistories.items.keys())) {
+            if (! stateRoomIds.has(roomId)) {
+                this.roomHistories.delete(roomId);
+            }
+        }
+
+        // Keep existing histories (preserving loaded messages and, crucially,
+        // live-only ephemeral history), create histories for newly joined
+        // rooms, and resync survivors against the fresh room snapshot.
+        for (const room of ev.state.rooms) {
+            const history = this.roomHistories.get(room.id);
+            if (history) {
+                void history.resync(room);
+            } else {
+                this.createHistoryForNewRoom(room);
+            }
+        }
+
         this.deferredSession.resolve();
     }
 }

package/src/state-tracker/PermissionsManager.ts

@@ -308,7 +308,11 @@ export class PermissionsManager extends EventTarget<PermissionsManagerEventMap>
     }
 
     private handleSession(ev: Session): void {
-        this.overwrites.deleteAll();
+        // Drop the fetch guards so permission checks recompute against fresh
+        // overwrites (getOverwrites refetches and upserts on the next access),
+        // and notify consumers to recompute so bound permission UI is never
+        // left showing stale results after a reconnect.
         this.overwritesPromises.forgetAll();
+        this.emit('change');
     }
 }

package/src/state-tracker/RelationshipsManager.ts

@@ -43,10 +43,9 @@ export class RelationshipsManager {
     }
 
     private handleRelationships(ev: Relationships): void {
-        this.relationships.deleteAll();
-        ev.relationships.forEach(relationship => {
-            this.relationships.set(relationship);
-        });
+        // Full list from the server: reconcile in place so a reconnect refetch
+        // updates a bound (visible) list without an intermediate empty state.
+        this.relationships.reconcile(...ev.relationships);
     }
 
     private handleNewRelationship(ev: NewRelationship): void {
@@ -62,7 +61,8 @@ export class RelationshipsManager {
     }
 
     private handleSession(): void {
+        // Keep the (possibly bound) collection; just drop the fetch guard so the
+        // next get() refetches and reconciles it in place.
         this.promises.forgetAll();
-        this.relationships.deleteAll();
     }
 }

package/src/state-tracker/RoomMessagesHistory.ts

@@ -1,7 +1,7 @@
 import {ChatStateTracker} from "./ChatStateTracker";
 import {NewTopic, Room, RoomUpdated, Topic, TopicDeleted} from "../types/src";
 import {IndexedCollection,} from "../IndexedObjectCollection";
-import {TopicHistoryWindow} from "./TopicHistoryWindow";
+import {TopicHistoryWindow, WindowState} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
@@ -39,6 +39,40 @@ export class RoomMessagesHistory {
         return this.historyWindows.get(topicId);
     }
 
+    /**
+     * Re-synchronise this room's history after a reconnect without discarding
+     * the existing window objects (which would blank the UI and, for ephemeral
+     * rooms, permanently drop live-only history).
+     *
+     * The window bindings are preserved; only windows that the application had
+     * actually pulled to the latest page (state === LATEST) are refreshed, with
+     * a single resetToLatest instead of a chain of catch-up requests. Windows
+     * that were never pulled (LIVE) or belong to an ephemeral room are left
+     * untouched so their in-memory context survives the reconnect.
+     */
+    public async resync(room: Room): Promise<void> {
+        this.room = room;
+        this.updateTraverseLock(room);
+
+        if (this.room.defaultTopic) {
+            this.createHistoryWindowForTopic(this.room.defaultTopic);
+        }
+
+        for (const [, window] of Array.from(this.historyWindows.items)) {
+            await window.setTraverseLock(this.traverseLock);
+
+            // Ephemeral history lives only in memory (the server does not
+            // persist it), so never refetch/replace it on reconnect.
+            if (this.traverseLock) {
+                continue;
+            }
+
+            if (window.state === WindowState.LATEST) {
+                await window.resetToLatest(true);
+            }
+        }
+    }
+
     private async handleRoomUpdated(ev: RoomUpdated): Promise<void> {
         if (this.room.id === ev.room.id) {
             this.room = ev.room;

package/src/state-tracker/RoomsManager.ts

@@ -303,16 +303,33 @@ export class RoomsManager {
                     ev.members,
                 )
             ]);
+        } else {
+            // Reconcile into the existing (bound) collection so a reconnect
+            // refetch updates it in place instead of leaving stale members.
+            this.members.get(ev.id).reconcile(...ev.members);
         }
     }
 
     private handleSession(ev: Session): void {
-        this.list.deleteAll();
-        this.topics.deleteAll();
-        this.topicsPromises.forgetAll();
-        this.members.deleteAll();
+        const stateRoomIds = new Set(ev.state.rooms.map(room => room.id));
+
+        // Remove only rooms that were left/deleted on the server during the
+        // downtime, reusing the cascade cleanup (members, topics, followed
+        // topics). Surviving rooms keep their identity and bindings.
+        const removedRoomIds = this.list.items
+            .filter(room => ! stateRoomIds.has(room.id))
+            .map(room => room.id);
+        if (removedRoomIds.length) {
+            this.deleteRoom(...removedRoomIds);
+        }
+
+        // Invalidate lazy caches so the next access refetches fresh data, but
+        // keep the collection objects: handleRoomMembers reconciles into them,
+        // so bound views refresh in place without blanking.
         this.membersPromises.forgetAll();
+        this.topicsPromises.forgetAll();
 
+        // Upsert surviving/new rooms from the authoritative snapshot.
         this.addJoinedRooms(...ev.state.rooms);
 
         this.deferredSession.resolve();