polfan-server-js-client 0.3.3 → 0.4.0

package/src/state-tracker/TopicHistoryWindow.ts

@@ -45,7 +45,6 @@ export abstract class TraversableRemoteCollection<
         fetchLimit: number,
         lastFetchCount: number,
         oldestId: string | null,
-        gaps: string[],
     } = {
         current: WindowState.LIVE,
         ongoing: undefined,
@@ -54,7 +53,6 @@ export abstract class TraversableRemoteCollection<
         fetchLimit: 50,
         lastFetchCount: 0,
         oldestId: null,
-        gaps: [],
     };
 
     /**
@@ -105,21 +103,6 @@ export abstract class TraversableRemoteCollection<
         return [WindowState.LATEST, WindowState.LIVE].includes(this.state);
     }
 
-    /**
-     * IDs of the items the window could not stitch to the ones loaded before
-     * them: there is a gap in front of each of them, i.e. the item right above
-     * it in the window is not its real predecessor and an unknown number of
-     * items in between was never fetched.
-     *
-     * Such a gap appears when the collection is resynchronised after a
-     * reconnect (see resyncToLatest) and more items than a single page arrived
-     * while the connection was down. The markers are kept in the window order
-     * and disappear together with the items they point at.
-     */
-    public get gaps(): readonly string[] {
-        return [...this.internalState.gaps];
-    }
-
     public get hasOldest(): boolean {
         return this.state === WindowState.OLDEST
             || this.state === WindowState.LATEST && this.length < this.fetchLimit
@@ -145,68 +128,11 @@ export abstract class TraversableRemoteCollection<
         }
 
         this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
-        this.internalState.gaps = []; // Whole content is replaced, old markers mean nothing.
         this.addItems(result, 'tail');
         this.internalState.current = WindowState.LATEST;
         this.emitChangeWithDiff(true, originalState);
     }
 
-    /**
-     * Refresh the window with the latest page, keeping the already loaded items
-     * instead of replacing them.
-     *
-     * This is the reconnect-friendly variant of resetToLatest: the items missed
-     * while the connection was down are pulled with a single request and merged
-     * on top of the loaded ones (items returned in both are deduplicated), so
-     * the context the application already had does not disappear. The window
-     * size limit is the only thing that pushes the oldest items out.
-     *
-     * An empty or partial page is not a reason to drop anything: it only means
-     * the collection has little (or nothing) left on the remote side, while the
-     * items loaded earlier are still valid. When the page is full and does not
-     * reach the loaded items, an unknown number of items in between was never
-     * fetched - both parts are still kept, and the seam between them is recorded
-     * in `gaps` so the application can show where the history is not continuous.
-     */
-    public async resyncToLatest(): Promise<void> {
-        if (this.internalState.ongoing) {
-            return;
-        }
-
-        let result;
-        const originalState = this.state;
-        this.internalState.ongoing = WindowState.LATEST;
-
-        try {
-            result = await this.fetchLatestItems();
-            this.internalState.lastFetchCount = result.length;
-        } finally {
-            this.internalState.ongoing = undefined;
-        }
-
-        const loaded = this.items;
-        const fetchedIds = new Set(result.map(item => this.getId(item)));
-        // Items present in the page are taken from it - the server copy is the
-        // up-to-date one.
-        const retained = loaded.filter(item => ! fetchedIds.has(this.getId(item)));
-
-        // Nothing can be missing in between when there is nothing to stitch,
-        // when the page is everything the remote side has (it is shorter than
-        // the requested limit), or when the page reaches the newest loaded item.
-        const isContinuous = ! retained.length
-            || result.length < this.internalState.fetchLimit
-            || fetchedIds.has(this.getId(loaded[loaded.length - 1]));
-
-        if (! isContinuous) {
-            this.markGapBefore(this.getId(result[0]));
-        }
-
-        this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
-        this.addItems([...retained, ...result], 'tail');
-        this.internalState.current = WindowState.LATEST;
-        this.emitChangeWithDiff(true, originalState);
-    }
-
     public async fetchPrevious(): Promise<void> {
         if (this.internalState.ongoing || this.hasOldest) {
             return;
@@ -214,7 +140,6 @@ export abstract class TraversableRemoteCollection<
 
         let result;
         const originalState = this.state;
-        const firstItem = this.getAt(0);
         this.internalState.ongoing = WindowState.PAST;
 
         try {
@@ -229,6 +154,7 @@ export abstract class TraversableRemoteCollection<
         }
 
         if (! result.length) {
+            const firstItem = this.getAt(0);
             this.internalState.oldestId = firstItem ? this.getId(firstItem) : null;
 
             await this.refreshFetchedState();
@@ -242,13 +168,6 @@ export abstract class TraversableRemoteCollection<
             return;
         }
 
-        if (firstItem) {
-            // The fetch asked for the items right before the one that was first,
-            // so whatever came back is its real predecessor: a gap marked in
-            // front of it (it used to be the top of the window) is closed now.
-            this.clearGapBefore(this.getId(firstItem));
-        }
-
         this.addItems(result, 'head');
         await this.refreshFetchedState();
         this.emitChangeWithDiff(true, originalState);
@@ -298,7 +217,6 @@ export abstract class TraversableRemoteCollection<
 
             if (result) {
                 this._items.deleteAll(); // Directly call deleteAll to prevent event emit.
-                this.internalState.gaps = []; // Whole content is replaced, old markers mean nothing.
                 this.addItems(result, 'tail');
                 await this.refreshFetchedState();
             }
@@ -309,16 +227,6 @@ export abstract class TraversableRemoteCollection<
         this.emitChangeWithDiff(!!result, originalState);
     }
 
-    public delete(...ids: string[]): void {
-        super.delete(...ids);
-        this.dropDanglingGaps();
-    }
-
-    public deleteAll(): void {
-        super.deleteAll();
-        this.internalState.gaps = [];
-    }
-
     protected abstract fetchLatestItems(): Promise<ItemT[]>;
 
     protected abstract fetchItemsBefore(): Promise<ItemT[] | null>;
@@ -347,8 +255,6 @@ export abstract class TraversableRemoteCollection<
         // Directly calls to prevent event emit.
         this._items.deleteAll();
         this._items.set(...(result.map(item => [this.getId(item), item] as [string, ItemT])));
-
-        this.dropDanglingGaps();
     }
 
     protected emitChangeWithDiff(itemChanged: boolean, originalState: WindowState): void {
@@ -357,37 +263,6 @@ export abstract class TraversableRemoteCollection<
         }
     }
 
-    /**
-     * Record that the history is not continuous in front of the given item.
-     */
-    protected markGapBefore(id: string): void {
-        if (! this.internalState.gaps.includes(id)) {
-            this.internalState.gaps = [...this.internalState.gaps, id];
-        }
-    }
-
-    /**
-     * Forget the gap in front of the given item - the items before it are known
-     * to be its real predecessors now.
-     */
-    protected clearGapBefore(id: string): void {
-        if (this.internalState.gaps.includes(id)) {
-            this.internalState.gaps = this.internalState.gaps.filter(gapId => gapId !== id);
-        }
-    }
-
-    /**
-     * Forget the gap markers pointing at items that are no longer in the window
-     * (trimmed, deleted or replaced), so `gaps` never refers to nothing.
-     */
-    protected dropDanglingGaps(): void {
-        if (! this.internalState.gaps.length) {
-            return;
-        }
-
-        this.internalState.gaps = this.internalState.gaps.filter(id => this.has(id));
-    }
-
     /**
      * Return array with messages trimmed using High/Low Watermark strategy.
      */
@@ -472,13 +347,6 @@ export class TopicHistoryWindow extends TraversableRemoteCollection<
         return super.resetToLatest(force);
     }
 
-    public async resyncToLatest(): Promise<void> {
-        if (this.internalState.traverseLock) {
-            return;
-        }
-        return super.resyncToLatest();
-    }
-
     public async fetchNext(): Promise<void> {
         if (this.internalState.traverseLock) {
             return;

package/src/state-tracker/UsersManager.ts

@@ -1,52 +1,52 @@
-import {ChatStateTracker} from "./ChatStateTracker";
-import {ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
-import {RoomMember, Session, SpaceMember, User} from "../types/src";
-import {extractUserFromMember} from "./functions";
-import {EventTarget} from "../EventTarget";
-
-export class UsersManager {
-    public readonly onlineStatus = new EventTarget<{ change: User }>();
-
-    private readonly users: ObservableIndexedObjectCollection<User> = new ObservableIndexedObjectCollection('id');
-
-    public constructor(private tracker: ChatStateTracker) {
-        // RoomMemberUpdated & SpaceMemberUpdated events are not contains user object
-        tracker.client.on('UserUpdated', event => this.handleUsers([event.user]));
-        tracker.client.on('RoomMembersJoined', event => this.handleMembers(event.members));
-        tracker.client.on('SpaceMemberJoined', event => this.handleMembers([event.member]));
-        tracker.client.on('SpaceMembers', event => this.handleMembers(event.members));
-        tracker.client.on('RoomMembers', event => this.handleMembers(event.members));
-        tracker.client.on('Messages', event => this.handleUsers(event.messages.map(message => message.author.user)));
-        tracker.client.on('NewMessage', event => this.handleUsers([event.message.author.user]));
-        tracker.client.on('Session', event => this.handleSession(event));
-    }
-
-    /**
-     * Get all available (cached) user objects at once.
-     */
-    public async getAvailable(): Promise<ObservableIndexedObjectCollection<User>> {
-        return this.users;
-    }
-
-    private handleMembers(members: (RoomMember | SpaceMember)[]): void {
-        this.handleUsers(members.map(extractUserFromMember));
-    }
-
-    private handleSession(session: Session): void {
-        // Keep the "seen users" cache across reconnects so bound user lists do
-        // not blank out; just ensure our own user is present/updated. Stale
-        // entries are refreshed as member/message collections refetch.
-        this.handleUsers([session.user]);
-    }
-
-    private handleUsers(users: User[]): void {
-        users.forEach(newUser => {
-            const oldUser = this.users.get(newUser.id);
-            if (oldUser && oldUser.online !== newUser.online) {
-                this.onlineStatus.emit('change', newUser);
-            }
-        });
-
-        this.users.set(...users);
-    }
+import {ChatStateTracker} from "./ChatStateTracker";
+import {ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {RoomMember, Session, SpaceMember, User} from "../types/src";
+import {extractUserFromMember} from "./functions";
+import {EventTarget} from "../EventTarget";
+
+export class UsersManager {
+    public readonly onlineStatus = new EventTarget<{ change: User }>();
+
+    private readonly users: ObservableIndexedObjectCollection<User> = new ObservableIndexedObjectCollection('id');
+
+    public constructor(private tracker: ChatStateTracker) {
+        // RoomMemberUpdated & SpaceMemberUpdated events are not contains user object
+        tracker.client.on('UserUpdated', event => this.handleUsers([event.user]));
+        tracker.client.on('RoomMembersJoined', event => this.handleMembers(event.members));
+        tracker.client.on('SpaceMemberJoined', event => this.handleMembers([event.member]));
+        tracker.client.on('SpaceMembers', event => this.handleMembers(event.members));
+        tracker.client.on('RoomMembers', event => this.handleMembers(event.members));
+        tracker.client.on('Messages', event => this.handleUsers(event.messages.map(message => message.author.user)));
+        tracker.client.on('NewMessage', event => this.handleUsers([event.message.author.user]));
+        tracker.client.on('Session', event => this.handleSession(event));
+    }
+
+    /**
+     * Get all available (cached) user objects at once.
+     */
+    public async getAvailable(): Promise<ObservableIndexedObjectCollection<User>> {
+        return this.users;
+    }
+
+    private handleMembers(members: (RoomMember | SpaceMember)[]): void {
+        this.handleUsers(members.map(extractUserFromMember));
+    }
+
+    private handleSession(session: Session): void {
+        // Keep the "seen users" cache across reconnects so bound user lists do
+        // not blank out; just ensure our own user is present/updated. Stale
+        // entries are refreshed as member/message collections refetch.
+        this.handleUsers([session.user]);
+    }
+
+    private handleUsers(users: User[]): void {
+        users.forEach(newUser => {
+            const oldUser = this.users.get(newUser.id);
+            if (oldUser && oldUser.status !== newUser.status) {
+                this.onlineStatus.emit('change', newUser);
+            }
+        });
+
+        this.users.set(...users);
+    }
 }

package/src/state-tracker/functions.ts

@@ -1,29 +1,29 @@
-import {Role, RoomMember, SpaceMember, User} from "../types/src";
-
-export function reorderRolesOnPriorityUpdate(allRoles: Role[], oldRole: Role, updatedRole: Role): Role[] {
-    // If the priority has changed, adjust the rest of roles
-    const increased = (updatedRole.priority - oldRole.priority) > 0;
-    const decreased = ! increased;
-    const changedRoles: Role[] = [];
-
-    allRoles.forEach(role => {
-        if (role.id === updatedRole.id) {
-            // Skip the updated role
-            return;
-        }
-        if (increased && oldRole.priority <= role.priority) {
-            role.priority--;
-            changedRoles.push(role);
-        }
-        if (decreased && updatedRole.priority <= role.priority) {
-            role.priority++;
-            changedRoles.push(role);
-        }
-    });
-
-    return changedRoles;
-}
-
-export function extractUserFromMember(member: RoomMember | SpaceMember): User | null {
-    return member.user ?? (member as RoomMember).spaceMember?.user;
+import {Role, RoomMember, SpaceMember, User} from "../types/src";
+
+export function reorderRolesOnPriorityUpdate(allRoles: Role[], oldRole: Role, updatedRole: Role): Role[] {
+    // If the priority has changed, adjust the rest of roles
+    const increased = (updatedRole.priority - oldRole.priority) > 0;
+    const decreased = ! increased;
+    const changedRoles: Role[] = [];
+
+    allRoles.forEach(role => {
+        if (role.id === updatedRole.id) {
+            // Skip the updated role
+            return;
+        }
+        if (increased && oldRole.priority <= role.priority) {
+            role.priority--;
+            changedRoles.push(role);
+        }
+        if (decreased && updatedRole.priority <= role.priority) {
+            role.priority++;
+            changedRoles.push(role);
+        }
+    });
+
+    return changedRoles;
+}
+
+export function extractUserFromMember(member: RoomMember | SpaceMember): User | null {
+    return member.user ?? (member as RoomMember).spaceMember?.user;
 }