@amityco/ts-sdk 6.35.3-c7e7d80.0 → 6.35.3-dc46366a.0

package/src/marker/events/onMessageMarked.ts

@@ -1,93 +0,0 @@
-import { get } from 'http';
-import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-import { getResolver } from '~/core/model';
-
-/**
- * ```js
- * import { onMessageMarked } from '@amityco/ts-sdk'
- * const dispose = onMessageMarked(markedMessage => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.Message} has been mark read/delivered
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Marker Events
- */
-export const onMessageMarked = (
-  callback: Amity.Listener<Amity.MessageMarker>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['marker.marked-message']) => {
-    ingestInCache(payload);
-
-    const cacheCollection = queryCache<Amity.MessageLiveCollectionCache>(['message', 'collection']);
-    const { contentMarkers, feedMarkers } = payload;
-
-    if (cacheCollection && cacheCollection?.length > 0 && feedMarkers?.length > 0) {
-      /**
-       * in case of read the message collection,
-       * use feedId of the feedMarkers to check if it equal to subChannelId.
-       */
-      const currentMessageCollection = cacheCollection.filter(currentMessage => {
-        return currentMessage.data?.query?.subChannelId === feedMarkers[0].feedId;
-      });
-
-      if (currentMessageCollection.length > 0 && contentMarkers?.length > 0) {
-        const currentMessages =
-          currentMessageCollection[0].data?.data
-            ?.map(messageId => pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])!)
-            .map(({ data }) => data)
-            .filter(Boolean) ?? [];
-
-        currentMessages.forEach(message => {
-          const cacheKeyMessageMarker = [
-            'messageMarker',
-            'get',
-            getResolver('messageMarker')({
-              creatorId: message.creatorPrivateId,
-              feedId: message.subChannelId,
-              contentId: message.messageId,
-            }),
-          ];
-
-          const messageMarker = pullFromCache<Amity.MessageMarker>(cacheKeyMessageMarker)?.data;
-
-          if (!messageMarker) return;
-
-          const isSameSubChannelId = contentMarkers[0].feedId === messageMarker.feedId;
-          const isReadCountLatest = contentMarkers[0].readCount > messageMarker.readCount!;
-          const isDeliveredCountLatest =
-            contentMarkers[0]?.deliveredCount > messageMarker.deliveredCount!;
-
-          if (isSameSubChannelId) {
-            const newCacheData = {
-              ...messageMarker,
-              readCount: isReadCountLatest ? contentMarkers[0].readCount : messageMarker.readCount!,
-              deliveredCount: isDeliveredCountLatest
-                ? contentMarkers[0].deliveredCount
-                : messageMarker.deliveredCount!,
-            };
-            pushToCache(cacheKeyMessageMarker, newCacheData);
-          }
-        });
-      }
-    }
-
-    callback(payload.contentMarkers[0]);
-  };
-
-  return createEventSubscriber(
-    client,
-    'messageMarker/onMessageMarked',
-    'marker.marked-message',
-    filter,
-  );
-};

package/src/marker/events/onMessageMarkerFetched.ts

@@ -1,34 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * ```js
- * import { onMessageMarkerFetched } from '@amityco/ts-sdk'
- * const dispose = onMessageMarkerFetched(messageMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.MessageMarker} has been fetched
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category MessageMarker Events
- */
-export const onMessageMarkerFetched = (
-  callback: Amity.Listener<Amity.MessageMarker>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.messageMarker.fetched']) => {
-    callback(payload.contentMarkers[0]);
-  };
-
-  return createEventSubscriber(
-    client,
-    'messageMarker/onMessageMarkerFetched',
-    'local.messageMarker.fetched',
-    filter,
-  );
-};

package/src/marker/events/onSubChannelMarkerFetched.ts

@@ -1,34 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * ```js
- * import { onSubChannelMarkerFetched } from '@amityco/ts-sdk'
- * const dispose = onSubChannelMarkerFetched(subChannelMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.SubChannelMarker} has been fetched
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category SubChannelMarker Events
- */
-export const onSubChannelMarkerFetched = (
-  callback: Amity.Listener<Amity.SubChannelMarker>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.subChannelMarker.fetched']) => {
-    payload.userFeedMarkers.forEach(callback);
-  };
-
-  return createEventSubscriber(
-    client,
-    'subChannelMarker/onSubChannelMarkerFetched',
-    'local.subChannelMarker.fetched',
-    filter,
-  );
-};

package/src/marker/events/onSubChannelMarkerUpdated.ts

@@ -1,34 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * ```js
- * import { onSubChannelMarkerUpdated } from '@amityco/ts-sdk'
- * const dispose = onSubChannelMarkerUpdated(subChannelMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.SubChannelMarker} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category SubChannelMarker Events
- */
-export const onSubChannelMarkerUpdated = (
-  callback: Amity.Listener<Amity.SubChannelMarker[]>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.subChannelMarker.updated']) => {
-    callback(payload.userFeedMarkers);
-  };
-
-  return createEventSubscriber(
-    client,
-    'subChannelMarker/onSubChannelMarkerUpdated',
-    'local.subChannelMarker.updated',
-    filter,
-  );
-};

package/src/marker/events/onSubChannelUnreadUpdatedLocal.ts

@@ -1,29 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * Internal used only
- *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category MessageMarker Events
- */
-export const onSubChannelUnreadUpdatedLocal = (
-  callback: Amity.Listener<Amity.Events['local.subChannelUnread.updated']>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.subChannelUnread.updated']) => {
-    callback(payload);
-  };
-
-  return createEventSubscriber(
-    client,
-    'subChannelMarker/onSubChannelUnreadUpdatedLocal',
-    'local.subChannelUnread.updated',
-    filter,
-  );
-};

package/src/marker/events/onUserFeedMarkerFetched.ts

@@ -1,37 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-import { persistUnreadCountInfo } from '../utils/persistUnreadCountInfo';
-
-/**
- * ```js
- * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
- * const dispose = onFeedMarkerUpdated(feedMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.UserMessageFeedMarkerPayload} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category FeedMarker Events
- */
-export const onUserFeedMarkerFetched = (
-  callback: Amity.Listener<Amity.UserMessageFeedMarkerPayload>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.userMessageFeedMarker.fetched']) => {
-    // update sub channel unread info and channel unread info in cache
-    persistUnreadCountInfo(payload.userMessageFeedMarker);
-    callback(payload.userMessageFeedMarker);
-  };
-
-  return createEventSubscriber(
-    client,
-    'feedMarker/onUserFeedMarkerFetched',
-    'local.userMessageFeedMarker.fetched',
-    filter,
-  );
-};

package/src/marker/events/onUserFeedMarkerUpdated.ts

@@ -1,39 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-import { persistUnreadCountInfo } from '../utils/persistUnreadCountInfo';
-
-/**
- * ```js
- * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
- * const dispose = onFeedMarkerUpdated(feedMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.UserFeedMarker} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category FeedMarker Events
- */
-export const onUserFeedMarkerUpdated = (
-  callback: Amity.Listener<Amity.FeedMarker>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['marker.userFeed-updated']) => {
-    persistUnreadCountInfo(payload);
-
-    payload.feedMarkers.forEach(feedMarker => {
-      callback(feedMarker);
-    });
-  };
-
-  return createEventSubscriber(
-    client,
-    'feedMarker/onUserFeedMarkerUpdated',
-    'marker.userFeed-updated',
-    filter,
-  );
-};

package/src/marker/events/onUserMarkerFetched.ts

@@ -1,51 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * ```js
- * import { onUserMarkerFetched } from '@amityco/ts-sdk'
- * const dispose = onUserMarkerFetched(userMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.UserMarker} has been fetched
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category UserMarker Events
- */
-export const onUserMarkerFetched = (
-  callback: Amity.Listener<Amity.UserMarker[]>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.userMarker.fetched']) => {
-    callback(payload.userMarkers);
-  };
-
-  return createEventSubscriber(
-    client,
-    'userMarker/onUserMarkerFetched',
-    'local.userMarker.fetched',
-    filter,
-  );
-};
-
-export const onUserMarkerFetchedLegacy = (
-  callback: Amity.Listener<Amity.UserMarker>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.userMarker.fetched']) => {
-    callback(payload.userMarkers[0]);
-  };
-
-  return createEventSubscriber(
-    client,
-    'userMarker/onUserMarkerFetched',
-    'local.userMarker.fetched',
-    filter,
-  );
-};

package/src/marker/events/onUserMarkerSync.ts

@@ -1,42 +0,0 @@
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
-
-/**
- * ```js
- * import { onUserMarkerSync } from '@amityco/ts-sdk'
- * const dispose = onUserMarkerSync(UserMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.UserMarker} has been sync
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category UserMarker Events
- */
-export const onUserMarkerSync = (
-  callback: Amity.Listener<Amity.UserMarker>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['marker.user-sync']) => {
-    const {
-      userMarkers,
-      userEntityMarkers: userEntityMarkersPayload,
-      userFeedMarkers: userFeedMarkersPayload,
-      ...rest
-    } = payload;
-
-    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
-    const userFeedMarker = convertSubChannelMarkerResponse(userFeedMarkersPayload);
-
-    ingestInCache({ userMarkers, userEntityMarkers, userFeedMarker, ...rest });
-    callback(userMarkers[0]);
-  };
-
-  return createEventSubscriber(client, 'UserMarker/onUserMarkerSync', 'marker.user-sync', filter);
-};

package/src/marker/events/onUserMessageFeedMarkerResolved.ts

@@ -1,29 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * Internal used only
- *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category MessageMarker Events
- */
-export const onUserMessageFeedMarkerResolved = (
-  callback: Amity.Listener<Amity.Events['local.userMessageFeedMarkers.resolved']>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.userMessageFeedMarkers.resolved']) => {
-    callback(payload);
-  };
-
-  return createEventSubscriber(
-    client,
-    'userMessageFeedMarker/onUserMessageFeedMarkerResolved',
-    'local.userMessageFeedMarkers.resolved',
-    filter,
-  );
-};

package/src/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId.ts

@@ -1,19 +0,0 @@
-import { pushToCache, queryCache } from '~/cache/api';
-
-export const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId: string) => {
-  const cacheKey = ['subChannelUnreadInfo', 'get'];
-  const cachedSubChannelUnread = queryCache<Amity.SubChannelUnreadInfo>(cacheKey);
-
-  if (cachedSubChannelUnread) {
-    const cachedTargetSubChannelUnread = cachedSubChannelUnread?.filter(
-      ({ data }) => data.channelId === channelId,
-    );
-
-    cachedTargetSubChannelUnread.forEach(({ key, data }) => {
-      pushToCache(key, {
-        ...data,
-        isDeleted: true,
-      });
-    });
-  }
-};

package/src/marker/utils/addFlagIsDeletedSubChannelUnreadBySubChannelId.ts

@@ -1,13 +0,0 @@
-import { pullFromCache, pushToCache } from '~/cache/api';
-
-export const addFlagIsDeletedSubChannelUnreadBySubChannelId = (subChannelId: string) => {
-  const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
-  const cachedSubChannelUnread = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
-
-  if (cachedSubChannelUnread) {
-    pushToCache(cacheKey, {
-      ...cachedSubChannelUnread,
-      isDeleted: true,
-    });
-  }
-};

package/src/marker/utils/addFlagSubChannelUnreadByChannelId.ts

@@ -1,19 +0,0 @@
-import { dropFromCache, pushToCache, queryCache } from '~/cache/api';
-
-export const addFlagSubChannelUnreadByChannelId = (channelId: string) => {
-  const cacheKey = ['subChannelUnreadInfo', 'get'];
-  const cachedSubChannelUnread = queryCache<Amity.SubChannelUnreadInfo>(cacheKey);
-
-  if (cachedSubChannelUnread) {
-    const cachedTargetSubChannelUnread = cachedSubChannelUnread?.filter(
-      ({ data }) => data.channelId === channelId,
-    );
-
-    cachedTargetSubChannelUnread.forEach(({ key, data }) => {
-      pushToCache(key, {
-        ...data,
-        isDeleted: true,
-      });
-    });
-  }
-};

package/src/marker/utils/addFlagSubChannelUnreadBySubChannelId.ts

@@ -1,13 +0,0 @@
-import { pullFromCache, pushToCache } from '~/cache/api';
-
-export const addFlagSubChannelUnreadBySubChannelId = (subChannelId: string) => {
-  const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
-  const cachedSubChannelUnread = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
-
-  if (cachedSubChannelUnread) {
-    pushToCache(cacheKey, {
-      ...cachedSubChannelUnread,
-      isDeleted: true,
-    });
-  }
-};

package/src/marker/utils/deleteChannelUnreadByChannelId.ts

@@ -1,11 +0,0 @@
-import { pullFromCache, dropFromCache } from '~/cache/api';
-
-export const deleteChannelUnreadByChannelId = (channelId: string) => {
-  const channelUnreadInfoCacheKey = ['channelUnreadInfo', 'get', channelId];
-  const channelUnreadInfoCache =
-    pullFromCache<Amity.ChannelUnreadInfo>(channelUnreadInfoCacheKey)?.data;
-
-  if (channelUnreadInfoCache) {
-    dropFromCache(channelUnreadInfoCacheKey);
-  }
-};

package/src/marker/utils/persistUnreadCountInfo.ts

@@ -1,47 +0,0 @@
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { reCalculateChannelUnreadInfo } from './reCalculateChannelUnreadInfo';
-
-export const persistUnreadCountInfo = (payload: Amity.UserFeedUpdatedPayload) => {
-  const { feedMarkers, userFeedMarkers } = payload;
-
-  // calculate sub channel unread info and channel unread info
-  if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
-    const channelIds: string[] = [];
-
-    const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
-
-    userFeedMarkers.forEach(userFeedMarker => {
-      const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
-      if (!feedMarker) return;
-
-      if (feedMarker.feedId === userFeedMarker.feedId) {
-        const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
-
-        const subChannelUnreadInfo: Amity.SubChannelUnreadInfo = {
-          subChannelId: feedMarker.feedId,
-          channelId: feedMarker.entityId,
-          readToSegment: userFeedMarker.readToSegment,
-          lastSegment: feedMarker.lastSegment,
-          lastMentionSegment: userFeedMarker.lastMentionSegment,
-          unreadCount: Math.max(0, unreadCount),
-          isMentioned: userFeedMarker.isMentioned,
-          isDeleted: feedMarker.isDeleted,
-          createdAt: userFeedMarker.createdAt,
-          updatedAt: userFeedMarker.updatedAt,
-        };
-
-        // update sub channel unread info in cache
-        ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
-
-        if (!channelIds.includes(feedMarker.entityId)) {
-          channelIds.push(feedMarker.entityId);
-        }
-      }
-    });
-
-    // re-calculate channel unread info in cache
-    channelIds.forEach(channelId => {
-      reCalculateChannelUnreadInfo(channelId);
-    });
-  }
-};

package/src/marker/utils/reCalculateChannelUnreadInfo.ts

@@ -1,41 +0,0 @@
-import { pushToCache, queryCache } from '~/cache/api';
-import { pullFromCache } from '~/cache/api/pullFromCache';
-
-export const reCalculateChannelUnreadInfo = (channelId: string): Amity.ChannelUnreadInfo => {
-  const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
-  const cacheChannelUnreadInfo =
-    pullFromCache<Amity.ChannelUnreadInfo>(cacheKeyChannelUnread)?.data;
-
-  const cacheKeySubChannelUnread = ['subChannelUnreadInfo', 'get'];
-  const cachedSubChannelUnreadInfo =
-    queryCache<Amity.SubChannelUnreadInfo>(cacheKeySubChannelUnread);
-
-  let channelUnreads = 0;
-  let isMentioned = false;
-
-  if (cachedSubChannelUnreadInfo && cachedSubChannelUnreadInfo?.length > 0) {
-    const subChannelUnreadsInfo = cachedSubChannelUnreadInfo?.filter(({ data }) => {
-      return data.channelId === channelId && !data.isDeleted;
-    });
-
-    channelUnreads = subChannelUnreadsInfo
-      .map(({ data }) => data.unreadCount)
-      .reduce((acc, cur) => acc + cur, 0);
-
-    isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
-  }
-
-  const channelUnreadInfo = {
-    ...(cacheChannelUnreadInfo ?? {
-      channelId,
-      createdAt: new Date().toISOString(),
-    }),
-    updatedAt: new Date().toISOString(),
-    unreadCount: channelUnreads,
-    isMentioned,
-  };
-
-  pushToCache(cacheKeyChannelUnread, channelUnreadInfo);
-
-  return channelUnreadInfo;
-};

package/src/marker/utils/resolveUserMessageFeedMakers.ts

@@ -1,17 +0,0 @@
-import { getUserMessageFeedMakers } from '../api/getUserMessageFeedMarkers';
-import { fireEvent } from '~/core/events';
-import { persistUnreadCountInfo } from './persistUnreadCountInfo';
-
-export const resolveUserMessageFeedMarkers = async (
-  channelIds: Amity.InternalChannel['channelInternalId'][],
-) => {
-  const queryPayload = await getUserMessageFeedMakers(channelIds);
-
-  const { feedMarkers, userFeedMarkers } = queryPayload;
-  persistUnreadCountInfo({
-    feedMarkers,
-    userFeedMarkers,
-  });
-
-  fireEvent('local.userMessageFeedMarkers.resolved', { feedMarkers, userFeedMarkers });
-};

package/src/marker/utils/updateSubChannelUnreadFromMessage.ts

@@ -1,40 +0,0 @@
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { getActiveClient } from '~/client/api/activeClient';
-
-export const updateSubChannelUnreadFromMessage = (message: Amity.RawMessage) => {
-  const client = getActiveClient();
-  const cacheKeyUnreadCount = ['subChannelUnreadInfo', 'get', message.messageFeedId];
-  const cachedUnreadCount = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKeyUnreadCount)?.data;
-
-  if (!cachedUnreadCount) return;
-
-  const lastSegment =
-    cachedUnreadCount.lastSegment < message.segment
-      ? message.segment
-      : cachedUnreadCount.lastSegment;
-
-  const unreadCount = lastSegment - cachedUnreadCount.readToSegment;
-
-  let { lastMentionSegment } = cachedUnreadCount;
-
-  if (message.mentionedUsers && message.mentionedUsers.length > 0) {
-    message.mentionedUsers.forEach(mention => {
-      if (
-        mention.type === 'channel' ||
-        (mention.type === 'user' && client.userId && mention.userPublicIds.includes(client.userId))
-      ) {
-        lastMentionSegment = message.segment;
-      }
-    });
-  }
-
-  const updatedCachedUnreadCount = {
-    ...cachedUnreadCount,
-    lastMentionSegment,
-    lastSegment,
-    isMentioned: !(cachedUnreadCount.readToSegment >= lastMentionSegment),
-    unreadCount: Math.max(unreadCount, 0),
-  };
-
-  pushToCache(cacheKeyUnreadCount, updatedCachedUnreadCount);
-};

package/src/messagePreview/utils/getChannelMessagePreview.ts

@@ -1,8 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-
-export const getChannelMessagePreview = (channelId: string) => {
-  return (
-    pullFromCache<Amity.InternalMessagePreview>(['messagePreviewChannel', 'get', channelId])
-      ?.data ?? null
-  );
-};