@amityco/ts-sdk 6.18.1-c018952.0 → 6.19.0

package/dist/index.esm.js

@@ -83,8 +83,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v6.18.0-esm'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v6.18.0-esm';
+        // the string ''v6.19.0-esm'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.19.0-esm';
     }
     catch (error) {
         return '__dev__';
@@ -20856,9 +20856,10 @@ const HIGH_PRIORITY_ANALYTIC_CACHE_KEY = ['analytic', 'high-priority'];
 
 const syncEvent = async (events) => {
     const client = getActiveClient();
-    await client.http.post('/api/v1/analytics/activities', {
+    const params = {
         activities: events,
-    });
+    };
+    await client.http.post('/api/v1/analytics/activities', params);
 };
 
 class AnalyticsEventSyncer {
@@ -20876,10 +20877,14 @@ class AnalyticsEventSyncer {
         }, 10 * SECOND$1);
     }
     stop() {
-        if (!this._timer)
-            return;
-        clearInterval(this._timer);
-        this._timer = undefined;
+        if (this._timer) {
+            clearInterval(this._timer);
+            this._timer = undefined;
+        }
+        if (this._high_priority_timer) {
+            clearInterval(this._high_priority_timer);
+            this._high_priority_timer = undefined;
+        }
     }
     async syncCapturedEvent() {
         try {
@@ -21029,6 +21034,12 @@ class AnalyticsEventCapturer {
             this._bufferNewSeenStoryReferenceIds = [];
         }, 300);
     }
+    resetAllBuckets() {
+        this._recentViewed = {};
+        this._recentHighPriorityViewed = {};
+        dropFromCache(ANALYTIC_CACHE_KEY);
+        dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+    }
     markStoryAsViewed(story) {
         this.markStory(story, "view" /* Amity.AnalyticEventActivityType.View */);
     }
@@ -21067,21 +21078,23 @@ class AnalyticsEngine {
         this._eventSyncer.start();
     }
     handleTokenExpired() {
-        this._eventSyncer.stop();
+        this._stopAndDestroy();
     }
     destroy() {
+        this._stopAndDestroy();
+    }
+    _stopAndDestroy() {
         this._eventSyncer.stop();
-        // query and destroy all objects.
-        dropFromCache(ANALYTIC_CACHE_KEY);
+        this._eventCapturer.resetAllBuckets();
     }
 }
-let instance$2;
+let instance$3;
 var AnalyticsEngine$1 = {
     getInstance: () => {
-        if (!instance$2) {
-            instance$2 = new AnalyticsEngine();
+        if (!instance$3) {
+            instance$3 = new AnalyticsEngine();
         }
-        return instance$2;
+        return instance$3;
     },
 };
 
@@ -21680,12 +21693,12 @@ class MessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$1 = null;
+let instance$2 = null;
 var ReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$1)
-            instance$1 = new MessageReadReceiptSyncEngine();
-        return instance$1;
+        if (!instance$2)
+            instance$2 = new MessageReadReceiptSyncEngine();
+        return instance$2;
     },
 };
 
@@ -22099,71 +22112,6 @@ const getChannelIsMentioned = (channel, marker) => {
         : (_d = (_c = getCachedMarker(channel.channelId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
 };
 
-/**
- * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
- * ```
- *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
- *
- * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.SubChannelMarker} objects
- *
- * @category Channel API
- * @async
- * @private
- */
-const getUserMessageFeedMakers = async (channelIds) => {
-    const client = getActiveClient();
-    client.log('channel/getUserMessageFeedMakers', channelIds);
-    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
-        params: {
-            channelIds,
-        },
-    });
-    return data;
-};
-
-const persistUnreadCountInfo = (payload) => {
-    const { feedMarkers, userFeedMarkers } = payload;
-    // calculate sub channel unread info and channel unread info
-    if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
-        const channelIds = [];
-        const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
-        userFeedMarkers.forEach(userFeedMarker => {
-            const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
-            if (!feedMarker)
-                return;
-            if (feedMarker.feedId === userFeedMarker.feedId) {
-                const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
-                const subChannelUnreadInfo = {
-                    subChannelId: feedMarker.feedId,
-                    channelId: feedMarker.entityId,
-                    readToSegment: userFeedMarker.readToSegment,
-                    lastSegment: feedMarker.lastSegment,
-                    lastMentionSegment: userFeedMarker.lastMentionSegment,
-                    unreadCount: Math.max(0, unreadCount),
-                    isMentioned: userFeedMarker.isMentioned,
-                    isDeleted: feedMarker.isDeleted,
-                    createdAt: userFeedMarker.createdAt,
-                    updatedAt: userFeedMarker.updatedAt,
-                };
-                // update sub channel unread info in cache
-                ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
-                if (!channelIds.includes(feedMarker.entityId)) {
-                    channelIds.push(feedMarker.entityId);
-                }
-            }
-        });
-        // re-calculate channel unread info in cache
-        channelIds.forEach(channelId => {
-            reCalculateChannelUnreadInfo(channelId);
-        });
-    }
-};
-
 const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 const isUnreadCountSupport$2 = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
 function convertFromRaw$2(channel, options = { isMessagePreviewUpdated: true }) {
@@ -22198,15 +22146,6 @@ const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated:
 const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpdated: true }) => {
     const client = getActiveClient();
     const networkPreviewSetting = await client.getMessagePreviewSetting(false);
-    // if consistent mode is enabled, persist the unread count info to the cache
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelId }) => channelId));
-        const { feedMarkers, userFeedMarkers } = queryPayload;
-        persistUnreadCountInfo({
-            feedMarkers,
-            userFeedMarkers,
-        });
-    }
     if (options.isMessagePreviewUpdated &&
         networkPreviewSetting !== "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */ &&
         rawPayload.messagePreviews &&
@@ -22274,6 +22213,7 @@ const getChannelByIds = async (channelIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
+    fireEvent('local.channel.fetched', data.channels);
     return {
         data: data.channels,
         cachedAt,
@@ -22344,6 +22284,44 @@ const getMessageMarkers = async (messageIds) => {
     return { data: contentMarkers, cachedAt };
 };
 
+const persistUnreadCountInfo = (payload) => {
+    const { feedMarkers, userFeedMarkers } = payload;
+    // calculate sub channel unread info and channel unread info
+    if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
+        const channelIds = [];
+        const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
+        userFeedMarkers.forEach(userFeedMarker => {
+            const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
+            if (!feedMarker)
+                return;
+            if (feedMarker.feedId === userFeedMarker.feedId) {
+                const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
+                const subChannelUnreadInfo = {
+                    subChannelId: feedMarker.feedId,
+                    channelId: feedMarker.entityId,
+                    readToSegment: userFeedMarker.readToSegment,
+                    lastSegment: feedMarker.lastSegment,
+                    lastMentionSegment: userFeedMarker.lastMentionSegment,
+                    unreadCount: Math.max(0, unreadCount),
+                    isMentioned: userFeedMarker.isMentioned,
+                    isDeleted: feedMarker.isDeleted,
+                    createdAt: userFeedMarker.createdAt,
+                    updatedAt: userFeedMarker.updatedAt,
+                };
+                // update sub channel unread info in cache
+                ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
+                if (!channelIds.includes(feedMarker.entityId)) {
+                    channelIds.push(feedMarker.entityId);
+                }
+            }
+        });
+        // re-calculate channel unread info in cache
+        channelIds.forEach(channelId => {
+            reCalculateChannelUnreadInfo(channelId);
+        });
+    }
+};
+
 /**
  * ```js
  * import { getSubChannelMarkers } from '@amityco/ts-sdk'
@@ -22710,13 +22688,13 @@ class SessionWatcher {
         this._listener.clear();
     }
 }
-let instance;
+let instance$1;
 var SessionWatcher$1 = {
     getInstance: () => {
-        if (!instance) {
-            instance = new SessionWatcher();
+        if (!instance$1) {
+            instance$1 = new SessionWatcher();
         }
-        return instance;
+        return instance$1;
     },
 };
 
@@ -23619,6 +23597,174 @@ var readReceiptSyncEngineOnLoginHandler = () => {
     };
 };
 
+const onOffline = (callback) => {
+    if (typeof window !== 'undefined' && window.addEventListener) {
+        window.addEventListener('offline', callback);
+        return () => window.removeEventListener('offline', callback);
+    }
+    if (typeof document !== 'undefined' && document.addEventListener) {
+        document.addEventListener('offline', callback);
+        return () => document.removeEventListener('offline', callback);
+    }
+    // Handle unsupported environment
+    console.error('Unsupported environment');
+    return () => console.error('Unsupported environment');
+};
+
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const getUserMessageFeedMakers = async (channelIds) => {
+    const client = getActiveClient();
+    client.log('channel/getUserMessageFeedMakers', channelIds);
+    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
+        params: {
+            channelIds,
+        },
+    });
+    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
+    return data;
+};
+
+class ObjectResolverEngine {
+    constructor() {
+        this.TIMER_INTERVAL_MS = SECOND$1;
+        this.BUFFER_ID_LIMIT = 100;
+        this.buffer = {
+            ["channel" /* Amity.ReferenceType.CHANNEL */]: [],
+            ["userMessageFeedMarker" /* Amity.ReferenceType.USER_MESSAGE_FEED_MARKER */]: [],
+        };
+        this.isResolvingTask = false;
+        this.connectionListener = [];
+        this.isConnected = true;
+        this.addConnectionListener();
+    }
+    startResolver() {
+        if (!this.timer) {
+            this.timer = setInterval(() => {
+                if (this.isConnected)
+                    this.resolveObjects();
+            }, this.TIMER_INTERVAL_MS);
+        }
+    }
+    stopResolver() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    resolve(id, referenceType) {
+        const objectIdList = this.getBuffer(referenceType);
+        if (objectIdList.includes(id))
+            return;
+        if (objectIdList.length >= this.BUFFER_ID_LIMIT) {
+            objectIdList.shift(); // Remove first element of the array
+        }
+        objectIdList.push(id);
+    }
+    addConnectionListener() {
+        if (this.connectionListener.length > 0)
+            return;
+        this.connectionListener.push(onOnline(() => {
+            this.isConnected = true;
+        }));
+        this.connectionListener.push(onOffline(() => {
+            this.isConnected = false;
+        }));
+    }
+    removeConnectionListener() {
+        if (this.connectionListener.length > 0)
+            this.connectionListener.forEach(listener => listener());
+    }
+    resolveObjects() {
+        if (this.isResolvingTask) {
+            return;
+        }
+        this.isResolvingTask = true;
+        // Get first 100 ids for all reference type supported.
+        const channelIds = this.getBuffer("channel" /* Amity.ReferenceType.CHANNEL */);
+        const userMessageFeedMarkerIds = this.getBuffer("userMessageFeedMarker" /* Amity.ReferenceType.USER_MESSAGE_FEED_MARKER */);
+        // Clear buffer
+        this.clearBuffer();
+        // Send Requests.
+        // Incase of failure: Ignore
+        // Incase of success: Persist in Domain DB & Notify Live collection
+        if (channelIds.length > 0)
+            getChannelByIds(channelIds);
+        if (userMessageFeedMarkerIds.length > 0)
+            getUserMessageFeedMakers(userMessageFeedMarkerIds);
+        // After sending request
+        this.isResolvingTask = false;
+    }
+    clearBuffer() {
+        this.buffer = {
+            ["channel" /* Amity.ReferenceType.CHANNEL */]: [],
+            ["userMessageFeedMarker" /* Amity.ReferenceType.USER_MESSAGE_FEED_MARKER */]: [],
+        };
+    }
+    getBuffer(referenceType) {
+        return this.buffer[referenceType];
+    }
+    // Session Management : SessionComponent
+    onSessionEstablished() {
+        this.startResolver();
+        this.addConnectionListener();
+    }
+    onSessionDestroyed() {
+        // Stop timer
+        this.stopResolver();
+        // Clear buffer
+        this.clearBuffer();
+        // Reset state
+        this.isResolvingTask = false;
+        // remove connection listener
+        this.removeConnectionListener();
+    }
+    onTokenExpired() {
+        this.stopResolver();
+    }
+}
+let instance = null;
+var ObjectResolverEngine$1 = {
+    getInstance: () => {
+        if (!instance)
+            instance = new ObjectResolverEngine();
+        return instance;
+    },
+};
+
+var objectResolverEngineOnLoginHandler = () => {
+    const objectResolverEngine = ObjectResolverEngine$1.getInstance();
+    objectResolverEngine.startResolver();
+    onSessionStateChange(state => {
+        if (state === "established" /* Amity.SessionStates.ESTABLISHED */) {
+            objectResolverEngine.onSessionEstablished();
+        }
+        else if (state === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            objectResolverEngine.onTokenExpired();
+        }
+        else {
+            objectResolverEngine.onSessionDestroyed();
+        }
+    });
+    return () => {
+        objectResolverEngine.onSessionDestroyed();
+    };
+};
+
 /* begin_public_function
   id: client.logout
 */
@@ -24218,22 +24364,21 @@ const onMessageCreatedLocal = (callback) => {
     };
 };
 
-const persistOptimisticUnreadInfo = (rawPayload) => {
-    rawPayload.messageFeeds.forEach(messageFeed => {
-        const subChannelUnreadInfo = {
-            channelId: messageFeed.channelId,
-            subChannelId: messageFeed.messageFeedId,
-            unreadCount: 0,
-            readToSegment: 0,
-            lastMentionSegment: 0,
-            lastSegment: 0,
-            isMentioned: false,
-            isDeleted: false,
-            createdAt: messageFeed.createdAt,
-            updatedAt: messageFeed.updatedAt,
-        };
-        pushToCache(['subChannelUnreadInfo', 'get', subChannelUnreadInfo.subChannelId], subChannelUnreadInfo);
-    });
+const persistOptimisticUnreadInfo = (subChannelOptimisticInfo) => {
+    const { channelId, subChannelId, createdAt, updatedAt } = subChannelOptimisticInfo;
+    const subChannelUnreadInfo = {
+        channelId,
+        subChannelId,
+        unreadCount: 0,
+        readToSegment: 0,
+        lastMentionSegment: 0,
+        lastSegment: 0,
+        isMentioned: false,
+        isDeleted: false,
+        createdAt,
+        updatedAt,
+    };
+    pushToCache(['subChannelUnreadInfo', 'get', subChannelUnreadInfo.subChannelId], subChannelUnreadInfo);
 };
 
 /**
@@ -24257,7 +24402,14 @@ const onSubChannelCreated = (callback) => {
         const payload = await prepareSubChannelPayload(rawPayload);
         // optimistically create subChannelUnreadInfo
         if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-            persistOptimisticUnreadInfo(rawPayload);
+            rawPayload.messageFeeds.forEach(subChannel => {
+                persistOptimisticUnreadInfo({
+                    channelId: subChannel.channelId,
+                    subChannelId: subChannel.messageFeedId,
+                    createdAt: subChannel.createdAt,
+                    updatedAt: subChannel.updatedAt,
+                });
+            });
         }
         ingestInCache(payload);
         callback(payload.messageFeeds[0]);
@@ -24673,7 +24825,7 @@ const login = async (params, sessionHandler, config) => {
         // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
         // the channel because currently backend can't handle this, so every time a user is banned from
         // a channel or the channel is deleted the channel's unread count will not be reset to zero
-        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), readReceiptSyncEngineOnLoginHandler());
+        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), readReceiptSyncEngineOnLoginHandler(), objectResolverEngineOnLoginHandler());
         const markerSyncUnsubscriber = await startMarkerSync();
         subscriptions.push(markerSyncUnsubscriber);
     }
@@ -25239,6 +25391,7 @@ const liveObject = (id, callback, key, fetcher, eventHandlers, options) => {
         dispatcher({ loading: false, data: eventModel, origin: 'event' });
     };
     const onFetch = () => {
+        // TODO: Ihis `@ts-ignore` is bring back to fix the build and it needs to be removed later
         // @ts-ignore
         const query = createQuery(fetcher, id, true);
         runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
@@ -29507,6 +29660,18 @@ const updateChannel = async (channelId, patch) => {
 };
 /* end_public_function */
 
+const prepareUnreadCountInfo = async (rawPayload) => {
+    const client = getActiveClient();
+    // if consistent mode is enabled, persist the unread count info to the cache
+    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelId }) => channelId));
+    const { feedMarkers, userFeedMarkers } = queryPayload;
+    persistUnreadCountInfo({
+        feedMarkers,
+        userFeedMarkers,
+    });
+    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
+};
+
 /**
  * ```js
  * import { getChannel } from '@amityco/ts-sdk'
@@ -29529,6 +29694,9 @@ const getChannel$1 = async (channelId) => {
     try {
         const { data: payload } = await client.http.get(`/api/v3/channels/${encodeURIComponent(channelId)}`);
         data = await prepareChannelPayload(payload);
+        if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+            prepareUnreadCountInfo(payload);
+        }
     }
     catch (error) {
         if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
@@ -29792,8 +29960,8 @@ const observeChannel = (channelId, callback) => {
         (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
     };
     const disposers = [];
-    disposers.push(onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')), onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')), onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')), onChannelMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')), onChannelMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')), convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel')(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')));
-    runQuery(createQuery(getChannel$1, channelId), result => result.data && router(result, 'onFetch'));
+    disposers.push(onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, "onUpdate" /* Amity.ChannelActionType.OnUpdate */)), onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, "onDelete" /* Amity.ChannelActionType.OnDelete */)), onChannelJoined(data => router({ data, loading: false, origin: 'event' }, "onJoin" /* Amity.ChannelActionType.OnJoin */)), onChannelLeft(data => router({ data, loading: false, origin: 'event' }, "onLeft" /* Amity.ChannelActionType.OnLeft */)), onChannelMuted(data => router({ data, loading: false, origin: 'event' }, "onMute" /* Amity.ChannelActionType.OnMute */)), onChannelMemberAdded(data => router({ data, loading: false, origin: 'event' }, "onMemberAdded" /* Amity.ChannelActionType.OnMemberAdded */)), onChannelMemberRemoved(data => router({ data, loading: false, origin: 'event' }, "onMemberRemoved" /* Amity.ChannelActionType.OnMemberRemoved */)), convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel')(data => router({ data, loading: false, origin: 'event' }, "onUpdate" /* Amity.ChannelActionType.OnUpdate */)));
+    runQuery(createQuery(getChannel$1, channelId), result => result.data && router(result, "onFetch" /* Amity.ChannelActionType.OnFetch */));
     return () => {
         log(`observeChannel(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -29827,7 +29995,7 @@ const observeChannels = (callback) => {
         (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, channel);
         (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, channel);
     };
-    disposers.push(onChannelCreated(data => router(data, 'onCreate')), onChannelUpdated(data => router(data, 'onUpdate')), onChannelDeleted(data => router(data, 'onDelete')), onChannelJoined(data => router(data, 'onJoin')), onChannelLeft(data => router(data, 'onLeft')), onChannelMuted(data => router(data, 'onMute')), onChannelMemberAdded(data => router(data, 'onMemberAdded')), onChannelMemberRemoved(data => router(data, 'onMemberRemoved')), convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel')(data => router(data, 'onUpdate')));
+    disposers.push(onChannelCreated(data => router(data, "onCreate" /* Amity.ChannelActionType.OnCreate */)), onChannelUpdated(data => router(data, "onUpdate" /* Amity.ChannelActionType.OnUpdate */)), onChannelDeleted(data => router(data, "onDelete" /* Amity.ChannelActionType.OnDelete */)), onChannelJoined(data => router(data, "onJoin" /* Amity.ChannelActionType.OnJoin */)), onChannelLeft(data => router(data, "onLeft" /* Amity.ChannelActionType.OnLeft */)), onChannelMuted(data => router(data, "onMute" /* Amity.ChannelActionType.OnMute */)), onChannelMemberAdded(data => router(data, "onMemberAdded" /* Amity.ChannelActionType.OnMemberAdded */)), onChannelMemberRemoved(data => router(data, "onMemberRemoved" /* Amity.ChannelActionType.OnMemberRemoved */)), convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel')(data => router(data, "onUpdate" /* Amity.ChannelActionType.OnUpdate */)));
     return () => {
         log(`observeChannels(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -32344,6 +32512,16 @@ class ChannelPaginationController extends PaginationController {
     }
 }
 
+/* eslint-disable no-use-before-define */
+class ChannelPaginationNoPageController extends PaginationNoPageController {
+    async getRequest(queryParams) {
+        const { data: queryResponse } = await this.http.get(`/api/v3/channels/list`, {
+            params: Object.assign({}, queryParams),
+        });
+        return queryResponse;
+    }
+}
+
 /* eslint-disable no-use-before-define */
 class ChannelQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload, paginationController) {
@@ -32379,11 +32557,22 @@ class ChannelQueryStreamController extends QueryStreamController {
             const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
             if (!collection)
                 return;
-            if (this.paginationController instanceof ChannelPaginationController &&
-                action === 'onCreate') {
-                collection.data = [...new Set([payload.channelId, ...collection.data])];
-                pushToCache(this.cacheKey, collection);
+            if (this.paginationController instanceof ChannelPaginationNoPageController)
+                return this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            if ([
+                "onCreate" /* Amity.ChannelActionType.OnCreate */,
+                "onJoin" /* Amity.ChannelActionType.OnJoin */,
+                "onFetch" /* Amity.ChannelActionType.OnFetch */,
+                "onUserMessageFeedMarkerFetch" /* Amity.ChannelActionType.OnUserMessageFeedMarkerFetch */,
+            ].includes(action)) {
+                if (Array.isArray(payload))
+                    collection.data = [
+                        ...new Set([...payload.map(({ channelId }) => channelId), ...collection.data]),
+                    ];
+                else
+                    collection.data = [...new Set([payload.channelId, ...collection.data])];
             }
+            pushToCache(this.cacheKey, collection);
             this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
         };
     }
@@ -32392,15 +32581,63 @@ class ChannelQueryStreamController extends QueryStreamController {
     }
 }
 
-/* eslint-disable no-use-before-define */
-class ChannelPaginationNoPageController extends PaginationNoPageController {
-    async getRequest(queryParams) {
-        const { data: queryResponse } = await this.http.get(`/api/v3/channels/list`, {
-            params: Object.assign({}, queryParams),
-        });
-        return queryResponse;
+/**
+ * ```js
+ * import { onChannelFetched } from '@amityco/ts-sdk'
+ * const dispose = onChannelFetched(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} list have been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        callback(payload);
+    };
+    return createEventSubscriber(client, 'onChannelFetched', 'local.channel.fetched', filter);
+};
+
+/**
+ * ```js
+ * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerUpdated(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMessageFeedMarkerPayload} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+const onUserFeedMarkerFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        // update sub channel unread info and channel unread info in cache
+        persistUnreadCountInfo(payload.userMessageFeedMarker);
+        callback(payload.userMessageFeedMarker);
+    };
+    return createEventSubscriber(client, 'feedMarker/onUserFeedMarkerFetched', 'local.userMessageFeedMarker.fetched', filter);
+};
+
+const resolveUnreadInfoOnChannelEvent = (channel, callback) => {
+    const client = getActiveClient();
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        const objectResolverEngine = ObjectResolverEngine$1.getInstance();
+        objectResolverEngine.resolve(channel.channelId, "userMessageFeedMarker" /* Amity.ReferenceType.USER_MESSAGE_FEED_MARKER */);
     }
-}
+    else
+        callback(channel);
+};
 
 /* eslint-disable no-use-before-define */
 class ChannelLiveCollectionController extends LiveCollectionController {
@@ -32410,7 +32647,18 @@ class ChannelLiveCollectionController extends LiveCollectionController {
         const paginationController = ChannelLiveCollectionController.getPaginationController(query);
         super(paginationController, queryStreamId, cacheKey, callback);
         this.query = query;
-        this.queryStreamController = new ChannelQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareChannelPayload, paginationController);
+        this.queryStreamController = new ChannelQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), async (channel) => {
+            try {
+                const client = getActiveClient();
+                if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+                    await prepareUnreadCountInfo(channel);
+                }
+            }
+            catch (e) {
+                console.error('Error while preparing unread count info', e);
+            }
+            return prepareChannelPayload(channel);
+        }, paginationController);
         this.paginationController = paginationController;
         this.callback = callback.bind(this);
         this.loadPage(true);
@@ -32534,15 +32782,19 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                             'get',
                             message.channelId,
                         ])) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!cacheData)
-                            return;
-                        updateChannelCache(cacheData, {
-                            lastActivity: message.createdAt,
-                        });
-                        callback(message);
+                        if (!cacheData) {
+                            const objectResolverEngine = ObjectResolverEngine$1.getInstance();
+                            objectResolverEngine.resolve(message.channelId, "channel" /* Amity.ReferenceType.CHANNEL */);
+                        }
+                        else {
+                            updateChannelCache(cacheData, {
+                                lastActivity: message.createdAt,
+                            });
+                            callback(message);
+                        }
                     });
                 }, 'messageId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 // TODO: merge this code to another onMessageCreated in this file
@@ -32562,12 +32814,19 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                         callback(message);
                     });
                 }, 'messageId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            { fn: onChannelDeleted, action: "onDelete" /* Amity.ChannelActionType.OnDelete */ },
+            { fn: onChannelUpdated, action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */ },
+            { fn: onChannelMuted, action: "onMute" /* Amity.ChannelActionType.OnMute */ },
+            {
+                fn: (callback) => {
+                    return onChannelJoined(channel => {
+                        resolveUnreadInfoOnChannelEvent(channel, callback);
+                    });
+                },
+                action: "onJoin" /* Amity.ChannelActionType.OnJoin */,
             },
-            { fn: onChannelDeleted, action: 'onDelete' },
-            { fn: onChannelUpdated, action: 'onUpdate' },
-            { fn: onChannelMuted, action: 'onMute' },
-            { fn: onChannelJoined, action: 'onJoin' },
             {
                 fn: (reactor) => {
                     const callback = (channel, member) => {
@@ -32582,17 +32841,17 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onChannelLeft(callback);
                 },
-                action: 'onLeft',
+                action: "onLeft" /* Amity.ChannelActionType.OnLeft */,
             },
-            { fn: onChannelMemberAdded, action: 'onMemberAdded' },
-            { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
+            { fn: onChannelMemberAdded, action: "onMemberAdded" /* Amity.ChannelActionType.OnMemberAdded */ },
+            { fn: onChannelMemberRemoved, action: "onMemberRemoved" /* Amity.ChannelActionType.OnMemberRemoved */ },
             {
                 fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload((callback) => {
@@ -32618,7 +32877,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onMessageCreatedMqtt(updateMessagePreview);
                 }, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload((callback) => {
@@ -32644,7 +32903,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onMessageCreatedLocal(updateMessagePreview);
                 }, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload((callback) => {
@@ -32659,7 +32918,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onMessageUpdated(updateMessagePreview);
                 }, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload((callback) => {
@@ -32680,7 +32939,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onMessageDeleted(updateMessagePreview);
                 }, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload((callback) => {
@@ -32700,7 +32959,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onSubChannelDeleted(updateMessagePreview);
                 }, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload((callback) => {
@@ -32719,19 +32978,48 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                     };
                     return onSubChannelUpdated(updateMessagePreview);
                 }, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload(onUserFeedMarkerUpdated, 'entityId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
                 fn: convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
-                action: 'onUpdate',
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: onChannelFetched,
+                action: "onFetch" /* Amity.ChannelActionType.OnFetch */,
+            },
+            {
+                fn: (callback) => {
+                    const handleUserFeedMarkerFetch = async (marker) => {
+                        if (marker.feedMarkers) {
+                            const channelIds = marker.feedMarkers.map(feedMarker => feedMarker.entityId);
+                            const channels = channelIds
+                                .map(channelId => { var _a; return (_a = pullFromCache(['channel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data; })
+                                .filter(Boolean);
+                            callback(channels);
+                        }
+                    };
+                    return onUserFeedMarkerFetched(handleUserFeedMarkerFetch);
+                },
+                action: "onUserMessageFeedMarkerFetch" /* Amity.ChannelActionType.OnUserMessageFeedMarkerFetch */,
             },
         ];
         if (this.paginationController instanceof PaginationController) {
-            return [...subscriptions, { fn: onChannelCreated, action: 'onCreate' }];
+            return [
+                ...subscriptions,
+                {
+                    fn: (callback) => {
+                        return onChannelCreated(channel => {
+                            resolveUnreadInfoOnChannelEvent(channel, callback);
+                        });
+                    },
+                    action: "onCreate" /* Amity.ChannelActionType.OnCreate */,
+                },
+            ];
         }
         return subscriptions;
     }
@@ -37949,7 +38237,7 @@ var index$2 = /*#__PURE__*/Object.freeze({
   getPoll: getPoll
 });
 
-const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDAARz+hmBgi8pJ\nQb8LeY41gtHhk+ACMwRfhsn7GqpqRQNG2qU0755mzZuVDUqjQMGSo8THJB7O+OJs\nflbZRkFXlFoFOVNw1UpNOgwEQZ6wB9oRwzepTJAfF1sVhm/o/ixvXh1zDFNDy6yZ\npXyiiJHUVxqyjllZhxnwdvjoVtDs6hW6awG09bB9nh/TTejlUKXoAgzqVwu/1QMu\nUVViET495elEe19aUarEy+oL2iKeXCEvqda/pWNBdbieFyJvvZ08HN8dPuT88wq2\njZLEAth1vrwQ2IAa4ktaLcBQdLJgIkrbDvAiVZ8lQAjS/bq5vXQikTGvoPlC5bbn\nvuOM/3eLAgMBAAECggEAVZ+peHAghq2QVj71nX5lxsNCKaCyYwixSJBpfouTt7Rz\nE6PpzMOXFi1W1o+I22jDakuSM2SOQKqI/u0QefB0r0O/KVk5NrZHXk0mkrdYtxOp\nUgaGyf8UvmjB+8VqHrNKyZdk9qtmbnNj01kTTcAtmE4H39zPR7eR/8Rul94vaZbs\nwCnKJS3mLT3JxyGug6lxanveKkjG+CKC1nJQYWaxCJxaFSzbwXQPvDhB+TvrIbee\npd5v4EAyEJohpr+T9oDGGJkb/KARBZCtwLyB976PKJwwBA8MRVL1i5QwawuMiMq5\nUtnOnbGKtCeFzaLbNU0Qi8bqyims84EQxC6DOu1fkQKBgQDdvsoBsEhsOXV7hlIJ\naEd0eSJZVkdqimxH8uGoMM2FeNaOrcB6yBXqTSP0R3OIyf8eaY6yjRvP30ZNXcll\n/gD3O1Mu6YmWQdt1W2WA6pKOsUuPXasf0pdOF7IiFZKlSabz5YHXFqwVuqm8loaj\nsXel3YWqPVdHiankE7tz+3ssnQKBgQDdqi4TNdD1MdEpihx19jr0QjUiXW3939FK\nqp30HESPEGDGQzXdmJgif9HhZb+cJSuWaHEbjgBrYahvgCF+y6LbEpOD+D/dmT+s\nDEAQaR84sah6dokwPjV8fjBSrcVFjCS+doxv0d3p/9OUEeyUhFrY03nxtIEYkLIE\n/Zvn37b4RwKBgQCLENVFe9XfsaVhQ5r9dV2iyTlmh7qgMZG5CbTFs12hQGhm8McO\n+Z7s41YSJCFr/yq1WwP4LJDtrBw99vyQr1zRsG35tNLp3gGRNzGQSQyC2uQFVHw2\np+7mNewsfhUK/gbrXNsyFnDz6635rPlhfbII3sWuP2wWXFqkxE9CbMwR7QKBgQC6\nawDMzxmo2/iYArrkyevSuEuPVxvFwpF1RgAI6C0QVCnPE38dmdN4UB7mfHekje4W\nVEercMURidPp0cxZolCYBQtilUjAyL0vqC3In1/Ogjq6oy3FEMxSop1pKxMY5j+Q\nnoqFD+6deLUrddeNH7J3X4LSr4dSbX4JjG+tlgt+yQKBgQCuwTL4hA6KqeInQ0Ta\n9VQX5Qr8hFlqJz1gpymi/k63tW/Ob8yedbg3WWNWyShwRMFYyY9S81ITFWM95uL6\nvF3x9rmRjwElJw9PMwVu6dmf/CO0Z1wzXSp2VVD12gbrUD/0/d7MUoJ9LgC8X8f/\nn0txLHYGHbx+nf95+JUg6lV3hg==\n-----END PRIVATE KEY-----";
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
 /*
  * The crypto algorithm used for importing key and signing string
  */