@amityco/ts-sdk-react-native 7.0.3-d7a9877.0 → 7.1.1-0e753e3.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/reactionRepository/api/addReaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addReaction.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/api/addReaction.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,WAAW;oBACP,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,QAAQ,OAAO,CAAC;IA4EnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,OAAO,GAAG,SAAS;CAtBrB,CAAC"}
+{"version":3,"file":"addReaction.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/api/addReaction.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,WAAW;oBACP,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,QAAQ,OAAO,CAAC;IAmFnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,OAAO,GAAG,SAAS;CAtBrB,CAAC"}

package/dist/reactionRepository/api/removeReaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeReaction.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/api/removeReaction.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,cAAc;oBACV,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,QAAQ,OAAO,CAAC;IA+EnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,OAAO,GAAG,SAAS;CAtBrB,CAAC"}
+{"version":3,"file":"removeReaction.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/api/removeReaction.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,cAAc;oBACV,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,QAAQ,OAAO,CAAC;IAsFnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,eAAe,CAAC,cAAc,CAAC,GAClD,OAAO,GAAG,SAAS;CAtBrB,CAAC"}

package/dist/reactionRepository/observers/getReactions/ReactionPaginationController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionPaginationController.d.ts","sourceRoot":"","sources":["../../../../src/reactionRepository/observers/getReactions/ReactionPaginationController.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAIlF,qBAAa,4BAA6B,SAAQ,oBAAoB,CACpE,UAAU,EACV,KAAK,CAAC,sBAAsB,CAC7B;IACO,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,sBAAsB,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS;CAoBtF"}
+{"version":3,"file":"ReactionPaginationController.d.ts","sourceRoot":"","sources":["../../../../src/reactionRepository/observers/getReactions/ReactionPaginationController.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAKlF,qBAAa,4BAA6B,SAAQ,oBAAoB,CACpE,UAAU,EACV,KAAK,CAAC,sBAAsB,CAC7B;IACO,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,sBAAsB,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS;CA2BtF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "7.0.3-d7a9877.0",
+  "version": "7.1.1-0e753e3.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;

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;
@@ -84,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'>;

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

@@ -46,6 +46,7 @@ declare global {
 
       log: Logger;
       http: AxiosInstance;
+      upload: AxiosInstance;
       mqtt?: Amity.MqttClient;
       ws?: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
@@ -66,6 +67,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;
+};

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -5,9 +5,8 @@ import { getChannelMarkers } from '~/marker/api/getChannelMarkers';
 import { updateChannelMessagePreviewCache } from '~/messagePreview/utils';
 import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
-import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
-import { getChannelIsMentioned } from './getChannelIsMentioned';
 import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+import { pushToCache } from '~/cache/api';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
@@ -48,6 +47,48 @@ export const preUpdateChannelCache = (
   });
 };
 
+const updateChannelUnread = ({
+  currentUserId,
+  channels,
+  channelUsers,
+}: {
+  currentUserId: Amity.User['userId'];
+  channels: Amity.RawChannel[];
+  channelUsers: Amity.RawMembership<'channel'>[];
+}) => {
+  for (let i = 0; i < channels.length; i += 1) {
+    const cacheKey = ['channelUnread', 'get', channels[i].channelId];
+    const channelUser = channelUsers.find(
+      channelUser =>
+        channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId,
+    );
+
+    let unreadCount = 0;
+    let readToSegment = null;
+    let lastMentionedSegment = null;
+    let isMentioned = false;
+
+    if (channelUser) {
+      readToSegment = channelUser.readToSegment;
+      lastMentionedSegment = channelUser.lastMentionedSegment;
+      unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
+      isMentioned = lastMentionedSegment > readToSegment;
+    }
+
+    const cacheChannelUnread: Amity.ChannelUnread = {
+      channelId: channels[i].channelId,
+      lastSegment: channels[i].messageCount,
+      readToSegment,
+      lastMentionedSegment,
+      unreadCount,
+      isMentioned,
+      isDeleted: channels[i].isDeleted || false,
+    };
+
+    pushToCache(cacheKey, cacheChannelUnread);
+  }
+};
+
 export const prepareChannelPayload = async (
   rawPayload: Amity.ChannelPayload,
   options: { isMessagePreviewUpdated?: boolean } = { isMessagePreviewUpdated: true },
@@ -64,28 +105,38 @@ export const prepareChannelPayload = async (
     updateChannelMessagePreviewCache(rawPayload);
   }
 
-  const markerIds = rawPayload.channels
-    // filter channel by type. Only conversation, community and broadcast type are included.
-    .filter(isUnreadCountSupport)
-    .map(({ channelInternalId }) => channelInternalId);
-
-  if (markerIds.length > 0) {
-    // since the get markers method requires a channel cache to function with the reducer.
-    preUpdateChannelCache(rawPayload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated });
-
-    try {
-      await getChannelMarkers(markerIds);
-    } catch (e) {
-      // empty block (from the spec, allow marker fetch to fail without having to do anything)
+  if (client.useLegacyUnreadCount) {
+    updateChannelUnread({
+      channels: rawPayload.channels,
+      channelUsers: rawPayload.channelUsers,
+      currentUserId: client.userId!,
+    });
+  } else {
+    const markerIds = rawPayload.channels
+      // filter channel by type. Only conversation, community and broadcast type are included.
+      .filter(isUnreadCountSupport)
+      .map(({ channelInternalId }) => channelInternalId);
+
+    if (markerIds.length > 0) {
+      // since the get markers method requires a channel cache to function with the reducer.
+      preUpdateChannelCache(rawPayload, {
+        isMessagePreviewUpdated: options.isMessagePreviewUpdated,
+      });
+
+      try {
+        await getChannelMarkers(markerIds);
+      } catch (e) {
+        // empty block (from the spec, allow marker fetch to fail without having to do anything)
+      }
     }
   }
 
-  // attach marker to channel
+  // convert raw channel to internal channel
   const channels = rawPayload.channels.map(payload =>
     convertFromRaw(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }),
   );
 
-  // user marker to channel users
+  // convert raw channel user to membership (add user object)
   const channelUsers: Amity.Membership<'channel'>[] = rawPayload.channelUsers.map(channelUser => {
     return convertRawMembershipToMembership<'channel'>(channelUser);
   });