@amityco/ts-sdk 7.1.1-207e990f.0 → 7.1.1-5d7c3fd0.0

package/src/client/utils/ReadReceiptSync/readReceiptSyncEngine.ts

@@ -1,7 +1,8 @@
 import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
 import { getActiveClient } from '../../api/activeClient';
+import { markAsReadBySegment } from '~/subChannelRepository/api/markAsReadBySegment';
+import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
 import { fireEvent } from '~/core/events';
-import { markChannelsAsReadBySegment } from '~/channelRepository/api/markChannelsAsReadBySegment';
 
 export class MessageReadReceiptSyncEngine {
   private client: Amity.Client;
@@ -37,9 +38,9 @@ export class MessageReadReceiptSyncEngine {
   syncReadReceipts(): void {
     if (this.jobQueue.length === 0 || this.isActive === false) return;
 
-    const readReceipts = this.getReadReceipts();
-    if (readReceipts) {
-      this.markReadApi(readReceipts);
+    const readReceipt = this.getReadReceipt();
+    if (readReceipt) {
+      this.markReadApi(readReceipt);
     }
   }
 
@@ -51,64 +52,79 @@ export class MessageReadReceiptSyncEngine {
 
     // Enqueue unsync read receipts to the job queue
     readReceipts?.forEach(({ data: readReceipt }) => {
-      this.enqueueReadReceipt(readReceipt.channelId, readReceipt.latestSegment);
+      this.enqueueReadReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
     });
   }
 
-  private getReadReceipts(): Amity.ReadReceiptSyncJob[] | undefined {
-    // get all read receipts from queue, now the queue is empty
-    const syncJob = this.jobQueue.splice(0, this.jobQueue.length);
-    if (syncJob.length === 0) return;
+  private getReadReceipt(): Amity.ReadReceiptSyncJob | undefined {
+    // Get first read receipt in queue
+    const syncJob = this.jobQueue[0];
 
-    return syncJob.filter(job => {
-      const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', job.channelId])?.data;
-      if (!readReceipt) return false;
-      if (readReceipt.latestSegment > readReceipt.latestSyncSegment) return true;
-      return false;
-    });
+    if (!syncJob) return;
+    // Skip when it's syncing
+    if (syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) return;
+
+    // Get readReceipt from cache by subChannelId
+    const readReceipt = pullFromCache<Amity.ReadReceipt>([
+      'readReceipt',
+      syncJob.subChannelId,
+    ])?.data;
+
+    if (!readReceipt) return;
+
+    if (readReceipt?.latestSegment > readReceipt?.latestSyncSegment) {
+      syncJob.segment = readReceipt.latestSegment;
+      return syncJob;
+    }
+    // Clear all synced job in job queue
+    this.removeSynedReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
+
+    // Recursion getReadReceipt() until get unsync read receipt or job queue is empty
+    return this.getReadReceipt();
   }
 
-  private async markReadApi(syncJobs: Amity.ReadReceiptSyncJob[]): Promise<void> {
-    // constuct payload
-    // example: [{ channelId: 'channelId', readToSegment: 2 }]
-    const syncJobsPayload = syncJobs.map(job => {
-      return {
-        channelId: job.channelId,
-        readToSegment: job.segment,
-      };
-    });
+  private async markReadApi(syncJob: Amity.ReadReceiptSyncJob): Promise<void> {
+    const newSyncJob = syncJob;
+    newSyncJob.syncState = Amity.ReadReceiptSyncState.SYNCING;
+
+    const { subChannelId, segment } = newSyncJob;
 
-    const response = await markChannelsAsReadBySegment(syncJobsPayload);
+    const response = await markAsReadBySegment({ subChannelId, readToSegment: segment });
 
     if (response) {
-      for (let i = 0; i < syncJobs.length; i += 1) {
-        // update lastestSyncSegment in read receipt cache
-        const cacheKey = ['readReceipt', syncJobs[i].channelId];
-        const readReceiptCache = pullFromCache<Amity.ReadReceipt>(cacheKey)?.data;
-
-        pushToCache(cacheKey, {
-          ...readReceiptCache,
-          latestSyncSegment: syncJobs[i].segment,
-        });
+      this.removeSynedReceipt(syncJob.subChannelId, syncJob.segment);
+
+      const readReceiptCache = pullFromCache<Amity.ReadReceipt>([
+        'readReceipt',
+        subChannelId,
+      ])?.data;
+
+      pushToCache(['readReceipt', subChannelId], {
+        ...readReceiptCache,
+        latestSyncSegment: segment,
+      });
+    } else if (!response) {
+      if (newSyncJob.retryCount > this.MAX_RETRY) {
+        this.removeJobFromQueue(newSyncJob);
+      } else {
+        newSyncJob.retryCount += 1;
+        newSyncJob.syncState = Amity.ReadReceiptSyncState.CREATED;
       }
-    } else {
-      for (let i = 0; i < syncJobs.length; i += 1) {
-        // push them back to queue if the syncing is failed and retry count is less than max retry
-        if (syncJobs[i].retryCount >= this.MAX_RETRY) return;
+    }
+  }
 
-        const updatedJob = {
-          ...syncJobs[i],
-          syncState: Amity.ReadReceiptSyncState.CREATED,
-          retryCount: syncJobs[i].retryCount + 1,
-        };
+  private removeSynedReceipt(subChannelId: string, segment: number) {
+    const syncJobs = this.jobQueue;
 
-        this.enqueueJob(updatedJob);
+    syncJobs.forEach(job => {
+      if (job.subChannelId === subChannelId && job.segment <= segment) {
+        this.removeJobFromQueue(job);
       }
-    }
+    });
   }
 
   private startObservingReadReceiptQueue(): void {
-    if (this.client.useLegacyUnreadCount) {
+    if (this.client.isUnreadCountEnabled) {
       this.isActive = true;
       this.startSyncReadReceipt();
     }
@@ -117,7 +133,8 @@ export class MessageReadReceiptSyncEngine {
   private stopObservingReadReceiptQueue(): void {
     this.isActive = false;
 
-    this.jobQueue.map(job => {
+    const syncJobs = this.jobQueue;
+    syncJobs.map(job => {
       if (job.syncState === Amity.ReadReceiptSyncState.SYNCING) {
         return { ...job, syncState: Amity.ReadReceiptSyncState.CREATED };
       }
@@ -153,47 +170,50 @@ export class MessageReadReceiptSyncEngine {
     this.startObservingReadReceiptQueue();
   }
 
-  markRead(channelId: string, segment: number): void {
-    // Step 1: Optimistic update of channelUnread.readToSegment to message.segment and update unreadCount value
-    const cacheKey = ['channelUnread', 'get', channelId];
-    const channelUnread = pullFromCache<Amity.ChannelUnread>(cacheKey)?.data;
+  markRead(subChannelId: string, segment: number): void {
+    // Step 1: Optimistic update of subChannelUnreadInfo.readToSegment to message.segment
+    const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
+    const subChannelUnreadInfo = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
 
-    if (channelUnread && segment > channelUnread.readToSegment) {
-      channelUnread.readToSegment = segment;
-      channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
+    if (subChannelUnreadInfo && segment > subChannelUnreadInfo.readToSegment) {
+      subChannelUnreadInfo.readToSegment = segment;
+      subChannelUnreadInfo.unreadCount = Math.max(subChannelUnreadInfo.lastSegment - segment, 0);
 
-      pushToCache(cacheKey, channelUnread);
-      fireEvent('local.channelUnread.updated', channelUnread);
+      const channelUnreadInfo = reCalculateChannelUnreadInfo(subChannelUnreadInfo.channelId);
+      fireEvent('local.channelUnread.updated', channelUnreadInfo);
+
+      pushToCache(cacheKey, subChannelUnreadInfo);
+      fireEvent('local.subChannelUnread.updated', subChannelUnreadInfo);
     }
 
     // Step 2: Enqueue the read receipt
-    this.enqueueReadReceipt(channelId, segment);
+    this.enqueueReadReceipt(subChannelId, segment);
   }
 
-  private enqueueReadReceipt(channelId: string, segment: number): void {
-    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', channelId])?.data;
+  private enqueueReadReceipt(subChannelId: string, segment: number): void {
+    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', subChannelId])?.data;
 
-    // Create new read receipt if it's not exists and add the job to queue
+    // Create new read receipt if it's not exists and add job to queue
     if (!readReceipt) {
-      const readReceiptChannel: Amity.ReadReceipt = {
-        channelId,
+      const readReceiptSubChannel: Amity.ReadReceipt = {
+        subChannelId,
         latestSegment: segment,
         latestSyncSegment: 0,
       };
-      pushToCache(['readReceipt', channelId], readReceiptChannel);
+
+      pushToCache(['readReceipt', subChannelId], readReceiptSubChannel);
     } else if (readReceipt.latestSegment < segment) {
-      // Update latestSegment in read receipt cache
-      pushToCache(['readReceipt', channelId], { ...readReceipt, latestSegment: segment });
+      pushToCache(['readReceipt', subChannelId], { ...readReceipt, latestSegment: segment });
     } else if (readReceipt.latestSyncSegment >= segment) {
       // Skip the job when lastSyncSegment > = segment
       return;
     }
 
-    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(channelId);
+    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(subChannelId);
 
     if (syncJob === null || syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) {
       syncJob = {
-        channelId,
+        subChannelId,
         segment,
         syncState: Amity.ReadReceiptSyncState.CREATED,
         retryCount: 0,
@@ -205,9 +225,11 @@ export class MessageReadReceiptSyncEngine {
     }
   }
 
-  private getSyncJob(channelId: string): Amity.ReadReceiptSyncJob | null {
-    const { jobQueue } = this;
-    const targetJob = jobQueue.find(job => job.channelId === channelId);
+  private getSyncJob(subChannelId: string): Amity.ReadReceiptSyncJob | null {
+    const syncJobs = this.jobQueue;
+
+    const targetJob = syncJobs.find(job => job.subChannelId === subChannelId);
+
     return targetJob || null;
   }
 
@@ -220,6 +242,13 @@ export class MessageReadReceiptSyncEngine {
       this.jobQueue.push(syncJob);
     }
   }
+
+  private removeJobFromQueue(item: Amity.ReadReceiptSyncJob) {
+    const index = this.jobQueue.indexOf(item);
+    if (index > -1) {
+      this.jobQueue.splice(index, 1);
+    }
+  }
 }
 
 let instance: MessageReadReceiptSyncEngine | null = null;

package/src/client/utils/endpoints.ts

@@ -6,6 +6,7 @@ export const API_REGIONS = {
 
 const URLS = {
   http: 'https://apix.{region}.amity.co',
+  upload: 'https://upload.{region}.amity.co',
   mqtt: 'wss://sse.{region}.amity.co:443/mqtt',
 } as const;
 

package/src/client/utils/setClientToken.ts

@@ -30,6 +30,14 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
     isUserDeleted: false,
   };
 
+  client.upload.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.upload.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
   // manually setup the token for ws transport
   if (client.ws) client.ws.io.opts.query = { token: accessToken };
 

package/src/core/model/idResolvers.ts

@@ -26,8 +26,6 @@ const idResolvers: Resolvers = {
   channelUnreadInfo: ({ channelId }) => channelId,
   subChannelUnreadInfo: ({ subChannelId }) => subChannelId,
 
-  channelUnread: ({ channelId }) => channelId,
-
   channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
   subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
   messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,

package/src/fileRepository/api/uploadFile.ts

@@ -42,7 +42,7 @@ export const uploadFile = async <T extends Amity.FileType = any>(
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+  const { data } = await client.upload.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
     headers,
     onUploadProgress({ loaded, total = 100 }) {
       onProgress && onProgress(Math.round((loaded * 100) / total));

package/src/fileRepository/api/uploadImage.ts

@@ -42,7 +42,7 @@ export const uploadImage = async (
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
+  const { data } = await client.upload.post<Amity.CreateFilePayload<'image'>>(
     '/api/v4/images',
     formData,
     {

package/src/fileRepository/api/uploadVideo.ts

@@ -48,7 +48,7 @@ export const uploadVideo = async (
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
+  const { data } = await client.upload.post<Amity.CreateFilePayload<'video'>>(
     '/api/v4/videos',
     formData,
     {

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

@@ -4,12 +4,12 @@ import { createEventSubscriber } from '~/core/events';
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.ChannelUnread} has been updated.
+ * 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 Channel Events
+ * @category MessageMarker Events
  */
 export const onChannelUnreadUpdatedLocal = (
   callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>,
@@ -22,7 +22,7 @@ export const onChannelUnreadUpdatedLocal = (
 
   return createEventSubscriber(
     client,
-    'channel/onChannelUnreadUpdatedLocal',
+    'channelMarker/onChannelUnreadUpdatedLocal',
     'local.channelUnread.updated',
     filter,
   );

package/src/messageRepository/events/onMessageCreated.ts

@@ -6,7 +6,6 @@ import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelU
 import { getActiveUser } from '~/client/api/activeUser';
 import { markReadMessage } from '../utils/markReadMessage';
 import { prepareMessagePayload } from '../utils';
-import { pullFromCache, pushToCache } from '~/cache/api';
 
 /**
  * ```js
@@ -41,39 +40,6 @@ export const onMessageCreatedMqtt = (
       });
     }
 
-    if (client.useLegacyUnreadCount) {
-      rawPayload.messages.forEach(message => {
-        const channelUnread = pullFromCache<Amity.ChannelUnread>([
-          'channelUnread',
-          'get',
-          message.channelId,
-        ])?.data;
-        if (!channelUnread || channelUnread.lastSegment >= message.segment) return;
-
-        const lastSegment = message.segment;
-        const isMentionedInMessage = message.mentionedUsers?.some(mention => {
-          return (
-            mention.type === 'channel' ||
-            (mention.type === 'user' &&
-              client.userId &&
-              mention.userPublicIds.includes(client.userId))
-          );
-        });
-
-        const lastMentionSegment = isMentionedInMessage
-          ? message.segment
-          : channelUnread.lastMentionSegment;
-
-        pushToCache(['channelUnread', 'get', message.channelId], {
-          ...channelUnread,
-          lastSegment,
-          unreadCount: lastSegment - channelUnread.readToSegment,
-          lastMentionSegment,
-          isMentioned: !(channelUnread.readToSegment >= lastMentionSegment),
-        });
-      });
-    }
-
     // Update in cache
     ingestInCache(payload);
 

package/src/messageRepository/utils/markReadMessage.ts

@@ -1,15 +1,8 @@
-import { getActiveClient } from '~/client/api/activeClient';
 import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
-import LegacyReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine';
 
 export const markReadMessage = (message: Amity.InternalMessage) => {
-  const client = getActiveClient();
+  const { subChannelId, channelSegment } = message;
+  const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
 
-  if (client.useLegacyUnreadCount) {
-    const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
-    markReadReceiptEngine.markRead(message.channelId, message.channelSegment);
-  } else {
-    const markReadReceiptEngine = LegacyReadReceiptSyncEngine.getInstance();
-    markReadReceiptEngine.markRead(message.subChannelId, message.channelSegment);
-  }
+  markReadReceiptEngine.markRead(subChannelId, channelSegment);
 };

package/dist/channelRepository/api/markChannelsAsReadBySegment.d.ts

@@ -1,16 +0,0 @@
-/**
- *
- * 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 declare const markChannelsAsReadBySegment: (readings: {
-    channelId: Amity.Channel['channelId'];
-    readToSegment: number;
-}[]) => Promise<boolean>;
-//# sourceMappingURL=markChannelsAsReadBySegment.d.ts.map

package/dist/channelRepository/api/markChannelsAsReadBySegment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markChannelsAsReadBySegment.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/api/markChannelsAsReadBySegment.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,2BAA2B,aAC5B;IACR,SAAS,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;IACtC,aAAa,EAAE,MAAM,CAAC;CACvB,EAAE,KACF,QAAQ,OAAO,CASjB,CAAC"}

package/dist/channelRepository/events/onChannelUnreadUpdatedLocal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onChannelUnreadUpdatedLocal.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/events/onChannelUnreadUpdatedLocal.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,aAC5B,MAAM,QAAQ,CAAC,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC,KACpE,MAAM,YAaR,CAAC"}

package/dist/channelRepository/utils/getLegacyChannelUnread.d.ts

@@ -1,2 +0,0 @@
-export declare const getLegacyChannelUnread: (channelId: string) => Amity.ChannelUnreadInfo | undefined;
-//# sourceMappingURL=getLegacyChannelUnread.d.ts.map

package/dist/channelRepository/utils/getLegacyChannelUnread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLegacyChannelUnread.d.ts","sourceRoot":"","sources":["../../../src/channelRepository/utils/getLegacyChannelUnread.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,cAAe,MAAM,wCAEvD,CAAC"}

package/dist/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine.d.ts

@@ -1,33 +0,0 @@
-export declare class LegacyMessageReadReceiptSyncEngine {
-    private client;
-    private isActive;
-    private MAX_RETRY;
-    private JOB_QUEUE_SIZE;
-    private jobQueue;
-    private timer;
-    private RECEIPT_SYNC_INTERVAL;
-    constructor();
-    startSyncReadReceipt(): void;
-    syncReadReceipts(): void;
-    private getUnsyncJobs;
-    private getReadReceipt;
-    private markReadApi;
-    private removeSynedReceipt;
-    private startObservingReadReceiptQueue;
-    private stopObservingReadReceiptQueue;
-    onSessionEstablished(): void;
-    onSessionDestroyed(): void;
-    onTokenExpired(): void;
-    onNetworkOffline(): void;
-    onNetworkOnline(): void;
-    markRead(subChannelId: string, segment: number): void;
-    private enqueueReadReceipt;
-    private getSyncJob;
-    private enqueueJob;
-    private removeJobFromQueue;
-}
-declare const _default: {
-    getInstance: () => LegacyMessageReadReceiptSyncEngine;
-};
-export default _default;
-//# sourceMappingURL=legacyReadReceiptSyncEngine.d.ts.map

package/dist/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacyReadReceiptSyncEngine.d.ts","sourceRoot":"","sources":["../../../../src/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine.ts"],"names":[],"mappings":"AAMA,qBAAa,kCAAkC;IAC7C,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO,CAAC,QAAQ,CAAQ;IAExB,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,cAAc,CAAO;IAE7B,OAAO,CAAC,QAAQ,CAAwC;IAExD,OAAO,CAAC,KAAK,CAA2B;IAGxC,OAAO,CAAC,qBAAqB,CAAK;;IASlC,oBAAoB;IAQpB,gBAAgB,IAAI,IAAI;IASxB,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,cAAc;YA2BR,WAAW;IA8BzB,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,8BAA8B;IAOtC,OAAO,CAAC,6BAA6B;IAgBrC,oBAAoB,IAAI,IAAI;IAI5B,kBAAkB,IAAI,IAAI;IAK1B,cAAc,IAAI,IAAI;IAKtB,gBAAgB,IAAI,IAAI;IAKxB,eAAe,IAAI,IAAI;IAKvB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAoBrD,OAAO,CAAC,kBAAkB;IAsC1B,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,kBAAkB;CAM3B;;;;AAID,wBAME"}

package/dist/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler.d.ts

@@ -1,3 +0,0 @@
-declare const _default: () => () => void;
-export default _default;
-//# sourceMappingURL=legacyReadReceiptSyncEngineOnLoginHandler.d.ts.map

package/dist/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacyReadReceiptSyncEngineOnLoginHandler.d.ts","sourceRoot":"","sources":["../../../../src/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler.ts"],"names":[],"mappings":";AAGA,wBAiBE"}

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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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/src/channelRepository/api/markChannelsAsReadBySegment.ts

@@ -1,29 +0,0 @@
-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/utils/getLegacyChannelUnread.ts

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