Order new search dialog results by recency

src/components/views/dialogs/SpotlightDialog.tsx

@@ -74,6 +74,7 @@ import { KeyBindingAction } from "../../../accessibility/KeyboardShortcuts";
 import { PosthogAnalytics } from "../../../PosthogAnalytics";
 import { getCachedRoomIDForAlias } from "../../../RoomAliasCache";
 import { roomContextDetailsText, spaceContextDetailsText } from "../../../utils/i18n-helpers";
+import { RecentAlgorithm } from "../../../stores/room-list/algorithms/tag-sorting/RecentAlgorithm";
 
 const MAX_RECENT_SEARCHES = 10;
 const SECTION_LIMIT = 50; // only show 50 results per section for performance reasons
@@ -210,6 +211,8 @@ type Result = IRoomResult | IResult;
 
 const isRoomResult = (result: any): result is IRoomResult => !!result?.room;
 
+const recentAlgorithm = new RecentAlgorithm();
+
 export const useWebSearchMetrics = (numResults: number, queryLength: number, viaSpotlight: boolean): void => {
     useEffect(() => {
         if (!queryLength) return;
@@ -280,6 +283,7 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", onFinished }) =>
 
         const results: [Result[], Result[], Result[]] = [[], [], []];
 
+        // Group results in their respective sections
         possibleResults.forEach(entry => {
             if (isRoomResult(entry)) {
                 if (!entry.room.normalizedName.includes(normalizedQuery) &&
@@ -295,8 +299,25 @@ const SpotlightDialog: React.FC<IProps> = ({ initialText = "", onFinished }) =>
             results[entry.section].push(entry);
         });
 
+        // Sort results by most recent activity
+
+        const myUserId = cli.getUserId();
+        for (const resultArray of results) {
+            resultArray.sort((a: Result, b: Result) => {
+                // This is not a room result, it should appear at the bottom of
+                // the list
+                if (!(a as IRoomResult).room) return 1;
+                if (!(b as IRoomResult).room) return -1;
+
+                const roomA = (a as IRoomResult).room;
+                const roomB = (b as IRoomResult).room;
+
+                return recentAlgorithm.getLastTs(roomB, myUserId) - recentAlgorithm.getLastTs(roomA, myUserId);
+            });
+        }
+
         return results;
-    }, [possibleResults, trimmedQuery]);
+    }, [possibleResults, trimmedQuery, cli]);
 
     const numResults = trimmedQuery ? people.length + rooms.length + spaces.length : 0;
     useWebSearchMetrics(numResults, query.length, true);

src/stores/room-list/algorithms/tag-sorting/RecentAlgorithm.ts

@@ -63,58 +63,59 @@ export const sortRooms = (rooms: Room[]): Room[] => {
     }
 
     const tsCache: { [roomId: string]: number } = {};
-    const getLastTs = (r: Room) => {
-        if (tsCache[r.roomId]) {
-            return tsCache[r.roomId];
-        }
 
-        const ts = (() => {
-            // Apparently we can have rooms without timelines, at least under testing
-            // environments. Just return MAX_INT when this happens.
-            if (!r || !r.timeline) {
-                return Number.MAX_SAFE_INTEGER;
-            }
+    return rooms.sort((a, b) => {
+        const roomALastTs = tsCache[a.roomId] ?? getLastTs(a, myUserId);
+        const roomBLastTs = tsCache[b.roomId] ?? getLastTs(b, myUserId);
 
-            // If the room hasn't been joined yet, it probably won't have a timeline to
-            // parse. We'll still fall back to the timeline if this fails, but chances
-            // are we'll at least have our own membership event to go off of.
-            const effectiveMembership = getEffectiveMembership(r.getMyMembership());
-            if (effectiveMembership !== EffectiveMembership.Join) {
-                const membershipEvent = r.currentState.getStateEvents("m.room.member", myUserId);
-                if (membershipEvent && !Array.isArray(membershipEvent)) {
-                    return membershipEvent.getTs();
-                }
-            }
+        tsCache[a.roomId] = roomALastTs;
+        tsCache[b.roomId] = roomBLastTs;
 
-            for (let i = r.timeline.length - 1; i >= 0; --i) {
-                const ev = r.timeline[i];
-                if (!ev.getTs()) continue; // skip events that don't have timestamps (tests only?)
+        return roomBLastTs - roomALastTs;
+    });
+};
 
-                if (
-                    (ev.getSender() === myUserId && shouldCauseReorder(ev)) ||
-                    Unread.eventTriggersUnreadCount(ev)
-                ) {
-                    return ev.getTs();
-                }
-            }
+const getLastTs = (r: Room, userId: string) => {
+    const ts = (() => {
+        // Apparently we can have rooms without timelines, at least under testing
+        // environments. Just return MAX_INT when this happens.
+        if (!r || !r.timeline) {
+            return Number.MAX_SAFE_INTEGER;
+        }
 
-            // we might only have events that don't trigger the unread indicator,
-            // in which case use the oldest event even if normally it wouldn't count.
-            // This is better than just assuming the last event was forever ago.
-            if (r.timeline.length && r.timeline[0].getTs()) {
-                return r.timeline[0].getTs();
-            } else {
-                return Number.MAX_SAFE_INTEGER;
+        // If the room hasn't been joined yet, it probably won't have a timeline to
+        // parse. We'll still fall back to the timeline if this fails, but chances
+        // are we'll at least have our own membership event to go off of.
+        const effectiveMembership = getEffectiveMembership(r.getMyMembership());
+        if (effectiveMembership !== EffectiveMembership.Join) {
+            const membershipEvent = r.currentState.getStateEvents("m.room.member", userId);
+            if (membershipEvent && !Array.isArray(membershipEvent)) {
+                return membershipEvent.getTs();
             }
-        })();
+        }
 
-        tsCache[r.roomId] = ts;
-        return ts;
-    };
+        for (let i = r.timeline.length - 1; i >= 0; --i) {
+            const ev = r.timeline[i];
+            if (!ev.getTs()) continue; // skip events that don't have timestamps (tests only?)
 
-    return rooms.sort((a, b) => {
-        return getLastTs(b) - getLastTs(a);
-    });
+            if (
+                (ev.getSender() === userId && shouldCauseReorder(ev)) ||
+                Unread.eventTriggersUnreadCount(ev)
+            ) {
+                return ev.getTs();
+            }
+        }
+
+        // we might only have events that don't trigger the unread indicator,
+        // in which case use the oldest event even if normally it wouldn't count.
+        // This is better than just assuming the last event was forever ago.
+        if (r.timeline.length && r.timeline[0].getTs()) {
+            return r.timeline[0].getTs();
+        } else {
+            return Number.MAX_SAFE_INTEGER;
+        }
+    })();
+    return ts;
 };
 
 /**
@@ -125,4 +126,8 @@ export class RecentAlgorithm implements IAlgorithm {
     public sortRooms(rooms: Room[], tagId: TagID): Room[] {
         return sortRooms(rooms);
     }
+
+    public getLastTs(room: Room, userId: string): number {
+        return getLastTs(room, userId);
+    }
 }