matrix-react-sdk/lib/stores/SpaceStore.js

SDK for matrix.org using React

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.SpaceStoreClass = exports.getOrder = exports.UPDATE_SELECTED_SPACE = exports.UPDATE_INVITED_SPACES = exports.UPDATE_TOP_LEVEL_SPACES = exports.SUGGESTED_ROOMS = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _lodash = require("lodash");

var _event = require("matrix-js-sdk/src/@types/event");

var _AsyncStoreWithClient = require("./AsyncStoreWithClient");

var _dispatcher = _interopRequireDefault(require("../dispatcher/dispatcher"));

var _RoomListStore = _interopRequireDefault(require("./room-list/RoomListStore"));

var _SettingsStore = _interopRequireDefault(require("../settings/SettingsStore"));

var _DMRoomMap = _interopRequireDefault(require("../utils/DMRoomMap"));

var _SpaceNotificationState = require("./notifications/SpaceNotificationState");

var _RoomNotificationStateStore = require("./notifications/RoomNotificationStateStore");

var _models = require("./room-list/models");

var _maps = require("../utils/maps");

var _sets = require("../utils/sets");

var _RoomViewStore = _interopRequireDefault(require("./RoomViewStore"));

/*
Copyright 2021 The Matrix.org Foundation C.I.C.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
const ACTIVE_SPACE_LS_KEY = "mx_active_space";
const SUGGESTED_ROOMS = Symbol("suggested-rooms");
exports.SUGGESTED_ROOMS = SUGGESTED_ROOMS;
const UPDATE_TOP_LEVEL_SPACES = Symbol("top-level-spaces");
exports.UPDATE_TOP_LEVEL_SPACES = UPDATE_TOP_LEVEL_SPACES;
const UPDATE_INVITED_SPACES = Symbol("invited-spaces");
exports.UPDATE_INVITED_SPACES = UPDATE_INVITED_SPACES;
const UPDATE_SELECTED_SPACE = Symbol("selected-space"); // Space Room ID will be emitted when a Space's children change

exports.UPDATE_SELECTED_SPACE = UPDATE_SELECTED_SPACE;
const MAX_SUGGESTED_ROOMS = 20;

const getSpaceContextKey = (space
/*: Room*/
) => `mx_space_context_${space?.roomId || "ALL_ROOMS"}`;

const partitionSpacesAndRooms = (arr
/*: Room[]*/
) =>
/*: [Room[], Room[]]*/
{
  // [spaces, rooms]
  return arr.reduce((result, room
  /*: Room*/
  ) => {
    result[room.isSpaceRoom() ? 0 : 1].push(room);
    return result;
  }, [[], []]);
}; // For sorting space children using a validated `order`, `m.room.create`'s `origin_server_ts`, `room_id`


const getOrder = (order
/*: string*/
, creationTs
/*: number*/
, roomId
/*: string*/
) =>
/*: Array<Many<ListIteratee<any>>>*/
{
  let validatedOrder
  /*: string*/
  = null;

  if (typeof order === "string" && Array.from(order).every((c
  /*: string*/
  ) => {
    const charCode = c.charCodeAt(0);
    return charCode >= 0x20 && charCode <= 0x7E;
  })) {
    validatedOrder = order;
  }

  return [validatedOrder, creationTs, roomId];
};

exports.getOrder = getOrder;

const getRoomFn
/*: FetchRoomFn*/
= (room
/*: Room*/
) => {
  return _RoomNotificationStateStore.RoomNotificationStateStore.instance.getRoomState(room);
};

class SpaceStoreClass extends _AsyncStoreWithClient.AsyncStoreWithClient
/*:: <IState>*/
{
  constructor() {
    super(_dispatcher.default, {});
    (0, _defineProperty2.default)(this, "rootSpaces", []);
    (0, _defineProperty2.default)(this, "parentMap", new _maps.EnhancedMap());
    (0, _defineProperty2.default)(this, "notificationStateMap", new Map());
    (0, _defineProperty2.default)(this, "spaceFilteredRooms", new Map());
    (0, _defineProperty2.default)(this, "_activeSpace", null);
    (0, _defineProperty2.default)(this, "_suggestedRooms", []);
    (0, _defineProperty2.default)(this, "_invitedSpaces", new Set());
    (0, _defineProperty2.default)(this, "fetchSuggestedRooms", async (space
    /*: Room*/
    , limit = MAX_SUGGESTED_ROOMS) => {
      try {
        const data
        /*: {
                        rooms: ISpaceSummaryRoom[];
                        events: ISpaceSummaryEvent[];
                    }*/
        = await this.matrixClient.getSpaceSummary(space.roomId, 0, true, false, limit);
        return data;
      } catch (e) {
        console.error(e);
      }

      return {
        rooms: [],
        events: []
      };
    });
    (0, _defineProperty2.default)(this, "getSpaceFilteredRoomIds", (space
    /*: Room | null*/
    ) =>
    /*: Set<string>*/
    {
      if (!space) {
        return new Set(this.matrixClient.getVisibleRooms().map(r => r.roomId));
      }

      return this.spaceFilteredRooms.get(space.roomId) || new Set();
    });
    (0, _defineProperty2.default)(this, "rebuild", (0, _lodash.throttle)(() => {
      const [visibleSpaces, visibleRooms] = partitionSpacesAndRooms(this.matrixClient.getVisibleRooms());
      const [joinedSpaces, invitedSpaces] = visibleSpaces.reduce((arr, s) => {
        if (s.getMyMembership() === "join") {
          arr[0].push(s);
        } else if (s.getMyMembership() === "invite") {
          arr[1].push(s);
        }

        return arr;
      }, [[], []]); // exclude invited spaces from unseenChildren as they will be forcibly shown at the top level of the treeview

      const unseenChildren = new Set([...visibleRooms, ...joinedSpaces]);
      const backrefs = new _maps.EnhancedMap(); // Sort spaces by room ID to force the cycle breaking to be deterministic

      const spaces = (0, _lodash.sortBy)(joinedSpaces, space => space.roomId); // TODO handle cleaning up links when a Space is removed

      spaces.forEach(space => {
        const children = this.getChildren(space.roomId);
        children.forEach(child => {
          unseenChildren.delete(child);
          backrefs.getOrCreate(child.roomId, new Set()).add(space.roomId);
        });
      });
      const [rootSpaces] = partitionSpacesAndRooms(Array.from(unseenChildren)); // somewhat algorithm to handle full-cycles

      const detachedNodes = new Set(spaces);

      const markTreeChildren = (rootSpace
      /*: Room*/
      , unseen
      /*: Set<Room>*/
      ) => {
        const stack = [rootSpace];

        while (stack.length) {
          const op = stack.pop();
          unseen.delete(op);
          this.getChildSpaces(op.roomId).forEach(space => {
            if (unseen.has(space)) {
              stack.push(space);
            }
          });
        }
      };

      rootSpaces.forEach(rootSpace => {
        markTreeChildren(rootSpace, detachedNodes);
      }); // Handle spaces forming fully cyclical relationships.
      // In order, assume each detachedNode is a root unless it has already
      // been claimed as the child of prior detached node.
      // Work from a copy of the detachedNodes set as it will be mutated as part of this operation.

      Array.from(detachedNodes).forEach(detachedNode => {
        if (!detachedNodes.has(detachedNode)) return; // declare this detached node a new root, find its children, without ever looping back to it

        detachedNodes.delete(detachedNode);
        rootSpaces.push(detachedNode);
        markTreeChildren(detachedNode, detachedNodes); // TODO only consider a detached node a root space if it has no *parents other than the ones forming cycles
      }); // TODO neither of these handle an A->B->C->A with an additional C->D
      // detachedNodes.forEach(space => {
      //     rootSpaces.push(space);
      // });

      this.rootSpaces = rootSpaces;
      this.parentMap = backrefs; // if the currently selected space no longer exists, remove its selection

      if (this._activeSpace && detachedNodes.has(this._activeSpace)) {
        this.setActiveSpace(null, false);
      }

      this.onRoomsUpdate(); // TODO only do this if a change has happened

      this.emit(UPDATE_TOP_LEVEL_SPACES, this.spacePanelSpaces); // build initial state of invited spaces as we would have missed the emitted events about the room at launch

      this._invitedSpaces = new Set(invitedSpaces);
      this.emit(UPDATE_INVITED_SPACES, this.invitedSpaces);
    }, 100, {
      trailing: true,
      leading: true
    }));
    (0, _defineProperty2.default)(this, "onSpaceUpdate", () => {
      this.rebuild();
    });
    (0, _defineProperty2.default)(this, "onSpaceMembersChange", (ev
    /*: MatrixEvent*/
    ) => {
      // skip this update if we do not have a DM with this user
      if (_DMRoomMap.default.shared().getDMRoomsForUserId(ev.getStateKey()).length < 1) return;
      this.onRoomsUpdate();
    });
    (0, _defineProperty2.default)(this, "onRoomsUpdate", (0, _lodash.throttle)(() => {
      // TODO resolve some updates as deltas
      const visibleRooms = this.matrixClient.getVisibleRooms();
      const oldFilteredRooms = this.spaceFilteredRooms;
      this.spaceFilteredRooms = new Map();
      this.rootSpaces.forEach(s => {
        // traverse each space tree in DFS to build up the supersets as you go up,
        // reusing results from like subtrees.
        const fn = (spaceId
        /*: string*/
        , parentPath
        /*: Set<string>*/
        ) =>
        /*: Set<string>*/
        {
          if (parentPath.has(spaceId)) return; // prevent cycles
          // reuse existing results if multiple similar branches exist

          if (this.spaceFilteredRooms.has(spaceId)) {
            return this.spaceFilteredRooms.get(spaceId);
          }

          const [childSpaces, childRooms] = partitionSpacesAndRooms(this.getChildren(spaceId));
          const roomIds = new Set(childRooms.map(r => r.roomId));
          const space = this.matrixClient?.getRoom(spaceId); // Add relevant DMs

          space?.getMembers().forEach(member => {
            if (member.membership !== "join" && member.membership !== "invite") return;

            _DMRoomMap.default.shared().getDMRoomsForUserId(member.userId).forEach(roomId => {
              roomIds.add(roomId);
            });
          });
          const newPath = new Set(parentPath).add(spaceId);
          childSpaces.forEach(childSpace => {
            fn(childSpace.roomId, newPath)?.forEach(roomId => {
              roomIds.add(roomId);
            });
          });
          this.spaceFilteredRooms.set(spaceId, roomIds);
          return roomIds;
        };

        fn(s.roomId, new Set());
      });
      const diff = (0, _maps.mapDiff)(oldFilteredRooms, this.spaceFilteredRooms); // filter out keys which changed by reference only by checking whether the sets differ

      const changed = diff.changed.filter(k => (0, _sets.setHasDiff)(oldFilteredRooms.get(k), this.spaceFilteredRooms.get(k)));
      [...diff.added, ...diff.removed, ...changed].forEach(k => {
        this.emit(k);
      });
      this.spaceFilteredRooms.forEach((roomIds, s) => {
        // Update NotificationStates
        this.getNotificationState(s)?.setRooms(visibleRooms.filter(room => {
          if (roomIds.has(room.roomId)) {
            return !_DMRoomMap.default.shared().getUserIdForRoomId(room.roomId) || _RoomListStore.default.instance.getTagsForRoom(room).includes(_models.DefaultTagID.Favourite);
          }

          return false;
        }));
      });
    }, 100, {
      trailing: true,
      leading: true
    }));
    (0, _defineProperty2.default)(this, "switchToRelatedSpace", (roomId
    /*: string*/
    ) => {
      if (this.suggestedRooms.find(r => r.room_id === roomId)) return;
      let parent = this.getCanonicalParent(roomId);

      if (!parent) {
        parent = this.rootSpaces.find(s => this.spaceFilteredRooms.get(s.roomId)?.has(roomId));
      }

      if (!parent) {
        const parents = Array.from(this.parentMap.get(roomId) || []);
        parent = parents.find(p => this.matrixClient.getRoom(p));
      } // don't trigger a context switch when we are switching a space to match the chosen room


      this.setActiveSpace(parent || null, false);
    });
    (0, _defineProperty2.default)(this, "onRoom", (room
    /*: Room*/
    , newMembership
    /*: string*/
    , oldMembership
    /*: string*/
    ) => {
      const membership = newMembership || room.getMyMembership();

      if (!room.isSpaceRoom()) {
        // this.onRoomUpdate(room);
        this.onRoomsUpdate();

        if (membership === "join") {
          // the user just joined a room, remove it from the suggested list if it was there
          const numSuggestedRooms = this._suggestedRooms.length;
          this._suggestedRooms = this._suggestedRooms.filter(r => r.room_id !== room.roomId);

          if (numSuggestedRooms !== this._suggestedRooms.length) {
            this.emit(SUGGESTED_ROOMS, this._suggestedRooms);
          } // if the room currently being viewed was just joined then switch to its related space


          if (newMembership === "join" && room.roomId === _RoomViewStore.default.getRoomId()) {
            this.switchToRelatedSpace(room.roomId);
          }
        }

        return;
      } // Space


      if (membership === "invite") {
        this._invitedSpaces.add(room);

        this.emit(UPDATE_INVITED_SPACES, this.invitedSpaces);
      } else if (oldMembership === "invite" && membership !== "join") {
        this._invitedSpaces.delete(room);

        this.emit(UPDATE_INVITED_SPACES, this.invitedSpaces);
      } else {
        this.onSpaceUpdate();
        this.emit(room.roomId);
      }

      if (membership === "join" && room.roomId === _RoomViewStore.default.getRoomId()) {
        // if the user was looking at the space and then joined: select that space
        this.setActiveSpace(room, false);
      }
    });
    (0, _defineProperty2.default)(this, "onRoomState", (ev
    /*: MatrixEvent*/
    ) => {
      const room = this.matrixClient.getRoom(ev.getRoomId());
      if (!room) return;

      switch (ev.getType()) {
        case _event.EventType.SpaceChild:
          if (room.isSpaceRoom()) {
            this.onSpaceUpdate();
            this.emit(room.roomId);
          }

          break;

        case _event.EventType.SpaceParent:
          // TODO rebuild the space parent and not the room - check permissions?
          // TODO confirm this after implementing parenting behaviour
          if (room.isSpaceRoom()) {
            this.onSpaceUpdate();
          }

          this.emit(room.roomId);
          break;

        case _event.EventType.RoomMember:
          if (room.isSpaceRoom()) {
            this.onSpaceMembersChange(ev);
          }

          break;
      }
    });
  } // The spaces representing the roots of the various tree-like hierarchies


  get invitedSpaces()
  /*: Room[]*/
  {
    return Array.from(this._invitedSpaces);
  }

  get spacePanelSpaces()
  /*: Room[]*/
  {
    return this.rootSpaces;
  }

  get activeSpace()
  /*: Room | null*/
  {
    return this._activeSpace || null;
  }

  get suggestedRooms()
  /*: ISpaceSummaryRoom[]*/
  {
    return this._suggestedRooms;
  }
  /**
   * Sets the active space, updates room list filters,
   * optionally switches the user's room back to where they were when they last viewed that space.
   * @param space which space to switch to.
   * @param contextSwitch whether to switch the user's context,
   * should not be done when the space switch is done implicitly due to another event like switching room.
   */


  async setActiveSpace(space
  /*: Room | null*/
  , contextSwitch = true) {
    if (space === this.activeSpace || space && !space?.isSpaceRoom()) return;
    this._activeSpace = space;
    this.emit(UPDATE_SELECTED_SPACE, this.activeSpace);
    this.emit(SUGGESTED_ROOMS, this._suggestedRooms = []);

    if (contextSwitch) {
      // view last selected room from space
      const roomId = window.localStorage.getItem(getSpaceContextKey(this.activeSpace)); // if the space being selected is an invite then always view that invite
      // else if the last viewed room in this space is joined then view that
      // else view space home or home depending on what is being clicked on

      if (space?.getMyMembership !== "invite" && this.matrixClient?.getRoom(roomId)?.getMyMembership() === "join") {
        _dispatcher.default.dispatch({
          action: "view_room",
          room_id: roomId,
          context_switch: true
        });
      } else if (space) {
        _dispatcher.default.dispatch({
          action: "view_room",
          room_id: space.roomId,
          context_switch: true
        });
      } else {
        _dispatcher.default.dispatch({
          action: "view_home_page"
        });
      }
    } // persist space selected


    if (space) {
      window.localStorage.setItem(ACTIVE_SPACE_LS_KEY, space.roomId);
    } else {
      window.localStorage.removeItem(ACTIVE_SPACE_LS_KEY);
    }

    if (space) {
      const data = await this.fetchSuggestedRooms(space);

      if (this._activeSpace === space) {
        this._suggestedRooms = data.rooms.filter(roomInfo => {
          return roomInfo.room_type !== _event.RoomType.Space && this.matrixClient.getRoom(roomInfo.room_id)?.getMyMembership() !== "join";
        });
        this.emit(SUGGESTED_ROOMS, this._suggestedRooms);
      }
    }
  }

  addRoomToSpace(space
  /*: Room*/
  , roomId
  /*: string*/
  , via
  /*: string[]*/
  , suggested = false, autoJoin = false) {
    return this.matrixClient.sendStateEvent(space.roomId, _event.EventType.SpaceChild, {
      via,
      suggested,
      auto_join: autoJoin
    }, roomId);
  }

  getChildren(spaceId
  /*: string*/
  )
  /*: Room[]*/
  {
    const room = this.matrixClient?.getRoom(spaceId);
    const childEvents = room?.currentState.getStateEvents(_event.EventType.SpaceChild).filter(ev => ev.getContent()?.via);
    return (0, _lodash.sortBy)(childEvents, ev => {
      const roomId = ev.getStateKey();
      const childRoom = this.matrixClient?.getRoom(roomId);
      const createTs = childRoom?.currentState.getStateEvents(_event.EventType.RoomCreate, "")?.getTs();
      return getOrder(ev.getContent().order, createTs, roomId);
    }).map(ev => {
      return this.matrixClient.getRoom(ev.getStateKey());
    }).filter(room => {
      return room?.getMyMembership() === "join" || room?.getMyMembership() === "invite";
    }) || [];
  }

  getChildRooms(spaceId
  /*: string*/
  )
  /*: Room[]*/
  {
    return this.getChildren(spaceId).filter(r => !r.isSpaceRoom());
  }

  getChildSpaces(spaceId
  /*: string*/
  )
  /*: Room[]*/
  {
    // don't show invited subspaces as they surface at the top level for better visibility
    return this.getChildren(spaceId).filter(r => r.isSpaceRoom() && r.getMyMembership() === "join");
  }

  getParents(roomId
  /*: string*/
  , canonicalOnly = false)
  /*: Room[]*/
  {
    const room = this.matrixClient?.getRoom(roomId);
    return room?.currentState.getStateEvents(_event.EventType.SpaceParent).filter(ev => {
      const content = ev.getContent();
      if (!content?.via) return false; // TODO apply permissions check to verify that the parent mapping is valid

      if (canonicalOnly && !content?.canonical) return false;
      return true;
    }).map(ev => this.matrixClient.getRoom(ev.getStateKey())).filter(Boolean) || [];
  }

  getCanonicalParent(roomId
  /*: string*/
  )
  /*: Room | null*/
  {
    const parents = this.getParents(roomId, true);
    return (0, _lodash.sortBy)(parents, r => r.roomId)?.[0] || null;
  }

  async reset() {
    this.rootSpaces = [];
    this.parentMap = new _maps.EnhancedMap();
    this.notificationStateMap = new Map();
    this.spaceFilteredRooms = new Map();
    this._activeSpace = null;
    this._suggestedRooms = [];
    this._invitedSpaces = new Set();
  }

  async onNotReady() {
    if (!_SettingsStore.default.getValue("feature_spaces")) return;

    if (this.matrixClient) {
      this.matrixClient.removeListener("Room", this.onRoom);
      this.matrixClient.removeListener("Room.myMembership", this.onRoom);
      this.matrixClient.removeListener("RoomState.events", this.onRoomState);
    }

    await this.reset();
  }

  async onReady() {
    if (!_SettingsStore.default.getValue("feature_spaces")) return;
    this.matrixClient.on("Room", this.onRoom);
    this.matrixClient.on("Room.myMembership", this.onRoom);
    this.matrixClient.on("RoomState.events", this.onRoomState);
    await this.onSpaceUpdate(); // trigger an initial update
    // restore selected state from last session if any and still valid

    const lastSpaceId = window.localStorage.getItem(ACTIVE_SPACE_LS_KEY);

    if (lastSpaceId) {
      this.setActiveSpace(this.matrixClient.getRoom(lastSpaceId));
    }
  }

  async onAction(payload
  /*: ActionPayload*/
  ) {
    if (!_SettingsStore.default.getValue("feature_spaces")) return;

    switch (payload.action) {
      case "view_room":
        {
          // Don't auto-switch rooms when reacting to a context-switch
          // as this is not helpful and can create loops of rooms/space switching
          if (payload.context_switch) break;
          const roomId = payload.room_id;
          const room = this.matrixClient?.getRoom(roomId);

          if (room?.isSpaceRoom()) {
            // Don't context switch when navigating to the space room
            // as it will cause you to end up in the wrong room
            this.setActiveSpace(room, false);
          } else if (this.activeSpace && !this.getSpaceFilteredRoomIds(this.activeSpace).has(roomId)) {
            this.switchToRelatedSpace(roomId);
          } // Persist last viewed room from a space
          // we don't await setActiveSpace above as we only care about this.activeSpace being up to date
          // synchronously for the below code - everything else can and should be async.


          window.localStorage.setItem(getSpaceContextKey(this.activeSpace), payload.room_id);
          break;
        }

      case "after_leave_room":
        if (this._activeSpace && payload.room_id === this._activeSpace.roomId) {
          this.setActiveSpace(null, false);
        }

        break;
    }
  }

  getNotificationState(key
  /*: string*/
  )
  /*: SpaceNotificationState*/
  {
    if (this.notificationStateMap.has(key)) {
      return this.notificationStateMap.get(key);
    }

    const state = new _SpaceNotificationState.SpaceNotificationState(key, getRoomFn);
    this.notificationStateMap.set(key, state);
    return state;
  } // traverse space tree with DFS calling fn on each space including the given root one,
  // if includeRooms is true then fn will be called on each leaf room, if it is present in multiple sub-spaces
  // then fn will be called with it multiple times.


  traverseSpace(spaceId
  /*: string*/
  , fn
  /*: (roomId: string) => void*/
  , includeRooms = false, parentPath
  /*: Set<string>*/
  ) {
    if (parentPath && parentPath.has(spaceId)) return; // prevent cycles

    fn(spaceId);
    const newPath = new Set(parentPath).add(spaceId);
    const [childSpaces, childRooms] = partitionSpacesAndRooms(this.getChildren(spaceId));

    if (includeRooms) {
      childRooms.forEach(r => fn(r.roomId));
    }

    childSpaces.forEach(s => this.traverseSpace(s.roomId, fn, includeRooms, newPath));
  }

}

exports.SpaceStoreClass = SpaceStoreClass;

class SpaceStore {
  static get instance()
  /*: SpaceStoreClass*/
  {
    return SpaceStore.internalInstance;
  }

}

exports.default = SpaceStore;
(0, _defineProperty2.default)(SpaceStore, "internalInstance", new SpaceStoreClass());
window.mxSpaceStore = SpaceStore.instance;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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