stream-chat-react-native-core 9.3.1 → 9.4.0-beta.10

package/src/components/ChannelList/hooks/__tests__/useChannelActionItems.test.tsx

@@ -1,276 +0,0 @@
-import { Alert, AlertButton } from 'react-native';
-
-import { renderHook } from '@testing-library/react-native';
-import type { Channel } from 'stream-chat';
-
-import type { TranslationContextValue } from '../../../../contexts/translationContext/TranslationContext';
-import * as TranslationContext from '../../../../contexts/translationContext/TranslationContext';
-import {
-  GetChannelActionItems,
-  buildDefaultChannelActionItems,
-  getChannelActionItems,
-  useChannelActionItems,
-} from '../useChannelActionItems';
-import * as useChannelActionsModule from '../useChannelActions';
-import * as useChannelMembershipStateModule from '../useChannelMembershipState';
-import * as useChannelMuteActiveModule from '../useChannelMuteActive';
-import * as useIsDirectChatModule from '../useIsDirectChat';
-
-const createChannelActions = (): useChannelActionsModule.ChannelActions => ({
-  archive: jest.fn(),
-  blockUser: jest.fn(),
-  deleteChannel: jest.fn(),
-  leave: jest.fn(),
-  muteChannel: jest.fn(),
-  muteUser: jest.fn(),
-  pin: jest.fn(),
-  unarchive: jest.fn(),
-  unblockUser: jest.fn(),
-  unmuteChannel: jest.fn(),
-  unmuteUser: jest.fn(),
-  unpin: jest.fn(),
-});
-
-const createChannelMock = (params?: {
-  blockedUserIds?: string[];
-  createdById?: string;
-  ownUserId?: string;
-}): Channel => {
-  const {
-    blockedUserIds = [],
-    createdById = 'current-user-id',
-    ownUserId = 'current-user-id',
-  } = params ?? {};
-  return {
-    data: {
-      created_by: {
-        id: createdById,
-      },
-    },
-    getClient: () => ({
-      blockedUsers: {
-        getLatestValue: () => ({ userIds: blockedUserIds }),
-      },
-      userID: ownUserId,
-    }),
-    state: {
-      members: {
-        own: { user: { id: ownUserId } },
-        other: { user: { id: 'other-user-id' } },
-      },
-    },
-  } as unknown as Channel;
-};
-
-describe('useChannelActionItems', () => {
-  const channel = createChannelMock();
-
-  const channelActions = createChannelActions();
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest
-      .spyOn(TranslationContext, 'useTranslationContext')
-      .mockImplementation(
-        () => ({ t: (value: string) => value }) as unknown as TranslationContextValue,
-      );
-    jest.spyOn(useChannelMembershipStateModule, 'useChannelMembershipState').mockReturnValue({
-      archived_at: undefined,
-      pinned_at: undefined,
-    } as never);
-    jest.spyOn(useChannelMuteActiveModule, 'useChannelMuteActive').mockReturnValue(false);
-    jest.spyOn(useIsDirectChatModule, 'useIsDirectChat').mockReturnValue(false);
-    jest.spyOn(useChannelActionsModule, 'useChannelActions').mockReturnValue(channelActions);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('returns default channel action items', () => {
-    const { result } = renderHook(() => useChannelActionItems({ channel }));
-
-    expect(result.current).toHaveLength(3);
-    expect(result.current.map((item) => item.action)).toEqual([
-      channelActions.muteChannel,
-      channelActions.leave,
-      expect.any(Function),
-    ]);
-    expect(result.current.map((item) => item.id)).toEqual(['mute', 'leave', 'deleteChannel']);
-    expect(result.current.map((item) => item.type)).toEqual([
-      'standard',
-      'destructive',
-      'destructive',
-    ]);
-    expect(result.current.map((item) => item.placement)).toEqual(['swipe', 'sheet', 'sheet']);
-  });
-
-  it('uses custom getChannelActionItems with context and defaultItems when provided', () => {
-    const customGetChannelActionItems = jest.fn(
-      ({ defaultItems }: Parameters<GetChannelActionItems>[0]) => defaultItems.slice(0, 1),
-    );
-
-    const { result } = renderHook(() =>
-      useChannelActionItems({
-        channel,
-        getChannelActionItems: customGetChannelActionItems,
-      }),
-    );
-
-    expect(customGetChannelActionItems).toHaveBeenCalledWith({
-      context: {
-        actions: channelActions,
-        channel,
-        isArchived: false,
-        isDirectChat: false,
-        isPinned: false,
-        muteActive: false,
-        t: expect.any(Function),
-      },
-      defaultItems: expect.any(Array),
-    });
-    expect(result.current).toHaveLength(1);
-    expect(result.current[0].action).toBe(channelActions.muteChannel);
-    expect(result.current[0].id).toBe('mute');
-    expect(result.current[0].type).toBe('standard');
-  });
-});
-
-describe('getChannelActionItems', () => {
-  const channel = createChannelMock();
-
-  it('creates action items in default order', () => {
-    const channelActions = createChannelActions();
-
-    const defaultItems = buildDefaultChannelActionItems({
-      actions: channelActions,
-      channel,
-      isArchived: false,
-      isDirectChat: false,
-      isPinned: false,
-      muteActive: false,
-      t: ((value: string) => value) as TranslationContextValue['t'],
-    });
-    const actionItems = getChannelActionItems({
-      context: {
-        actions: channelActions,
-        channel,
-        isArchived: false,
-        isDirectChat: false,
-        isPinned: false,
-        muteActive: false,
-        t: ((value: string) => value) as TranslationContextValue['t'],
-      },
-      defaultItems,
-    });
-
-    expect(actionItems.map((item) => item.action)).toEqual([
-      channelActions.muteChannel,
-      channelActions.leave,
-      expect.any(Function),
-    ]);
-    expect(actionItems.map((item) => item.id)).toEqual(['mute', 'leave', 'deleteChannel']);
-    expect(actionItems.map((item) => item.type)).toEqual([
-      'standard',
-      'destructive',
-      'destructive',
-    ]);
-  });
-
-  it('returns direct-chat variants for mute and block states', () => {
-    const channelActions = createChannelActions();
-    const actionItems = buildDefaultChannelActionItems({
-      actions: channelActions,
-      channel: createChannelMock({ blockedUserIds: ['other-user-id'] }),
-      isArchived: true,
-      isDirectChat: true,
-      isPinned: false,
-      muteActive: true,
-      t: ((value: string) => value) as TranslationContextValue['t'],
-    });
-
-    expect(actionItems.map((item) => item.id)).toEqual(['mute', 'block', 'leave', 'deleteChannel']);
-    expect(actionItems.map((item) => item.action)).toEqual([
-      channelActions.unmuteUser,
-      channelActions.unblockUser,
-      channelActions.leave,
-      expect.any(Function),
-    ]);
-    expect(actionItems.map((item) => item.label)).toEqual([
-      'Unmute User',
-      'Unblock User',
-      'Leave Chat',
-      'Delete Chat',
-    ]);
-    expect(actionItems.map((item) => item.placement)).toEqual(['sheet', 'sheet', 'sheet', 'sheet']);
-  });
-
-  it('omits delete action when current user is not the channel creator', () => {
-    const actionItems = buildDefaultChannelActionItems({
-      actions: createChannelActions(),
-      channel: createChannelMock({ createdById: 'someone-else' }),
-      isArchived: false,
-      isDirectChat: false,
-      isPinned: false,
-      muteActive: false,
-      t: ((value: string) => value) as TranslationContextValue['t'],
-    });
-
-    expect(actionItems.map((item) => item.id)).toEqual(['mute', 'leave']);
-  });
-
-  it('uses group mute variants for labels and placements', () => {
-    const channelActions = createChannelActions();
-    const actionItems = buildDefaultChannelActionItems({
-      actions: channelActions,
-      channel,
-      isArchived: true,
-      isDirectChat: false,
-      isPinned: false,
-      muteActive: true,
-      t: ((value: string) => value) as TranslationContextValue['t'],
-    });
-
-    expect(actionItems[0].action).toBe(channelActions.unmuteChannel);
-    expect(actionItems[0].label).toBe('Unmute Group');
-    expect(actionItems[0].placement).toBe('swipe');
-
-    expect(actionItems[1].action).toBe(channelActions.leave);
-    expect(actionItems[1].label).toBe('Leave Group');
-    expect(actionItems[1].placement).toBe('sheet');
-  });
-
-  it('shows delete confirmation and calls deleteChannel on destructive confirm', async () => {
-    const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(jest.fn());
-    const channelActions = createChannelActions();
-
-    const actionItems = buildDefaultChannelActionItems({
-      actions: channelActions,
-      channel,
-      isArchived: false,
-      isDirectChat: false,
-      isPinned: false,
-      muteActive: false,
-      t: ((value: string) => value) as TranslationContextValue['t'],
-    });
-
-    const deleteItem = actionItems.find((item) => item.id === 'deleteChannel');
-    expect(deleteItem).toBeDefined();
-    deleteItem?.action();
-
-    expect(alertSpy).toHaveBeenCalledWith(
-      'Delete group',
-      "Are you sure you want to delete this group? This can't be undone.",
-      expect.any(Array),
-    );
-
-    const buttons = (alertSpy.mock.calls[0]?.[2] ?? []) as AlertButton[];
-    const destructiveButton = buttons.find((button) => button.style === 'destructive');
-
-    expect(destructiveButton?.text).toBe('Delete');
-    await destructiveButton?.onPress?.();
-    expect(channelActions.deleteChannel).toHaveBeenCalledTimes(1);
-
-    alertSpy.mockRestore();
-  });
-});

package/src/components/ChannelList/hooks/__tests__/useChannelActions.test.tsx

@@ -1,123 +0,0 @@
-import React, { PropsWithChildren } from 'react';
-
-import { act, renderHook } from '@testing-library/react-native';
-import type { Channel } from 'stream-chat';
-
-import { ChatProvider } from '../../../../contexts/chatContext/ChatContext';
-import { useChannelActions } from '../useChannelActions';
-
-const createWrapper =
-  (client: unknown) =>
-  ({ children }: PropsWithChildren) => (
-    <ChatProvider value={{ client } as never}>{children}</ChatProvider>
-  );
-
-const createClient = () => ({
-  blockUser: jest.fn(),
-  notifications: {
-    add: jest.fn(),
-    remove: jest.fn(),
-    startTimeout: jest.fn(),
-  },
-  muteUser: jest.fn(),
-  unBlockUser: jest.fn(),
-  unmuteUser: jest.fn(),
-  userID: 'current-user-id',
-});
-
-const createChannel = (client: ReturnType<typeof createClient>) =>
-  ({
-    archive: jest.fn(),
-    getClient: () => client,
-    mute: jest.fn(),
-    pin: jest.fn(),
-    removeMembers: jest.fn(),
-    state: {
-      members: {
-        current: { user: { id: 'current-user-id' } },
-        other: { user: { id: 'other-user-id', name: 'Other User' } },
-      },
-    },
-    unarchive: jest.fn(),
-    unmute: jest.fn(),
-    unpin: jest.fn(),
-  }) as unknown as Channel;
-
-describe('useChannelActions', () => {
-  it('notifies when channel mute succeeds', async () => {
-    const client = createClient();
-    const channel = createChannel(client);
-    const { result } = renderHook(() => useChannelActions(channel), {
-      wrapper: createWrapper(client),
-    });
-
-    await act(async () => {
-      await result.current.muteChannel();
-    });
-
-    expect(channel.mute).toHaveBeenCalledTimes(1);
-    expect(client.notifications.add).toHaveBeenCalledWith({
-      message: 'Channel muted',
-      options: {
-        severity: 'success',
-        type: 'api:channel:mute:success',
-      },
-      origin: {
-        context: { channel },
-        emitter: 'ChannelActions',
-      },
-    });
-  });
-
-  it('notifies when channel mute fails', async () => {
-    const error = new Error('mute failed');
-    const client = createClient();
-    const channel = createChannel(client);
-    jest.mocked(channel.mute).mockRejectedValue(error);
-    const { result } = renderHook(() => useChannelActions(channel), {
-      wrapper: createWrapper(client),
-    });
-
-    await act(async () => {
-      await result.current.muteChannel();
-    });
-
-    expect(client.notifications.add).toHaveBeenCalledWith({
-      message: 'Failed to update channel mute status',
-      options: {
-        originalError: error,
-        severity: 'error',
-        type: 'api:channel:mute:failed',
-      },
-      origin: {
-        context: { channel },
-        emitter: 'ChannelActions',
-      },
-    });
-  });
-
-  it('notifies when a direct channel user is blocked', async () => {
-    const client = createClient();
-    const channel = createChannel(client);
-    const { result } = renderHook(() => useChannelActions(channel), {
-      wrapper: createWrapper(client),
-    });
-
-    await act(async () => {
-      await result.current.blockUser();
-    });
-
-    expect(client.blockUser).toHaveBeenCalledWith('other-user-id');
-    expect(client.notifications.add).toHaveBeenCalledWith({
-      message: 'User blocked',
-      options: {
-        severity: 'success',
-        type: 'api:user:block:success',
-      },
-      origin: {
-        context: { channel },
-        emitter: 'ChannelActions',
-      },
-    });
-  });
-});

package/src/components/ChannelList/hooks/useChannelActionItems.tsx

@@ -1,221 +0,0 @@
-import React, { useMemo } from 'react';
-import { Alert } from 'react-native';
-
-import type { Channel } from 'stream-chat';
-
-import { ChannelActions, getOtherUserInDirectChannel } from './useChannelActions';
-import { useChannelActions } from './useChannelActions';
-import { useChannelMembershipState } from './useChannelMembershipState';
-
-import { useChannelMuteActive } from './useChannelMuteActive';
-import { useIsDirectChat } from './useIsDirectChat';
-
-import { useTheme, useTranslationContext } from '../../../contexts';
-import type { TranslationContextValue } from '../../../contexts/translationContext/TranslationContext';
-import { IconProps, Mute, BlockUser, Delete, Sound } from '../../../icons';
-import { ArrowBoxLeft } from '../../../icons/leave';
-
-export type ChannelActionHandler = () => Promise<void> | void;
-
-export type ChannelActionItem = {
-  action: ChannelActionHandler;
-  Icon: React.ComponentType<IconProps>;
-  id: 'mute' | 'block' | 'archive' | 'leave' | 'deleteChannel' | string;
-  label: string;
-  placement: 'both' | 'sheet' | 'swipe';
-  type: 'destructive' | 'standard';
-};
-
-export type ChannelActionItemsParams = {
-  actions: ChannelActions;
-  channel: Channel;
-  isArchived: boolean;
-  isDirectChat: boolean;
-  isPinned: boolean;
-  muteActive: boolean;
-  t: TranslationContextValue['t'];
-};
-
-export type BuildDefaultChannelActionItems = (
-  channelActionItemsParams: ChannelActionItemsParams,
-) => ChannelActionItem[];
-
-const ChannelActionsIcon = ({
-  Icon,
-  ...rest
-}: { Icon: React.ComponentType<IconProps> } & IconProps) => {
-  const {
-    theme: { semantics },
-  } = useTheme();
-
-  return <Icon stroke={semantics.textSecondary} width={20} height={20} {...rest} />;
-};
-
-export const buildDefaultChannelActionItems: BuildDefaultChannelActionItems = (
-  channelActionItemsParams,
-) => {
-  const {
-    actions: {
-      deleteChannel,
-      leave,
-      muteChannel,
-      unmuteChannel,
-      muteUser,
-      unmuteUser,
-      blockUser,
-      unblockUser,
-    },
-    isDirectChat,
-    muteActive,
-    t,
-    channel,
-  } = channelActionItemsParams;
-  const ownUserId = channel.getClient().userID;
-
-  const client = channel.getClient();
-
-  const isBlocked = isDirectChat
-    ? new Set(client.blockedUsers.getLatestValue().userIds).has(
-        getOtherUserInDirectChannel(channel)?.user?.id ?? '',
-      )
-    : undefined;
-
-  const actionItems: ChannelActionItem[] = [
-    {
-      action: isDirectChat
-        ? muteActive
-          ? unmuteUser
-          : muteUser
-        : muteActive
-          ? unmuteChannel
-          : muteChannel,
-      Icon: (props) =>
-        muteActive ? (
-          <Sound width={20} height={20} {...props} />
-        ) : (
-          <Mute
-            width={20}
-            height={20}
-            {...props}
-            stroke={undefined}
-            fill={props.fill ?? props.stroke}
-          />
-        ),
-      id: 'mute',
-      label: isDirectChat
-        ? muteActive
-          ? t('Unmute User')
-          : t('Mute User')
-        : muteActive
-          ? t('Unmute Group')
-          : t('Mute Group'),
-      placement: isDirectChat ? 'sheet' : 'swipe',
-      type: 'standard',
-    },
-  ];
-
-  if (isDirectChat) {
-    actionItems.push({
-      action: isBlocked ? unblockUser : blockUser,
-      Icon: (props) => <ChannelActionsIcon Icon={BlockUser} {...props} />,
-      id: 'block',
-      label: isBlocked ? t('Unblock User') : t('Block User'),
-      placement: 'sheet',
-      type: 'standard',
-    });
-  }
-
-  actionItems.push({
-    action: leave,
-    Icon: (props) => <ChannelActionsIcon Icon={ArrowBoxLeft} {...props} />,
-    id: 'leave',
-    label: isDirectChat ? t('Leave Chat') : t('Leave Group'),
-    placement: 'sheet',
-    type: 'destructive',
-  });
-
-  if (channel.data?.created_by?.id === ownUserId) {
-    actionItems.push({
-      action: () => {
-        const title = isDirectChat ? t('Delete chat') : t('Delete group');
-        const message = isDirectChat
-          ? t("Are you sure you want to delete this chat? This can't be undone.")
-          : t("Are you sure you want to delete this group? This can't be undone.");
-
-        Alert.alert(title, message, [
-          {
-            style: 'cancel',
-            text: t('Cancel'),
-          },
-          {
-            onPress: async () => {
-              await deleteChannel();
-            },
-            style: 'destructive',
-            text: t('Delete'),
-          },
-        ]);
-      },
-      Icon: (props) => <ChannelActionsIcon Icon={Delete} {...props} />,
-      id: 'deleteChannel',
-      label: isDirectChat ? t('Delete Chat') : t('Delete Group'),
-      placement: 'sheet',
-      type: 'destructive',
-    });
-  }
-
-  return actionItems;
-};
-
-export type GetChannelActionItems = (params: {
-  context: ChannelActionItemsParams;
-  defaultItems: ChannelActionItem[];
-}) => ChannelActionItem[];
-
-export const getChannelActionItems: GetChannelActionItems = ({ defaultItems }) => defaultItems;
-
-type UseChannelActionItemsParams = {
-  channel: Channel;
-  getChannelActionItems?: GetChannelActionItems;
-};
-
-export const useChannelActionItems = ({
-  channel,
-  getChannelActionItems: getChannelActionItemsProp = getChannelActionItems,
-}: UseChannelActionItemsParams) => {
-  const { t } = useTranslationContext();
-  const membership = useChannelMembershipState(channel);
-  const channelActions = useChannelActions(channel);
-  const isDirectChat = useIsDirectChat(channel);
-  const isPinned = Boolean(membership?.pinned_at);
-  const isArchived = Boolean(membership?.archived_at);
-
-  const muteActive = useChannelMuteActive(channel);
-
-  const channelActionItemsParams = useMemo(
-    () => ({
-      actions: channelActions,
-      channel,
-      isArchived,
-      isDirectChat,
-      isPinned,
-      muteActive,
-      t,
-    }),
-    [channel, muteActive, channelActions, isArchived, isDirectChat, isPinned, t],
-  );
-
-  const defaultItems = useMemo(
-    () => buildDefaultChannelActionItems(channelActionItemsParams),
-    [channelActionItemsParams],
-  );
-
-  return useMemo(
-    () =>
-      getChannelActionItemsProp({
-        context: channelActionItemsParams,
-        defaultItems,
-      }),
-    [channelActionItemsParams, defaultItems, getChannelActionItemsProp],
-  );
-};

package/src/components/ChannelList/hooks/useChannelMuteActive.ts

@@ -1,18 +0,0 @@
-import { Channel } from 'stream-chat';
-
-import { getOtherUserInDirectChannel } from './useChannelActions';
-import { useIsDirectChat } from './useIsDirectChat';
-import { useMutedChannels } from './useMutedChannels';
-import { useMutedUsers } from './useMutedUsers';
-
-export const useChannelMuteActive = (channel: Channel) => {
-  const isDirectChat = useIsDirectChat(channel);
-  const mutedChannels = useMutedChannels(channel);
-  const mutedUsers = useMutedUsers(channel);
-
-  return isDirectChat
-    ? !!mutedUsers.find(
-        (mutedUser) => getOtherUserInDirectChannel(channel)?.user?.id === mutedUser.target.id,
-      )
-    : !!mutedChannels.find((mutedChannel) => channel.cid === mutedChannel.channel?.cid);
-};