move the fact that we're prototyping only with joined members up the stack to client

only MatrixClient really needs to know that for now we only load joined members, the rest of the code can be generic for other membership types as that is the eventual plan, to also support invites at least.

src/client.js

@@ -767,7 +767,18 @@ MatrixClient.prototype.loadRoomMembersIfNeeded = async function(roomId) {
     if (!room || !room.membersNeedLoading()) {
         return;
     }
-    const membersPromise = this.joinedMembers(roomId);
+    const joinedMembersPromise = this.joinedMembers(roomId);
+    const membersPromise = joinedMembersPromise.then((profiles) => {
+        return Object.entries(profiles).map(([userId, profile]) => {
+            return {
+                userId: userId,
+                avatarUrl: profile.avatar_url,
+                displayName: profile.display_name,
+                membership: "join",  // as we need to support invitees as well
+                                    // in the future, already include but hardcode it
+            };
+        });
+    });
     await room.setLazilyLoadedMembers(membersPromise);
 };
 

src/models/event-timeline-set.js

@@ -74,11 +74,11 @@ function EventTimelineSet(room, opts) {
 utils.inherits(EventTimelineSet, EventEmitter);
 
 /**
- * Sets the lazily loaded members. For now only joined members.
+ * Sets the lazily loaded members.
- * @param {Profile[]} joinedMembers array with {avatar_url, display_name } tuples
+ * @param {Member[]} members array of {userId, avatarUrl, displayName, membership} tuples
  */
-EventTimelineSet.prototype.setJoinedMembers = function(joinedMembers) {
+EventTimelineSet.prototype.setLazilyLoadedMembers = function(members) {
-    this._timelines.forEach((tl) => tl.setJoinedMembers(joinedMembers));
+    this._timelines.forEach((tl) => tl.setLazilyLoadedMembers(members));
 };
 
 /**

src/models/event-timeline.js

@@ -159,12 +159,12 @@ EventTimeline.prototype.getRoomId = function() {
 };
 
 /**
- * Sets the lazily loaded members. For now only joined members.
+ * Sets the lazily loaded members.
- * @param {Profile[]} joinedMembers array with {avatar_url, display_name } tuples
+ * @param {Member[]} members array of {userId, avatarUrl, displayName, membership} tuples
  */
-EventTimeline.prototype.setJoinedMembers = function(joinedMembers) {
+EventTimeline.prototype.setLazilyLoadedMembers = function(members) {
-    this._startState.setJoinedMembers(joinedMembers);
+    this._startState.setLazilyLoadedMembers(members);
-    this._endState.setJoinedMembers(joinedMembers);
+    this._endState.setLazilyLoadedMembers(members);
 };
 
 /**

src/models/room-member.js

@@ -105,15 +105,14 @@ RoomMember.prototype.setMembershipEvent = function(event, roomState) {
 
 /**
  * Update this room member from a lazily loaded member
- * @param {string} displayName
+ * @param {Member} memberInfo a {userId, avatarUrl, displayName, membership} tuple
- * @param {string} avatarUrl
  * @param {RoomState} roomState the room state this member is part of, needed to disambiguate the display name
  */
-RoomMember.prototype.setAsJoinedMember = function(displayName, avatarUrl, roomState) {
+RoomMember.prototype.setAsLazilyLoadedMember = function(memberInfo, roomState) {
-    this.membership = "join";
+    this.membership = memberInfo.membership;
-    this.name = calculateDisplayName(this.userId, displayName, roomState);
+    this.name = calculateDisplayName(this.userId, memberInfo.displayName, roomState);
-    this.rawDisplayName = displayName || this.userId;
+    this.rawDisplayName = memberInfo.displayName || this.userId;
-    this._lazyLoadAvatarUrl = avatarUrl;
+    this._lazyLoadAvatarUrl = memberInfo.avatarUrl;
     this._isLazilyLoaded = true;
     //TODO: race condition between existing membership events since started syncing
 };

src/models/room-state.js

@@ -275,27 +275,29 @@ RoomState.prototype._updateMember = function(member) {
 };
 
 /**
- * Sets the lazily loaded members. For now only joined members.
+ * Sets the lazily loaded members.
- * @param {Profile[]} joinedMembers array with {avatar_url, display_name } tuples
+ * @param {Member[]} members array of {userId, avatarUrl, displayName, membership} tuples
  */
-RoomState.prototype.setJoinedMembers = function(joinedMembers) {
+RoomState.prototype.setLazilyLoadedMembers = function(members) {
-    Object.entries(joinedMembers).forEach(([userId, details]) => {
+    members.forEach((member) => this._setLazilyLoadedMember(member));
-        this._setJoinedMember(userId, details.display_name, details.avatar_url);
-    });
 };
-
+/**
-RoomState.prototype._setJoinedMember = function(userId, displayName, avatarUrl) {
+ * Add/updates a lazily loaded member.
-    const member = new RoomMember(this.roomId, userId);
+ * @param {Member} memberInfo a {userId, avatarUrl, displayName, membership} tuple
+ */
+RoomState.prototype._setLazilyLoadedMember = function(memberInfo) {
+    const member = new RoomMember(this.roomId, memberInfo.userId);
     // try to find the member event for the user and set it first on the member
     // so inspection of the event is possible later on if we have it
-    const userMemberEvent = this.getStateEvents("m.room.member", userId);
+    const userMemberEvent = this.getStateEvents("m.room.member", member.userId);
     if (userMemberEvent) {
         member.setMembershipEvent(userMemberEvent, this);
     }
     // override the displayName and avatarUrl from the lazily loaded members
     // as this is guaranteed to be the current state
-    member.setAsJoinedMember(displayName, avatarUrl, this);
+    member.setAsLazilyLoadedMember(memberInfo, this);
-    const isNewMember = !this.members[userId];
+
+    const isNewMember = !this.members[member.userId];
 
     _updateDisplayNameCache(this, member.userId, member.name);
     this._updateMember(member);

src/models/room.js

@@ -226,18 +226,18 @@ Room.prototype.membersNeedLoading = function() {
 
 /**
  * Sets the lazily loaded members from the result of calling /joined_members
- * @param {Promise} joinedMembersPromise promise with result of /joined_members endpoint
+ * @param {Promise} membersPromise promise with array of {userId, avatarUrl, displayName, membership} tuples
  */
-Room.prototype.setLazilyLoadedMembers = async function(joinedMembersPromise) {
+Room.prototype.setLazilyLoadedMembers = async function(membersPromise) {
     this._membersNeedLoading = false;
     let members = null;
     try {
-        members = await joinedMembersPromise;
+        members = await membersPromise;
     } catch (err) {
         this._membersNeedLoading = true;
         throw err;  //rethrow so calling code is aware operation failed
     }
-    this._timelineSets.forEach((tlSet) => tlSet.setJoinedMembers(members.joined));
+    this._timelineSets.forEach((tlSet) => tlSet.setLazilyLoadedMembers(members));
     this.emit('Room', this);
 };