@ermis-network/ermis-chat-react 1.0.6 → 1.0.8

package/src/components/ChannelList.tsx

@@ -4,6 +4,7 @@ import type { Channel, Event, ChannelFilters } from '@ermis-network/ermis-chat-s
 import { parseSystemMessage, parseSignalMessage } from '@ermis-network/ermis-chat-sdk';
 import { useChatClient } from '../hooks/useChatClient';
 import { useChannelListUpdates } from '../hooks/useChannelListUpdates';
+import { useOnlineUsers } from '../hooks/useOnlineUsers';
 import { replaceMentionsForPreview, buildUserMap } from '../utils';
 import { useChannelRowUpdates } from '../hooks/useChannelRowUpdates';
 import { usePendingState } from '../hooks/usePendingState';
@@ -11,6 +12,14 @@ import { Avatar } from './Avatar';
 import type { ChannelItemProps, ChannelListProps } from '../types';
 
 export type { ChannelListProps, ChannelItemProps } from '../types';
+import type { ChannelActionsProps } from '../types';
+import { TopicModal } from './TopicModal';
+import { DefaultChannelActions, computeDefaultActions } from './ChannelActions';
+import { isDirectChannel, hasTopicsEnabled } from '../channelTypeUtils';
+import { canManageChannel, isPendingMember, isSkippedMember, isFriendChannel } from '../channelRoleUtils';
+
+export { DefaultChannelActions } from './ChannelActions';
+export type { ChannelAction, ChannelActionsProps } from '../types';
 
 /**
  * Get a human-readable preview string for the last message,
@@ -19,26 +28,28 @@ export type { ChannelListProps, ChannelItemProps } from '../types';
 function getLastMessagePreview(
   channel: Channel,
   myUserId?: string,
-): { text: string; user: string } {
+): { text: string; user: string; timestamp?: string | Date } {
   const lastMsg = channel.state?.latestMessages?.slice(-1)[0];
   if (!lastMsg) return { text: '', user: '' };
 
+  const timestamp = lastMsg.created_at;
+
   const msgType = lastMsg.type || 'regular';
   const rawText = lastMsg.text ?? '';
 
   if (msgType === 'system') {
     const userMap = buildUserMap(channel.state);
-    return { text: parseSystemMessage(rawText, userMap), user: '' };
+    return { text: parseSystemMessage(rawText, userMap), user: '', timestamp };
   }
 
   if (msgType === 'signal') {
     const result = parseSignalMessage(rawText, myUserId || '');
-    return { text: result?.text || rawText, user: '' };
+    return { text: result?.text || rawText, user: '', timestamp };
   }
 
   // Display 'Sticker' if message is a sticker
   if (msgType === 'sticker' || (lastMsg as Record<string, unknown>).sticker_url) {
-    return { text: 'Sticker', user: lastMsg.user?.name || lastMsg.user_id || '' };
+    return { text: 'Sticker', user: lastMsg.user?.name || lastMsg.user_id || '', timestamp };
   }
 
   // Regular / other
@@ -78,6 +89,7 @@ function getLastMessagePreview(
   return {
     text: displayText,
     user: lastMsg.user?.name || lastMsg.user_id || '',
+    timestamp,
   };
 }
 
@@ -91,25 +103,69 @@ export const ChannelItem: React.FC<ChannelItemProps> = React.memo(({
   unreadCount,
   lastMessageText,
   lastMessageUser,
+  lastMessageTimestamp,
   onSelect,
   AvatarComponent,
   isBlocked,
   isPending,
   pendingBadgeLabel,
   blockedBadgeLabel,
+  isClosedTopic,
+  closedTopicIcon,
+  PinnedIconComponent,
+  ChannelActionsComponent,
+  onAddTopic,
+  onEditTopic,
+  onToggleCloseTopic,
+  hiddenActions,
+  actionLabels,
+  actionIcons,
+  isOnline,
 }) => {
+  const { client } = useChatClient();
+  const currentUserId = client.userID;
+
   // Subscribe to channel.updated so that when name/image/description change,
   // we re-render from within (bypasses React.memo which only blocks parent-driven re-renders)
-  const [, forceUpdate] = useState(0);
+  const [updateCount, forceUpdate] = useState(0);
   useEffect(() => {
-    const sub = channel.on('channel.updated', () => forceUpdate((c) => c + 1));
-    return () => sub.unsubscribe();
+    const handleUpdate = () => forceUpdate((c) => c + 1);
+    const sub1 = channel.on('channel.updated', handleUpdate);
+    const sub2 = channel.on('channel.pinned', handleUpdate);
+    const sub3 = channel.on('channel.unpinned', handleUpdate);
+    return () => {
+      sub1.unsubscribe();
+      sub2.unsubscribe();
+      sub3.unsubscribe();
+    };
   }, [channel]);
 
+  const defaultActions = useMemo(
+    () => computeDefaultActions(channel, currentUserId, { onAddTopic, onEditTopic, onToggleCloseTopic, isBlocked, actionLabels, actionIcons }),
+    [channel, currentUserId, updateCount, onAddTopic, onEditTopic, onToggleCloseTopic, isBlocked, actionLabels, actionIcons],
+  );
+
+  const filteredActions = useMemo(() => {
+    if (!hiddenActions || hiddenActions.length === 0) return defaultActions;
+    return defaultActions.filter(a => !hiddenActions.includes(a.id));
+  }, [defaultActions, hiddenActions]);
+  const ActionsComponent = ChannelActionsComponent || DefaultChannelActions;
+
   const name = channel.data?.name || channel.cid;
   const image = channel.data?.image as string | undefined;
   const showUnread = hasUnread && !isActive;
 
+  const timestampText = useMemo(() => {
+    if (!lastMessageTimestamp) return null;
+    const d = new Date(lastMessageTimestamp);
+    if (isNaN(d.getTime())) return null;
+    const today = new Date();
+    const isToday = d.toDateString() === today.toDateString();
+    return isToday
+      ? d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
+      : d.toLocaleDateString(undefined, { month: 'short', day: 'numeric' });
+  }, [lastMessageTimestamp]);
+
   const handleClick = useCallback(() => {
     onSelect(channel);
   }, [channel, onSelect]);
@@ -118,47 +174,90 @@ export const ChannelItem: React.FC<ChannelItemProps> = React.memo(({
     'ermis-channel-list__item',
     isActive ? 'ermis-channel-list__item--active' : '',
     showUnread ? 'ermis-channel-list__item--unread' : '',
-    isBlocked ? 'ermis-channel-list__item--blocked' : '',
     isPending ? 'ermis-channel-list__item--pending' : '',
   ].filter(Boolean).join(' ');
 
   return (
     <div className={itemClass} onClick={handleClick}>
-      <AvatarComponent image={image} name={name} size={40} />
-      <div className="ermis-channel-list__item-content">
-        <div className="ermis-channel-list__item-name">{name}</div>
-        {lastMessageText && (
-          <div className="ermis-channel-list__item-last-message">
-            {lastMessageUser && (
-              <span className="ermis-channel-list__item-last-message-user">
-                {lastMessageUser}:{' '}
-              </span>
-            )}
-            <span>{lastMessageText}</span>
-          </div>
+      <div className="ermis-channel-list__item-avatar-wrapper">
+        <AvatarComponent image={image} name={name} size={40} disableLightbox />
+        {isOnline !== undefined && (
+          <span className={`ermis-channel-list__online-dot ermis-channel-list__online-dot--${isOnline ? 'online' : 'offline'}`} />
         )}
       </div>
-      {showUnread && unreadCount > 0 && (
-        <span className="ermis-channel-list__unread-badge">
-          {unreadCount > 99 ? '99+' : unreadCount}
-        </span>
-      )}
-      {isBlocked && (
-        <span className="ermis-channel-list__blocked-icon" title={blockedBadgeLabel || "Blocked"}>
-          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-            <circle cx="12" cy="12" r="10" />
-            <line x1="4.93" y1="4.93" x2="19.07" y2="19.07" />
-          </svg>
-        </span>
-      )}
-      {isPending && (
-        <span className="ermis-channel-list__pending-badge">{pendingBadgeLabel || 'Invited'}</span>
+      <div className="ermis-channel-list__item-content">
+        <div className="ermis-channel-list__item-top-row">
+          <div className="ermis-channel-list__item-name">{name}</div>
+          {channel.data?.is_pinned === true && !isClosedTopic && PinnedIconComponent && (
+            <span className="ermis-channel-list__pinned-icon" title="Pinned">
+              <PinnedIconComponent />
+            </span>
+          )}
+          {isClosedTopic && (
+            <span className="ermis-channel-list__closed-icon">
+              {closedTopicIcon || (
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                  <rect x="3" y="11" width="18" height="11" rx="2" ry="2" />
+                  <path d="M7 11V7a5 5 0 0 1 10 0v4" />
+                </svg>
+              )}
+            </span>
+          )}
+          {!isClosedTopic && timestampText && <div className="ermis-channel-list__item-timestamp">{timestampText}</div>}
+
+          {isPending && (
+            <span className="ermis-channel-list__pending-badge">{pendingBadgeLabel || 'Invited'}</span>
+          )}
+
+          {isBlocked && (
+            <span className="ermis-channel-list__blocked-icon" title={blockedBadgeLabel || "Blocked"}>
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                <circle cx="12" cy="12" r="10" />
+                <line x1="4.93" y1="4.93" x2="19.07" y2="19.07" />
+              </svg>
+            </span>
+          )}
+        </div>
+        <div className="ermis-channel-list__item-bottom-row">
+          {!isClosedTopic && lastMessageText && (
+            <div className="ermis-channel-list__item-last-message">
+              {lastMessageUser && (
+                <span className="ermis-channel-list__item-last-message-user">
+                  {lastMessageUser}:{' '}
+                </span>
+              )}
+              <span>{lastMessageText}</span>
+            </div>
+          )}
+
+          {!isClosedTopic && (
+            <div className="ermis-channel-list__item-badges">
+              {showUnread && unreadCount > 0 && (
+                <span className="ermis-channel-list__unread-badge">
+                  {unreadCount > 99 ? '99+' : unreadCount}
+                </span>
+              )}
+            </div>
+          )}
+        </div>
+      </div>
+      {!isPending && (
+        <div className="ermis-channel-list__item-actions-wrapper">
+          <ActionsComponent channel={channel} actions={filteredActions} onClose={() => { }} />
+        </div>
       )}
     </div>
   );
 });
 ChannelItem.displayName = 'ChannelItem';
 
+export const DefaultPinnedIcon = React.memo(() => (
+  <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor">
+    <path d="M16 12V4h1V2H7v2h1v8l-2 2v2h5.2v6h1.6v-6H18v-2l-2-2z" />
+  </svg>
+));
+DefaultPinnedIcon.displayName = 'DefaultPinnedIcon';
+
 const DefaultLoading = React.memo(({ text }: { text?: string }) => (
   <div className="ermis-channel-list__loading">{text || 'Loading channels...'}</div>
 ));
@@ -182,6 +281,16 @@ type ChannelRowProps = {
   currentUserId?: string;
   pendingBadgeLabel?: string;
   blockedBadgeLabel?: string;
+  closedTopicIcon?: React.ReactNode;
+  PinnedIconComponent?: React.ComponentType;
+  ChannelActionsComponent?: React.ComponentType<ChannelActionsProps>;
+  onAddTopic?: (channel: Channel) => void;
+  onEditTopic?: (channel: Channel) => void;
+  onToggleCloseTopic?: (channel: Channel, isClosed: boolean) => void;
+  hiddenActions?: string[];
+  actionLabels?: import('../types').ChannelActionLabels;
+  actionIcons?: import('../types').ChannelActionIcons;
+  isOnline?: boolean;
 };
 
 const ChannelRow: React.FC<ChannelRowProps> = React.memo(({
@@ -194,28 +303,43 @@ const ChannelRow: React.FC<ChannelRowProps> = React.memo(({
   currentUserId,
   pendingBadgeLabel,
   blockedBadgeLabel,
+  closedTopicIcon,
+  PinnedIconComponent,
+  ChannelActionsComponent,
+  onAddTopic,
+  onEditTopic,
+  onToggleCloseTopic,
+  hiddenActions,
+  actionLabels,
+  actionIcons,
+  isOnline,
 }) => {
   // Use the new custom hook to handle all row-level realtime updates
   const { isBannedInChannel, isBlockedInChannel, updateCount } = useChannelRowUpdates(channel, currentUserId);
   const { isPending } = usePendingState(channel, currentUserId);
+  const isSkipped = isSkippedMember(channel.state?.membership?.channel_role as string);
 
   const channelState = channel.state as unknown as Record<string, unknown> | undefined;
   const rawUnreadCount = (channelState?.unreadCount as number) ?? 0;
-  const unreadCount = (isBannedInChannel || isBlockedInChannel || isPending) ? 0 : rawUnreadCount;
+
+  const isClosedTopic = channel.data?.is_closed_topic === true;
+
+  // Render logic continues...
+  const unreadCount = (isBannedInChannel || isBlockedInChannel || isPending || isSkipped) ? 0 : rawUnreadCount;
   const hasUnread = unreadCount > 0;
 
-  // Derive last message preview computation is deferred here, 
-  // so it only executes when VList actually mounts this visible item
-  const { text: rawLastMessageText, user: rawLastMessageUser } = useMemo(
+  // Derive last message preview computation
+  const { text: rawLastMessageText, user: rawLastMessageUser, timestamp: rawLastMessageTimestamp } = useMemo(
     () => getLastMessagePreview(channel, currentUserId),
     // Recompute if latestMessage changes or we get a force update
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [channel, channel.state?.latestMessages, updateCount]
   );
 
-  // Hide last message preview when banned, blocked, or pending
-  const lastMessageText = (isBannedInChannel || isBlockedInChannel || isPending) ? '' : rawLastMessageText;
-  const lastMessageUser = (isBannedInChannel || isBlockedInChannel || isPending) ? '' : rawLastMessageUser;
+  // Hide last message preview when banned, blocked, pending or skipped
+  const lastMessageText = (isBannedInChannel || isBlockedInChannel || isPending || isSkipped) ? '' : rawLastMessageText;
+  const lastMessageUser = (isBannedInChannel || isBlockedInChannel || isPending || isSkipped) ? '' : rawLastMessageUser;
+  const lastMessageTimestamp = (isBannedInChannel || isBlockedInChannel || isPending || isSkipped) ? null : rawLastMessageTimestamp;
 
   if (renderChannel) {
     return (
@@ -233,17 +357,208 @@ const ChannelRow: React.FC<ChannelRowProps> = React.memo(({
       unreadCount={unreadCount}
       lastMessageText={lastMessageText}
       lastMessageUser={lastMessageUser}
+      lastMessageTimestamp={lastMessageTimestamp}
       onSelect={handleSelect}
       AvatarComponent={AvatarComponent}
       isBlocked={isBlockedInChannel}
       isPending={isPending}
       pendingBadgeLabel={pendingBadgeLabel}
       blockedBadgeLabel={blockedBadgeLabel}
+      isClosedTopic={isClosedTopic}
+      closedTopicIcon={closedTopicIcon}
+      PinnedIconComponent={PinnedIconComponent}
+      ChannelActionsComponent={ChannelActionsComponent}
+      onAddTopic={onAddTopic}
+      onEditTopic={onEditTopic}
+      onToggleCloseTopic={onToggleCloseTopic}
+      hiddenActions={hiddenActions}
+      actionLabels={actionLabels}
+      actionIcons={actionIcons}
+      isOnline={isOnline}
     />
   );
 });
 ChannelRow.displayName = 'ChannelRow';
 
+export const ChannelTopicGroup = React.memo(({
+  channel,
+  activeChannel,
+  handleSelect,
+  renderChannel,
+  ChannelItemComponent,
+  AvatarComponent,
+  GeneralTopicAvatarComponent,
+  TopicAvatarComponent,
+  currentUserId,
+  pendingBadgeLabel,
+  blockedBadgeLabel,
+  generalTopicLabel,
+  closedTopicIcon,
+  PinnedIconComponent,
+  ChannelActionsComponent,
+  onAddTopic,
+  onEditTopic,
+  onToggleCloseTopic,
+  hiddenActions,
+  actionLabels,
+  actionIcons,
+}: any) => {
+  const { updateCount } = useChannelRowUpdates(channel, currentUserId);
+  const [isExpanded, setIsExpanded] = useState(true);
+  const [topicUpdateCount, setTopicUpdateCount] = useState(0);
+
+  useEffect(() => {
+    const subs: { unsubscribe: () => void }[] = [];
+    const handleUpdate = () => setTopicUpdateCount((c) => c + 1);
+    const currentTopics = channel.state?.topics || [];
+    currentTopics.forEach((t: Channel) => {
+      subs.push(t.on('channel.pinned', handleUpdate));
+      subs.push(t.on('channel.unpinned', handleUpdate));
+      subs.push(t.on('message.new', handleUpdate));
+      subs.push(t.on('message.deleted', handleUpdate));
+    });
+    return () => {
+      subs.forEach((s) => s.unsubscribe());
+    };
+  }, [channel.state?.topics]);
+
+  const handleToggle = useCallback(() => setIsExpanded((prev) => !prev), []);
+
+  const userRole = channel.state?.members?.[currentUserId]?.channel_role;
+  const hasTopicAddPermission = canManageChannel(userRole);
+
+  const getTopicTime = (t: Channel) => {
+    const lastMsg = t.state?.latestMessages?.slice(-1)[0];
+    if (lastMsg?.created_at) return new Date(lastMsg.created_at).getTime();
+    if (t.data?.last_message_at) return new Date(t.data.last_message_at as string | Date).getTime();
+    if (t.data?.created_at) return new Date(t.data.created_at as string | Date).getTime();
+    return 0;
+  };
+
+  const topics = useMemo(() => {
+    const allTopics = channel.state?.topics || [];
+    return [...allTopics].sort((a: any, b: any) => {
+      const aPinned = a.data?.is_pinned === true;
+      const bPinned = b.data?.is_pinned === true;
+      if (aPinned && !bPinned) return -1;
+      if (!aPinned && bPinned) return 1;
+
+      return getTopicTime(b) - getTopicTime(a);
+    });
+  }, [channel.state?.topics, topicUpdateCount]);
+  const name = channel.data?.name || channel.cid;
+  const image = channel.data?.image as string | undefined;
+
+  const GeneralAvatar = useCallback(() => (
+    <div className="ermis-channel-list__topic-hashtag">#</div>
+  ), []);
+
+  const TopicEmojiAvatar = useCallback(({ image }: any) => {
+    let emoji = '💬';
+    if (image && typeof image === 'string' && image.startsWith('emoji://')) {
+      emoji = image.replace('emoji://', '');
+    }
+    return <div className="ermis-channel-list__topic-hashtag">{emoji}</div>;
+  }, []);
+
+  const generalChannelProxy = useMemo(() => {
+    return new Proxy(channel, {
+      get(target, prop, receiver) {
+        if (prop === 'data') {
+          return { ...target.data, name: generalTopicLabel || 'general', is_pinned: false };
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === 'function' ? value.bind(target) : value;
+      }
+    });
+  }, [channel, generalTopicLabel]);
+
+  const defaultActions = useMemo(
+    () => computeDefaultActions(channel, currentUserId, { onAddTopic, actionLabels, actionIcons }),
+    [channel, currentUserId, updateCount, onAddTopic, actionLabels, actionIcons],
+  );
+
+  const filteredActions = useMemo(() => {
+    if (!hiddenActions || hiddenActions.length === 0) return defaultActions;
+    return defaultActions.filter((a: any) => !hiddenActions.includes(a.id));
+  }, [defaultActions, hiddenActions]);
+  const ActionsComponent = ChannelActionsComponent || DefaultChannelActions;
+
+  return (
+    <div className="ermis-channel-list__topic-group">
+      <div
+        className={`ermis-channel-list__topic-header ${isExpanded ? 'ermis-channel-list__topic-header--expanded' : ''}`}
+        onClick={handleToggle}
+      >
+        <AvatarComponent image={image} name={name} size={40} disableLightbox />
+        <div className="ermis-channel-list__topic-header-name">{name}</div>
+
+        {channel.data?.is_pinned === true && PinnedIconComponent && (
+          <span className="ermis-channel-list__pinned-icon" title="Pinned">
+            <PinnedIconComponent />
+          </span>
+        )}
+
+        <div className="ermis-channel-list__topic-actions-wrapper">
+          <ActionsComponent channel={channel} actions={filteredActions} onClose={() => { }} />
+        </div>
+
+        <svg
+          className="ermis-channel-list__accordion-icon"
+          width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"
+        >
+          <polyline points="6 9 12 15 18 9"></polyline>
+        </svg>
+      </div>
+
+      {isExpanded && (
+        <div className="ermis-channel-list__topic-sublist">
+          <ChannelRow
+            channel={generalChannelProxy as any}
+            isActive={activeChannel?.cid === channel.cid}
+            handleSelect={handleSelect}
+            renderChannel={renderChannel}
+            ChannelItemComponent={ChannelItemComponent}
+            AvatarComponent={GeneralTopicAvatarComponent || GeneralAvatar}
+            currentUserId={currentUserId}
+            pendingBadgeLabel={pendingBadgeLabel}
+            blockedBadgeLabel={blockedBadgeLabel}
+            closedTopicIcon={closedTopicIcon}
+            PinnedIconComponent={PinnedIconComponent}
+            ChannelActionsComponent={() => null}
+            hiddenActions={hiddenActions}
+            actionLabels={actionLabels}
+            actionIcons={actionIcons}
+          />
+          {topics.map((topicChannel: any) => (
+            <ChannelRow
+              key={topicChannel.cid}
+              channel={topicChannel}
+              isActive={activeChannel?.cid === topicChannel.cid}
+              handleSelect={handleSelect}
+              renderChannel={renderChannel}
+              ChannelItemComponent={ChannelItemComponent}
+              AvatarComponent={TopicAvatarComponent || TopicEmojiAvatar}
+              currentUserId={currentUserId}
+              pendingBadgeLabel={pendingBadgeLabel}
+              blockedBadgeLabel={blockedBadgeLabel}
+              closedTopicIcon={closedTopicIcon}
+              PinnedIconComponent={PinnedIconComponent}
+              ChannelActionsComponent={ChannelActionsComponent}
+              onEditTopic={onEditTopic}
+              onToggleCloseTopic={onToggleCloseTopic}
+              hiddenActions={hiddenActions}
+              actionLabels={actionLabels}
+              actionIcons={actionIcons}
+            />
+          ))}
+        </div>
+      )}
+    </div>
+  );
+});
+ChannelTopicGroup.displayName = 'ChannelTopicGroup';
+
 export const ChannelList: React.FC<ChannelListProps> = React.memo(({
   filters = { type: ['messaging', 'team', 'meeting'], include_pinned_messages: true } as unknown as ChannelFilters,
   sort = [],
@@ -261,28 +576,93 @@ export const ChannelList: React.FC<ChannelListProps> = React.memo(({
   loadingLabel,
   emptyStateLabel = 'No channels found',
   blockedBadgeLabel = 'Blocked',
+  ChannelTopicGroupComponent,
+  GeneralTopicAvatarComponent,
+  TopicAvatarComponent,
+  generalTopicLabel = 'general',
+  onAddTopic,
+  TopicEmojiPickerComponent,
+  closedTopicIcon,
+  PinnedIconComponent = DefaultPinnedIcon,
+  ChannelActionsComponent,
+  onEditTopic,
+  onToggleCloseTopic,
+  hiddenActions,
+  actionLabels,
+  actionIcons,
+  showOnlineStatus = true,
 }) => {
   const { client, activeChannel, setActiveChannel } = useChatClient();
   const [channels, setChannels] = useState<Channel[]>([]);
   const [loading, setLoading] = useState(true);
   const [isPendingExpanded, setIsPendingExpanded] = useState(true);
+  const [addingTopicForChannel, setAddingTopicForChannel] = useState<Channel | null>(null);
+  const [editingTopicForChannel, setEditingTopicForChannel] = useState<Channel | null>(null);
+
+  const handleAddTopicClick = useCallback((channel: Channel) => {
+    if (onAddTopic) {
+      onAddTopic(channel);
+    } else {
+      setAddingTopicForChannel(channel);
+    }
+  }, [onAddTopic]);
+
+  const handleEditTopicClick = useCallback((channel: Channel) => {
+    if (onEditTopic) {
+      onEditTopic(channel);
+    } else {
+      setEditingTopicForChannel(channel);
+    }
+  }, [onEditTopic]);
+
+  const handleToggleCloseTopicClick = useCallback(async (channel: Channel, isClosed: boolean) => {
+    if (onToggleCloseTopic) {
+      onToggleCloseTopic(channel, isClosed);
+      return;
+    }
+
+    const parentCid = channel.data?.parent_cid as string | undefined;
+    if (!parentCid) return;
+
+    const parentChannel = client.activeChannels[parentCid];
+    if (!parentChannel) return;
+
+    try {
+      if (isClosed) {
+        await parentChannel.reopenTopic(channel.cid);
+      } else {
+        await parentChannel.closeTopic(channel.cid);
+      }
+    } catch (err) {
+      console.error('Failed to toggle topic close state', err);
+    }
+  }, [client.activeChannels, onToggleCloseTopic]);
 
   // Group channels into pending and regular
   const { pendingChannels, regularChannels } = useMemo<{ pendingChannels: Channel[], regularChannels: Channel[] }>(() => {
     const pending: Channel[] = [];
+    const pinned: Channel[] = [];
     const regular: Channel[] = [];
 
     channels.forEach(ch => {
       const ms = ch.state?.membership as Record<string, unknown> | undefined;
-      const isPending = ms?.channel_role === 'pending' || ms?.role === 'pending';
+      const isPending = isPendingMember(ms?.channel_role as string);
+      const isSkipped = isSkippedMember(ms?.channel_role as string);
+      
+      if (isSkipped) {
+        return; // Filter out completely
+      }
+
       if (isPending) {
         pending.push(ch);
+      } else if (ch.data?.is_pinned) {
+        pinned.push(ch);
       } else {
         regular.push(ch);
       }
     });
 
-    return { pendingChannels: pending, regularChannels: regular };
+    return { pendingChannels: pending, regularChannels: [...pinned, ...regular] };
   }, [channels]);
 
   const filtersKey = useMemo(() => JSON.stringify(filters), [filters]);
@@ -306,6 +686,28 @@ export const ChannelList: React.FC<ChannelListProps> = React.memo(({
   // Real-time: List manipulation (move to top, add, delete)
   useChannelListUpdates(channels, setChannels);
 
+  // Online status: compute set of online friend user IDs (skip if disabled)
+  const onlineUsers = useOnlineUsers(showOnlineStatus ? channels : []);
+
+  // Helper: get the "other" user ID from a direct channel
+  const getOtherUserId = useCallback((channel: Channel): string | undefined => {
+    if (!isDirectChannel(channel) || !client.userID) return undefined;
+    const members = channel.state?.members;
+    if (!members) return undefined;
+    for (const memberId of Object.keys(members)) {
+      if (memberId !== client.userID) return memberId;
+    }
+    return undefined;
+  }, [client.userID]);
+
+  // Helper: compute isOnline for a channel (undefined for non-friend channels)
+  const getIsOnline = useCallback((channel: Channel): boolean | undefined => {
+    const otherUserId = getOtherUserId(channel);
+    if (!otherUserId || !client.userID) return undefined;
+    if (!isFriendChannel(channel, otherUserId, client.userID)) return undefined;
+    return onlineUsers.has(otherUserId);
+  }, [getOtherUserId, onlineUsers, client.userID]);
+
   const handleSelect = useCallback(
     (channel: Channel) => {
       setActiveChannel(channel);
@@ -315,10 +717,11 @@ export const ChannelList: React.FC<ChannelListProps> = React.memo(({
       const ms = channel.state?.membership as Record<string, unknown> | undefined;
       const chState = channel.state as unknown as Record<string, unknown> | undefined;
       const isBannedInChannel = Boolean(ms?.banned);
-      const isBlockedInChannel = channel.type === 'messaging' && Boolean(ms?.blocked);
-      const isPending = ms?.channel_role === 'pending' || ms?.role === 'pending';
+      const isBlockedInChannel = isDirectChannel(channel) && Boolean(ms?.blocked);
+      const isPending = isPendingMember(ms?.channel_role as string);
+      const isSkipped = isSkippedMember(ms?.channel_role as string);
 
-      if (!isBannedInChannel && !isBlockedInChannel && !isPending && (chState?.unreadCount as number) > 0) {
+      if (!isBannedInChannel && !isBlockedInChannel && !isPending && !isSkipped && (chState?.unreadCount as number) > 0) {
         channel.markRead().catch(() => { });
         // Optimistically reset unread to update UI immediately
         if (chState) chState.unreadCount = 0;
@@ -367,6 +770,13 @@ export const ChannelList: React.FC<ChannelListProps> = React.memo(({
               currentUserId={client.userID}
               pendingBadgeLabel={pendingBadgeLabel}
               blockedBadgeLabel={blockedBadgeLabel}
+              closedTopicIcon={closedTopicIcon}
+              PinnedIconComponent={PinnedIconComponent}
+              ChannelActionsComponent={ChannelActionsComponent}
+              hiddenActions={hiddenActions}
+              actionLabels={actionLabels}
+              actionIcons={actionIcons}
+              isOnline={getIsOnline(channel)}
             />
           );
         })}
@@ -377,6 +787,37 @@ export const ChannelList: React.FC<ChannelListProps> = React.memo(({
         )}
         {regularChannels.map((channel: Channel) => {
           const isActive = activeChannel?.cid === channel.cid;
+          const isTeamWithTopics = hasTopicsEnabled(channel);
+
+          if (isTeamWithTopics) {
+            const GroupComponent = ChannelTopicGroupComponent || ChannelTopicGroup;
+            return (
+              <GroupComponent
+                key={channel.cid}
+                channel={channel}
+                activeChannel={activeChannel}
+                handleSelect={handleSelect}
+                renderChannel={renderChannel}
+                ChannelItemComponent={ChannelItemComponent}
+                AvatarComponent={AvatarComponent}
+                GeneralTopicAvatarComponent={GeneralTopicAvatarComponent}
+                TopicAvatarComponent={TopicAvatarComponent}
+                currentUserId={client.userID}
+                pendingBadgeLabel={pendingBadgeLabel}
+                blockedBadgeLabel={blockedBadgeLabel}
+                generalTopicLabel={generalTopicLabel}
+                onAddTopic={handleAddTopicClick}
+                closedTopicIcon={closedTopicIcon}
+                PinnedIconComponent={PinnedIconComponent}
+                ChannelActionsComponent={ChannelActionsComponent}
+                onEditTopic={handleEditTopicClick}
+                onToggleCloseTopic={handleToggleCloseTopicClick}
+                hiddenActions={hiddenActions}
+                actionLabels={actionLabels}
+                actionIcons={actionIcons}
+              />
+            );
+          }
 
           return (
             <ChannelRow
@@ -390,10 +831,36 @@ export const ChannelList: React.FC<ChannelListProps> = React.memo(({
               currentUserId={client.userID}
               pendingBadgeLabel={pendingBadgeLabel}
               blockedBadgeLabel={blockedBadgeLabel}
+              closedTopicIcon={closedTopicIcon}
+              PinnedIconComponent={PinnedIconComponent}
+              ChannelActionsComponent={ChannelActionsComponent}
+              onAddTopic={handleAddTopicClick}
+              onEditTopic={handleEditTopicClick}
+              onToggleCloseTopic={handleToggleCloseTopicClick}
+              hiddenActions={hiddenActions}
+              actionLabels={actionLabels}
+              actionIcons={actionIcons}
+              isOnline={getIsOnline(channel)}
             />
           );
         })}
       </VList>
+      {addingTopicForChannel && (
+        <TopicModal
+          isOpen={true}
+          onClose={() => setAddingTopicForChannel(null)}
+          parentChannel={addingTopicForChannel}
+          EmojiPickerComponent={TopicEmojiPickerComponent}
+        />
+      )}
+      {editingTopicForChannel && (
+        <TopicModal
+          isOpen={true}
+          onClose={() => setEditingTopicForChannel(null)}
+          topic={editingTopicForChannel}
+          EmojiPickerComponent={TopicEmojiPickerComponent}
+        />
+      )}
     </div>
   );
 });