snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/client/views/navigation/sidepanel/hooks/useChannelsChildrenList.spec.ts

@@ -0,0 +1,126 @@
+import { mockAppRoot } from '@rocket.chat/mock-providers';
+import type { SubscriptionWithRoom } from '@rocket.chat/ui-contexts';
+import { renderHook } from '@testing-library/react';
+
+import { createFakeSubscription } from '../../../../../tests/mocks/data';
+import { emptyUnread, createMockGlobalStore } from '../../../../../tests/mocks/utils';
+import { isUnreadSubscription } from '../../contexts/RoomsNavigationContext';
+
+const fakeTeam = { ...createFakeSubscription({ alert: true }) };
+const fakeChannel = { ...createFakeSubscription({ t: 'c', alert: true }) };
+
+const teamChildChannel = {
+	...createFakeSubscription({ t: 'c', ...emptyUnread, prid: fakeTeam.rid }),
+};
+const unreadTeamChildChannel = {
+	...createFakeSubscription({ t: 'c', alert: true, prid: fakeTeam.rid }),
+};
+const childChannel = {
+	...createFakeSubscription({ t: 'c', ...emptyUnread, prid: fakeChannel.rid }),
+};
+const userMentionsChildChannel = {
+	...createFakeSubscription({ t: 'c', userMentions: 1, prid: fakeChannel.rid }),
+};
+const groupMentionsChildChannel = {
+	...createFakeSubscription({ t: 'c', groupMentions: 1, prid: fakeChannel.rid }),
+};
+const unreadChildChannel = {
+	...createFakeSubscription({ t: 'c', unread: 1, prid: fakeChannel.rid }),
+};
+const tUnreadChildChannel = {
+	...createFakeSubscription({ t: 'c', tunread: ['1'], prid: fakeChannel.rid }),
+};
+const tUnreadUserChildChannel = {
+	...createFakeSubscription({ t: 'c', tunreadUser: ['1'], prid: fakeChannel.rid }),
+};
+const tUnreadGroupChildChannel = {
+	...createFakeSubscription({ t: 'c', tunreadGroup: ['1'], prid: fakeChannel.rid }),
+};
+
+const teamsSubscriptions = [fakeTeam, teamChildChannel, unreadTeamChildChannel] as unknown as SubscriptionWithRoom[];
+const channelsSubscriptions = [
+	fakeChannel,
+	childChannel,
+	userMentionsChildChannel,
+	groupMentionsChildChannel,
+	unreadChildChannel,
+	tUnreadChildChannel,
+	tUnreadUserChildChannel,
+	tUnreadGroupChildChannel,
+] as unknown as SubscriptionWithRoom[];
+
+const subscriptionsMock = [...teamsSubscriptions, ...channelsSubscriptions] as unknown as SubscriptionWithRoom[];
+
+jest.mock('../../../../stores/Subscriptions', () => {
+	return {
+		Subscriptions: createMockGlobalStore(subscriptionsMock),
+	};
+});
+
+it('should return all subscriptions parent of fakeChannel', async () => {
+	const { useChannelsChildrenList } = await import('./useChannelsChildrenList');
+
+	const { result } = renderHook(() => useChannelsChildrenList(fakeChannel.rid, false), {
+		wrapper: mockAppRoot().withSubscriptions(subscriptionsMock).build(),
+	});
+
+	expect(result.current).toHaveLength(channelsSubscriptions.length);
+	expect(result.current[0].rid).toBe(fakeChannel.rid);
+
+	if (result.current[0].rid === fakeChannel.rid) return;
+	expect(result.current[0].prid).toBe(fakeChannel.rid);
+});
+
+it('should return unread subscriptions after parent but before read ones for channels', async () => {
+	const { useChannelsChildrenList } = await import('./useChannelsChildrenList');
+
+	const { result } = renderHook(() => useChannelsChildrenList(fakeChannel.rid, true), {
+		wrapper: mockAppRoot().withSubscriptions(subscriptionsMock).build(),
+	});
+
+	expect(result.current).toHaveLength(channelsSubscriptions.length);
+	expect(result.current[0].rid).toBe(fakeChannel.rid);
+
+	expect(isUnreadSubscription(result.current[1])).toBe(true);
+	expect(isUnreadSubscription(result.current[2])).toBe(true);
+	expect(isUnreadSubscription(result.current[3])).toBe(true);
+	expect(isUnreadSubscription(result.current[4])).toBe(true);
+	expect(isUnreadSubscription(result.current[5])).toBe(true);
+	expect(isUnreadSubscription(result.current[6])).toBe(true);
+
+	expect(isUnreadSubscription(result.current[7])).toBe(false);
+
+	if (result.current[0].rid === fakeChannel.rid) return;
+	expect(result.current[0].prid).toBe(fakeChannel.rid);
+});
+
+it('should return subscriptions parent of fakeTeam', async () => {
+	const { useChannelsChildrenList } = await import('./useChannelsChildrenList');
+
+	const { result } = renderHook(() => useChannelsChildrenList(fakeTeam.rid, false), {
+		wrapper: mockAppRoot().withSubscriptions(subscriptionsMock).build(),
+	});
+
+	expect(result.current).toHaveLength(teamsSubscriptions.length);
+	expect(result.current[0].rid).toBe(fakeTeam.rid);
+
+	if (result.current[0].rid === fakeTeam.rid) return;
+	expect(result.current[0].prid).toBe(fakeTeam.rid);
+});
+
+it('should return unread subscriptions after parent but before read ones for teams', async () => {
+	const { useChannelsChildrenList } = await import('./useChannelsChildrenList');
+
+	const { result } = renderHook(() => useChannelsChildrenList(fakeTeam.rid, true), {
+		wrapper: mockAppRoot().withSubscriptions(subscriptionsMock).build(),
+	});
+
+	expect(result.current).toHaveLength(teamsSubscriptions.length);
+	expect(result.current[0].rid).toBe(fakeTeam.rid);
+
+	expect(isUnreadSubscription(result.current[1])).toBe(true);
+	expect(isUnreadSubscription(result.current[2])).toBe(false);
+
+	if (result.current[0].rid === fakeTeam.rid) return;
+	expect(result.current[0].prid).toBe(fakeTeam.rid);
+});

apps/meteor/client/views/navigation/sidepanel/hooks/useChannelsChildrenList.ts

@@ -0,0 +1,57 @@
+import type { SubscriptionWithRoom } from '@rocket.chat/ui-contexts';
+import { useShallow } from 'zustand/shallow';
+
+import { pipe } from '../../../../lib/cachedStores/pipe';
+import { Subscriptions } from '../../../../stores';
+import { isUnreadSubscription } from '../../contexts/RoomsNavigationContext';
+
+const sortByLmPipe = pipe<SubscriptionWithRoom>().sortByField('lm', -1);
+
+/**
+ * This helper function is used to ensure that the main room (main team room or parent's discussion room)
+ * is always at the top of the list.
+ */
+const getMainRoomAndSort = (records: SubscriptionWithRoom[], unreadOnly: boolean, teamId?: string) => {
+	const mainRoom = records.find((record) => (teamId ? record.teamMain : !record.prid));
+	const filteredRecords = records.filter((record) => mainRoom?.rid !== record.rid);
+	const sortedRecords = sortByLmPipe.apply(filteredRecords);
+	const rest = !unreadOnly
+		? sortedRecords
+		: sortedRecords
+				.reduce(
+					(result, record) => {
+						if (isUnreadSubscription(record)) {
+							result[0].push(record);
+							return result;
+						}
+						result[1].push(record);
+						return result;
+					},
+					[[] as SubscriptionWithRoom[], [] as SubscriptionWithRoom[]],
+				)
+				.flat();
+
+	if (mainRoom) {
+		rest.unshift(mainRoom);
+	}
+
+	return rest;
+};
+
+export const useChannelsChildrenList = (parentRid: string, unreadOnly: boolean, teamId?: string) => {
+	return Subscriptions.use(
+		useShallow((state) => {
+			const records = state.filter((subscription) => {
+				if (parentRid === subscription.prid || parentRid === subscription.rid) {
+					return true;
+				}
+				if (teamId && subscription.teamId === teamId) {
+					return true;
+				}
+				return false;
+			});
+
+			return getMainRoomAndSort(records, unreadOnly, teamId);
+		}),
+	);
+};

apps/meteor/client/views/navigation/sidepanel/hooks/useRoomMenuActions.spec.ts

@@ -0,0 +1,104 @@
+import { mockAppRoot } from '@rocket.chat/mock-providers';
+import { renderHook } from '@testing-library/react';
+
+import { useRoomMenuActions } from './useRoomMenuActions';
+import { createFakeSubscription } from '../../../../../tests/mocks/data';
+
+const mockSubscription = createFakeSubscription({ name: 'room1', fname: 'Room 1', t: 'c', disableNotifications: false, rid: 'room1' });
+
+jest.mock('../../../../../client/lib/rooms/roomCoordinator', () => ({
+	roomCoordinator: {
+		getRoomDirectives: () => ({
+			getUiText: () => 'leaveWarning',
+		}),
+	},
+}));
+
+jest.mock('../../../../../client/lib/LegacyRoomManager', () => ({
+	LegacyRoomManager: {
+		close: jest.fn(),
+	},
+}));
+
+// TODO: Update this mock when we get the mocked OmnichannelContext working
+jest.mock('../../../omnichannel/hooks/useOmnichannelPrioritiesMenu', () => ({
+	useOmnichannelPrioritiesMenu: jest.fn(() => [{ id: 'priority', content: 'Priority', icon: 'priority', onClick: jest.fn() }]),
+}));
+
+const mockHookProps = {
+	rid: 'room1',
+	type: 'c',
+	name: 'Room 1',
+	isUnread: true,
+	cl: true,
+	roomOpen: true,
+	hideDefaultOptions: false,
+	href: '/channel/room1',
+} as const;
+
+describe('useRoomMenuActions', () => {
+	it('should return all menu options for normal rooms', () => {
+		const { result } = renderHook(() => useRoomMenuActions(mockHookProps), {
+			wrapper: mockAppRoot()
+				.withSubscription({ ...mockSubscription, rid: 'room1' })
+				.withPermission('leave-c')
+				.withPermission('leave-p')
+				.withSetting('Favorite_Rooms', true)
+				.build(),
+		});
+
+		const actions = result.current;
+		expect(actions).toHaveLength(2);
+		expect(actions[0].items).toHaveLength(4);
+		expect(actions[1].title).toBe('Notifications');
+		expect(actions[1].items).toHaveLength(2);
+	});
+
+	it('should return priorities section for omnichannel room', () => {
+		const { result } = renderHook(() => useRoomMenuActions({ ...mockHookProps, type: 'l' }), {
+			wrapper: mockAppRoot()
+				.withSubscription({ ...mockSubscription, t: 'l' })
+				.withPermission('leave-c')
+				.withPermission('leave-p')
+				.withSetting('Favorite_Rooms', true)
+				.build(),
+		});
+
+		expect(result.current.length).toBe(2);
+		expect(result.current[1].title).toBe('Priorities');
+		expect(result.current.some((section) => section.title === 'Notifications')).toBe(false);
+		expect(result.current[0].items).toHaveLength(2);
+		expect(result.current[0].title).toBe('');
+	});
+
+	it('should not return any menu option if hideDefaultOptions', () => {
+		const { result } = renderHook(() => useRoomMenuActions({ ...mockHookProps, hideDefaultOptions: true }), {
+			wrapper: mockAppRoot()
+				.withSubscription(mockSubscription)
+				.withPermission('leave-c')
+				.withPermission('leave-p')
+				.withSetting('Favorite_Rooms', true)
+				.build(),
+		});
+
+		expect(result.current).toHaveLength(0);
+	});
+
+	it('should not return favorite room option if setting is disabled', () => {
+		const { result } = renderHook(() => useRoomMenuActions(mockHookProps), {
+			wrapper: mockAppRoot()
+				.withSubscription(mockSubscription)
+				.withPermission('leave-c')
+				.withPermission('leave-p')
+				.withSetting('Favorite_Rooms', false)
+				.build(),
+		});
+
+		const actions = result.current;
+		expect(actions).toHaveLength(2);
+		expect(actions[0].items).toHaveLength(3);
+		expect(actions[0].items.some((item) => item.id === 'toggleFavorite')).toBe(false);
+		expect(actions[1].title).toBe('Notifications');
+		expect(actions[1].items).toHaveLength(2);
+	});
+});

apps/meteor/client/views/navigation/sidepanel/hooks/useRoomMenuActions.ts

@@ -0,0 +1,145 @@
+import type { RoomType } from '@rocket.chat/core-typings';
+import type { GenericMenuItemProps } from '@rocket.chat/ui-client';
+import { usePermission, useRouter, useSetting, useUserSubscription } from '@rocket.chat/ui-contexts';
+import type { LocationPathname } from '@rocket.chat/ui-contexts';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useLeaveRoomAction } from '../../../../hooks/menuActions/useLeaveRoom';
+import { useToggleFavoriteAction } from '../../../../hooks/menuActions/useToggleFavoriteAction';
+import { useToggleNotificationAction } from '../../../../hooks/menuActions/useToggleNotificationsAction';
+import { useToggleReadAction } from '../../../../hooks/menuActions/useToggleReadAction';
+import { useHideRoomAction } from '../../../../hooks/useHideRoomAction';
+import { useOmnichannelPrioritiesMenu } from '../../../omnichannel/hooks/useOmnichannelPrioritiesMenu';
+
+type RoomMenuActionsProps = {
+	rid: string;
+	type: RoomType;
+	name: string;
+	isUnread?: boolean;
+	cl?: boolean;
+	roomOpen?: boolean;
+	hideDefaultOptions: boolean;
+	href: LocationPathname | undefined;
+};
+
+export const useRoomMenuActions = ({
+	rid,
+	type,
+	name,
+	isUnread,
+	cl,
+	roomOpen,
+	hideDefaultOptions,
+	href,
+}: RoomMenuActionsProps): { title: string; items: GenericMenuItemProps[] }[] => {
+	const { t } = useTranslation();
+	const subscription = useUserSubscription(rid);
+	const router = useRouter();
+
+	const isFavorite = Boolean(subscription?.f);
+	const canLeaveChannel = usePermission('leave-c');
+	const canLeavePrivate = usePermission('leave-p');
+	const canFavorite = useSetting('Favorite_Rooms', true);
+	const isNotificationEnabled = !subscription?.disableNotifications;
+
+	const canLeave = ((): boolean => {
+		if (type === 'c' && !canLeaveChannel) {
+			return false;
+		}
+		if (type === 'p' && !canLeavePrivate) {
+			return false;
+		}
+		return !((cl != null && !cl) || ['d', 'l'].includes(type));
+	})();
+
+	const handleHide = useHideRoomAction({ rid, type, name }, { redirect: false });
+	const handleToggleFavorite = useToggleFavoriteAction({ rid, isFavorite });
+	const handleToggleRead = useToggleReadAction({ rid, isUnread, subscription });
+	const handleLeave = useLeaveRoomAction({ rid, type, name, roomOpen });
+	const handleToggleNotification = useToggleNotificationAction({ rid, isNotificationEnabled, roomName: name });
+
+	const isOmnichannelRoom = type === 'l';
+	const prioritiesMenu = useOmnichannelPrioritiesMenu(rid);
+
+	const roomMenuOptions = useMemo<GenericMenuItemProps[]>(() => {
+		if (hideDefaultOptions || !subscription) {
+			return [];
+		}
+
+		const options: (GenericMenuItemProps | false)[] = [
+			!isOmnichannelRoom && {
+				id: 'hideRoom',
+				icon: 'eye-off',
+				content: t('Hide'),
+				onClick: handleHide,
+			},
+			{
+				id: 'toggleRead',
+				icon: 'flag',
+				content: isUnread ? t('Mark_read') : t('Mark_unread'),
+				onClick: handleToggleRead,
+			},
+			canFavorite && {
+				id: 'toggleFavorite',
+				icon: isFavorite ? 'star-filled' : 'star',
+				content: isFavorite ? t('Unfavorite') : t('Favorite'),
+				onClick: handleToggleFavorite,
+			},
+			canLeave && {
+				id: 'leaveRoom',
+				icon: 'sign-out',
+				content: t('Leave_room'),
+				onClick: handleLeave,
+			},
+		];
+		return options.filter(Boolean) as GenericMenuItemProps[];
+	}, [
+		hideDefaultOptions,
+		subscription,
+		isOmnichannelRoom,
+		t,
+		handleHide,
+		isUnread,
+		handleToggleRead,
+		canFavorite,
+		isFavorite,
+		handleToggleFavorite,
+		canLeave,
+		handleLeave,
+	]);
+
+	const notificationsMenuOptions = useMemo<GenericMenuItemProps[]>(() => {
+		if (!subscription || hideDefaultOptions || isOmnichannelRoom || !href) {
+			return [];
+		}
+
+		const options: GenericMenuItemProps[] = [
+			{
+				id: 'turnOnNotifications',
+				icon: isNotificationEnabled ? 'bell' : 'bell-off',
+				content: isNotificationEnabled ? t('Turn_OFF') : t('Turn_ON'),
+				onClick: handleToggleNotification,
+			},
+			{
+				id: 'notifications',
+				icon: 'customize',
+				content: t('Preferences'),
+				onClick: () => router.navigate(`${href}/push-notifications` as LocationPathname),
+			},
+		];
+		return options.filter(Boolean);
+	}, [hideDefaultOptions, isNotificationEnabled, subscription, t, router, href, handleToggleNotification, isOmnichannelRoom]);
+
+	if (isOmnichannelRoom) {
+		return [
+			...(roomMenuOptions.length > 0 ? [{ title: '', items: roomMenuOptions }] : []),
+			...(prioritiesMenu.length > 0 ? [{ title: t('Priorities'), items: prioritiesMenu }] : []),
+		];
+	}
+
+	return [
+		...(roomMenuOptions.length > 0 ? [{ title: '', items: roomMenuOptions }] : []),
+		...(notificationsMenuOptions.length > 0 ? [{ title: t('Notifications'), items: notificationsMenuOptions }] : []),
+	];
+};