@ethora/chat-component-rn 26.8.8 → 26.9.0

package/src/components/Modals/NewChatModal/UpdNewChatModal.tsx

@@ -14,6 +14,7 @@ import { RoomMember } from '../../../types/types';
 import ModalContent from './ModalContent';
 import { ModalBackground } from '../styledModalComponents';
 import { addRoom, setCurrentRoom } from '../../../roomStore/roomsSlice';
+import { subscribeRoomForPush } from '../../../services/pushSubscriptionService';
 
 const NewChatModal: React.FC = () => {
   const config = useSelector(
@@ -101,6 +102,7 @@ const NewChatModal: React.FC = () => {
       dispatch(addRoom({ roomData: normalizedChat }));
       dispatch(setCurrentRoom({ roomJID: normalizedChat.jid }));
       client?.presenceInRoomStanza(normalizedChat.jid);
+      subscribeRoomForPush(client, normalizedChat.jid);
     }
   };
 

package/src/components/Modals/UserProfileModal/UserProfileModal.tsx

@@ -16,7 +16,6 @@ import {
   ChatIcon,
   EditIcon,
   IconDoc,
-  LeaveIcon,
   LockIcon,
   LogoutIcon,
   ProfileIcon,
@@ -541,19 +540,6 @@ const UserProfileModal: React.FC<UserProfileModalProps> = ({
           scrollY={scrollY}
           actions={heroActions}
           titleStyle={chatTextStyle(config?.typography?.profile?.title)}
-          titleAccessory={
-            isOwnProfile ? (
-              <TouchableOpacity
-                testID={`${PREFIX}-logout`}
-                activeOpacity={0.7}
-                style={styles.leaveButton}
-                onPress={handleLogout}
-              >
-                <LeaveIcon color="#FFFFFF" width={18} height={18} />
-                <Text style={styles.leaveLabel}>{t('action.leave')}</Text>
-              </TouchableOpacity>
-            ) : undefined
-          }
         />
 
         <View style={styles.body}>
@@ -685,20 +671,6 @@ const createStyles = (theme: ChatTheme) => StyleSheet.create({
     fontSize: 16,
     marginTop: 4,
   },
-  leaveButton: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    gap: 6,
-    paddingHorizontal: 12,
-    paddingVertical: 7,
-    borderRadius: 18,
-    backgroundColor: 'rgba(0,0,0,0.35)',
-  },
-  leaveLabel: {
-    color: '#FFFFFF',
-    fontSize: 14,
-    fontWeight: '500',
-  },
   tabsRow: {
     flexDirection: 'row',
     gap: 20,

package/src/components/RoomComponents/SwipeableRoomRow.tsx

@@ -0,0 +1,133 @@
+import React, { useCallback, useMemo, useRef } from 'react';
+import { StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+import ReanimatedSwipeable, {
+  type SwipeableMethods,
+} from 'react-native-gesture-handler/ReanimatedSwipeable';
+import { LeaveIcon, ReportIcon } from '../../assets/icons';
+import { useTheme } from '../../hooks/useTheme';
+import { useT } from '../../i18n/useT';
+import type { ChatTheme } from '../../theme/theme';
+
+/** Width of one action button behind the row. */
+export const ROOM_ACTION_WIDTH = 84;
+
+/**
+ * Only one row shows its actions at a time, as in the messengers: opening
+ * another one, or the list being scrolled, folds the open one back.
+ */
+let openRow: SwipeableMethods | null = null;
+
+export const closeOpenRoomRow = (): void => {
+  openRow?.close();
+  openRow = null;
+};
+
+interface SwipeableRoomRowProps {
+  /** Identifies the row to the host's callbacks. */
+  roomJid: string;
+  onReport: (roomJid: string) => void;
+  onLeave: (roomJid: string) => void;
+  children: React.ReactNode;
+}
+
+/**
+ * A room-list row that slides left to show Report and Leave behind it,
+ * the way chats do in the big messengers. A tap on an action folds the
+ * row back first, so the list is tidy under whatever the action opens.
+ */
+const SwipeableRoomRow: React.FC<SwipeableRoomRowProps> = ({
+  roomJid,
+  onReport,
+  onLeave,
+  children,
+}) => {
+  const theme = useTheme();
+  const t = useT();
+  const styles = useMemo(() => createStyles(theme), [theme]);
+  const ref = useRef<SwipeableMethods>(null);
+
+  const onWillOpen = useCallback(() => {
+    if (openRow && openRow !== ref.current) {openRow.close();}
+    openRow = ref.current;
+  }, []);
+  const onClose = useCallback(() => {
+    if (openRow === ref.current) {openRow = null;}
+  }, []);
+
+  const act = useCallback(
+    (what: (jid: string) => void) => {
+      ref.current?.close();
+      what(roomJid);
+    },
+    [roomJid]
+  );
+
+  const renderRightActions = useCallback(
+    () => (
+      <View style={styles.actions}>
+        <TouchableOpacity
+          testID={`room-action-report-${roomJid.split('@')[0]}`}
+          accessibilityRole="button"
+          accessibilityLabel={t('action.report')}
+          activeOpacity={0.8}
+          style={[styles.action, { backgroundColor: theme.textSecondary }]}
+          onPress={() => act(onReport)}
+        >
+          <ReportIcon color={theme.textOnPrimary} width={22} height={22} />
+          <Text style={styles.label}>{t('action.report')}</Text>
+        </TouchableOpacity>
+        <TouchableOpacity
+          testID={`room-action-leave-${roomJid.split('@')[0]}`}
+          accessibilityRole="button"
+          accessibilityLabel={t('action.leave')}
+          activeOpacity={0.8}
+          style={[styles.action, { backgroundColor: theme.danger }]}
+          onPress={() => act(onLeave)}
+        >
+          <LeaveIcon color={theme.textOnPrimary} width={22} height={22} />
+          <Text style={styles.label}>{t('action.leave')}</Text>
+        </TouchableOpacity>
+      </View>
+    ),
+    [act, onLeave, onReport, roomJid, styles, t, theme]
+  );
+
+  return (
+    <ReanimatedSwipeable
+      ref={ref}
+      testID={`room-swipe-${roomJid.split('@')[0]}`}
+      friction={2}
+      rightThreshold={ROOM_ACTION_WIDTH / 2}
+      overshootRight={false}
+      enableTrackpadTwoFingerGesture
+      renderRightActions={renderRightActions}
+      onSwipeableWillOpen={onWillOpen}
+      onSwipeableClose={onClose}
+      // The row must cover the actions until it moves.
+      childrenContainerStyle={{ backgroundColor: theme.listBackground }}
+    >
+      {children}
+    </ReanimatedSwipeable>
+  );
+};
+
+export default SwipeableRoomRow;
+
+const createStyles = (theme: ChatTheme) =>
+  StyleSheet.create({
+    actions: {
+      flexDirection: 'row',
+      width: ROOM_ACTION_WIDTH * 2,
+    },
+    action: {
+      width: ROOM_ACTION_WIDTH,
+      alignItems: 'center',
+      justifyContent: 'center',
+      gap: 4,
+    },
+    label: {
+      color: theme.textOnPrimary,
+      fontSize: 12,
+      fontWeight: '600',
+    },
+  });

package/src/context/xmppProvider.tsx

@@ -39,7 +39,12 @@ import { getRooms as prefetchRoomsViaRest } from '../networking/api-requests/roo
 import { allRoomPresences } from '../networking/xmpp/allRoomPresences.xmpp';
 import { pushSubscriptionService } from '../services/pushSubscriptionService';
 import { store } from '../roomStore';
-import { logout, setStoreClient, setConfig } from '../roomStore/chatSettingsSlice';
+import {
+  logout,
+  setStoreClient,
+  setConfig,
+  setConnectionState,
+} from '../roomStore/chatSettingsSlice';
 import { logoutService } from '../hooks/useLogout';
 import {
   setLogoutState,
@@ -260,7 +265,12 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       created.setOnOnline(() => {
         const underlying = (created as any).client;
         if (!underlying) {return;}
-        allRoomPresences(underlying)
+        // The headers say "Updating…" until the rooms are joined again and
+        // the archive caught up - a stream that is up is not yet a chat
+        // that is. Same tick as the client's own 'online', so the title
+        // never shows the plain state in between.
+        store.dispatch(setConnectionState('syncing'));
+        const rejoin = allRoomPresences(underlying)
           .catch((e) =>
             devPushLog('warn', 'reconnect: allRoomPresences re-join failed', e)
           )
@@ -268,7 +278,7 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
         // Also refresh the private store so unread / lastViewed markers
         // are accurate after a long reconnect — the MUC re-join above only
         // restores delivery, not unread state. Idempotent on first connect.
-        created
+        const markers = created
           .getChatsPrivateStoreRequestStanza()
           .catch((e: unknown) =>
             devPushLog('warn', 'reconnect: privateStore refresh failed', e)
@@ -283,9 +293,16 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
         // point, so this is a no-op until the bootstrap's own history load
         // populates it. Customer-reported #32.
         const rooms = store.getState().rooms?.rooms || {};
-        updateMessagesTillLast(rooms, created).catch((e: unknown) =>
+        const catchUp = updateMessagesTillLast(rooms, created).catch((e: unknown) =>
           devPushLog('warn', 'reconnect: offline catch-up sync failed', e)
         );
+        Promise.allSettled([rejoin, markers, catchUp]).then(() => {
+          // Only if this stream is still the live one: a drop meanwhile
+          // has already put the headers back to "Connecting…".
+          if (created.status === 'online') {
+            store.dispatch(setConnectionState('online'));
+          }
+        });
       });
 
       setClient(created);

package/src/helpers/updateMessagesTillLast.tsx

@@ -1,6 +1,6 @@
 import XmppClient from '../networking/xmppClient';
 import { store } from '../roomStore';
-import { setRoomMessages } from '../roomStore/roomsSlice';
+import { addRoomMessages, setRoomMessages } from '../roomStore/roomsSlice';
 import { IMessage, IRoom } from '../types/types';
 import { checkUniqueUsers } from './checkUniqueUsers';
 
@@ -88,6 +88,13 @@ export const updateMessagesTillLast = async (
                   Number(message.id) === Number(lastCachedMessagesTimeStamp)
               );
 
+              // Merge the page now, whatever comes next: what the cache
+              // already holds is skipped, the rest is what arrived while
+              // the stream was down.
+              store.dispatch(
+                addRoomMessages({ roomJID: jid, messages: fetchedMessages })
+              );
+
               if (!isMessageFound && !(counter <= maxFetchAttempts - 1)) {
                 // Fire-and-forget — checkUniqueUsers resolves to an
                 // updated RoomMember list, but there's no slice

package/src/hooks/useChatSettingState.tsx

@@ -12,6 +12,9 @@ export const useChatSettingState = () => {
   const uiLocale = useSelector(
     (state: RootState) => state.chatSettingStore.uiLocale
   );
+  const connection = useSelector(
+    (state: RootState) => state.chatSettingStore.connection
+  );
   const config = useSelector(
     (state: RootState) => state.chatSettingStore.config
   );
@@ -33,6 +36,7 @@ export const useChatSettingState = () => {
 
   return {
     uiLocale,
+    connection,
     user,
     activeFile,
     activeModal,

package/src/hooks/useConnectionLabel.ts

@@ -0,0 +1,16 @@
+import { useChatSettingState } from './useChatSettingState';
+import { useT } from '../i18n/useT';
+
+/**
+ * What the headers say in place of their usual title while the session is
+ * not usable yet: "Connecting…" until the stream is up (first connect and
+ * every reconnect), "Updating…" while rooms are re-joined and the archive
+ * caught up. Nothing once the chat is live.
+ */
+export const useConnectionLabel = (): string | undefined => {
+  const { connection } = useChatSettingState();
+  const t = useT();
+  if (connection === 'connecting') {return t('connection.connecting');}
+  if (connection === 'syncing') {return t('connection.updating');}
+  return undefined;
+};

package/src/i18n/strings.ts

@@ -16,6 +16,8 @@ export type UiStringTable = Record<string, string>;
 const en: UiStringTable = {
   'search.placeholder': 'Search...',
   'roomList.title': 'Chats',
+  'connection.connecting': 'Connecting…',
+  'connection.updating': 'Updating…',
   'menu.newChat': 'New Chat',
   'menu.profile': 'Profile',
   'menu.settings': 'Settings',
@@ -335,6 +337,8 @@ const en: UiStringTable = {
 const fr: UiStringTable = {
   'search.placeholder': 'Rechercher...',
   'roomList.title': 'Discussions',
+  'connection.connecting': 'Connexion…',
+  'connection.updating': 'Mise à jour…',
   'menu.newChat': 'Nouvelle discussion',
   'menu.profile': 'Profil',
   'menu.settings': 'Paramètres',
@@ -654,6 +658,8 @@ const fr: UiStringTable = {
 const es: UiStringTable = {
   'search.placeholder': 'Buscar...',
   'roomList.title': 'Conversaciones',
+  'connection.connecting': 'Conectando…',
+  'connection.updating': 'Actualizando…',
   'menu.newChat': 'Nuevo chat',
   'menu.profile': 'Perfil',
   'menu.settings': 'Configuración',
@@ -973,6 +979,8 @@ const es: UiStringTable = {
 const pt: UiStringTable = {
   'search.placeholder': 'Pesquisar...',
   'roomList.title': 'Conversas',
+  'connection.connecting': 'A ligar…',
+  'connection.updating': 'A atualizar…',
   'menu.newChat': 'Nova conversa',
   'menu.profile': 'Perfil',
   'menu.settings': 'Definições',
@@ -1292,6 +1300,8 @@ const pt: UiStringTable = {
 const ht: UiStringTable = {
   'search.placeholder': 'Chèche...',
   'roomList.title': 'Chat yo',
+  'connection.connecting': 'Ap konekte…',
+  'connection.updating': 'Ap mete ajou…',
   'menu.newChat': 'Nouvo chat',
   'menu.profile': 'Pwofil',
   'menu.settings': 'Paramèt',
@@ -1611,6 +1621,8 @@ const ht: UiStringTable = {
 const zh: UiStringTable = {
   'search.placeholder': '搜索...',
   'roomList.title': '聊天',
+  'connection.connecting': '连接中…',
+  'connection.updating': '更新中…',
   'menu.newChat': '新聊天',
   'menu.profile': '个人资料',
   'menu.settings': '设置',

package/src/networking/api-requests/rooms.api.ts

@@ -212,11 +212,25 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
 const ROOM_MEMBERS_TTL_MS = 5 * 60_000;
 const roomMembersLoads = new Map<string, { at: number; done: Promise<boolean> }>();
 
-export function loadRoomMembers(roomJid: string): Promise<boolean> {
+/**
+ * Fetches the room's own REST record (`/chats/my/{name}`) and applies what
+ * only the backend knows: the full roster, and whether the room is
+ * end-to-end encrypted. Skipped while the roster is already complete,
+ * unless `force` - a room that arrived through XMPP (the room list
+ * stanza, an invite) was never described by REST at all, so it has no
+ * `e2ee` and shows no padlock until this runs.
+ */
+export function loadRoomMembers(
+  roomJid: string,
+  options: { force?: boolean } = {}
+): Promise<boolean> {
   const jid = String(roomJid || '').split('/')[0]!;
   const room = store.getState().rooms.rooms?.[jid];
   if (!room) {return Promise.resolve(false);}
-  if ((room.roomMembers?.length ?? 0) >= Number(room.usersCnt || 0)) {
+  if (
+    !options.force &&
+    (room.roomMembers?.length ?? 0) >= Number(room.usersCnt || 0)
+  ) {
     return Promise.resolve(false);
   }
   const running = roomMembersLoads.get(jid);
@@ -227,23 +241,35 @@ export function loadRoomMembers(roomJid: string): Promise<boolean> {
       const response: any = await getRoomByName(jid.split('@')[0]!);
       const item: ApiRoom = response?.result ?? response;
       const members = Array.isArray(item?.members) ? item.members : [];
-      if (members.length === 0) {return false;}
+      if (!item || typeof item !== 'object') {return false;}
       dispatchUsersSetFromRestItems([item]);
       const current = store.getState().rooms.rooms?.[jid];
       if (!current) {return false;}
+      const e2ee = item.e2ee === true || current.e2ee === true;
       store.dispatch(
         updateRoom({
           jid,
           updates: {
-            roomMembers: toRoomMembers(members),
-            usersCnt: Math.max(memberCount(item), members.length),
-            ...(current.e2ee
+            ...(members.length > 0
+              ? {
+                  roomMembers: toRoomMembers(members),
+                  usersCnt: Math.max(memberCount(item), members.length),
+                }
+              : {}),
+            ...(e2ee ? { e2ee: true } : {}),
+            ...(e2ee && members.length > 0
               ? { members: toE2eeMembers(members, ownAppId()) }
               : {}),
+            // What the stanza list did not carry.
+            ...(!current.title && item.title ? { title: item.title } : {}),
+            ...(!current.icon && (item.picture || item.icon)
+              ? { icon: item.picture || item.icon }
+              : {}),
+            ...(!current.type && (item as any).type ? { type: (item as any).type } : {}),
           },
         })
       );
-      return true;
+      return members.length > 0;
     } catch (error) {
       roomMembersLoads.delete(jid);
       console.warn('[ethora-rn] rooms.api: could not load room members', jid, error);

package/src/networking/stanzaHandlers.ts

@@ -23,6 +23,8 @@ import { setDeleteModal } from '../roomStore/chatSettingsSlice';
 import { messageNotificationManager } from '../utils/messageNotificationManager';
 import { transformCallLogMessage } from '../helpers/callLogMessage';
 import { translateKey } from '../i18n/strings';
+import { loadRoomMembers } from './api-requests/rooms.api';
+import { subscribeRoomForPush } from '../services/pushSubscriptionService';
 
 // TO DO: we are thinking to refactor this code in the following way:
 // each stanza will be parsed for 'type'
@@ -502,6 +504,14 @@ const onGetChatRooms = (stanza: Element, xmpp: any) => {
       if (!store.getState().rooms.activeRoomJID) {
         store.dispatch(setCurrentRoom({ roomJID: fresh[0].jid }));
       }
+      // The stanza says nothing about encryption or the roster: ask REST
+      // for each new room, so an encrypted room gets its padlock (and
+      // its recipients) without waiting for the next full load.
+      for (const room of fresh) {
+        loadRoomMembers(room.jid, { force: true }).catch(() => {});
+        // ...and pushes for it: the bootstrap's MucSub pass is over.
+        subscribeRoomForPush(xmpp, room.jid);
+      }
     }
     for (const jid of jids) {
       try {

package/src/networking/xmppClient.ts

@@ -29,6 +29,7 @@ import { pushLog as devPushLog, isDevLogActive } from '../utils/devLogger';
 import { normalizeRoomJid } from '../helpers/normalizeRoomJid';
 import { store } from '../roomStore';
 import { applyPrivateStoreMarkers } from '../roomStore/roomsSlice';
+import { setConnectionState } from '../roomStore/chatSettingsSlice';
 import {
   clearOutboundSends,
   enqueueOutboundSend,
@@ -129,7 +130,38 @@ export class XmppClient {
   service: string = '';
   conference: string = '';
   username: string;
-  status: 'offline' | 'connecting' | 'online' | 'error' = 'offline';
+  private _status: 'offline' | 'connecting' | 'online' | 'error' = 'offline';
+
+  /**
+   * The stream's state. Every change is mirrored into the store
+   * (`chatSettingStore.connection`) so the headers can say "Connecting…":
+   * a class field is nothing React can follow. `offline` and `error` are
+   * reported as `connecting` while a retry is scheduled - that is what the
+   * user is waiting for - and as `offline` only once nothing will try
+   * (logout, unmount).
+   */
+  get status(): 'offline' | 'connecting' | 'online' | 'error' {
+    return this._status;
+  }
+
+  set status(next: 'offline' | 'connecting' | 'online' | 'error') {
+    const changed = next !== this._status;
+    this._status = next;
+    if (!changed) {return;}
+    try {
+      const reported =
+        next === 'online'
+          ? 'online'
+          : next === 'connecting' || !this.suppressReconnect
+            ? 'connecting'
+            : 'offline';
+      if (store.getState().chatSettingStore.connection !== reported) {
+        store.dispatch(setConnectionState(reported));
+      }
+    } catch {
+      /* no store in some test harnesses */
+    }
+  }
 
   password = '';
   reconnectAttempts = 0;

package/src/roomStore/chatSettingsSlice.ts

@@ -44,8 +44,18 @@ export interface ChatState {
    * `config.i18n.locale`, which is the default for a user who never chose.
    */
   uiLocale?: string;
+  /**
+   * Where the XMPP session stands, for the headers: `connecting` until the
+   * stream is up (also while it is being re-established), `syncing` while
+   * rooms are re-joined and the archive caught up after a (re)connect,
+   * `online` once that is done, `offline` when the stream is down and
+   * nothing is trying (logged out).
+   */
+  connection?: ConnectionState;
 }
 
+export type ConnectionState = 'connecting' | 'syncing' | 'online' | 'offline';
+
 export const unpackAndTransform = (input?: User): User => {
   return {
     // Was hardcoded to '' — every setUser dropped the user's own bio, so
@@ -231,6 +241,12 @@ const reducers = {
   ) => {
     state.uiLocale = action.payload || undefined;
   },
+  setConnectionState: (
+    state: WritableDraft<ChatState>,
+    action: PayloadAction<ConnectionState>
+  ) => {
+    state.connection = action.payload;
+  },
 };
 
 export const chatSlice: Slice<ChatState, typeof reducers, 'chat'> = createSlice({
@@ -255,6 +271,7 @@ export const {
   setThemePreference,
   setPushEnabled,
   setUiLocale,
+  setConnectionState,
 } = chatSlice.actions;
 
 export default chatSlice.reducer;

package/src/roomStore/roomsSlice.ts

@@ -4,6 +4,7 @@ import { EditAction, HistoryPreloadState, IMessage, IRoom } from '../types/types
 import { insertMessageWithDelimiter } from '../helpers/insertMessageWithDelimiter';
 import { msgSortableMs } from '../helpers/msgSortableMs';
 import type XmppClient from '../networking/xmppClient';
+import { subscribeRoomForPush } from '../services/pushSubscriptionService';
 
 // Per-room runtime message cap. Mirrors the persistence layer's
 // MESSAGE_LIMIT so what's in memory matches what's on disk; otherwise
@@ -509,11 +510,13 @@ const isValidRoomJid = (jid: unknown): jid is string => {
 export const addRoomViaApi = createAsyncThunk(
   'roomMessages/addRoomViaApi',
   async (
-    { room, xmpp: _xmpp }: { room: IRoom; xmpp: XmppClient },
+    { room, xmpp }: { room: IRoom; xmpp: XmppClient },
     { dispatch }
   ) => {
     if (!room || !room.jid) return;
     dispatch(roomsStore.actions.addRoomFromApi({ room }));
+    // A room made now was not in the bootstrap's MucSub pass.
+    subscribeRoomForPush(xmpp, room.jid);
   }
 );
 

package/src/services/pushSubscriptionService.ts

@@ -114,3 +114,20 @@ export class PushSubscriptionService {
 
 export const pushSubscriptionService = new PushSubscriptionService();
 
+/**
+ * Push for a room that turned up after the bootstrap (created here, an
+ * invite, the room list after a reconnect): the bootstrap subscribed only
+ * the rooms it had, so without this a new room is silent until the next
+ * app start. Best effort, never throws; `wrapper` is the SDK's XmppClient
+ * (its `client` the underlying stream).
+ */
+export const subscribeRoomForPush = (wrapper: any, roomJid: string): void => {
+  const client = wrapper?.client;
+  const jid = String(roomJid || '').split('/')[0];
+  if (!client || !jid.includes('@')) {return;}
+  const nick = client.jid?.getLocal?.();
+  pushSubscriptionService
+    .subscribeToRoom(client, jid, nick)
+    .catch((error) => console.warn('[PushService] late subscribe failed', jid, error));
+};
+

package/src/types/types.ts

@@ -652,6 +652,8 @@ export interface IConfig {
   };
   disableProfilesInteractions?: boolean;
   disableUserCount?: boolean;
+  /** No Report / Leave behind a room-list row swiped to the left. */
+  disableRoomSwipeActions?: boolean;
   disableSentLogic?: boolean;
   disableTypingIndicator?: boolean;
   // Hide the full-screen "Connection error" overlay (the dark modal with

package/src/version.ts

@@ -1,3 +1,3 @@
 // Generated by scripts/sync-version.mjs on `npm version`.
 // Edit package.json's version instead of this file.
-export const ETHORA_CHAT_COMPONENT_VERSION = '26.8.8';
+export const ETHORA_CHAT_COMPONENT_VERSION = '26.9.0';