@ethora/chat-component-rn 26.4.2 → 26.5.2

package/lib/module/roomStore/persistence.js

@@ -0,0 +1,139 @@
+"use strict";
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+// -------------------------------------------------------------------
+// Lightweight RN persistence layer. Mirrors what redux-persist gives
+// the web component:
+//
+//   - persist chatSettingStore.user (sanitized) and rooms state
+//   - blacklist transient fields (modals, activeRoomJID, etc.)
+//   - cap each room's messages to the most recent MESSAGE_LIMIT (100)
+//   - debounced writes (200ms) on relevant action types
+//
+// Not encrypted. We rely on AsyncStorage's per-app sandbox.
+// -------------------------------------------------------------------
+
+const KEY_CHAT = '@ethora/persist:chatSettingStore';
+const KEY_ROOMS = '@ethora/persist:rooms';
+
+// Per-room message cap on disk. Mirror this value in `roomsSlice`'s
+// in-memory cap (see `enforceMessageCap`) so the runtime and persisted
+// shapes stay aligned.
+export const MESSAGE_LIMIT = 100;
+const sanitizeUser = user => {
+  if (!user) {
+    return null;
+  }
+  // Drop secrets we don't want at rest — destructure to omit, then
+  // explicitly zero them in the persisted shape.
+  const {
+    token: _token,
+    refreshToken: _refreshToken,
+    xmppPassword: _xmppPassword,
+    ...rest
+  } = user;
+  return {
+    ...rest,
+    token: '',
+    refreshToken: '',
+    xmppPassword: ''
+  };
+};
+const sanitizeMessages = messages => {
+  if (!Array.isArray(messages)) {
+    return [];
+  }
+  if (messages.length <= MESSAGE_LIMIT) {
+    return messages;
+  }
+  return messages.slice(-MESSAGE_LIMIT);
+};
+const sanitizeRooms = rooms => {
+  if (!rooms || typeof rooms !== 'object') {
+    return {};
+  }
+  const out = {};
+  for (const [jid, room] of Object.entries(rooms)) {
+    if (!jid || typeof jid !== 'string' || !jid.includes('@')) {
+      continue;
+    }
+    if (!room || typeof room !== 'object' || Array.isArray(room)) {
+      continue;
+    }
+    out[jid] = {
+      ...room,
+      messages: sanitizeMessages(room?.messages || []),
+      composing: false,
+      composingList: [],
+      isLoading: false,
+      historyPreloadState: 'idle'
+    };
+  }
+  return out;
+};
+let writeTimer = null;
+
+/**
+ * Middleware that debounces writes of the persisted slices to AsyncStorage.
+ * Only triggers on actions that actually mutate persisted state.
+ */
+export const persistenceMiddleware = storeAPI => next => action => {
+  const result = next(action);
+  const type = action?.type || '';
+  if (!type.startsWith('roomMessages/') && !type.startsWith('chat/setUser') && !type.startsWith('chat/updateUser') && !type.startsWith('chat/refreshTokens') && !type.startsWith('chat/logout')) {
+    return result;
+  }
+  if (writeTimer) {
+    clearTimeout(writeTimer);
+  }
+  writeTimer = setTimeout(() => {
+    try {
+      const state = storeAPI.getState();
+      const chatPayload = {
+        user: sanitizeUser(state.chatSettingStore?.user)
+      };
+      const roomsPayload = {
+        rooms: sanitizeRooms(state.rooms?.rooms || {})
+      };
+      AsyncStorage.multiSet([[KEY_CHAT, JSON.stringify(chatPayload)], [KEY_ROOMS, JSON.stringify(roomsPayload)]]).catch(e => console.warn('persist write failed', e));
+    } catch (e) {
+      console.warn('persist serialize failed', e);
+    }
+  }, 200);
+  return result;
+};
+
+/**
+ * Read persisted slices from AsyncStorage. Called once at store creation;
+ * we DON'T hydrate synchronously (AsyncStorage is async) — instead, the
+ * caller dispatches rehydrate actions when the read resolves.
+ */
+export async function readPersistedState() {
+  try {
+    const [chatRaw, roomsRaw] = await AsyncStorage.multiGet([KEY_CHAT, KEY_ROOMS]);
+    const chat = chatRaw[1] ? JSON.parse(chatRaw[1]) : null;
+    const rooms = roomsRaw[1] ? JSON.parse(roomsRaw[1]) : null;
+    return {
+      chat,
+      rooms
+    };
+  } catch (e) {
+    console.warn('persist read failed', e);
+    return {
+      chat: null,
+      rooms: null
+    };
+  }
+}
+export async function clearPersistedState() {
+  try {
+    await AsyncStorage.multiRemove([KEY_CHAT, KEY_ROOMS]);
+  } catch (e) {
+    console.warn('persist clear failed', e);
+  }
+}
+export const PERSIST_KEYS = {
+  KEY_CHAT,
+  KEY_ROOMS
+};
+//# sourceMappingURL=persistence.js.map

package/lib/module/roomStore/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AsyncStorage","KEY_CHAT","KEY_ROOMS","MESSAGE_LIMIT","sanitizeUser","user","token","_token","refreshToken","_refreshToken","xmppPassword","_xmppPassword","rest","sanitizeMessages","messages","Array","isArray","length","slice","sanitizeRooms","rooms","out","jid","room","Object","entries","includes","composing","composingList","isLoading","historyPreloadState","writeTimer","persistenceMiddleware","storeAPI","next","action","result","type","startsWith","clearTimeout","setTimeout","state","getState","chatPayload","chatSettingStore","roomsPayload","multiSet","JSON","stringify","catch","e","console","warn","readPersistedState","chatRaw","roomsRaw","multiGet","chat","parse","clearPersistedState","multiRemove","PERSIST_KEYS"],"sourceRoot":"../../../src","sources":["roomStore/persistence.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/roomStore/roomHeapSlice.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = {
+  messageHeap: []
+};
+
+// Reducers extracted as a named const so we can give the slice an
+// explicit Slice<State, typeof reducers, Name> type. Without that, tsc's
+// declaration emission inlines immer's internal WritableNonArrayDraft
+// type and fails with TS4023.
+const reducers = {
+  addMessageToHeap: (state, action) => {
+    state.messageHeap.push(action.payload);
+  },
+  removeMessageFromHeapById: (state, action) => {
+    const index = state.messageHeap.findIndex(m => m.id === action.payload);
+    if (index !== -1) {
+      state.messageHeap.splice(index, 1);
+    }
+  },
+  clearHeap: state => {
+    state.messageHeap = [];
+  }
+};
+export const roomHeapSlice = createSlice({
+  name: 'roomHeapStore',
+  initialState,
+  reducers
+});
+export const {
+  addMessageToHeap,
+  clearHeap,
+  removeMessageFromHeapById
+} = roomHeapSlice.actions;
+export default roomHeapSlice.reducer;
+//# sourceMappingURL=roomHeapSlice.js.map

package/lib/module/roomStore/roomHeapSlice.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createSlice","initialState","messageHeap","reducers","addMessageToHeap","state","action","push","payload","removeMessageFromHeapById","index","findIndex","m","id","splice","clearHeap","roomHeapSlice","name","actions","reducer"],"sourceRoot":"../../../src","sources":["roomStore/roomHeapSlice.ts"],"mappings":";;AAAA,SAASA,WAAW,QAAmC,kBAAkB;AAQzE,MAAMC,YAAgC,GAAG;EACvCC,WAAW,EAAE;AACf,CAAC;;AAED;AACA;AACA;AACA;AACA,MAAMC,QAAQ,GAAG;EACfC,gBAAgB,EAAEA,CAACC,KAAwC,EAAEC,MAA+B,KAAK;IAC/FD,KAAK,CAACH,WAAW,CAACK,IAAI,CAACD,MAAM,CAACE,OAAO,CAAC;EACxC,CAAC;EACDC,yBAAyB,EAAEA,CAACJ,KAAwC,EAAEC,MAA6B,KAAK;IACtG,MAAMI,KAAK,GAAGL,KAAK,CAACH,WAAW,CAACS,SAAS,CAAEC,CAAC,IAAKA,CAAC,CAACC,EAAE,KAAKP,MAAM,CAACE,OAAO,CAAC;IACzE,IAAIE,KAAK,KAAK,CAAC,CAAC,EAAE;MAChBL,KAAK,CAACH,WAAW,CAACY,MAAM,CAACJ,KAAK,EAAE,CAAC,CAAC;IACpC;EACF,CAAC;EACDK,SAAS,EAAGV,KAAwC,IAAK;IACvDA,KAAK,CAACH,WAAW,GAAG,EAAE;EACxB;AACF,CAAC;AAED,OAAO,MAAMc,aAA0E,GAAGhB,WAAW,CAAC;EACpGiB,IAAI,EAAE,eAAe;EACrBhB,YAAY;EACZE;AACF,CAAC,CAAC;AAEF,OAAO,MAAM;EACXC,gBAAgB;EAChBW,SAAS;EACTN;AACF,CAAC,GAAGO,aAAa,CAACE,OAAO;AAEzB,eAAeF,aAAa,CAACG,OAAO","ignoreList":[]}

package/lib/module/roomStore/roomsSlice.js

@@ -0,0 +1,467 @@
+"use strict";
+
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { insertMessageWithDelimiter } from '../helpers/insertMessageWithDelimiter';
+// Per-room runtime message cap. Mirrors the persistence layer's
+// MESSAGE_LIMIT so what's in memory matches what's on disk; otherwise
+// long sessions grow the array unbounded (memory leak) and reload
+// shows fewer messages than the user saw last in the session.
+//
+// The cap fires on the APPEND path (new messages arriving) — paginated
+// older history added via unshift/splice is exempt, so the user can
+// page backward arbitrarily far without instantly losing what they
+// just fetched. After cap eviction we drop from the head (oldest).
+const RUNTIME_MESSAGE_LIMIT = 100;
+const enforceMessageCap = messages => {
+  // Trim oldest until we're at/under the limit. Mutates in place
+  // (immer-compatible inside reducers).
+  while (messages.length > RUNTIME_MESSAGE_LIMIT) {
+    messages.shift();
+  }
+};
+const initialState = {
+  rooms: {},
+  activeRoomJID: null,
+  isLoading: false,
+  editAction: {
+    isEdit: false,
+    roomJid: '',
+    messageId: '',
+    text: ''
+  },
+  pendingNotificationJid: null
+};
+const isValidRoomJid = jid => {
+  if (typeof jid !== 'string' || !jid) return false;
+  if (!jid.includes('@')) return false;
+  return true;
+};
+export const addRoomViaApi = createAsyncThunk('roomMessages/addRoomViaApi', async ({
+  room,
+  xmpp: _xmpp
+}, {
+  dispatch
+}) => {
+  if (!room || !room.jid) return;
+  dispatch(roomsStore.actions.addRoomFromApi({
+    room
+  }));
+});
+
+// Reducers extracted so the slice can carry an explicit
+// Slice<State, typeof reducers, Name> annotation, which prevents tsc
+// from inlining immer's internal WritableNonArrayDraft type into the
+// emitted .d.ts (TS4023). See chatSettingsSlice.ts for the same pattern.
+const reducers = {
+  addRoom(state, action) {
+    const {
+      roomData
+    } = action.payload;
+    const existing = state.rooms[roomData.jid];
+    // Preserve a pre-existing lastViewedTimestamp (the private-store
+    // pull may have landed before /chats/my finished). If neither
+    // source set one, stamp `Date.now()` so initial REST history
+    // counts as "seen" — without this default, every back-history
+    // message read by the unread middleware satisfies `>0` and the
+    // badge shows the entire room population on first paint.
+    const lastViewed = roomData.lastViewedTimestamp ?? existing?.lastViewedTimestamp ?? Date.now();
+    state.rooms[roomData.jid] = {
+      ...roomData,
+      lastViewedTimestamp: lastViewed
+    };
+  },
+  deleteRoom(state, action) {
+    const {
+      jid
+    } = action.payload;
+    if (state.rooms[jid]) {
+      delete state.rooms[jid];
+    }
+  },
+  updateRoom(state, action) {
+    const {
+      jid,
+      updates
+    } = action.payload;
+    const existingRoom = state.rooms[jid];
+    if (existingRoom) {
+      state.rooms[jid] = {
+        ...existingRoom,
+        ...updates
+      };
+    }
+  },
+  setRoomMessages(state, action) {
+    const {
+      roomJID,
+      messages
+    } = action.payload;
+    if (state.rooms[roomJID]) {
+      // Cap to the runtime limit on replace too — guards against a
+      // single MAM page returning more than the limit (would balloon
+      // the array on its own).
+      const capped = messages.length > RUNTIME_MESSAGE_LIMIT ? messages.slice(-RUNTIME_MESSAGE_LIMIT) : messages;
+      state.rooms[roomJID].messages = capped;
+    }
+  },
+  deleteRoomMessage(state, action) {
+    const {
+      roomJID,
+      messageId
+    } = action.payload;
+    if (state.rooms[roomJID]) {
+      state.rooms[roomJID].messages.map(message => {
+        if (message.id === messageId) {
+          message.isDeleted = true;
+        }
+      });
+    }
+  },
+  setEditAction: (state, action) => {
+    if (action.payload?.isEdit) {
+      state.editAction = action.payload;
+    } else {
+      state.editAction = {
+        isEdit: false,
+        roomJid: '',
+        messageId: '',
+        text: ''
+      };
+    }
+  },
+  editRoomMessage(state, action) {
+    const {
+      roomJID,
+      messageId,
+      text
+    } = action.payload;
+    if (state.rooms[roomJID]) {
+      state.rooms[roomJID].messages.map(message => {
+        if (message.id === messageId) {
+          message.body = text;
+        }
+      });
+    }
+  },
+  addRoomMessage(state, action) {
+    const {
+      roomJID,
+      message,
+      start
+    } = action.payload;
+
+    // Guard against the "stanza arrived before /chats/my completed"
+    // race — without this, the optional-chain `?.messages` falls
+    // back to undefined, and the assignment below tries to set
+    // `.messages` on undefined → TypeError. Caller can safely
+    // ignore the message; the room will get its messages array on
+    // `addRoom` when the API response lands.
+    if (!state.rooms[roomJID]) {
+      return;
+    }
+    if (!state.rooms[roomJID].messages) {
+      state.rooms[roomJID].messages = [];
+    }
+    const roomMessages = state.rooms[roomJID].messages;
+    const lengthBefore = roomMessages.length;
+    if (roomMessages.length === 0 || start) {
+      roomMessages.unshift(message);
+    } else {
+      const lastViewedTimestamp = state.rooms[roomJID].lastViewedTimestamp ? new Date(state.rooms[roomJID].lastViewedTimestamp) : null;
+      insertMessageWithDelimiter(roomMessages, message, lastViewedTimestamp);
+    }
+
+    // Apply the in-memory cap only when the array actually GREW
+    // (i.e. this wasn't a dedupe/merge that left length unchanged).
+    // Otherwise repeated echoes of the same message would chip away
+    // at the oldest history for no reason.
+    if (roomMessages.length > lengthBefore) {
+      enforceMessageCap(roomMessages);
+    }
+  },
+  deleteAllRooms(state) {
+    state.rooms = {};
+  },
+  setComposing(state, action) {
+    const {
+      chatJID,
+      composing,
+      composingList
+    } = action.payload;
+    state.rooms[chatJID].composing = composing;
+    state.rooms[chatJID].composingList = composingList;
+  },
+  setIsLoading: (state, action) => {
+    const {
+      chatJID,
+      loading,
+      loadingText
+    } = action.payload;
+    if (chatJID && state.rooms?.[chatJID]) {
+      state.rooms[chatJID].isLoading = loading;
+    }
+    state.isLoading = loading;
+    state.loadingText = loadingText;
+  },
+  setLastViewedTimestamp: (state, action) => {
+    const {
+      chatJID,
+      timestamp
+    } = action.payload;
+    if (state.rooms[chatJID]) {
+      state.rooms[chatJID].lastViewedTimestamp = timestamp;
+      // timestamp === 0 means "user is currently viewing this room" —
+      // unread is cleared. Otherwise count messages received strictly
+      // after the last-viewed instant.
+      if (!timestamp) {
+        state.rooms[chatJID].unreadMessages = 0;
+      } else {
+        state.rooms[chatJID].unreadMessages = countNewerMessages(state.rooms[chatJID].messages, timestamp);
+      }
+    }
+  },
+  setRoomRole: (state, action) => {
+    const {
+      chatJID,
+      role
+    } = action.payload;
+    if (state.rooms[chatJID]) {
+      state.rooms[chatJID].role = role;
+    }
+  },
+  setRoomNoMessages: (state, action) => {
+    const {
+      value,
+      chatJID
+    } = action.payload;
+    if (chatJID) {
+      state.rooms[chatJID].noMessages = value;
+    }
+  },
+  setCurrentRoom: (state, action) => {
+    // Accept null/empty so callers can clear the active room (e.g.
+    // back button from chat → return to RoomList). Mirrors web.
+    state.activeRoomJID = action.payload.roomJID || '';
+  },
+  /**
+   * Stash a JID that a push notification asked us to open before
+   * the rooms list has loaded. The Chat component clears this once
+   * the room exists locally and dispatches `setCurrentRoom`.
+   */
+  setPendingNotificationJid: (state, action) => {
+    state.pendingNotificationJid = action.payload;
+  },
+  clearPendingNotificationJid: state => {
+    state.pendingNotificationJid = null;
+  },
+  /**
+   * Stamp a message in `state.rooms[roomJID].messages` with an updated
+   * reactions list. The reactionsMiddleware listens for this action to
+   * keep `IRoom.lastMessage` / `lastMessageTimestamp` in sync.
+   */
+  setReactions: (state, action) => {
+    const {
+      roomJID,
+      messageId,
+      reactions
+    } = action.payload;
+    const room = state.rooms[roomJID];
+    if (!room?.messages) {
+      return;
+    }
+    for (const msg of room.messages) {
+      if (msg?.id === messageId) {
+        msg.reactions = reactions;
+        break;
+      }
+    }
+  },
+  setLogoutState: state => {
+    state.rooms = {};
+    state.activeRoomJID = null;
+    state.isLoading = false;
+  },
+  setActiveMessage: (state, action) => {
+    const {
+      id,
+      chatJID
+    } = action.payload;
+    state.rooms[chatJID].messages.map(message => {
+      if (message.id === id) {
+        message.activeMessage = true;
+      } else {
+        message.activeMessage = false;
+      }
+    });
+  },
+  setCloseActiveMessage: (state, action) => {
+    const {
+      chatJID
+    } = action.payload;
+    state.rooms[chatJID].messages.map(message => {
+      message.activeMessage = false;
+    });
+  },
+  /**
+   * Batched update used by the history preload scheduler. Each patch is
+   * applied to its room: messages REPLACE (when provided), state fields
+   * MERGE. Rooms that don't exist yet are ignored.
+   */
+  addRoomFromApi: (state, action) => {
+    const {
+      room
+    } = action.payload;
+    if (!isValidRoomJid(room?.jid)) return;
+    const existing = state.rooms[room.jid];
+    const incomingMessages = Array.isArray(room.messages) ? room.messages : [];
+    const existingMessages = Array.isArray(existing?.messages) ? existing.messages : [];
+    state.rooms[room.jid] = {
+      ...existing,
+      ...room,
+      title: room.title || existing?.title || room.title,
+      usersCnt: (() => {
+        const incoming = typeof room.usersCnt === 'number' && room.usersCnt > 0 ? room.usersCnt : 0;
+        const previous = typeof existing?.usersCnt === 'number' && existing.usersCnt > 0 ? existing.usersCnt : 0;
+        if (incoming === 0 && previous === 0) return room.usersCnt;
+        return Math.max(incoming, previous);
+      })(),
+      icon: room.icon ?? existing?.icon,
+      messages: existingMessages.length > 0 ? existingMessages : incomingMessages,
+      unreadMessages: existing?.unreadMessages ?? room.unreadMessages ?? 0,
+      lastViewedTimestamp: existing?.lastViewedTimestamp ?? room.lastViewedTimestamp ?? 0,
+      unreadBaselineTimestamp: existing?.unreadBaselineTimestamp ?? existing?.lastViewedTimestamp ?? room.unreadBaselineTimestamp ?? room.lastViewedTimestamp ?? 0,
+      composingList: existing?.composingList ?? room.composingList,
+      composing: existing?.composing ?? room.composing,
+      unreadCapped: existing?.unreadCapped ?? room.unreadCapped ?? false,
+      historyPreloadState: existing?.historyPreloadState ?? room.historyPreloadState ?? 'idle',
+      messageStats: existing?.messageStats ?? room.messageStats,
+      historyComplete: existing?.historyComplete ?? room.historyComplete
+    };
+  },
+  applyRoomsPreloadBatch: (state, action) => {
+    const {
+      rooms
+    } = action.payload;
+    for (const patch of rooms) {
+      const room = state.rooms[patch.jid];
+      if (!room) {
+        continue;
+      }
+      if (typeof patch.historyPreloadState !== 'undefined') {
+        room.historyPreloadState = patch.historyPreloadState;
+      }
+      if (typeof patch.unreadCapped !== 'undefined') {
+        room.unreadCapped = patch.unreadCapped;
+      }
+      if (typeof patch.historyComplete !== 'undefined') {
+        room.historyComplete = patch.historyComplete;
+      }
+      if (Array.isArray(patch.messages)) {
+        // Merge: keep any locally-pending messages, replace the rest.
+        const pending = room.messages?.filter(m => m?.pending) || [];
+        room.messages = [...patch.messages, ...pending];
+      }
+    }
+  }
+};
+export const roomsStore = createSlice({
+  name: 'roomMessages',
+  initialState,
+  reducers
+});
+
+// Count messages strictly newer than the given millisecond timestamp.
+// Uses `msg.id` (server-authoritative microsecond timestamp prefixed by
+// 13-digit millis — see helpers/dateComparison `getHighResolutionTimestamp`)
+// because `msg.date` can be derived client-side (createMessageFromXml
+// falls back to `Date.now()` for realtime stanzas without a `date`
+// attr), which makes the comparison drift vs what the server assigned.
+// Excludes the "delimiter-new" sentinel, pending sends, and the current
+// user's own messages (parity with unreadMiddleware's isOwnMessage
+// filter — without this, the reducer and the middleware disagree about
+// the count and we get a flicker as the badge gets written twice with
+// different values on every message).
+export const msgSortableMs = msg => {
+  const id = String(msg?.id || '');
+  const m = /^(\d{13})/.exec(id);
+  if (m) {
+    return Number(m[1]);
+  }
+  if (msg?.date) {
+    const t = new Date(msg.date).getTime();
+    if (Number.isFinite(t)) {
+      return t;
+    }
+  }
+  return 0;
+};
+const norm = s => {
+  if (s == null) {
+    return '';
+  }
+  let v = String(s).toLowerCase();
+  v = v.split('/')[0];
+  v = v.split('@')[0];
+  return v.replace(/_/g, '');
+};
+const isOwn = (msg, selfXmpp, selfWallet) => {
+  if (!selfXmpp && !selfWallet) {
+    return false;
+  }
+  const candidates = [norm(msg?.user?.id), norm(msg?.user?.userJID), norm(msg?.user?.xmppUsername), norm(msg?.xmppFrom)].filter(Boolean);
+  if (candidates.length === 0) {
+    return false;
+  }
+  const self = new Set([norm(selfXmpp), norm(selfWallet)].filter(Boolean));
+  for (const c of candidates) {
+    if (self.has(c)) {
+      return true;
+    }
+  }
+  return false;
+};
+const countNewerMessages = (messages, timestamp, selfXmpp = '', selfWallet = '') => {
+  if (!messages?.length || !timestamp) {
+    return 0;
+  }
+  let count = 0;
+  for (const message of messages) {
+    if (!message || message.id === 'delimiter-new' || message.pending) {
+      continue;
+    }
+    if (isOwn(message, selfXmpp, selfWallet)) {
+      continue;
+    }
+    const ms = msgSortableMs(message);
+    if (Number.isFinite(ms) && ms > timestamp) {
+      count += 1;
+    }
+  }
+  return count;
+};
+export const {
+  addRoom,
+  deleteAllRooms,
+  setRoomMessages,
+  addRoomMessage,
+  deleteRoomMessage,
+  setEditAction,
+  editRoomMessage,
+  setComposing,
+  setIsLoading,
+  setLastViewedTimestamp,
+  setRoomNoMessages,
+  setCurrentRoom,
+  setRoomRole,
+  setLogoutState,
+  setActiveMessage,
+  setCloseActiveMessage,
+  deleteRoom,
+  updateRoom,
+  applyRoomsPreloadBatch,
+  setPendingNotificationJid,
+  clearPendingNotificationJid,
+  setReactions
+} = roomsStore.actions;
+export default roomsStore.reducer;
+//# sourceMappingURL=roomsSlice.js.map