@amityco/ts-sdk 6.17.1-e9b6af1.0 → 6.17.2-ea577e1.0

package/dist/index.cjs.js

@@ -98,8 +98,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v6.17.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v6.17.0-cjs';
+        // the string ''v6.17.1-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.17.1-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -5826,7 +5826,14 @@ const getUserMarker = async () => {
     if (client.cache)
         ingestInCache({ userMarkers }, { cachedAt });
     fireEvent('local.userMarker.fetched', { userMarkers });
-    return { data: userMarkers[0], cachedAt };
+    const latestUserMarker = userMarkers.reduce((maxUserMarker, userMarker) => {
+        if (maxUserMarker == null ||
+            new Date(maxUserMarker.lastSyncAt).getTime() < new Date(userMarker.lastSyncAt).getTime()) {
+            return userMarker;
+        }
+        return maxUserMarker;
+    }, null);
+    return { data: latestUserMarker, cachedAt };
 };
 
 /** @hidden */
@@ -6001,17 +6008,25 @@ const preUpdateMessageCache = (rawPayload) => {
         messages: rawPayload.messages.map(message => convertFromRaw(message, rawPayload.reactions)),
     });
 };
+const DEBOUNCE_TIME = 2000;
+const currentDebounceMap = {};
 const prepareMessagePayload = async (payload, event) => {
     const markerIds = payload.messages.map(({ messageId }) => messageId);
     if (markerIds.length > 0) {
         // since the get markers method requires a channel cache to function with the reducer.
         preUpdateMessageCache(payload);
-        try {
-            await getMessageMarkers(markerIds);
-        }
-        catch (e) {
-            // empty block (from the spec, allow marker fetch to fail without having to do anything)
+        const markerIdsKey = markerIds.join('');
+        if (currentDebounceMap[markerIdsKey]) {
+            clearTimeout(currentDebounceMap[markerIdsKey]);
         }
+        currentDebounceMap[markerIdsKey] = setTimeout(() => {
+            try {
+                getMessageMarkers(markerIds);
+            }
+            catch (_error) {
+                // do nothing
+            }
+        }, DEBOUNCE_TIME);
     }
     const { messageFeeds } = payload, restPayload = __rest(payload, ["messageFeeds"]);
     // upsert messageFeeds to subchannel cache because messageFeeds from event payload not include messagePreviewId
@@ -6617,43 +6632,92 @@ const initializeMessagePreviewSetting = async () => {
 
 /**
  * ```js
- * import { getFeedSettings } from '@amityco/ts-sdk'
- * const feedSettings = await getFeedSettings()
- * const postFeedSetting = feedSettings.post
+ * import { getSocialSettings } from '@amityco/ts-sdk'
+ * const socialSettings = await getSocialSettings()
  * ```
  *
- * Fetches a {@link Amity.FeedSettings} object
+ * Fetches a {@link Amity.SocialSettings} object
  *
- * @returns A Promise of {@link Amity.FeedSettings} object
+ * @returns A Promise of {@link Amity.SocialSettings} object
  *
  * @category Client API
  * @async
  */
-const getFeedSettings = async () => {
+const getSocialSettings = async () => {
     const client = getActiveClient();
-    const { data } = await client.http.get(`/api/v3/network-settings/feed-setting`);
-    return Object.fromEntries(data.feedSettings.map(({ feedType, contentSettings }) => {
-        return [feedType, contentSettings];
-    }));
+    const { data } = await client.http.get(`/api/v3/network-settings/social`);
+    return data.socialNetworkSetting;
+};
+
+const checkUserPermission = (userId, permission) => {
+    var _a;
+    const user = (_a = pullFromCache(['users', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!user)
+        return false;
+    return user.permissions.some(x => x === permission);
+};
+
+const checkCommunityPermission = (userId, permission, communityId) => {
+    var _a;
+    if (!userId)
+        return false;
+    const member = (_a = pullFromCache([
+        'communityUsers',
+        'get',
+        `${communityId}#${userId}`,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!member)
+        return false;
+    if (member.permissions.some(x => x === permission))
+        return true;
+    return checkUserPermission(userId, permission);
+};
+
+const checkChannelPermission = (userId, permission, channelId) => {
+    var _a;
+    if (!userId)
+        return false;
+    const member = (_a = pullFromCache([
+        'channelUsers',
+        'get',
+        `${channelId}#${userId}`,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!member)
+        return false;
+    if (member.permissions.some(x => x === permission))
+        return true;
+    return checkUserPermission(userId, permission);
+};
+
+const hasPermission$1 = (permission) => {
+    const { userId } = getActiveClient();
+    return {
+        currentUser: () => checkUserPermission(userId, permission),
+        community: (communityId) => checkCommunityPermission(userId, permission, communityId),
+        channel: (channelId) => checkChannelPermission(userId, permission, channelId),
+    };
 };
 
 /**
  * ```js
- * import { getSocialSettings } from '@amityco/ts-sdk'
- * const socialSettings = await getSocialSettings()
+ * import { getFeedSettings } from '@amityco/ts-sdk'
+ * const feedSettings = await getFeedSettings()
+ * const postFeedSetting = feedSettings.post
  * ```
  *
- * Fetches a {@link Amity.SocialSettings} object
+ * Fetches a {@link Amity.FeedSettings} object
  *
- * @returns A Promise of {@link Amity.SocialSettings} object
+ * @returns A Promise of {@link Amity.FeedSettings} object
  *
  * @category Client API
  * @async
  */
-const getSocialSettings = async () => {
+const getFeedSettings = async () => {
     const client = getActiveClient();
-    const { data } = await client.http.get(`/api/v3/network-settings/social`);
-    return data.socialNetworkSetting;
+    const { data } = await client.http.get(`/api/v3/network-settings/feed-setting`);
+    return Object.fromEntries(data.feedSettings.map(({ feedType, contentSettings }) => {
+        return [feedType, contentSettings];
+    }));
 };
 
 /*
@@ -7358,6 +7422,7 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         sessionState,
         accessTokenExpiryWatcher,
         sessionHandler,
+        hasPermission: hasPermission$1,
         getFeedSettings,
         getSocialSettings,
         getMessagePreviewSetting,
@@ -7452,7 +7517,9 @@ const markerSync = async (deviceLastSyncAt) => {
 const onChannelMarkerFetched = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        callback(payload.userEntityMarkers[0]);
+        payload.userEntityMarkers.forEach(marker => {
+            callback(marker);
+        });
     };
     return createEventSubscriber(client, 'channelMarker/onChannelMarkerFetched', 'local.channelMarker.fetched', filter);
 };
@@ -7566,6 +7633,13 @@ const onFeedMarkerUpdated = (callback) => {
  * @category UserMarker Events
  */
 const onUserMarkerFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        callback(payload.userMarkers);
+    };
+    return createEventSubscriber(client, 'userMarker/onUserMarkerFetched', 'local.userMarker.fetched', filter);
+};
+const onUserMarkerFetchedLegacy = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
         callback(payload.userMarkers[0]);
@@ -7821,7 +7895,10 @@ const getTotalUnreadCount = (callback) => {
     if (!userId)
         throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
     const callbackDataSelector = (data) => { var _a; return (_a = data === null || data === void 0 ? void 0 : data.unreadCount) !== null && _a !== void 0 ? _a : 0; };
-    return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
+    return liveObject(userId, callback, 'userId', async () => {
+        const { data: userMarker, cachedAt } = await getUserMarker();
+        return { data: userMarker, cachedAt };
+    }, [onUserMarkerFetchedLegacy], {
         callbackDataSelector,
     });
 };
@@ -7847,16 +7924,77 @@ const getUserUnread = (callback) => {
     const { _id: userId } = getActiveUser();
     if (!userId)
         throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-    const callbackDataSelector = (data) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Object feature you need to enable Cache!');
+    }
+    const timestamp = Date.now();
+    log(`liveUserUnread(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    let isUnsyncedModel = false; // for messages
+    const dispatcher = (data) => {
+        const userUnread = data.data;
+        callback({
+            data: {
+                hasMentioned: userUnread.hasMentioned,
+                unreadCount: userUnread.unreadCount,
+            },
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (userMarkers) => {
         var _a;
-        return {
-            unreadCount: (_a = data === null || data === void 0 ? void 0 : data.unreadCount) !== null && _a !== void 0 ? _a : 0,
-            hasMentioned: !!(data === null || data === void 0 ? void 0 : data.hasMentioned),
-        };
+        const filterUserMarkers = userMarkers.filter(userMarker => userId === userMarker.userId);
+        const latestUserMarker = filterUserMarkers.reduce((currentMaxUserMarker, userMarker) => {
+            if (currentMaxUserMarker == null ||
+                new Date(userMarker.lastSyncAt).getTime() >
+                    new Date(currentMaxUserMarker.lastSyncAt).getTime()) {
+                return userMarker;
+            }
+            return currentMaxUserMarker;
+        }, null);
+        dispatcher({
+            loading: false,
+            data: {
+                unreadCount: (_a = latestUserMarker === null || latestUserMarker === void 0 ? void 0 : latestUserMarker.unreadCount) !== null && _a !== void 0 ? _a : 0,
+                hasMentioned: filterUserMarkers.some(userMarker => !!userMarker.hasMentioned),
+            },
+        });
+    };
+    function isAmityUserMarkerData(data) {
+        if (data == null)
+            return false;
+        return data.data != null;
+    }
+    const onFetch = () => {
+        const query = createQuery(getUserMarker);
+        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+            if (!isAmityUserMarkerData(data))
+                return;
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* 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(onUserMarkerFetched(userMarkers => realtimeRouter(userMarkers)));
+    onFetch();
+    return () => {
+        disposers.forEach(fn => fn());
     };
-    return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
-        callbackDataSelector,
-    });
 };
 
 /**
@@ -8167,21 +8305,30 @@ const onUserMarkerSync = (callback) => {
  *
  * @category Message Events
  */
-const onMessageCreated = (callback, local = true) => {
+const onMessageCreatedMqtt = (callback) => {
     const client = getActiveClient();
     const filter = async (rawPayload) => {
         const payload = await prepareMessagePayload(rawPayload);
-        const message = payload.messages[0];
         // Update in cache
         ingestInCache(payload);
-        callback(message);
+        payload.messages.forEach(message => {
+            callback(message);
+        });
     };
     const disposers = [
         createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
     ];
-    if (local) {
-        createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload => callback(payload.messages[0]));
-    }
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+const onMessageCreatedLocal = (callback) => {
+    const client = getActiveClient();
+    const disposers = [
+        createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload => payload.messages.forEach(message => {
+            callback(message);
+        })),
+    ];
     return () => {
         disposers.forEach(fn => fn());
     };
@@ -8495,18 +8642,22 @@ let isWaitingForResponse = false;
 let deviceLastSyncAt = null;
 const getDeviceLastSyncAt = () => {
     if (deviceLastSyncAt == null) {
-        return new Date().toISOString();
+        return new Date();
     }
     return deviceLastSyncAt;
 };
 const saveDeviceLastSyncAt = (lastSyncAt) => {
-    if (!deviceLastSyncAt || new Date(lastSyncAt).getTime() > new Date(deviceLastSyncAt).getTime()) {
+    if (lastSyncAt == null)
+        return;
+    if (!deviceLastSyncAt || lastSyncAt.getTime() > deviceLastSyncAt.getTime()) {
         deviceLastSyncAt = lastSyncAt;
     }
 };
 const fetchDeviceLastSyncAt = async () => {
     const { data: userMarker } = await getUserMarker();
-    saveDeviceLastSyncAt(userMarker.lastSyncAt);
+    if (userMarker == null)
+        return;
+    saveDeviceLastSyncAt(new Date(userMarker.lastSyncAt));
 };
 /**
  * list of conditions that make timer still trigger the syncing process.
@@ -8544,18 +8695,33 @@ const markerSyncTrigger = async () => {
         // no event that require to call marker sync API
         return;
     }
-    isWaitingForResponse = true;
-    // any past events are considered processed here.
-    // however during waiting for the response, RTE could add the new message event;
-    // which will make the engine trigger another call next round.
-    events = [];
-    const response = await markerSync(getDeviceLastSyncAt());
-    saveDeviceLastSyncAt(response.data.userMarkers[0].lastSyncAt);
-    if (response.hasMore) {
-        events.push("has_more" /* Amity.MarkerSyncEvent.HAS_MORE */);
-    }
-    // eslint-disable-next-line require-atomic-updates
-    isWaitingForResponse = false;
+    try {
+        isWaitingForResponse = true;
+        // any past events are considered processed here.
+        // however during waiting for the response, RTE could add the new message event;
+        // which will make the engine trigger another call next round.
+        events = [];
+        const response = await markerSync(getDeviceLastSyncAt().toISOString());
+        const latestLastSyncAt = response.data.userMarkers.reduce((maxLastSyncAt, userMarker) => {
+            if (maxLastSyncAt == null ||
+                maxLastSyncAt.getTime() < new Date(userMarker.lastSyncAt).getTime()) {
+                return new Date(userMarker.lastSyncAt);
+            }
+            return maxLastSyncAt;
+        }, null);
+        saveDeviceLastSyncAt(latestLastSyncAt);
+        if (response.hasMore) {
+            events.push("has_more" /* Amity.MarkerSyncEvent.HAS_MORE */);
+        }
+    }
+    catch (_a) {
+        // prevent sync from stopping
+    }
+    finally {
+        if (isWaitingForResponse) {
+            isWaitingForResponse = false;
+        }
+    }
 };
 const registerEventListeners = () => {
     if (disposers.length > 0) {
@@ -8569,14 +8735,11 @@ const registerEventListeners = () => {
     disposers.push(onOnline(() => {
         // should add RESUME to the event to trigger marker syncing again
         events.push("resume" /* Amity.MarkerSyncEvent.RESUME */);
-    }), onMessageCreated(message => {
+    }), onMessageCreatedMqtt(message => {
         // only conversation, community and broadcast types can sync
         if (isUnreadCountSupport(message))
             events.push("new message" /* Amity.MarkerSyncEvent.NEW_MESSAGE */);
-    }, 
-    // only trigger sync from remote events to prevent an unread count equal `-1`
-    // when an optimistic message creation is performed.
-    false), onChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.CHANNEL_CREATED */)), onChannelDeleted(() => events.push("subchannel is deleted" /* Amity.MarkerSyncEvent.CHANNEL_DELETED */)), onChannelJoined(() => events.push("subchannel is joined" /* Amity.MarkerSyncEvent.CHANNEL_JOINED */)), onChannelLeft(() => events.push("subchannel is left" /* Amity.MarkerSyncEvent.CHANNEL_LEFT */)), onSubChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED */)), onSubChannelDeleted(() => 
+    }), onChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.CHANNEL_CREATED */)), onChannelDeleted(() => events.push("subchannel is deleted" /* Amity.MarkerSyncEvent.CHANNEL_DELETED */)), onChannelJoined(() => events.push("subchannel is joined" /* Amity.MarkerSyncEvent.CHANNEL_JOINED */)), onChannelLeft(() => events.push("subchannel is left" /* Amity.MarkerSyncEvent.CHANNEL_LEFT */)), onSubChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED */)), onSubChannelDeleted(() => 
     /*
      workaround: when receiving the event for sub-channel deletion,
      before triggering marker update, the SDK will have to add a 2-second delay.
@@ -13117,7 +13280,26 @@ const getChannel = (channelId, callback) => {
                 });
                 callback(message);
             };
-            return onMessageCreated(updateMessagePreview);
+            return onMessageCreatedMqtt(updateMessagePreview);
+        }, 'channelId', 'channel'),
+        convertEventPayload((callback) => {
+            const updateMessagePreview = async (message) => {
+                var _a;
+                const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+                if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                    return;
+                await handleMessageCreated(message);
+                if (message.channelId !== channelId)
+                    return;
+                const channel = (_a = pullFromCache(['channel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                if (!channel)
+                    return;
+                updateChannelCache(channel, {
+                    messagePreviewId: message.messageId,
+                });
+                callback(message);
+            };
+            return onMessageCreatedLocal(updateMessagePreview);
         }, 'channelId', 'channel'),
         convertEventPayload((callback) => {
             const updateMessagePreview = async (message) => {
@@ -13556,7 +13738,27 @@ class ChannelLiveCollectionController extends LiveCollectionController {
             {
                 // TODO: merge this code to another onMessageCreated in this file
                 fn: convertEventPayload((callback) => {
-                    return onMessageCreated(message => {
+                    return onMessageCreatedMqtt(message => {
+                        var _a;
+                        const cacheData = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!cacheData)
+                            return;
+                        updateChannelCache(cacheData, {
+                            lastActivity: message.createdAt,
+                        });
+                        callback(message);
+                    });
+                }, 'messageId', 'channel'),
+                action: 'onUpdate',
+            },
+            {
+                // TODO: merge this code to another onMessageCreated in this file
+                fn: convertEventPayload((callback) => {
+                    return onMessageCreatedLocal(message => {
                         var _a;
                         const cacheData = (_a = pullFromCache([
                             'channel',
@@ -13610,7 +13812,33 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                         });
                         callback(message);
                     };
-                    return onMessageCreated(updateMessagePreview);
+                    return onMessageCreatedMqtt(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: 'onUpdate',
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        var _a;
+                        const messagePreviewSetting = await ChannelLiveCollectionController.getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageCreated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        const channel = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!channel)
+                            return;
+                        updateChannelCache(channel, {
+                            messagePreviewId: message.messageId,
+                        });
+                        callback(message);
+                    };
+                    return onMessageCreatedLocal(updateMessagePreview);
                 }, 'channelId', 'channel'),
                 action: 'onUpdate',
             },
@@ -15112,7 +15340,7 @@ class MessageLiveCollectionController extends LiveCollectionController {
     }
     startSubscription() {
         return this.queryStreamController.subscribeRTE([
-            { fn: onMessageCreated, action: 'onCreate' },
+            { fn: onMessageCreatedMqtt, action: 'onCreate' },
             { fn: onMessageDeleted, action: 'onDelete' },
             { fn: onMessageUpdated, action: 'onUpdate' },
             { fn: onMessageFlagged, action: 'onFlagged' },
@@ -15311,7 +15539,7 @@ const observeMessages = (subChannelId, callback) => {
         (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, message);
         (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, message);
     };
-    disposers.push(onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), convertEventPayload(onMessageMarkerFetched, 'contentId', 'message')(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), convertEventPayload(onMessageMarked, 'contentId', 'message')(data => router({ data, loading: false, origin: 'event' }, 'onCreate')));
+    disposers.push(onMessageCreatedMqtt(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), onMessageCreatedLocal(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), convertEventPayload(onMessageMarkerFetched, 'contentId', 'message')(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), convertEventPayload(onMessageMarked, 'contentId', 'message')(data => router({ data, loading: false, origin: 'event' }, 'onCreate')));
     return () => {
         log(`observeMessages(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -15332,7 +15560,8 @@ var index$c = /*#__PURE__*/Object.freeze({
   flagMessage: flagMessage,
   unflagMessage: unflagMessage,
   isMessageFlaggedByMe: isMessageFlaggedByMe,
-  onMessageCreated: onMessageCreated,
+  onMessageCreatedMqtt: onMessageCreatedMqtt,
+  onMessageCreatedLocal: onMessageCreatedLocal,
   onMessageUpdated: onMessageUpdated,
   onMessageDeleted: onMessageDeleted,
   onMessageFlagged: onMessageFlagged,
@@ -15600,7 +15829,30 @@ const getSubChannel = (subChannelId, callback) => {
                 });
                 callback(message);
             };
-            return onMessageCreated(updateMessagePreview);
+            return onMessageCreatedMqtt(updateMessagePreview);
+        }, 'subChannelId', 'subChannel'),
+        convertEventPayload((callback) => {
+            const updateMessagePreview = async (message) => {
+                var _a;
+                const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+                if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                    return;
+                await handleMessageCreated(message);
+                if (message.subChannelId !== subChannelId)
+                    return;
+                const subChannel = (_a = pullFromCache([
+                    'subChannel',
+                    'get',
+                    subChannelId,
+                ])) === null || _a === void 0 ? void 0 : _a.data;
+                if (!subChannel)
+                    return;
+                updateSubChannelCache(message.subChannelId, subChannel, {
+                    messagePreviewId: message.messageId,
+                });
+                callback(message);
+            };
+            return onMessageCreatedLocal(updateMessagePreview);
         }, 'subChannelId', 'subChannel'),
         convertEventPayload((callback) => {
             const updateMessagePreview = async (message) => {
@@ -15765,7 +16017,42 @@ class SubChannelLiveCollectionController extends LiveCollectionController {
             },
             {
                 fn: callback => {
-                    return onMessageCreated(async (message) => {
+                    return onMessageCreatedMqtt(async (message) => {
+                        var _a, _b;
+                        const cacheData = pullFromCache([
+                            'subChannel',
+                            'get',
+                            message.subChannelId,
+                        ]);
+                        if (!cacheData)
+                            return;
+                        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!collection || !collection.data.includes(message.subChannelId))
+                            return;
+                        const client = getActiveClient();
+                        const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageCreated(message);
+                        const subChannelCache = (_b = pullFromCache([
+                            'subChannel',
+                            'get',
+                            message.subChannelId,
+                        ])) === null || _b === void 0 ? void 0 : _b.data;
+                        if (!subChannelCache)
+                            return;
+                        updateSubChannelCache(message.subChannelId, subChannelCache, {
+                            lastActivity: message.createdAt,
+                            messagePreviewId: message.messageId,
+                        });
+                        callback(Object.assign(Object.assign({}, cacheData.data), { messagePreviewId: message.messageId, subChannelId: message.subChannelId, lastActivity: message.createdAt }));
+                    });
+                },
+                action: 'onUpdate',
+            },
+            {
+                fn: callback => {
+                    return onMessageCreatedLocal(async (message) => {
                         var _a, _b;
                         const cacheData = pullFromCache([
                             'subChannel',
@@ -21404,6 +21691,157 @@ const getTargetsByTargetIds = (params, callback) => {
     };
 };
 
+class StoryQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, paginationController) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.paginationController = paginationController;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    saveToMainDB(response) {
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        const convertedData = convertStoryRawToInternal(response);
+        if (client.cache) {
+            ingestInCache(convertedData, { cachedAt });
+            // Update local last story expires
+            updateLocalLastStoryExpires(convertedData.stories);
+            // Map storyId to referenceId
+            mappingStoryIdToReferenceId(convertedData.stories);
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getStoryReferenceIds(story) {
+        if (story === null || story === void 0 ? void 0 : story.referenceId) {
+            return story.referenceId;
+        }
+        return story.storyId;
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.stories.map(this.getStoryReferenceIds),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const stories = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...stories, ...response.stories.map(this.getStoryReferenceIds)])] }));
+        }
+    }
+    reactor(action) {
+        return (payload) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            const newReferenceIds = payload.map(({ referenceId }) => referenceId);
+            collection.data = [...new Set([...newReferenceIds, ...collection.data])];
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+/* eslint-disable no-use-before-define */
+class StoryPaginationNoPageController extends PaginationNoPageController {
+    async getRequest(queryParams) {
+        const { data: queryResponse } = await this.http.get('/api/v4/stories-by-targets', {
+            params: Object.assign({}, queryParams),
+        });
+        return queryResponse;
+    }
+}
+
+class StoryLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ["story-target-ids" /* STORY_KEY_CACHE.STORY_TARGET_IDS */, 'collection', queryStreamId];
+        const paginationController = new StoryPaginationNoPageController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new StoryQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), paginationController);
+        this.paginationController = paginationController;
+        this.callback = callback.bind(this);
+        this.loadPage(true);
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    persistModel(response) {
+        this.queryStreamController.saveToMainDB(response);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        let data = collection.data
+            .map(referenceId => pullFromCache(["story" /* STORY_KEY_CACHE.STORY */, 'get', referenceId]))
+            .filter(Boolean)
+            .map(internStory => LinkedObject.story(internStory.data));
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        data = this.applyFilter(data);
+        this.callback({
+            onNextPage: undefined,
+            data,
+            hasNextPage: false,
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        var _a, _b;
+        const internalStories = data;
+        const orderBy = ((_b = (_a = this.query) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.orderBy) || 'desc';
+        return orderBy === 'asc'
+            ? internalStories.sort(sortByFirstCreated)
+            : internalStories.sort(sortByLastCreated);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onStoryCreated, action: "onCreate" /* Amity.StoryActionType.OnCreate */ },
+            { fn: onStoryUpdated, action: "onUpdate" /* Amity.StoryActionType.OnUpdate */ },
+            { fn: onStoryDeleted, action: "onDelete" /* Amity.StoryActionType.OnDelete */ },
+            { fn: onStoryError, action: "onError" /* Amity.StoryActionType.OnError */ },
+        ]);
+    }
+}
+
+const getStoriesByTargetIds = (params, callback, config) => {
+    const { log, cache, userId } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getStoriesByTargetIds(tmpid: ${timestamp}) > listen`);
+    const storyLiveCollection = new StoryLiveCollectionController(params, callback);
+    const disposers = storyLiveCollection.startSubscription();
+    const cacheKey = storyLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getStoriesByTargetIds(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createImageStory: createImageStory,
@@ -21413,7 +21851,8 @@ var index = /*#__PURE__*/Object.freeze({
   getActiveStoriesByTarget: getActiveStoriesByTarget,
   getStoryByStoryId: getStoryByStoryId,
   getTargetById: getTargetById,
-  getTargetsByTargetIds: getTargetsByTargetIds
+  getTargetsByTargetIds: getTargetsByTargetIds,
+  getStoriesByTargetIds: getStoriesByTargetIds
 });
 
 /**
@@ -21518,6 +21957,7 @@ exports.onMessageMarkerFetched = onMessageMarkerFetched;
 exports.onSubChannelMarkerFetched = onSubChannelMarkerFetched;
 exports.onSubChannelMarkerUpdated = onSubChannelMarkerUpdated;
 exports.onUserMarkerFetched = onUserMarkerFetched;
+exports.onUserMarkerFetchedLegacy = onUserMarkerFetchedLegacy;
 exports.pullFromCache = pullFromCache;
 exports.pushToCache = pushToCache;
 exports.queryCache = queryCache;