@amityco/ts-sdk 7.6.1-1a687cb5.0 → 7.6.1-2841ad2c.0

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

@@ -78,7 +78,7 @@ declare global {
         metadata: Amity.MetadataFor<T>;
       };
       accessType: Amity.FileAccessType;
-    } & (T extends 'video' | 'clip' ? Amity.VideoFileExtraPayload : unknown) &
+    } & (T extends 'video' ? Amity.VideoFileExtraPayload : unknown) &
       Amity.Timestamps &
       Amity.SoftDelete;
 
@@ -588,5 +588,37 @@ declare global {
     type JoinRequestPayload = {
       joinRequests: Amity.RawJoinRequest[];
     };
+
+    type LiveReactionPayload = {
+      reactions: Amity.LiveReaction[];
+    };
+
+    type RawChannelSetMuted = {
+      channelId: string;
+      muteTimeout: Amity.timestamp;
+      actior: string;
+    };
+
+    type ChannelSetMutedPayload = RawChannelSetMuted[];
+
+    type RawChannelSetUserMuted = {
+      channelId: string;
+      userIds: string[];
+      muteTimeout: Amity.timestamp;
+      actor: string;
+    };
+
+    type RawStreamViewerBan = {
+      networkId: string;
+      streamId: string;
+      userId: string;
+      actor: string;
+      createdAt: Amity.timestamp;
+    };
+
+    type StreamViewerBanPayload = RawStreamViewerBan[];
+    type StreamViewerUnbanPayload = RawStreamViewerBan[];
+
+    type ChannelSetUserMutedPayload = RawChannelSetUserMuted;
   }
 }

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

@@ -25,6 +25,7 @@ declare global {
       OnJoin = 'onJoin',
       OnLeft = 'onLeft',
       OnMute = 'onMute',
+      onUnmute = 'onUnmute',
       OnMemberAdded = 'onMemberAdded',
       OnMemberRemoved = 'onMemberRemoved',
       OnUserMessageFeedMarkerFetch = 'onUserMessageFeedMarkerFetch',
@@ -61,6 +62,11 @@ declare global {
       isPublic?: boolean;
 
       lastActivity: Amity.timestamp;
+
+      attachedTo?: {
+        postId?: string;
+        videoStreamId?: string;
+      };
     } & Amity.Metadata &
       Amity.Taggable &
       Amity.Timestamps &
@@ -94,6 +100,9 @@ declare global {
       messagePreview?: Amity.MessagePreview | null;
       markAsRead: () => Promise<boolean>;
       previewMembers: Amity.Membership<'channel'>[];
+      myMembership: (
+        callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>,
+      ) => Amity.Unsubscriber;
     };
 
     type QueryChannels = {

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

@@ -32,7 +32,6 @@ declare global {
       | 'poll'
       | 'json'
       | 'liveStream'
-      | 'clip'
       | string;
 
     type ContentFeedType = ValueOf<typeof ContentFeedType>;
@@ -63,13 +62,6 @@ declare global {
       };
     };
 
-    type ContentDataClip = {
-      thumbnailFileId: Amity.File<'image'>['fileId'];
-      fileId: Amity.File<'clip'>['fileId'];
-      isMuted?: boolean;
-      displayMode?: Amity.ClipDisplayMode;
-    };
-
     type ContentDataPoll = {
       pollId: Amity.Poll['pollId'];
     };
@@ -90,8 +82,6 @@ declare global {
       ? ContentDataPoll
       : T extends 'liveStream'
       ? ContentDataStream
-      : T extends 'clip'
-      ? ContentDataClip
       : T extends 'json'
       ? Record<string, unknown>
       : T extends string

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

@@ -11,9 +11,8 @@ declare global {
     } & Amity.Timestamps;
 
     type QueryGlobalFeed = {
-      dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
+      dataType?: 'video' | 'image' | 'file' | 'liveStream';
       queryToken?: string;
-      resolveParent?: boolean;
     };
   }
 }

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

@@ -2,7 +2,6 @@ export const FileType = Object.freeze({
   FILE: 'file',
   IMAGE: 'image',
   VIDEO: 'video',
-  CLIP: 'clip',
 });
 
 export const VideoResolution = Object.freeze({
@@ -56,16 +55,12 @@ declare global {
 
     type VideoMetadata = Record<string, never>;
 
-    type ClipMetadata = Record<string, never>;
-
     type MetadataFor<T extends FileType> = T extends 'file'
       ? FileMetadata
       : T extends 'image'
       ? ImageMetadata
       : T extends 'video'
       ? VideoMetadata
-      : T extends 'clip'
-      ? ClipMetadata
       : never;
 
     type File<T extends FileType = any> = Amity.FilePayload<T>;

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

@@ -0,0 +1,25 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawLiveReaction = {
+      userId: string; // user's public ID
+      referenceId: string; // post's internal ID
+      referencePublicId: string; // post's public ID
+      referenceType: string; // 'post'
+      reactionName: string; // 'love
+      // date string in ISO format
+      occurredAt: string;
+    };
+
+    type InternalLiveReaction = RawLiveReaction;
+
+    type LiveReaction = InternalLiveReaction;
+
+    type CreateLiveReactionRequest = Omit<RawLiveReaction, 'userId' | 'referenceId' | 'occurredAt'>;
+
+    type CreateLiveReactionResponse = {
+      addedIds: string[];
+    };
+  }
+}

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

@@ -5,7 +5,6 @@ export const PostContentType = Object.freeze({
   VIDEO: 'video',
   LIVESTREAM: 'liveStream',
   POLL: 'poll',
-  CLIP: 'clip',
 });
 
 declare global {
@@ -71,9 +70,11 @@ declare global {
 
     type InternalPost<T extends PostContentType = any> = RawPost<T> & {
       feedType?: 'reviewing' | 'published';
+      // childPosts?: Amity.RawPost[];
     };
 
     type PostLinkObject = {
+      childrenPosts: Amity.Post[];
       latestComments: (Amity.Comment | null)[];
       creator: Amity.User | undefined;
       analytics: {
@@ -83,13 +84,12 @@ declare global {
       getVideoInfo: () => Amity.File<'video'> | undefined;
       getVideoThumbnailInfo: () => Amity.File<'image'> | undefined;
       getFileInfo: () => Amity.File<'file'> | undefined;
-      getClipInfo: () => Amity.File<'clip'> | undefined;
+      getPollInfo: () => Amity.Poll | undefined;
+      getLivestreamInfo: () => Amity.Stream | undefined;
     };
 
     type Post<T extends PostContentType = any> = Amity.InternalPost<T> & Amity.PostLinkObject;
 
-    type ClipDisplayMode = 'fill' | 'fit';
-
     type QueryPosts = {
       targetId: string;
       targetType: Amity.InternalPost['targetType'];

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

@@ -73,6 +73,13 @@ declare global {
        */
       targetId?: string; // communityId, userId, etc..
       targetType?: string; // 'community', 'user', etc..
+
+      /*
+       * when stream linked with a post and a live channel.
+       */
+      postId?: string;
+      channelId?: string;
+      channelEnabled?: boolean;
     } & Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete;
@@ -81,9 +88,14 @@ declare global {
 
     type StreamLinkedObject = {
       moderation?: Amity.StreamModeration;
+      post?: Amity.InternalPost;
+      getLiveChat: () => Promise<Amity.Channel<'live'> | undefined>;
     };
 
-    type Stream = Amity.InternalStream & Amity.StreamLinkedObject;
+    type Stream = Omit<Amity.InternalStream & Amity.StreamLinkedObject, 'watcherUrl'> & {
+      isBanned: boolean;
+      watcherUrl: null;
+    };
 
     type QueryStreams = {
       isLive?: boolean;

package/src/@types/index.ts

@@ -43,3 +43,4 @@ export * from './domains/invitation';
 export * from './domains/joinRequest';
 export * from './domains/pin';
 export * from './domains/pinnedPost';
+export * from './domains/liveReaction';

package/src/channelRepository/api/createChannel.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+import { constructChannelObject } from '../utils/constructChannelObject';
 
 /* begin_public_function
   id: channel.create
@@ -23,11 +23,14 @@ import { constructChannelDynamicValue } from '../utils/constructChannelDynamicVa
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: { type: T; userIds?: Amity.InternalUser['userId'][] } & Pick<
-    Amity.Channel<T>,
-    'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'
-  >,
-): Promise<Amity.Cached<Amity.InternalChannel>> => {
+  bundle: {
+    type: T;
+    userIds?: Amity.InternalUser['userId'][];
+    // For live channel linked with a livestream post
+    videoStreamId?: string;
+    postId?: string;
+  } & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'>,
+): Promise<Amity.Cached<Amity.Channel<T>>> => {
   const client = getActiveClient();
   client.log('user/createChannel', bundle);
 
@@ -53,7 +56,7 @@ export const createChannel = async <T extends Amity.ChannelType>(
 
   const { channels } = data;
   return {
-    data: constructChannelDynamicValue(channels[0]),
+    data: constructChannelObject(channels[0]),
     cachedAt,
   };
 };

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -24,6 +24,7 @@ import {
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
 import { LinkedObject } from '~/utils/linkedObject';
+import { onChannelSetUserMuted } from '~/channelRepository/events/onChannelSetUserMuted';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -89,6 +90,7 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
       { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
       { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+      { fn: onChannelSetUserMuted, action: 'onChannelSetUserMuted' },
       { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
     ]);
   }

package/src/channelRepository/events/index.ts

@@ -4,7 +4,7 @@ export * from './onChannelDeleted';
 
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onChannelMuted';
+export * from './onChannelSetMuted';
 
 export * from './onChannelMemberAdded';
 export * from './onChannelMemberRemoved';

package/src/channelRepository/events/onChannelSetMuted.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+
+type CallbackFn = Amity.Listener<Amity.StaticInternalChannel>;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
+export const onChannelSetMuted = (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payloads: Amity.ChannelSetMutedPayload) => {
+      payloads.forEach(payload => {
+        upsertInCache(['channel', 'get', payload.channelId], {
+          // If muteTimeout > now => user is muted
+          // Otherwise => user is unmuted
+          isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+        });
+      });
+
+      const channel = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        payloads[0].channelId,
+      ])?.data;
+
+      if (channel) {
+        callbacks.forEach(cb => cb(channel));
+      }
+    };
+
+    mainDisposer = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/events/onChannelSetUserMuted.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { pullFromCache, upsertInCache } from '~/cache/api';
+
+type CallbackFn = (
+  channel: Amity.StaticInternalChannel,
+  member: Amity.Membership<'channel'>,
+) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
+export const onChannelSetUserMuted = (
+  callback: (channel: Amity.StaticInternalChannel, member: Amity.Membership<'channel'>) => void,
+): Amity.Unsubscriber => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelSetUserMutedPayload) => {
+      payload.userIds.forEach(userId =>
+        // If muteTimeout > now => user is muted
+        // Otherwise => user is unmuted
+        upsertInCache(['channelUsers', 'get', `${payload.channelId}#${userId}`], {
+          isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+        }),
+      );
+
+      const channel = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        payload.channelId,
+      ])?.data;
+
+      const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+        'channelUsers',
+        'get',
+        `${payload.channelId}#${payload.userIds[0]}`,
+      ])?.data;
+
+      if (channel && channelUser) {
+        callbacks.forEach(cb => cb(channel, channelUser));
+      }
+    };
+
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelUserMute',
+      'channel.setMutedUsers',
+      filter,
+    );
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/internalApi/getChannel.ts

@@ -9,7 +9,6 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
 import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js

package/src/channelRepository/internalApi/getMyMembership.ts

@@ -0,0 +1,37 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { ASCApiError } from '~/core/errors';
+
+/**
+ *
+ * get current user's membership data
+ *
+ * @returns the {@link Amity.Membership<'channel'>} objects
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const getMyMembership = (channelId: string): Amity.Cached<Amity.Membership<'channel'>> => {
+  const client = getActiveClient();
+  client.log('channel/getMyMembership.locally');
+
+  const cacheChannelUser = pullFromCache<Amity.Membership<'channel'>>([
+    'channelUsers',
+    'get',
+    `${channelId}#${client.userId}`,
+  ]);
+
+  if (!cacheChannelUser) {
+    throw new ASCApiError(
+      'Item not found!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+  }
+
+  return {
+    data: cacheChannelUser.data,
+    cachedAt: cacheChannelUser.cachedAt,
+  };
+};

package/src/channelRepository/observers/getChannel.ts

@@ -10,7 +10,7 @@ import {
   onChannelMemberBanned,
   onChannelMemberRemoved,
   onChannelMemberUnbanned,
-  onChannelMuted,
+  onChannelSetMuted,
   onChannelUpdated,
 } from '../events';
 import { dropFromCache, pullFromCache } from '~/cache/api';
@@ -104,7 +104,7 @@ export const getChannel = (
       onChannelMemberRemoved,
       onChannelMemberBanned,
       onChannelMemberUnbanned,
-      onChannelMuted,
+      onChannelSetMuted,
       convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
       convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
       convertEventPayload(

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

@@ -11,7 +11,6 @@ import {
   onChannelLeft,
   onChannelMemberAdded,
   onChannelMemberRemoved,
-  onChannelMuted,
   onChannelUpdated,
 } from '~/channelRepository/events';
 import {
@@ -58,6 +57,7 @@ import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFe
 import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
 import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
+import { onChannelSetMuted } from '~/channelRepository/events/onChannelSetMuted';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -313,7 +313,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
       { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
-      { fn: onChannelMuted, action: Amity.ChannelActionType.OnMute },
+      { fn: onChannelSetMuted, action: Amity.ChannelActionType.OnMute },
       {
         fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
           return onChannelJoined(channel => {

package/src/channelRepository/observers/getMyMembership.ts

@@ -0,0 +1,98 @@
+import { getActiveUser } from '~/client/api/activeUser';
+import { getMyMembership as _getMyMembership } from '../internalApi/getMyMembership';
+import { ASCApiError, ASCError } from '~/core/errors';
+import { getActiveClient } from '~/client/api/activeClient';
+import { isEqual } from '~/utils/isEqual';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+import { channelMemberLinkedObject } from '~/utils/linkedObject/channelMemberLinkedObject';
+import { onChannelMemberBanned, onChannelMemberUnbanned } from '../events';
+import { onChannelSetUserMuted } from '../events/onChannelSetUserMuted';
+
+export const getMyMembership = (
+  channelId: string,
+  callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | 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('This observable object need the cache data!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveMymembership(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  let isUnsyncedModel = false; // for messages
+
+  let model: Amity.Membership<'channel'> | undefined;
+
+  const dispatcher = (data: Amity.LiveObject<Amity.Membership<'channel'> | undefined>) => {
+    callback({
+      ...data,
+      data: data.data ? channelMemberLinkedObject(data.data) : data.data,
+    });
+  };
+
+  const realtimeRouter = (_: Amity.StaticInternalChannel, __: Amity.RawMembership<'channel'>) => {
+    const { data } = _getMyMembership(channelId);
+
+    if (isEqual(model, data)) return;
+
+    dispatcher({
+      loading: false,
+      data,
+    });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(async () => _getMyMembership(channelId));
+
+    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(onChannelMemberBanned(realtimeRouter));
+  disposers.push(onChannelMemberUnbanned(realtimeRouter));
+  disposers.push(onChannelSetUserMuted(realtimeRouter));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channelRepository/utils/constructChannelObject.ts

@@ -1,6 +1,6 @@
 import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { constructChannelDynamicValue } from './constructChannelDynamicValue';
-import { LinkedObject } from '~/utils/linkedObject';
+import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
 
 export const constructChannelObject = (channel: Amity.StaticInternalChannel): Amity.Channel => {
   /**
@@ -10,7 +10,7 @@ export const constructChannelObject = (channel: Amity.StaticInternalChannel): Am
    * 3. [LinkedObject.channel] add markAsRead >> Amity.InternalChannel -> Amity.Channel
    */
 
-  return LinkedObject.channel(
+  return channelLinkedObject(
     constructChannelDynamicValue(getChannelMessagePreviewWithUser(channel)),
   );
 };

package/src/client/api/login.ts

@@ -13,6 +13,7 @@ import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLog
 import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
 import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
 import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
+import reactionSyncEngineOnLoginHandler from '~/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -201,6 +202,7 @@ export const login = async (
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
       objectResolverEngineOnLoginHandler(),
+      reactionSyncEngineOnLoginHandler(),
     );
 
     if (client.useLegacyUnreadCount) {