@amityco/ts-sdk-react-native 6.17.0 → 6.17.3

package/dist/index.cjs.js

@@ -118,8 +118,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.3-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.17.3-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -1454,6 +1454,16 @@ const getPostTopic = ({ path }, level = exports.SubscriptionLevels.POST) => {
 const getCommentTopic = ({ path }) => {
     return path;
 };
+// Subscribe on comment and story update on a single story
+const getStoryTopic = ({ targetId, targetType, storyId, }) => {
+    const user = getActiveUser();
+    return `${getNetworkId(user)}/social/${targetType}/${targetId}/story/${storyId}/#`;
+};
+// Subscribe on comment and story update on stories under community
+const getCommunityStoriesTopic = ({ targetId, targetType, }) => {
+    const user = getActiveUser();
+    return `${getNetworkId(user)}/social/${targetType}/${targetId}/story/#`;
+};
 const getMyFollowersTopic = () => {
     const user = getActiveUser();
     return `${getNetworkId(user)}/membership/${user._id}/+/+`;
@@ -4989,7 +4999,7 @@ class AnalyticsEventCapturer {
             return;
         this._throttleStoryTimer = setTimeout(() => {
             clearTimeout(this._throttleStoryTimer);
-            fireEvent('local.story.updated', { referenceIds: this._bufferNewSeenStoryReferenceIds });
+            fireEvent('local.story.reload', { referenceIds: this._bufferNewSeenStoryReferenceIds });
             this._bufferNewSeenStoryReferenceIds = [];
         }, 300);
     }
@@ -5854,7 +5864,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 */
@@ -6029,17 +6046,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
@@ -6660,43 +6685,92 @@ const initializeMessagePreviewSetting = async () => {
 
 /**
  * ```js
- * import { getFeedSettings } from '@amityco/ts-sdk-react-native'
- * const feedSettings = await getFeedSettings()
- * const postFeedSetting = feedSettings.post
+ * import { getSocialSettings } from '@amityco/ts-sdk-react-native'
+ * 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-react-native'
- * const socialSettings = await getSocialSettings()
+ * import { getFeedSettings } from '@amityco/ts-sdk-react-native'
+ * 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];
+    }));
 };
 
 /*
@@ -6958,6 +7032,11 @@ const logout = async () => {
     client.userId = undefined;
     client.token = undefined;
     client.http.defaults.headers.common.Authorization = '';
+    client.http.defaults.metadata = {
+        tokenExpiry: '',
+        isGlobalBanned: false,
+        isUserDeleted: false,
+    };
     client.ws.io.opts.query = { token: '' };
     /*
      * Cache should be usable if tokenExpired
@@ -7142,7 +7221,7 @@ async function runMqtt() {
  * @async
  */
 const login = async (params, sessionHandler, config) => {
-    var _a, _b, _c;
+    var _a, _b;
     const client = getActiveClient();
     let unsubWatcher;
     client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey, sessionState: client.sessionState }, params));
@@ -7154,25 +7233,35 @@ const login = async (params, sessionHandler, config) => {
         subscriptions = [];
     }
     // default values
-    (_a = params.deviceId) !== null && _a !== void 0 ? _a : (params.deviceId = await getDeviceId());
+    const defaultDeviceId = await getDeviceId();
     try {
-        // @ts-ignore: in that particular case, typing can be
-        // ignored since we enforce default values just before.
-        const { users } = await setClientToken(params);
+        const { users } = await setClientToken(Object.assign(Object.assign({}, params), { displayName: (params === null || params === void 0 ? void 0 : params.displayName) || params.userId, deviceId: (params === null || params === void 0 ? void 0 : params.deviceId) || defaultDeviceId }));
+        const user = users.find(u => u.userId === params.userId);
+        if (user == null) {
+            throw new ASCError(`${params.userId} has not been founded`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        if (user.isDeleted) {
+            terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
+            return false;
+        }
+        if (user.isGlobalBanned) {
+            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
+            return false;
+        }
         // FIXME: events are duplicated if connectClient is called few times without disconnectClient
         // wire websocket events to our event emitter
         proxyWebsocketEvents(client.ws, client.emitter);
         client.ws.once('connect', () => {
             client.ws.open();
         });
-        client.userId = params.userId;
+        client.userId = user.userId;
         client.sessionHandler = sessionHandler;
         /*
          * Cannot push to subscriptions as watcher needs to continue working even if
          * token expires
          */
-        unsubWatcher = client.accessTokenExpiryWatcher((_b = client.token) === null || _b === void 0 ? void 0 : _b.expiresAt, (_c = client.token) === null || _c === void 0 ? void 0 : _c.issuedAt, sessionHandler);
-        setActiveUser(users[0]);
+        unsubWatcher = client.accessTokenExpiryWatcher((_a = client.token) === null || _a === void 0 ? void 0 : _a.expiresAt, (_b = client.token) === null || _b === void 0 ? void 0 : _b.issuedAt, sessionHandler);
+        setActiveUser(user);
     }
     catch (error) {
         /*
@@ -7401,6 +7490,7 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         sessionState,
         accessTokenExpiryWatcher,
         sessionHandler,
+        hasPermission: hasPermission$1,
         getFeedSettings,
         getSocialSettings,
         getMessagePreviewSetting,
@@ -7495,7 +7585,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);
 };
@@ -7609,6 +7701,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]);
@@ -7864,7 +7963,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,
     });
 };
@@ -7890,16 +7992,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 === null || data === void 0 ? void 0 : 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,
-    });
 };
 
 /**
@@ -8210,21 +8373,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());
     };
@@ -8538,18 +8710,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.
@@ -8587,18 +8763,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) {
@@ -8612,14 +8803,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.
@@ -13160,7 +13348,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) => {
@@ -13599,7 +13806,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',
@@ -13653,7 +13880,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',
             },
@@ -15155,7 +15408,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' },
@@ -15233,6 +15486,7 @@ class MessageLiveCollectionController extends LiveCollectionController {
     }
 }
 
+/* eslint-disable no-use-before-define */
 /* begin_public_function
   id: message.query
 */
@@ -15353,7 +15607,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());
@@ -15374,7 +15628,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,
@@ -15642,7 +15897,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) => {
@@ -15807,7 +16085,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',
@@ -16472,6 +16785,10 @@ const onCommunityUpdated = (callback) => createCommunityEventSubscriber('communi
  */
 const onCommunityDeleted = (callback) => createCommunityEventSubscriber('community.deleted', callback);
 
+function isNonNullable(value) {
+    return value != null;
+}
+
 function hasPermission(member, payload, permission) {
     if (member.permissions.some(x => x === permission)) {
         return true;
@@ -16482,21 +16799,21 @@ function hasPermission(member, payload, permission) {
 }
 function getEventRelatedMember(event, payload) {
     if (event === 'community.joined' || event === 'community.left') {
-        return payload.communityUsers[0];
+        return payload.communityUsers;
     }
     // NOTE: backend returns the one who took the action and the one on whom
     // the action was taken. We need the 2nd one
     if (event === 'community.userRemoved') {
-        return payload.communityUsers.filter(x => x.communityMembership === 'none')[0];
+        return payload.communityUsers.filter(x => x.communityMembership === 'none');
     }
     if (event === 'community.userBanned') {
-        return payload.communityUsers.filter(x => x.communityMembership === 'banned')[0];
+        return payload.communityUsers.filter(x => x.communityMembership === 'banned');
     }
     // NOTE: it might be that in certain edge cases permission check won't be enough
     if (event === 'community.userUnbanned') {
-        return payload.communityUsers.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'))[0];
+        return payload.communityUsers.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'));
     }
-    return payload.communityUsers.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'))[0];
+    return payload.communityUsers.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'));
 }
 const createCommunityMemberEventSubscriber = (event, callback) => {
     const client = getActiveClient();
@@ -16520,12 +16837,17 @@ const createCommunityMemberEventSubscriber = (event, callback) => {
                 'get',
                 preparedPayload.communities[0].communityId,
             ]);
-            const member = pullFromCache([
-                'communityUsers',
-                'get',
-                getResolver('communityUsers')(getEventRelatedMember(event, preparedPayload)),
-            ]);
-            callback(community.data, member.data);
+            const members = getEventRelatedMember(event, preparedPayload)
+                .map(member => {
+                const memberCache = pullFromCache([
+                    'communityUsers',
+                    'get',
+                    getResolver('communityUsers')(member),
+                ]);
+                return memberCache === null || memberCache === void 0 ? void 0 : memberCache.data;
+            })
+                .filter(isNonNullable);
+            callback(community.data, members);
         }
     };
     return createEventSubscriber(client, event, event, filter);
@@ -17570,19 +17892,25 @@ const getMembers = (params, callback, config) => {
             error: data.error,
         });
     };
-    const realtimeRouter = (_) => (_, communityMember) => {
+    const realtimeRouter = (_) => (_, communityMembers) => {
         var _a;
-        if (params.communityId !== communityMember.communityId) {
-            return;
-        }
         const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
+        if (!collection) {
             return;
-        const communityMemberCacheId = getResolver('communityUsers')({
-            communityId: params.communityId,
-            userId: communityMember.userId,
-        });
-        collection.data = [...new Set([communityMemberCacheId, ...collection.data])];
+        }
+        const communityMemberCacheIds = communityMembers
+            .map(communityMember => {
+            if (params.communityId !== communityMember.communityId) {
+                return;
+            }
+            const communityMemberCacheId = getResolver('communityUsers')({
+                communityId: params.communityId,
+                userId: communityMember.userId,
+            });
+            return communityMemberCacheId;
+        })
+            .filter(isNonNullable);
+        collection.data = [...new Set([...communityMemberCacheIds, ...collection.data])];
         pushToCache(cacheKey, collection);
         pushToCache(cacheByCommunityIdKey, collection);
         responder(collection, true);
@@ -20889,7 +21217,7 @@ const createStory = async (payload) => {
     if (client.cache)
         ingestInCache(convertedResponse);
     pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, payload.targetId], "synced" /* Amity.SyncState.Synced */);
-    fireEvent('story.created', convertedResponse);
+    fireEvent('local.story.created', convertedResponse);
     const cachedAt = client.cache && Date.now();
     return {
         data: convertedResponse.stories.length > 0 ? convertedResponse.stories[0] : undefined,
@@ -20934,7 +21262,7 @@ const createImageStory = async (targetType, targetId, formData, metadata = {}, i
     pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, targetId], "syncing" /* Amity.SyncState.Syncing */);
     // Fire optimistic event
     createOptimisticEvent({ payload, formData }, optimisticData => {
-        fireEvent('story.created', optimisticData);
+        fireEvent('local.story.created', optimisticData);
     });
     try {
         const { data } = await uploadImage(formData);
@@ -20945,7 +21273,7 @@ const createImageStory = async (targetType, targetId, formData, metadata = {}, i
         payload = Object.assign(Object.assign({}, payload), { data: Object.assign(Object.assign({}, payload.data), { fileId }) });
         // Fire optimistic event - update fileId
         createOptimisticEvent({ payload, formData }, optimisticData => {
-            fireEvent('story.created', optimisticData);
+            fireEvent('local.story.created', optimisticData);
         });
         const result = await createStory(payload);
         if (!result.data)
@@ -20956,7 +21284,7 @@ const createImageStory = async (targetType, targetId, formData, metadata = {}, i
         pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, targetId], "error" /* Amity.SyncState.Error */);
         // Fire optimistic event - failed to upload image
         createOptimisticEvent({ payload: Object.assign(Object.assign({}, payload), { syncState: "error" /* Amity.SyncState.Error */ }), formData }, optimisticData => {
-            fireEvent('story.error', optimisticData);
+            fireEvent('local.story.error', optimisticData);
         });
         throw error;
     }
@@ -20995,7 +21323,7 @@ const createVideoStory = async (targetType, targetId, formData, metadata = {}, i
     pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, targetId], "syncing" /* Amity.SyncState.Syncing */);
     // Fire optimistic event
     createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
-        fireEvent('story.created', optimisticData);
+        fireEvent('local.story.created', optimisticData);
     });
     try {
         const { data } = await uploadVideo(formData, ContentFeedType.STORY);
@@ -21006,7 +21334,7 @@ const createVideoStory = async (targetType, targetId, formData, metadata = {}, i
         payload = Object.assign(Object.assign({}, payload), { data: Object.assign(Object.assign({}, payload.data), { fileId, videoFileId: { original: fileId } }) });
         // Fire optimistic event - update fileId
         createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
-            fireEvent('story.created', optimisticData);
+            fireEvent('local.story.created', optimisticData);
         });
         const result = await createStory(payload);
         if (!result.data)
@@ -21017,7 +21345,7 @@ const createVideoStory = async (targetType, targetId, formData, metadata = {}, i
         pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, targetId], "error" /* Amity.SyncState.Error */);
         // Fire optimistic upload failed
         createOptimisticEvent({ payload: Object.assign(Object.assign({}, payload), { syncState: "error" /* Amity.SyncState.Error */ }), formData, isVideo: true }, optimisticData => {
-            fireEvent('story.error', optimisticData);
+            fireEvent('local.story.error', optimisticData);
         });
         throw error;
     }
@@ -21065,12 +21393,86 @@ const softDeleteStory = async (storyId) => {
 };
 
 const onStoryUpdated = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        // Apply the necessary field for story payload
+        const convertPayload = convertStoryRawToInternal(payload);
+        ingestInCache(convertPayload);
+        callback(convertPayload.stories);
+    };
+    const disposers = [createEventSubscriber(client, 'onStoryUpdated', 'story.updated', filter)];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+const onStoryUpdatedLocal = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
         ingestInCache(payload);
         callback(payload.stories);
     };
-    return createEventSubscriber(client, 'onStoryUpdated', 'story.updated', filter);
+    const disposers = [
+        createEventSubscriber(client, 'onStoryUpdated', 'local.story.updated', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+const onStoryReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        const convertPayload = convertStoryRawToInternal(payload);
+        ingestInCache(convertPayload);
+        callback(convertPayload.stories);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onStoryReactionAdded', 'story.reactionAdded', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+const onStoryReactionAddedLocal = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        ingestInCache(payload);
+        callback(payload.stories);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onStoryReactionAdded', 'local.story.reactionAdded', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+const onStoryReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        const convertPayload = convertStoryRawToInternal(payload);
+        ingestInCache(convertPayload);
+        callback(convertPayload.stories);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onStoryReactionRemoved', 'story.reactionRemoved', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+const onStoryReactionRemovedLocal = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        ingestInCache(payload);
+        callback(payload.stories);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onStoryReactionRemoved', 'local.story.reactionRemoved', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
 const updateLocalLastStoryExpires = (stories) => {
@@ -21120,21 +21522,54 @@ const getActiveStoriesByTarget$1 = async ({ targetType, targetId, options, }) =>
 };
 
 const onStoryCreated = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        // Apply the necessary field for story payload
+        const convertPayload = convertStoryRawToInternal(payload);
+        ingestInCache(convertPayload);
+        callback(convertPayload.stories);
+    };
+    const disposers = [createEventSubscriber(client, 'onStoryCreated', 'story.created', filter)];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+const onStoryCreatedLocal = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
         ingestInCache(payload);
         callback(payload.stories);
     };
-    return createEventSubscriber(client, 'onStoryCreated', 'story.created', filter);
+    const disposers = [
+        createEventSubscriber(client, 'onStoryCreated', 'local.story.created', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
 const onStoryDeleted = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        const convertPayload = convertStoryRawToInternal(payload);
+        ingestInCache(convertPayload);
+        callback(convertPayload.stories);
+    };
+    const disposer = [createEventSubscriber(client, 'onStoryDeleted', 'story.deleted', filter)];
+    return () => {
+        disposer.forEach(fn => fn());
+    };
+};
+const onStoryDeletedLocal = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
         ingestInCache(payload);
         callback(payload.stories);
     };
-    return createEventSubscriber(client, 'onStoryDeleted', 'story.deleted', filter);
+    const disposer = [createEventSubscriber(client, 'onStoryDeleted', 'local.story.deleted', filter)];
+    return () => {
+        disposer.forEach(fn => fn());
+    };
 };
 
 const onStoryError = (callback) => {
@@ -21143,7 +21578,7 @@ const onStoryError = (callback) => {
         ingestInCache(payload);
         callback(payload.stories);
     };
-    return createEventSubscriber(client, 'onStoryError', 'story.error', filter);
+    return createEventSubscriber(client, 'onStoryError', 'local.story.error', filter);
 };
 
 const onStoryLocalDataUpdated = (callback) => {
@@ -21151,9 +21586,29 @@ const onStoryLocalDataUpdated = (callback) => {
     const filter = (payload) => {
         callback(payload);
     };
-    return createEventSubscriber(client, 'onStoryLocalDataUpdated', 'local.story.updated', filter);
+    return createEventSubscriber(client, 'onStoryLocalDataUpdated', 'local.story.reload', filter);
 };
 
+/**
+ * ```js
+ * import { StoryRepository } from '@amityco/js-sdk';
+ * let storiesData;
+ *
+ * const unsubscribe = StoryRepository.getActiveStoriesByTarget({ targetId, targetType }, response => {
+ *  storiesData = response.data;
+ * });
+ *
+ * unsubscribe();
+ * ```
+ *
+ * Observe all mutations on a given {@link Amity.Story}
+ *
+ * @param params for querying stories from a community
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the story
+ *
+ * @category SubChannel Live Object
+ */
 const getActiveStoriesByTarget = (params, callback) => {
     const { log, cache } = getActiveClient();
     const disposers = [];
@@ -21269,7 +21724,7 @@ const getActiveStoriesByTarget = (params, callback) => {
         });
     };
     onFetch(true);
-    disposers.push(onStoryCreated(realtimeRouter()), onStoryUpdated(realtimeRouter()), onStoryDeleted(realtimeRouter()), onStoryError(realtimeRouter()), onStoryLocalDataUpdated(reloadData()), () => dropFromCache(cacheKey));
+    disposers.push(onStoryCreated(realtimeRouter()), onStoryUpdated(realtimeRouter()), onStoryDeleted(realtimeRouter()), onStoryReactionAdded(realtimeRouter()), onStoryReactionRemoved(realtimeRouter()), onStoryError(realtimeRouter()), onStoryCreatedLocal(realtimeRouter()), onStoryUpdatedLocal(realtimeRouter()), onStoryDeletedLocal(realtimeRouter()), onStoryReactionAddedLocal(realtimeRouter()), onStoryReactionRemovedLocal(realtimeRouter()), onStoryLocalDataUpdated(reloadData()), () => dropFromCache(cacheKey));
     return () => {
         log(`getActiveStoriesByTarget(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -21338,7 +21793,17 @@ const getStoryByStoryId = (storyId, callback) => {
             return;
         }
         callback(Object.assign(Object.assign({}, data), { data: LinkedObject.story(data.data) }));
-    }, 'storyId', getStoryByStoryId$1, [getSingleItemFromArray(onStoryDeleted), getSingleItemFromArray(onStoryError)]);
+    }, 'storyId', getStoryByStoryId$1, [
+        getSingleItemFromArray(onStoryUpdated),
+        getSingleItemFromArray(onStoryDeleted),
+        getSingleItemFromArray(onStoryReactionAdded),
+        getSingleItemFromArray(onStoryReactionRemoved),
+        getSingleItemFromArray(onStoryError),
+        getSingleItemFromArray(onStoryUpdatedLocal),
+        getSingleItemFromArray(onStoryDeletedLocal),
+        getSingleItemFromArray(onStoryReactionAddedLocal),
+        getSingleItemFromArray(onStoryReactionRemovedLocal),
+    ]);
 };
 
 const getTargetsByTargetIds$1 = async (targets) => {
@@ -21431,6 +21896,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,
@@ -21440,7 +22056,8 @@ var index = /*#__PURE__*/Object.freeze({
   getActiveStoriesByTarget: getActiveStoriesByTarget,
   getStoryByStoryId: getStoryByStoryId,
   getTargetById: getTargetById,
-  getTargetsByTargetIds: getTargetsByTargetIds
+  getTargetsByTargetIds: getTargetsByTargetIds,
+  getStoriesByTargetIds: getStoriesByTargetIds
 });
 
 /**
@@ -21512,6 +22129,7 @@ exports.filterBySearchTerm = filterBySearchTerm;
 exports.filterByStringComparePartially = filterByStringComparePartially;
 exports.getChannelTopic = getChannelTopic;
 exports.getCommentTopic = getCommentTopic;
+exports.getCommunityStoriesTopic = getCommunityStoriesTopic;
 exports.getCommunityTopic = getCommunityTopic;
 exports.getMarkedMessageTopic = getMarkedMessageTopic;
 exports.getMessageTopic = getMessageTopic;
@@ -21523,6 +22141,7 @@ exports.getRole = getRole;
 exports.getSmartFeedChannelTopic = getSmartFeedChannelTopic;
 exports.getSmartFeedMessageTopic = getSmartFeedMessageTopic;
 exports.getSmartFeedSubChannelTopic = getSmartFeedSubChannelTopic;
+exports.getStoryTopic = getStoryTopic;
 exports.getSubChannelTopic = getSubChannelTopic;
 exports.getUserTopic = getUserTopic;
 exports.isAfterBefore = isAfterBefore;
@@ -21545,6 +22164,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;