@webinex/chatify 2.0.0-build2 → 2.0.0-build202511241945

package/src/core/api/chatMessageApi.ts

@@ -1,156 +0,0 @@
-import { unsubscribe } from '../client';
-import { Debounce, DebounceValue } from '../debounce';
-import { ChatMessage, chatId } from '../types';
-import { DEFAULT_MESSAGE_LIST_TAKE, __baseApi, __settings } from './baseApi';
-
-export interface ChatMessageListResult {
-  messages: ChatMessage[];
-  hasMore: boolean;
-}
-
-const CHAT_MESSAGE_READ_QUEUE = new Debounce<string>({
-  callback: (id) => __settings.client.readChatMessage({ id }),
-  compare: (a, b) => -a.localeCompare(b),
-  groupBy: (id) => chatId(id),
-  timeout: 500,
-});
-
-export const __chatMessageApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({
-    getChatMessageList: builder.query<ChatMessageListResult, { chatId: string }>({
-      queryFn: async ({ chatId }) => {
-        const messages = await __settings.client.chatMessages({
-          chatId,
-          skip: 0,
-          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
-        });
-        return {
-          data: {
-            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
-            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
-          },
-        };
-      },
-      providesTags: ['message', 'chat', 'account'],
-      onCacheEntryAdded: async ({ chatId }, { dispatch, cacheEntryRemoved, cacheDataLoaded }) => {
-        await cacheDataLoaded;
-
-        unsubscribe(
-          __settings.client.subscribe('chatify://chat-new-message', ([message]) => {
-            message.chatId === chatId &&
-              dispatch(
-                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
-                  draft.messages.unshift(message);
-                }),
-              );
-          }),
-
-          __settings.client.subscribe('chatify://chat-member-added', ([eventChatId, , , message]) => {
-            eventChatId === chatId &&
-              dispatch(
-                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
-                  draft.messages.unshift(message);
-                }),
-              );
-          }),
-
-          __settings.client.subscribe('chatify://chat-member-removed', ([eventChatId, , , message]) => {
-            eventChatId === chatId &&
-              dispatch(
-                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
-                  draft.messages.unshift(message);
-                }),
-              );
-          }),
-
-          __settings.client.subscribe('chatify://chat-name-changed', ([eventChatId, , message]) => {
-            eventChatId === chatId &&
-              dispatch(
-                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
-                  draft.messages.unshift(message);
-                }),
-              );
-          }),
-        ).when(cacheEntryRemoved);
-      },
-    }),
-
-    fetchNextChatMessageList: builder.mutation<void, { chatId: string }>({
-      queryFn: async ({ chatId }, { getState }) => {
-        const current = __chatMessageApi.endpoints.getChatMessageList.select({ chatId })(getState() as any);
-        const messages = await __settings.client.chatMessages({
-          chatId,
-          skip: current.data!.messages.length,
-          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
-        });
-        return {
-          data: null!,
-          meta: {
-            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
-            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
-          },
-        };
-      },
-      onQueryStarted: async ({ chatId }, { dispatch, queryFulfilled }) => {
-        const result = await queryFulfilled;
-        const meta: ChatMessageListResult = result.meta! as any;
-
-        dispatch(
-          __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
-            draft.hasMore = meta.hasMore;
-            draft.messages.push(...meta!.messages);
-          }),
-        );
-      },
-    }),
-
-    sendChatMessage: builder.mutation<void, { chatId: string; text: string }>({
-      queryFn: async ({ chatId, text }) => {
-        const requestId = new Date().getTime().toString();
-
-        await __settings.client.sendChatMessage({
-          chatId,
-          text,
-          files: [],
-          requestId,
-        });
-
-        return { data: null!, meta: { requestId } };
-      },
-    }),
-
-    readChatMessage: builder.mutation<void, { id: string }>({
-      queryFn: async () => {
-        return { data: null! };
-      },
-      onQueryStarted: async ({ id }, { dispatch }) => {
-        CHAT_MESSAGE_READ_QUEUE.push(id);
-        dispatch(
-          __chatMessageApi.endpoints.getChatMessageReadQueue.initiate(undefined, { forceRefetch: true }),
-        );
-      },
-    }),
-
-    getChatMessageReadQueue: builder.query<DebounceValue<string>[], void>({
-      queryFn: async () => ({ data: CHAT_MESSAGE_READ_QUEUE.units }),
-      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved }) => {
-        unsubscribe(
-          CHAT_MESSAGE_READ_QUEUE.subscribe((value) => {
-            dispatch(
-              __chatMessageApi.util.updateQueryData('getChatMessageReadQueue', undefined, () => value.units),
-            );
-          }),
-        ).when(cacheEntryRemoved);
-      },
-    }),
-  }),
-});
-
-export const {
-  useFetchNextChatMessageListMutation,
-  useGetChatMessageListQuery,
-  useReadChatMessageMutation,
-  useSendChatMessageMutation,
-  useGetChatMessageReadQueueQuery,
-  useLazyGetChatMessageListQuery,
-} = __chatMessageApi;

package/src/core/api/threadApi.ts

@@ -1,132 +0,0 @@
-import { Thread, ThreadWatchListItem, calcThreadListUnreadCount } from '../types';
-import { __baseApi, __settings } from './baseApi';
-import { unsubscribe } from '../client';
-import { useMemo } from 'react';
-
-export const __threadApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({
-    getWatchThreadList: builder.query<ThreadWatchListItem[], void>({
-      queryFn: async () => {
-        const threads = await __settings.client.watchThreads();
-        return { data: threads };
-      },
-      providesTags: ['account', 'thread'],
-      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
-        await cacheDataLoaded;
-
-        unsubscribe(
-          __settings.client.subscribe(
-            'chatify://thread-created',
-            ([thread, watch]) =>
-              watch &&
-              updateCachedData((threads) => {
-                threads.push(thread);
-              }),
-          ),
-          __settings.client.subscribe('chatify://thread-message-new', ([threadId, message, readForId]) =>
-            updateCachedData((threads) => {
-              const thread = threads.find((x) => x.id === threadId);
-              if (!thread) return;
-
-              thread.lastMessage = message;
-
-              if (readForId === __settings.me()) {
-                thread.lastReadMessageId = message.id;
-              }
-            }),
-          ),
-          __settings.client.subscribe('chatify://thread-message-read', ([threadId, messageId]) =>
-            updateCachedData((threads) => {
-              const thread = threads.find((x) => x.id === threadId);
-              if (!thread) return;
-
-              thread.lastReadMessageId = messageId;
-            }),
-          ),
-          __settings.client.subscribe('chatify://thread-watch-added', ([thread]) =>
-            updateCachedData((threads) => {
-              threads.push(thread);
-            }),
-          ),
-          __settings.client.subscribe('chatify://thread-watch-removed', ([id]) =>
-            updateCachedData((threads) => {
-              const index = threads.findIndex((x) => x.id === id);
-              if (index !== -1) threads.splice(index, 1);
-            }),
-          ),
-        ).when(cacheEntryRemoved);
-      },
-    }),
-
-    getThread: builder.query<Thread, { id: string }>({
-      queryFn: async ({ id }) => {
-        const threads = await __settings.client.thread(id);
-        return { data: threads };
-      },
-      providesTags: ['account', 'thread'],
-      onCacheEntryAdded: async ({ id }, { cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
-        await cacheDataLoaded;
-
-        unsubscribe(
-          __settings.client.subscribe(
-            'chatify://thread-message-read',
-            ([threadId, messageId]) =>
-              id === threadId &&
-              updateCachedData((t) => {
-                t.lastReadMessageId = messageId;
-              }),
-          ),
-          __settings.client.subscribe(
-            'chatify://thread-message-new',
-            ([threadId, message, readForId]) =>
-              id === threadId &&
-              updateCachedData((thread) => {
-                thread.lastMessageId = message.id;
-                thread.lastReadMessageId =
-                  readForId === __settings.me() ? message.id : thread.lastReadMessageId;
-              }),
-          ),
-          __settings.client.subscribe(
-            'chatify://thread-watch-added',
-            ([threadListItem]) =>
-              id === threadListItem.id &&
-              updateCachedData((thread) => {
-                thread.watch = true;
-                thread.lastMessageId = threadListItem.lastMessage?.id ?? null;
-                thread.lastReadMessageId = threadListItem.lastReadMessageId ?? null;
-              }),
-          ),
-          __settings.client.subscribe(
-            'chatify://thread-watch-removed',
-            ([threadId]) =>
-              id === threadId &&
-              updateCachedData((thread) => {
-                thread.watch = false;
-              }),
-          ),
-        ).when(cacheEntryRemoved);
-      },
-    }),
-
-    watchThread: builder.mutation<void, { id: string; watch: boolean }>({
-      queryFn: async ({ id, watch }) => {
-        await __settings.client.watchThread(id, watch);
-        return { data: null! };
-      },
-    }),
-  }),
-});
-
-export function useUnreadThreadMessageCount() {
-  const { data: threads, ...state } = useGetWatchThreadListQuery();
-  const count = useMemo(() => (threads != null ? calcThreadListUnreadCount(threads) : null), [threads]);
-  return [count, state] as const;
-}
-
-export const {
-  useGetWatchThreadListQuery,
-  useGetThreadQuery,
-  useLazyGetThreadQuery,
-  useLazyGetWatchThreadListQuery,
-  useWatchThreadMutation,
-} = __threadApi;

package/src/core/api/threadMessageApi.ts

@@ -1,127 +0,0 @@
-import { DEFAULT_MESSAGE_LIST_TAKE, __baseApi, __settings } from './baseApi';
-import { SendThreadMessageRequest, ThreadMessage, parseThreadMessageId } from '../types';
-import { unsubscribe } from '../client';
-import { Debounce, DebounceValue } from '../debounce';
-
-export interface ThreadMessageList {
-  messages: ThreadMessage[];
-  hasMore: boolean;
-}
-
-const THREAD_MESSAGE_READ_QUEUE = new Debounce<string>({
-  callback: (id) => __settings.client.readThreadMessage(id),
-  compare: (a, b) => -a.localeCompare(b),
-  groupBy: (id) => parseThreadMessageId(id)[0],
-  timeout: 500,
-});
-
-export const __threadMessageApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({
-    getThreadMessageList: builder.query<ThreadMessageList, { threadId: string }>({
-      queryFn: async (args) => {
-        const requestArgs = {
-          skip: 0,
-          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
-          ...args,
-        };
-        const messages = await __settings.client.threadMessages(requestArgs);
-        return {
-          data: {
-            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
-            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
-          },
-        };
-      },
-      providesTags: ['account', 'thread', 'thread-message'],
-      onCacheEntryAdded: async ({ threadId }, { cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
-        await cacheDataLoaded;
-
-        unsubscribe(
-          __settings.client.subscribe('chatify://thread-message-new', ([_threadId, message]) => {
-            threadId === _threadId &&
-              updateCachedData((messageList) => {
-                !messageList.messages.some((x) => x.id === message.id) &&
-                  messageList.messages.unshift(message);
-              });
-          }),
-        ).when(cacheEntryRemoved);
-      },
-    }),
-
-    fetchNextThreadMessageList: builder.mutation<void, { threadId: string }>({
-      queryFn: async ({ threadId }, { getState }) => {
-        const current = __threadMessageApi.endpoints.getThreadMessageList.select({ threadId })(
-          getState() as any,
-        );
-        const messages = await __settings.client.threadMessages({
-          threadId,
-          skip: current.data!.messages.length,
-          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
-        });
-        return {
-          data: null!,
-          meta: {
-            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
-            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
-          },
-        };
-      },
-      onQueryStarted: async ({ threadId }, { dispatch, queryFulfilled }) => {
-        const result = await queryFulfilled;
-        const meta: ThreadMessageList = result.meta! as any;
-
-        dispatch(
-          __threadMessageApi.util.updateQueryData('getThreadMessageList', { threadId }, (draft) => {
-            draft.hasMore = meta.hasMore;
-            draft.messages.push(...meta!.messages);
-          }),
-        );
-      },
-    }),
-
-    sendThreadMessage: builder.mutation<string, SendThreadMessageRequest>({
-      queryFn: async (args) => {
-        const id = await __settings.client.sendThreadMessage(args);
-        return { data: id };
-      },
-    }),
-
-    readThreadMessage: builder.mutation<void, { id: string }>({
-      queryFn: async () => {
-        return { data: null! };
-      },
-      onQueryStarted: async ({ id }, { dispatch }) => {
-        THREAD_MESSAGE_READ_QUEUE.push(id);
-        dispatch(
-          __threadMessageApi.endpoints.getThreadMessageReadQueue.initiate(undefined, { forceRefetch: true }),
-        );
-      },
-    }),
-
-    getThreadMessageReadQueue: builder.query<DebounceValue<string>[], void>({
-      queryFn: async () => ({ data: THREAD_MESSAGE_READ_QUEUE.units }),
-      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved }) => {
-        unsubscribe(
-          THREAD_MESSAGE_READ_QUEUE.subscribe((value) => {
-            dispatch(
-              __threadMessageApi.util.updateQueryData(
-                'getThreadMessageReadQueue',
-                undefined,
-                () => value.units,
-              ),
-            );
-          }),
-        ).when(cacheEntryRemoved);
-      },
-    }),
-  }),
-});
-
-export const {
-  useFetchNextThreadMessageListMutation,
-  useGetThreadMessageListQuery,
-  useLazyGetThreadMessageListQuery,
-  useReadThreadMessageMutation,
-  useSendThreadMessageMutation,
-  useGetThreadMessageReadQueueQuery,
-} = __threadMessageApi;

package/src/ui/ChatGroup/List/ChatList.tsx

@@ -1,42 +0,0 @@
-import { Menu, MenuProps } from 'antd';
-import { useCallback, useMemo } from 'react';
-import type { MenuItemType } from 'antd/es/menu/hooks/useItems';
-import { useGetChatListQuery } from '../../../core';
-import { ChatListItemBox } from './ChatListItemBox';
-import { customize } from '../../customize';
-import { useChatGroupContext } from '../ChatGroupContext';
-
-function useOnSelect() {
-  const { openChat } = useChatGroupContext();
-
-  return useCallback(
-    (info: Parameters<NonNullable<MenuProps['onSelect']>>[0]) => openChat(info.key as string),
-    [openChat],
-  );
-}
-
-function useMenuItems() {
-  const { data: chats } = useGetChatListQuery();
-
-  return useMemo<MenuItemType[] | undefined>(() => {
-    return chats
-      ?.slice()
-      .sort((a, b) => -a.message.id.substring(47).localeCompare(b.message.id.substring(47)))
-      .map((x) => ({ key: x.id, label: <ChatListItemBox chat={x} /> }));
-  }, [chats]);
-}
-
-export const ChatList = customize('ChatList', () => {
-  const { chatId } = useChatGroupContext();
-  const selected = useMemo(() => (chatId ? [chatId] : []), [chatId]);
-  const onSelect = useOnSelect();
-  const items = useMenuItems();
-
-  return (
-    <>
-      {items && (
-        <Menu className="wxchtf-chat-list" selectedKeys={selected} onSelect={onSelect} items={items} />
-      )}
-    </>
-  );
-});