@amityco/ts-sdk 7.1.1-61f30ce0.0 → 7.1.1-67cf0d9.0

package/dist/marker/events/onChannelUnreadInfoUpdatedLocal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.channelUnreadInfo} has been updated.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category ChannelMarker Events
+ */
+export declare const onChannelUnreadInfoUpdatedLocal: (callback: Amity.Listener<Amity.Events['local.channelUnreadInfo.updated']>) => Amity.Unsubscriber;
+//# sourceMappingURL=onChannelUnreadInfoUpdatedLocal.d.ts.map

package/dist/marker/events/onChannelUnreadInfoUpdatedLocal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onChannelUnreadInfoUpdatedLocal.d.ts","sourceRoot":"","sources":["../../../src/marker/events/onChannelUnreadInfoUpdatedLocal.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B,aAChC,MAAM,QAAQ,CAAC,MAAM,MAAM,CAAC,iCAAiC,CAAC,CAAC,KACxE,MAAM,YAaR,CAAC"}

package/dist/messageRepository/events/onMessageCreated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onMessageCreated.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/events/onMessageCreated.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,aACrB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YA+BR,CAAC;AAEF,eAAO,MAAM,qBAAqB,aACtB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YAoBR,CAAC"}
+{"version":3,"file":"onMessageCreated.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/events/onMessageCreated.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,aACrB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YA0ER,CAAC;AAEF,eAAO,MAAM,qBAAqB,aACtB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YAoBR,CAAC"}

package/dist/messageRepository/observers/getMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/observers/getMessage.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,cACV,MAAM,OAAO,CAAC,WAAW,CAAC,YAC3B,MAAM,kBAAkB,CAAC,MAAM,OAAO,CAAC,KAChD,MAAM,YAmBR,CAAC"}
+{"version":3,"file":"getMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/observers/getMessage.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,cACV,MAAM,OAAO,CAAC,WAAW,CAAC,YAC3B,MAAM,kBAAkB,CAAC,MAAM,OAAO,CAAC,KAChD,MAAM,YAmBR,CAAC"}

package/dist/messageRepository/utils/markReadMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markReadMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/utils/markReadMessage.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,YAAa,MAAM,eAAe,SAK7D,CAAC"}
+{"version":3,"file":"markReadMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/utils/markReadMessage.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,YAAa,MAAM,eAAe,SAU7D,CAAC"}

package/dist/utils/linkedObject/index.d.ts

@@ -11,6 +11,5 @@ export declare const LinkedObject: {
     reactor: (reactor: Amity.InternalReactor) => Amity.Reactor;
     channel: (channel: Amity.InternalChannel<any>) => Amity.Channel<any>;
     pinnedPost: (pinnedPost: Amity.RawPin) => Amity.PinnedPost;
-    notificationTray: (noti: Amity.RawNotificationTrayItem) => Amity.NotificationTrayItem;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/linkedObject/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAcxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,YAAY;;;;;;;;;;;;;CAaxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.1.1-61f30ce0.0",
+  "version": "7.1.1-67cf0d9.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/events.ts

@@ -237,7 +237,8 @@ declare global {
       };
 
       'local.subChannelUnread.updated': Amity.SubChannelUnreadInfo;
-      'local.channelUnread.updated': Amity.ChannelUnreadInfo;
+      'local.channelUnreadInfo.updated': Amity.ChannelUnreadInfo;
+      'local.channelUnread.updated': Amity.ChannelUnread;
 
       'local.story.created': Amity.StoryPayload;
       'local.story.updated': Amity.StoryPayload;
@@ -255,11 +256,6 @@ declare global {
       'local.story.error': Amity.StoryPayload;
       'local.story.reload': { referenceIds: Amity.Story['referenceId'][] };
 
-      'local.notificationTraySeen.updated': Amity.InternalNotificationTraySeen;
-      'local.notificationTrayItem.updated': {
-        notificationTrayItems: Amity.InternalNotificationTrayItem[];
-      };
-
       sessionStateChange: Amity.SessionStates;
       // used by accessTokenExpiryWatcher
       tokenExpired: Amity.SessionStates.TOKEN_EXPIRED;

package/src/@types/core/model.ts

@@ -25,6 +25,8 @@ declare global {
       channelUnreadInfo: Amity.ChannelUnreadInfo;
       subChannelUnreadInfo: Amity.SubChannelUnreadInfo;
 
+      channelUnread: Amity.ChannelUnread;
+
       channelMarker: Amity.ChannelMarker;
       subChannelMarker: Amity.SubChannelMarker;
       messageMarker: Amity.MessageMarker;
@@ -55,9 +57,6 @@ declare global {
 
       pinTarget: Amity.InternalPinTarget;
       pin: Amity.InternalPin;
-
-      notificationTrayItem: Amity.InternalNotificationTrayItem;
-      notificationTraySeen: Amity.InternalNotificationTraySeen;
     };
 
     type Model = ValueOf<Models>;
@@ -87,6 +86,8 @@ declare global {
       channelUnreadInfo: Pick<Amity.ChannelUnreadInfo, 'channelId'>;
       subChannelUnreadInfo: Pick<Amity.SubChannelUnreadInfo, 'subChannelId'>;
 
+      channelUnread: Pick<Amity.ChannelUnread, 'channelId'>;
+
       channelMarker: Pick<Amity.ChannelMarker, 'entityId' | 'userId'>;
       subChannelMarker: Pick<Amity.SubChannelMarker, 'feedId' | 'entityId' | 'userId'>;
       messageMarker: Pick<Amity.MessageMarker, 'feedId' | 'contentId' | 'creatorId'>;
@@ -117,9 +118,6 @@ declare global {
 
       pinTarget: Pick<Amity.InternalPinTarget, 'targetId'>;
       pin: Pick<Amity.InternalPin, 'placement' | 'referenceId'>;
-
-      notificationTrayItem: Amity.InternalNotificationTrayItem;
-      notificationTraySeen: Amity.InternalNotificationTraySeen;
     };
   }
 }

package/src/@types/core/payload.ts

@@ -26,7 +26,6 @@ declare global {
       blockUser: Amity.BlockedUserPayload;
       semanticSearchPost: Amity.SemanticSearchPostPayload;
       semanticSearchCommunity: Amity.SemanticSearchCommunityPayload;
-      notificationTrayItem: Amity.NotificationTrayPayload;
     };
 
     type UserPayload = {
@@ -379,30 +378,6 @@ declare global {
       reactions: Amity.InternalReactor[];
     } & Amity.StoryPayload;
 
-    type NotificationTrayPayload = {
-      notificationTrayItems: Amity.RawNotificationTrayItem[];
-      users: Amity.RawUser[];
-      files?: Amity.File[];
-    };
-
-    type ProcessedNotificationTrayPayload = Omit<
-      NotificationTrayPayload,
-      'notificationTrayItems' | 'users'
-    > & {
-      notificationTrayItems: Amity.InternalNotificationTrayItem[];
-      users: Amity.InternalUser[];
-      files?: Amity.File[];
-    };
-
-    type NotificationTraySeenPayload = {
-      lastTraySeenAt: Amity.timestamp;
-      lastTrayOccuredAt: Amity.timestamp;
-    };
-
-    type NotificationTraySeenUpdatedPayload = {
-      lastTraySeenAt: Amity.timestamp;
-    };
-
     /**
      * Items that extend from `Amity.PostPayload`
      * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)

package/src/@types/core/readReceipt.ts

@@ -8,12 +8,25 @@ declare global {
     }
 
     type ReadReceipt = {
-      subChannelId: Amity.SubChannel['subChannelId'];
+      channelId: Amity.Channel['channelId'];
       latestSegment: number;
       latestSyncSegment: number;
     };
 
     type ReadReceiptSyncJob = {
+      channelId: Amity.Channel['channelId'];
+      segment: number;
+      syncState: ReadReceiptSyncState;
+      retryCount: number;
+    };
+
+    type LegacyReadReceipt = {
+      subChannelId: Amity.SubChannel['subChannelId'];
+      latestSegment: number;
+      latestSyncSegment: number;
+    };
+
+    type LegacyReadReceiptSyncJob = {
       subChannelId: Amity.SubChannel['subChannelId'];
       segment: number;
       syncState: ReadReceiptSyncState;

package/src/@types/domains/channel.ts

@@ -84,6 +84,8 @@ declare global {
     > & {
       isMentioned: boolean;
       subChannelsUnreadCount: number;
+      // legacy unread count does not use the maker service
+      unreadCount: number;
     };
 
     /* public type */
@@ -137,5 +139,16 @@ declare global {
       Amity.Membership<'channel'>['userId'],
       Pick<QueryChannelMembers, 'page'>
     >;
+
+    // Use for channel's unread count value stored in the local cache
+    type ChannelUnread = {
+      channelId: Amity.Channel['channelId'];
+      unreadCount: number;
+      isMentioned: boolean;
+      readToSegment: number | null;
+      lastSegment: number;
+      lastMentionedSegment: number | null;
+      isDeleted: boolean;
+    };
   }
 }

package/src/@types/domains/client.ts

@@ -36,6 +36,7 @@ declare global {
 
       log: Logger;
       http: AxiosInstance;
+      upload: AxiosInstance;
       mqtt?: Amity.MqttClient;
       ws?: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
@@ -56,6 +57,8 @@ declare global {
 
       isUnreadCountEnabled: boolean;
 
+      useLegacyUnreadCount: boolean;
+
       use: () => void;
 
       accessTokenExpiryWatcher: (sessionHandler: Amity.SessionHandler) => Amity.Unsubscriber;

package/src/channelRepository/api/markChannelsAsReadBySegment.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ *
+ * Mark subChannel as read by readToSegment
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to update
+ * @param readToSegment the segment to mark as read
+ * @returns a success boolean if the {@link Amity.SubChannel} was updated
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const markChannelsAsReadBySegment = async (
+  readings: {
+    channelId: Amity.Channel['channelId'];
+    readToSegment: number;
+  }[],
+): Promise<boolean> => {
+  const client = getActiveClient();
+
+  try {
+    await client.http.post<Amity.MarkAsReadPayload>('api/v3/channels/seen', { channels: readings });
+    return true;
+  } catch (e) {
+    return false;
+  }
+};

package/src/channelRepository/events/onChannelDeleted.ts

@@ -6,6 +6,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareChannelPayload } from '../utils/prepareChannelPayload';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
 
 type CallbackFn = (channel: Amity.StaticInternalChannel) => void;
 const callbacks: CallbackFn[] = [];
@@ -28,12 +29,24 @@ export const onChannelDeleted = (callback: Amity.Listener<Amity.StaticInternalCh
     const filter = async (payload: Amity.ChannelPayload) => {
       const data = await prepareChannelPayload(payload);
 
-      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        data.channels.forEach(channel => {
+      const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+      const isLegacyUnreadCount = client.useLegacyUnreadCount;
+
+      data.channels.forEach(channel => {
+        if (isConsistentMode) {
           addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
           deleteChannelUnreadByChannelId(channel.channelId);
-        });
-      }
+        } else if (isLegacyUnreadCount) {
+          const cacheKey = ['channelUnread', 'get', channel.channelId];
+          const cache = pullFromCache<Amity.ChannelUnread>(cacheKey);
+          if (cache) {
+            pushToCache(cacheKey, {
+              ...cache,
+              isDeleted: true,
+            });
+          }
+        }
+      });
 
       ingestInCache(data);
       callbacks.forEach(cb => cb(data.channels[0]));

package/src/channelRepository/events/onChannelLeft.ts

@@ -6,6 +6,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareChannelPayload } from '../utils';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
+import { dropFromCache } from '~/cache/api';
 
 type CallbackFn = (
   channel: Amity.StaticInternalChannel,
@@ -40,10 +41,17 @@ export const onChannelLeft = (
         isMessagePreviewUpdated: isLeftByMe,
       });
 
-      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
+      const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+      const isLegacyUnreadCount = client.useLegacyUnreadCount;
+
+      if (isLeftByMe) {
         preparedPayload.channels.forEach(channel => {
-          addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-          deleteChannelUnreadByChannelId(channel.channelId);
+          if (isConsistentMode) {
+            addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+            deleteChannelUnreadByChannelId(channel.channelId);
+          } else if (isLegacyUnreadCount) {
+            dropFromCache(['channelUnread', 'get', channel.channelId]);
+          }
         });
       }
 

package/src/{marker → channelRepository}/events/onChannelUnreadUpdatedLocal.ts

@@ -4,12 +4,12 @@ import { createEventSubscriber } from '~/core/events';
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ * Fired when an {@link Amity.ChannelUnread} has been updated.
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category MessageMarker Events
+ * @category Channel Events
  */
 export const onChannelUnreadUpdatedLocal = (
   callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>,
@@ -22,7 +22,7 @@ export const onChannelUnreadUpdatedLocal = (
 
   return createEventSubscriber(
     client,
-    'channelMarker/onChannelUnreadUpdatedLocal',
+    'channel/onChannelUnreadUpdatedLocal',
     'local.channelUnread.updated',
     filter,
   );

package/src/channelRepository/internalApi/getTotalChannelsUnread.ts

@@ -0,0 +1,38 @@
+import { queryCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ *
+ * Calculate user unread from {@link Amity.ChannelUnread} objects
+ *
+ * @returns the {@link Amity.UserUnread} objects
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const getTotalChannelsUnread = (): Amity.Cached<Amity.UserUnread> => {
+  const client = getActiveClient();
+  client.log('channel/getTotalChannelsUnread.locally');
+
+  const cachedChannelsUnread =
+    queryCache<Amity.ChannelUnread>(['channelUnread', 'get'])?.filter(({ data }) => {
+      return !data.isDeleted;
+    }) || [];
+
+  const totalChannelsUnread: Amity.UserUnread = cachedChannelsUnread?.reduce(
+    (acc, { data }) => {
+      acc.unreadCount += data.unreadCount;
+      acc.isMentioned = acc.isMentioned || data.isMentioned;
+      return acc;
+    },
+    { unreadCount: 0, isMentioned: false as boolean },
+  ) || { unreadCount: 0, isMentioned: false };
+
+  const cachedAt = client.cache && Date.now();
+
+  return {
+    data: totalChannelsUnread,
+    cachedAt,
+  };
+};

package/src/channelRepository/observers/getChannel.ts

@@ -32,8 +32,9 @@ import { isEqual } from '~/utils/isEqual';
 import { updateChannelCache } from '../utils/updateChannelCache';
 import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
 import { onSubChannelCreated } from '~/subChannelRepository';
-import { onChannelUnreadUpdatedLocal } from '~/marker/events/onChannelUnreadUpdatedLocal';
+import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '../utils/constructChannelObject';
+import { onChannelUnreadUpdatedLocal } from '../events/onChannelUnreadUpdatedLocal';
 
 /* begin_public_function
   id: channel.get
@@ -295,6 +296,7 @@ export const getChannel = (
         'channel',
       ),
       convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
+      convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
       convertEventPayload(onChannelUnreadUpdatedLocal, 'channelId', 'channel'),
     ],
     {

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -55,8 +55,9 @@ import { prepareUnreadCountInfo } from '~/channelRepository/utils/prepareUnreadC
 import { resolveUnreadInfoOnChannelEvent } from '~/channelRepository/utils/resolveUnreadInfoOnChannelEvent';
 import { onChannelResolved } from '~/channelRepository/events/onChannelResolved';
 import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFeedMarkerResolved';
-import { onChannelUnreadUpdatedLocal } from '~/marker/events/onChannelUnreadUpdatedLocal';
+import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
+import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -566,6 +567,10 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
         },
         action: Amity.ChannelActionType.OnResolveUnread,
       },
+      {
+        fn: convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
+        action: Amity.ChannelActionType.OnUpdate,
+      },
       {
         fn: convertEventPayload(onChannelUnreadUpdatedLocal, 'channelId', 'channel'),
         action: Amity.ChannelActionType.OnUpdate,

package/src/channelRepository/observers/getTotalChannelsUnread.ts

@@ -0,0 +1,129 @@
+import { getActiveUser } from '~/client/api/activeUser';
+import { getTotalChannelsUnread as _getTotalChannelsUnread } from '../internalApi/getTotalChannelsUnread';
+import { onChannelUnreadUpdatedLocal } from '../events/onChannelUnreadUpdatedLocal';
+import { ASCApiError, ASCError } from '~/core/errors';
+import { getActiveClient } from '~/client';
+import { convertGetterPropsToStatic } from '~/utils/object';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+import { isEqual } from '~/utils/isEqual';
+
+/* begin_public_function
+  id: totalChannelsUnread.get
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk';
+ *
+ * let totalChannelsUnread;
+ *
+ * const unsubscribe = ChannelRepository.getTotalChannelsUnread(response => {
+ *   unread = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.UserUnread}
+ *
+ * @returns An {@link Amity.UserUnread} function to run when willing to stop observing the message
+ *
+ * @category User Unread Live Object
+ *
+ */
+
+export const getTotalChannelsUnread = (
+  callback: Amity.LiveObjectCallback<Amity.UserUnread | undefined>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Object feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveTotalChannelsUnread(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  let isUnsyncedModel = false; // for messages
+
+  let model: Amity.UserUnread | undefined;
+
+  const dispatcher = (data: Amity.LiveObject<Amity.UserUnread | undefined>) => {
+    const { data: userUnread } = data;
+
+    const callbackModel = userUnread
+      ? {
+          unreadCount: userUnread.unreadCount,
+          isMentioned: userUnread.isMentioned,
+        }
+      : undefined;
+
+    model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
+
+    callback({
+      data: callbackModel
+        ? { ...callbackModel, isMentioned: callbackModel.isMentioned }
+        : callbackModel,
+
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (userUnread: Amity.UserUnread) => {
+    if (isEqual(model, userUnread)) return;
+
+    dispatcher({
+      loading: false,
+      data: userUnread,
+    });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(async () => _getTotalChannelsUnread());
+
+    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedModel = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedModel) {
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(onChannelUnreadUpdatedLocal(realtimeRouter));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channelRepository/observers/index.ts

@@ -1,2 +1,3 @@
 export * from './getChannel';
 export * from './getChannels';
+export * from './getTotalChannelsUnread';

package/src/channelRepository/utils/constructChannelDynamicValue.ts

@@ -1,17 +1,27 @@
+import { get } from 'http';
 import { shallowClone } from '~/utils/shallowClone';
 import { getChannelIsMentioned } from './getChannelIsMentioned';
 import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
+import { getActiveClient } from '~/client/api/activeClient';
+import { getLegacyChannelUnread } from './getLegacyChannelUnread';
 
 export const constructChannelDynamicValue = (
   channel: Amity.StaticInternalChannel,
 ): Amity.InternalChannel => {
+  const client = getActiveClient();
   const { messageCount, ...rest } = channel;
+
   return shallowClone(rest, {
-    get isMentioned() {
-      return getChannelIsMentioned(rest);
+    get unreadCount() {
+      return getLegacyChannelUnread(rest.channelId)?.unreadCount ?? 0;
     },
     get subChannelsUnreadCount() {
       return getSubChannelsUnreadCount(rest);
     },
+    get isMentioned() {
+      if (client.useLegacyUnreadCount)
+        return getLegacyChannelUnread(rest.channelId)?.isMentioned ?? false;
+      return getChannelIsMentioned(rest);
+    },
   });
 };

package/src/channelRepository/utils/getLegacyChannelUnread.ts

@@ -0,0 +1,5 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+
+export const getLegacyChannelUnread = (channelId: string) => {
+  return pullFromCache<Amity.ChannelUnreadInfo>(['channelUnread', 'get', channelId])?.data;
+};