@amityco/ts-sdk-react-native 6.32.7-289cad7.0 → 6.32.7-686c44c.0

package/dist/index.cjs.js

@@ -5895,6 +5895,10 @@ const messageLinkedObject = (message) => {
         },
         get deliveredCount() {
             return getMessageReadCount(message).deliveredCount;
+        },
+        get creator() {
+            var _a;
+            return (_a = pullFromCache(['user', 'get', message.creatorId])) === null || _a === void 0 ? void 0 : _a.data;
         }, markRead: () => markReadMessage(message) });
 };
 
@@ -10248,6 +10252,18 @@ class QueryStreamController {
     }
 }
 
+var EnumFollowActions;
+(function (EnumFollowActions) {
+    EnumFollowActions["OnRequested"] = "onRequested";
+    EnumFollowActions["OnAccepted"] = "onAccepted";
+    EnumFollowActions["OnDeclined"] = "onDeclined";
+    EnumFollowActions["OnCanceled"] = "onCanceled";
+    EnumFollowActions["OnFollowed"] = "onFollowed";
+    EnumFollowActions["OnUnfollowed"] = "onUnfollowed";
+    EnumFollowActions["OnDeleted"] = "onDeleted";
+    EnumFollowActions["OnUserDeleted"] = "onUserDeleted";
+})(EnumFollowActions || (EnumFollowActions = {}));
+
 class BlockedUserQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -10276,10 +10292,13 @@ class BlockedUserQueryStreamController extends QueryStreamController {
         }
     }
     reactor(action) {
-        return (followStatus) => {
+        return (targetUser) => {
             var _a;
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            pushToCache(this.cacheKey, collection);
+            if (action === EnumFollowActions.OnFollowed) {
+                const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                const updatedCollection = collection === null || collection === void 0 ? void 0 : collection.data.filter(id => id !== targetUser.userId);
+                pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: updatedCollection }));
+            }
             this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
         };
     }
@@ -10476,560 +10495,593 @@ var EnumUserActions;
     EnumUserActions["OnUserFlagCleared"] = "onUserFlagCleared";
 })(EnumUserActions || (EnumUserActions = {}));
 
-class BlockedUserLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash__default["default"](query);
-        const cacheKey = ['blockedUsers', 'collection', queryStreamId];
-        const paginationController = new BlockedUserPaginationController(query);
-        super(paginationController, queryStreamId, cacheKey, callback);
-        this.query = query;
-        this.queryStreamController = new BlockedUserQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareBlockedUserPayload);
-        this.callback = callback.bind(this);
-        this.loadPage({ initial: 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: {},
-            });
+const createFollowEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const payload = prepareFollowersPayload(data);
+        if (!client.cache) {
+            callback(payload.follows[0]);
         }
-    }
-    async persistModel(queryPayload) {
-        await this.queryStreamController.saveToMainDB(queryPayload);
-    }
-    persistQueryStream({ response, direction, refresh, }) {
-        this.queryStreamController.appendToQueryStream(response, direction, refresh);
-    }
-    startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            {
-                fn: onUserDeleted$2,
-                action: EnumUserActions.OnUserDeleted,
-            },
-        ]);
-    }
-    notifyChange({ origin, loading, error }) {
-        var _a, _b;
-        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        const data = this.applyFilter((_b = collection.data
-            .map(id => pullFromCache(['user', 'get', id]))
-            .filter(isNonNullable)
-            .map(({ data }) => data)
-            .map(LinkedObject.user)) !== null && _b !== void 0 ? _b : []);
-        if (!this.shouldNotify(data) && origin === 'event')
-            return;
-        this.callback({
-            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
-            data,
-            hasNextPage: !!this.paginationController.getNextToken(),
-            loading,
-            error,
-        });
-    }
-    // eslint-disable-next-line class-methods-use-this
-    applyFilter(data) {
-        let users = data;
-        users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
-        return users;
-    }
-}
+        else {
+            ingestInCache(payload);
+            callback(payload.follows[0]);
+        }
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+const createLocalFollowEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const payload = prepareFollowStatusPayload(data);
+        if (!client.cache) {
+            callback(payload.follows[0]);
+        }
+        else {
+            ingestInCache(payload);
+            callback(payload.follows[0]);
+        }
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
 
-/* begin_public_function
-  id: user.get_blocked_users
-*/
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk-react-native'
- * const unblockedUser = await UserRepository.blockUser('userId')
+ * import { onUserFollowed } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFollowed(status => {
+ *   // ...
+ * })
  * ```
  *
- * Blocks a {@link Amity.InternalUser}
+ * Fired when a user follows another users and confirmation is not required
  *
- * @param params The params to get blocked {@link Amity.InternalUser}s
- * @param callback to recieve updates on unblocked {@link Amity.InternalUser}s
- * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Post API
- * @async
+ * @category Follow Events
  */
-const getBlockedUsers$1 = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
-    }
-    const timestamp = Date.now();
-    log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
-    const blockedUserLiveCollection = new BlockedUserLiveCollectionController(params, callback);
-    const disposers = blockedUserLiveCollection.startSubscription();
-    const cacheKey = blockedUserLiveCollection.getCacheKey();
-    disposers.push(() => dropFromCache(cacheKey));
-    return () => {
-        log(`getBlockedUsers(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-        dropFromCache(cacheKey);
-    };
-};
-/* end_public_function */
-
-/* eslint-disable no-use-before-define */
-const getBlockedUsers = (params, callback, config) => {
-    console.log('Deprecation Notice: UserRepository.Relationship.getBlockedUsers will be deprecated on 9th June 2023, please use UserRepository.getBlockedUsers instead.');
-    return getBlockedUsers$1(params, callback);
-};
+const onUserFollowed = (callback) => createFollowEventSubscriber('follow.created', callback);
 
-/* begin_public_function
-  id: user.relationship.follow
-*/
 /**
  * ```js
- * import { follow } from '@amityco/ts-sdk-react-native'
- * const status = await follow('foobar')
+ * import { onUserUnfollowed } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFollowed(status => {
+ *   // ...
+ * })
  * ```
  *
- * Follow the user
+ * Fired when a user unfollows
  *
- * @param userId the ID of the {@link Amity.InternalUser}
- * @returns the status {@link Amity.FollowStatus}
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Follow API
- * @async
+ * @category Follow Events
  */
-const follow = async (userId) => {
-    const client = getActiveClient();
-    client.log('follow/follow', userId);
-    const { data } = await client.http.post(`/api/v4/me/following/${userId}`);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(data, { cachedAt });
-    }
-    const payload = prepareFollowStatusPayload(data);
-    if (data.follows[0].status === 'accepted') {
-        fireEvent('local.follow.created', payload);
-    }
-    else {
-        fireEvent('local.follow.requested', payload);
-    }
-    return {
-        data: data.follows[0],
-        cachedAt,
-    };
-};
-/* end_public_function */
+const onUserUnfollowed = (callback) => createFollowEventSubscriber('follow.unfollowed', callback);
 
-/* begin_public_function
-  id: user.relationship.unfollow
-*/
 /**
  * ```js
- * import { unfollow } from '@amityco/ts-sdk-react-native'
- * await unfollow('foobar')
+ * import { onFollowerDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onFollowerDeleted(status => {
+ *   // ...
+ * })
  * ```
  *
- * Cancel the follow request or unfollow the user
+ * Fired when a follower has been deleted
  *
- * @param userId the ID of the {@link Amity.InternalUser}
- * @returns A success boolean if the user {@link Amity.InternalUser} was unfollowed
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Follow API
- * @async
+ * @category Follow Events
  */
-const unfollow = async (userId) => {
-    const client = getActiveClient();
-    client.log('follow/unfollow', userId);
-    const { data } = await client.http.delete(`/api/v4/me/following/${userId}`);
-    if (client.cache) {
-        ingestInCache(data);
-    }
-    const payload = prepareFollowStatusPayload(data);
-    fireEvent('local.follow.unfollowed', payload);
-    return true;
-};
-/* end_public_function */
+const onFollowerDeleted = (callback) => createFollowEventSubscriber('follow.followerDeleted', callback);
 
 /**
- * @deprecated This API renamed to `acceptMyFollower`.
- * Please use acceptMyFollower() instead.
- *
  * ```js
- * import { acceptFollower } from '@amityco/ts-sdk-react-native'
- * await acceptFollower('foobar')
+ * import { onFollowerRequested } from '@amityco/ts-sdk-react-native'
+ * const dispose = onFollowerRequested(status => {
+ *   // ...
+ * })
  * ```
  *
- * Accept the follow request
+ * Fired when a user follows another users and confirmation is required
  *
- * @param userId the ID of the {@link Amity.InternalUser} follower
- * @returns A success boolean if the follow request was accepted
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Follow API
- * @async
+ * @category Follow Events
  */
-const acceptFollower = async (userId) => {
-    const client = getActiveClient();
-    client.log('follow/acceptFollower', userId);
-    const { data } = await client.http.post(`/api/v4/me/followers/${userId}`);
-    if (client.cache) {
-        ingestInCache(data);
-    }
-    const payload = prepareFollowStatusPayload(data);
-    fireEvent('local.follow.accepted', payload);
-    return true;
-};
+const onFollowerRequested = (callback) => createFollowEventSubscriber('follow.requested', callback);
 
-/* begin_public_function
-  id: user.relationship.accept_follow
-*/
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk-react-native'
- * await UserRepository.Relationship.acceptMyFollower('foobar')
+ * import { onFollowRequestCanceled } from '@amityco/ts-sdk-react-native'
+ * const dispose = onFollowRequestCanceled(status => {
+ *   // ...
+ * })
  * ```
  *
- * Accept the follow request
+ * Fired when a follow request has been canceled
  *
- * @param userId the ID of the {@link Amity.InternalUser} follower
- * @returns A success boolean if the follow request was accepted
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Follow API
- * @async
+ * @category Follow Events
  */
-const acceptMyFollower = async (userId) => {
-    const client = getActiveClient();
-    client.log('follow/acceptMyFollower', userId);
-    const { data } = await client.http.post(`/api/v4/me/followers/${userId}`);
-    if (client.cache) {
-        ingestInCache(data);
-    }
-    const payload = prepareFollowStatusPayload(data);
-    fireEvent('local.follow.accepted', payload);
-    return true;
-};
-/* end_public_function */
+const onFollowRequestCanceled = (callback) => createFollowEventSubscriber('follow.requestCanceled', callback);
 
 /**
- * @deprecated This API renamed to `declineMyFollower`.
- * Please use declineMyFollower() instead.
+ * ```js
+ * import { onFollowRequestAccepted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onFollowRequestAccepted(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been accepted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
+ * @category Follow Events
+ */
+const onFollowRequestAccepted = (callback) => createFollowEventSubscriber('follow.accepted', callback);
+
+/**
  * ```js
- * import { declineFollower } from '@amityco/ts-sdk-react-native'
- * await declineFollower('foobar')
+ * import { onFollowRequestDeclined } from '@amityco/ts-sdk-react-native'
+ * const dispose = onFollowRequestDeclined(status => {
+ *   // ...
+ * })
  * ```
  *
- * Decline the follow request or delete the follower
+ * Fired when a follow request has been declined
  *
- * @param userId the ID of the {@link Amity.InternalUser} follower
- * @returns A success boolean if the follow request was decline
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Follow API
- * @async
+ * @category Follow Events
  */
-const declineFollower = async (userId) => {
-    const client = getActiveClient();
-    client.log('follow/declineFollower', userId);
-    const { data } = await client.http.delete(`/api/v4/me/followers/${userId}`);
-    if (client.cache) {
-        ingestInCache(data);
-    }
-    const payload = prepareFollowStatusPayload(data);
-    fireEvent('local.follow.requestDeclined', payload);
-    return true;
-};
+const onFollowRequestDeclined = (callback) => createFollowEventSubscriber('follow.requestDeclined', callback);
 
-/* begin_public_function
-  id: user.relationship.decline_follow
-*/
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk-react-native'
- * await UserRepository.Relationship.declineMyFollower('foobar')
+ * import { getFollowInfo } from '@amityco/ts-sdk-react-native'
+ * const { data: followInfo } = await getFollowInfo('foobar')
  * ```
  *
- * Decline the follow request or delete the follower
+ * Fetches the number of followers, followings, pending requests and the follow status for current user
  *
- * @param userId the ID of the {@link Amity.InternalUser} follower
- * @returns A success boolean if the follow request was decline
+ * @param userId the ID of the {@link Amity.InternalUser}
+ * @returns the associated {@link Amity.FollowInfo} object
  *
  * @category Follow API
  * @async
  */
-const declineMyFollower = async (userId) => {
+const getFollowInfo$1 = async (userId) => {
+    var _a, _b;
     const client = getActiveClient();
-    client.log('follow/declineMyFollower', userId);
-    const { data } = await client.http.delete(`/api/v4/me/followers/${userId}`);
+    client.log('follow/getFollowInfo', userId);
+    const { data } = await client.http.get(client.userId === userId ? `/api/v4/me/followInfo` : `/api/v5/users/${userId}/followInfo`);
+    const cachedAt = client.cache && Date.now();
+    const followInfo = 'follows' in data
+        ? Object.assign(Object.assign({}, data.followCounts[0]), { status: (_b = (_a = data.follows) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.status }) : data.followCounts[0];
     if (client.cache) {
-        ingestInCache(data);
+        pushToCache(['followInfo', 'get', userId], followInfo, {
+            cachedAt,
+        });
     }
-    const payload = prepareFollowStatusPayload(data);
-    fireEvent('local.follow.requestDeclined', payload);
-    return true;
-};
-/* end_public_function */
-
-const createFollowEventSubscriber = (event, callback) => {
-    const client = getActiveClient();
-    const filter = (data) => {
-        const payload = prepareFollowersPayload(data);
-        if (!client.cache) {
-            callback(payload.follows[0]);
-        }
-        else {
-            ingestInCache(payload);
-            callback(payload.follows[0]);
-        }
+    return {
+        data: followInfo,
+        cachedAt,
     };
-    return createEventSubscriber(client, event, event, filter);
 };
-const createLocalFollowEventSubscriber = (event, callback) => {
-    const client = getActiveClient();
-    const filter = (data) => {
-        const payload = prepareFollowStatusPayload(data);
-        if (!client.cache) {
-            callback(payload.follows[0]);
-        }
-        else {
-            ingestInCache(payload);
-            callback(payload.follows[0]);
-        }
-    };
-    return createEventSubscriber(client, event, event, filter);
-};
-
 /**
  * ```js
- * import { onUserFollowed } from '@amityco/ts-sdk-react-native'
- * const dispose = onUserFollowed(status => {
- *   // ...
- * })
+ * import { getFollowInfo } from '@amityco/ts-sdk-react-native'
+ * const { data: followInfo } = getFollowInfo.locally('foobar')
  * ```
  *
- * Fired when a user follows another users and confirmation is not required
+ * Fetches the number of followers, followings, pending requests and the follow status for current user from cache
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param userId the ID of the {@link Amity.InternalUser}
+ * @returns the associated {@link Amity.FollowInfo} object
  *
- * @category Follow Events
+ * @category Follow API
  */
-const onUserFollowed = (callback) => createFollowEventSubscriber('follow.created', callback);
+getFollowInfo$1.locally = (userId) => {
+    const client = getActiveClient();
+    client.log('follow/getFollowInfo.locally', userId);
+    if (!client.cache) {
+        return;
+    }
+    const cached = pullFromCache(['followInfo', 'get', userId]);
+    if (!cached) {
+        return;
+    }
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
 
 /**
  * ```js
- * import { onUserUnfollowed } from '@amityco/ts-sdk-react-native'
- * const dispose = onUserFollowed(status => {
+ * import { onFollowInfoUpdated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onFollowInfoUpdated(followInfo => {
  *   // ...
  * })
  * ```
  *
- * Fired when a user unfollows
+ * Fired when a {@link Amity.FollowInfo} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Follow Events
  */
-const onUserUnfollowed = (callback) => createFollowEventSubscriber('follow.unfollowed', callback);
+const onFollowInfoUpdated = (callback) => {
+    const handler = async (payload) => {
+        const [{ data: followInfoFrom }, { data: followInfoTo }] = await Promise.all([
+            getFollowInfo$1(payload.from),
+            getFollowInfo$1(payload.to),
+        ]);
+        callback(followInfoFrom);
+        callback(followInfoTo);
+    };
+    const disposers = [
+        createFollowEventSubscriber('follow.created', handler),
+        createFollowEventSubscriber('follow.requested', handler),
+        createFollowEventSubscriber('follow.accepted', handler),
+        createFollowEventSubscriber('follow.unfollowed', handler),
+        createFollowEventSubscriber('follow.requestCanceled', handler),
+        createFollowEventSubscriber('follow.requestDeclined', handler),
+        createFollowEventSubscriber('follow.followerDeleted', handler),
+        createLocalFollowEventSubscriber('local.follow.created', handler),
+        createLocalFollowEventSubscriber('local.follow.requested', handler),
+        createLocalFollowEventSubscriber('local.follow.accepted', handler),
+        createLocalFollowEventSubscriber('local.follow.unfollowed', handler),
+        createLocalFollowEventSubscriber('local.follow.requestDeclined', handler),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
 
-/**
- * ```js
- * import { onFollowerDeleted } from '@amityco/ts-sdk-react-native'
- * const dispose = onFollowerDeleted(status => {
- *   // ...
- * })
- * ```
- *
- * Fired when a follower has been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Follow Events
- */
-const onFollowerDeleted = (callback) => createFollowEventSubscriber('follow.followerDeleted', callback);
+const onLocalUserFollowed = (callback) => createLocalFollowEventSubscriber('local.follow.created', callback);
+
+const onLocalUserUnfollowed = (callback) => createLocalFollowEventSubscriber('local.follow.unfollowed', callback);
+
+const onLocalFollowerRequested = (callback) => createLocalFollowEventSubscriber('local.follow.requested', callback);
+
+const onLocalFollowRequestAccepted = (callback) => createLocalFollowEventSubscriber('local.follow.accepted', callback);
 
+const onLocalFollowRequestDeclined = (callback) => createLocalFollowEventSubscriber('local.follow.requestDeclined', callback);
+
+const convertEventPayload = (eventHandler, sourceModelProp, destinationDomain) => (callback) => eventHandler(sourceModel => {
+    var _a, _b;
+    if (!sourceModel) {
+        return sourceModel;
+    }
+    const client = getActiveClient();
+    const { objectSyncMap } = client;
+    /*
+     * NOTE: For objects created locally (optimistic creation), the SDK stores them with their local ID as the cache key, which is used throughout the entire SDK session (in-memory) for syncing updates.
+     * If the payload or response only contains the remote ID of the same object, the SDK will look up the corresponding local ID to retrieve the object.
+     */
+    const resolvedId = isLocalId(sourceModel[sourceModelProp])
+        ? sourceModel[sourceModelProp]
+        : (_a = objectSyncMap.get(sourceModel[sourceModelProp])) !== null && _a !== void 0 ? _a : sourceModel[sourceModelProp];
+    const model = (_b = pullFromCache([
+        destinationDomain,
+        'get',
+        `${resolvedId}`,
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+    if (!model)
+        return;
+    return callback(model);
+});
+
+class BlockedUserLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['blockedUsers', 'collection', queryStreamId];
+        const paginationController = new BlockedUserPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new BlockedUserQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareBlockedUserPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: 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: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: onUserDeleted$2,
+                action: EnumUserActions.OnUserDeleted,
+            },
+            // In the case of unblocking a user, we need to subscribe to the follow events
+            {
+                fn: convertEventPayload(onLocalUserFollowed, 'to', 'user'),
+                action: EnumFollowActions.OnFollowed,
+            },
+            {
+                fn: convertEventPayload(onUserFollowed, 'to', 'user'),
+                action: EnumFollowActions.OnFollowed,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter((_b = collection.data
+            .map(id => pullFromCache(['user', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)
+            .map(LinkedObject.user)) !== null && _b !== void 0 ? _b : []);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    applyFilter(data) {
+        let users = data;
+        users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+        return users;
+    }
+}
+
+/* begin_public_function
+  id: user.get_blocked_users
+*/
 /**
  * ```js
- * import { onFollowerRequested } from '@amityco/ts-sdk-react-native'
- * const dispose = onFollowerRequested(status => {
- *   // ...
- * })
+ * import { UserRepository } from '@amityco/ts-sdk-react-native'
+ * const unblockedUser = await UserRepository.blockUser('userId')
  * ```
  *
- * Fired when a user follows another users and confirmation is required
+ * Blocks a {@link Amity.InternalUser}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param params The params to get blocked {@link Amity.InternalUser}s
+ * @param callback to recieve updates on unblocked {@link Amity.InternalUser}s
+ * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
  *
- * @category Follow Events
+ * @category Post API
+ * @async
  */
-const onFollowerRequested = (callback) => createFollowEventSubscriber('follow.requested', callback);
+const getBlockedUsers$1 = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
+    const blockedUserLiveCollection = new BlockedUserLiveCollectionController(params, callback);
+    const disposers = blockedUserLiveCollection.startSubscription();
+    const cacheKey = blockedUserLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getBlockedUsers(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+        dropFromCache(cacheKey);
+    };
+};
+/* end_public_function */
+
+/* eslint-disable no-use-before-define */
+const getBlockedUsers = (params, callback, config) => {
+    console.log('Deprecation Notice: UserRepository.Relationship.getBlockedUsers will be deprecated on 9th June 2023, please use UserRepository.getBlockedUsers instead.');
+    return getBlockedUsers$1(params, callback);
+};
 
+/* begin_public_function
+  id: user.relationship.follow
+*/
 /**
  * ```js
- * import { onFollowRequestCanceled } from '@amityco/ts-sdk-react-native'
- * const dispose = onFollowRequestCanceled(status => {
- *   // ...
- * })
+ * import { follow } from '@amityco/ts-sdk-react-native'
+ * const status = await follow('foobar')
  * ```
  *
- * Fired when a follow request has been canceled
+ * Follow the user
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param userId the ID of the {@link Amity.InternalUser}
+ * @returns the status {@link Amity.FollowStatus}
  *
- * @category Follow Events
+ * @category Follow API
+ * @async
  */
-const onFollowRequestCanceled = (callback) => createFollowEventSubscriber('follow.requestCanceled', callback);
+const follow = async (userId) => {
+    const client = getActiveClient();
+    client.log('follow/follow', userId);
+    const { data } = await client.http.post(`/api/v4/me/following/${userId}`);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+        ingestInCache(data, { cachedAt });
+    }
+    const payload = prepareFollowStatusPayload(data);
+    if (data.follows[0].status === 'accepted') {
+        fireEvent('local.follow.created', payload);
+    }
+    else {
+        fireEvent('local.follow.requested', payload);
+    }
+    return {
+        data: data.follows[0],
+        cachedAt,
+    };
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: user.relationship.unfollow
+*/
 /**
  * ```js
- * import { onFollowRequestAccepted } from '@amityco/ts-sdk-react-native'
- * const dispose = onFollowRequestAccepted(status => {
- *   // ...
- * })
+ * import { unfollow } from '@amityco/ts-sdk-react-native'
+ * await unfollow('foobar')
  * ```
  *
- * Fired when a follow request has been accepted
+ * Cancel the follow request or unfollow the user
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param userId the ID of the {@link Amity.InternalUser}
+ * @returns A success boolean if the user {@link Amity.InternalUser} was unfollowed
  *
- * @category Follow Events
+ * @category Follow API
+ * @async
  */
-const onFollowRequestAccepted = (callback) => createFollowEventSubscriber('follow.accepted', callback);
+const unfollow = async (userId) => {
+    const client = getActiveClient();
+    client.log('follow/unfollow', userId);
+    const { data } = await client.http.delete(`/api/v4/me/following/${userId}`);
+    if (client.cache) {
+        ingestInCache(data);
+    }
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.unfollowed', payload);
+    return true;
+};
+/* end_public_function */
 
 /**
+ * @deprecated This API renamed to `acceptMyFollower`.
+ * Please use acceptMyFollower() instead.
+ *
  * ```js
- * import { onFollowRequestDeclined } from '@amityco/ts-sdk-react-native'
- * const dispose = onFollowRequestDeclined(status => {
- *   // ...
- * })
+ * import { acceptFollower } from '@amityco/ts-sdk-react-native'
+ * await acceptFollower('foobar')
  * ```
  *
- * Fired when a follow request has been declined
+ * Accept the follow request
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param userId the ID of the {@link Amity.InternalUser} follower
+ * @returns A success boolean if the follow request was accepted
  *
- * @category Follow Events
+ * @category Follow API
+ * @async
  */
-const onFollowRequestDeclined = (callback) => createFollowEventSubscriber('follow.requestDeclined', callback);
+const acceptFollower = async (userId) => {
+    const client = getActiveClient();
+    client.log('follow/acceptFollower', userId);
+    const { data } = await client.http.post(`/api/v4/me/followers/${userId}`);
+    if (client.cache) {
+        ingestInCache(data);
+    }
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.accepted', payload);
+    return true;
+};
 
+/* begin_public_function
+  id: user.relationship.accept_follow
+*/
 /**
  * ```js
- * import { getFollowInfo } from '@amityco/ts-sdk-react-native'
- * const { data: followInfo } = await getFollowInfo('foobar')
+ * import { UserRepository } from '@amityco/ts-sdk-react-native'
+ * await UserRepository.Relationship.acceptMyFollower('foobar')
  * ```
  *
- * Fetches the number of followers, followings, pending requests and the follow status for current user
+ * Accept the follow request
  *
- * @param userId the ID of the {@link Amity.InternalUser}
- * @returns the associated {@link Amity.FollowInfo} object
+ * @param userId the ID of the {@link Amity.InternalUser} follower
+ * @returns A success boolean if the follow request was accepted
  *
  * @category Follow API
  * @async
  */
-const getFollowInfo$1 = async (userId) => {
-    var _a, _b;
+const acceptMyFollower = async (userId) => {
     const client = getActiveClient();
-    client.log('follow/getFollowInfo', userId);
-    const { data } = await client.http.get(client.userId === userId ? `/api/v4/me/followInfo` : `/api/v5/users/${userId}/followInfo`);
-    const cachedAt = client.cache && Date.now();
-    const followInfo = 'follows' in data
-        ? Object.assign(Object.assign({}, data.followCounts[0]), { status: (_b = (_a = data.follows) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.status }) : data.followCounts[0];
+    client.log('follow/acceptMyFollower', userId);
+    const { data } = await client.http.post(`/api/v4/me/followers/${userId}`);
     if (client.cache) {
-        pushToCache(['followInfo', 'get', userId], followInfo, {
-            cachedAt,
-        });
+        ingestInCache(data);
     }
-    return {
-        data: followInfo,
-        cachedAt,
-    };
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.accepted', payload);
+    return true;
 };
+/* end_public_function */
+
 /**
+ * @deprecated This API renamed to `declineMyFollower`.
+ * Please use declineMyFollower() instead.
+ *
  * ```js
- * import { getFollowInfo } from '@amityco/ts-sdk-react-native'
- * const { data: followInfo } = getFollowInfo.locally('foobar')
+ * import { declineFollower } from '@amityco/ts-sdk-react-native'
+ * await declineFollower('foobar')
  * ```
  *
- * Fetches the number of followers, followings, pending requests and the follow status for current user from cache
+ * Decline the follow request or delete the follower
  *
- * @param userId the ID of the {@link Amity.InternalUser}
- * @returns the associated {@link Amity.FollowInfo} object
+ * @param userId the ID of the {@link Amity.InternalUser} follower
+ * @returns A success boolean if the follow request was decline
  *
  * @category Follow API
+ * @async
  */
-getFollowInfo$1.locally = (userId) => {
+const declineFollower = async (userId) => {
     const client = getActiveClient();
-    client.log('follow/getFollowInfo.locally', userId);
-    if (!client.cache) {
-        return;
-    }
-    const cached = pullFromCache(['followInfo', 'get', userId]);
-    if (!cached) {
-        return;
+    client.log('follow/declineFollower', userId);
+    const { data } = await client.http.delete(`/api/v4/me/followers/${userId}`);
+    if (client.cache) {
+        ingestInCache(data);
     }
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.requestDeclined', payload);
+    return true;
 };
 
+/* begin_public_function
+  id: user.relationship.decline_follow
+*/
 /**
  * ```js
- * import { onFollowInfoUpdated } from '@amityco/ts-sdk-react-native'
- * const dispose = onFollowInfoUpdated(followInfo => {
- *   // ...
- * })
+ * import { UserRepository } from '@amityco/ts-sdk-react-native'
+ * await UserRepository.Relationship.declineMyFollower('foobar')
  * ```
  *
- * Fired when a {@link Amity.FollowInfo} has been updated
+ * Decline the follow request or delete the follower
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param userId the ID of the {@link Amity.InternalUser} follower
+ * @returns A success boolean if the follow request was decline
  *
- * @category Follow Events
+ * @category Follow API
+ * @async
  */
-const onFollowInfoUpdated = (callback) => {
-    const handler = async (payload) => {
-        const [{ data: followInfoFrom }, { data: followInfoTo }] = await Promise.all([
-            getFollowInfo$1(payload.from),
-            getFollowInfo$1(payload.to),
-        ]);
-        callback(followInfoFrom);
-        callback(followInfoTo);
-    };
-    const disposers = [
-        createFollowEventSubscriber('follow.created', handler),
-        createFollowEventSubscriber('follow.requested', handler),
-        createFollowEventSubscriber('follow.accepted', handler),
-        createFollowEventSubscriber('follow.unfollowed', handler),
-        createFollowEventSubscriber('follow.requestCanceled', handler),
-        createFollowEventSubscriber('follow.requestDeclined', handler),
-        createFollowEventSubscriber('follow.followerDeleted', handler),
-        createLocalFollowEventSubscriber('local.follow.created', handler),
-        createLocalFollowEventSubscriber('local.follow.requested', handler),
-        createLocalFollowEventSubscriber('local.follow.accepted', handler),
-        createLocalFollowEventSubscriber('local.follow.unfollowed', handler),
-        createLocalFollowEventSubscriber('local.follow.requestDeclined', handler),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-const onLocalUserFollowed = (callback) => createLocalFollowEventSubscriber('local.follow.created', callback);
-
-const onLocalUserUnfollowed = (callback) => createLocalFollowEventSubscriber('local.follow.unfollowed', callback);
-
-const onLocalFollowerRequested = (callback) => createLocalFollowEventSubscriber('local.follow.requested', callback);
-
-const onLocalFollowRequestAccepted = (callback) => createLocalFollowEventSubscriber('local.follow.accepted', callback);
-
-const onLocalFollowRequestDeclined = (callback) => createLocalFollowEventSubscriber('local.follow.requestDeclined', callback);
+const declineMyFollower = async (userId) => {
+    const client = getActiveClient();
+    client.log('follow/declineMyFollower', userId);
+    const { data } = await client.http.delete(`/api/v4/me/followers/${userId}`);
+    if (client.cache) {
+        ingestInCache(data);
+    }
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.requestDeclined', payload);
+    return true;
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -11159,18 +11211,6 @@ class FollowerPaginationController extends PaginationController {
     }
 }
 
-var EnumFollowActions;
-(function (EnumFollowActions) {
-    EnumFollowActions["OnRequested"] = "onRequested";
-    EnumFollowActions["OnAccepted"] = "onAccepted";
-    EnumFollowActions["OnDeclined"] = "onDeclined";
-    EnumFollowActions["OnCanceled"] = "onCanceled";
-    EnumFollowActions["OnFollowed"] = "onFollowed";
-    EnumFollowActions["OnUnfollowed"] = "onUnfollowed";
-    EnumFollowActions["OnDeleted"] = "onDeleted";
-    EnumFollowActions["OnUserDeleted"] = "onUserDeleted";
-})(EnumFollowActions || (EnumFollowActions = {}));
-
 class FollowerQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -11248,7 +11288,7 @@ const onFollowerUserDeleted = ({ userId }) => (callback) => {
 
 class FollowerLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
-        const queryStreamId = hash__default["default"](query);
+        const queryStreamId = hash__default["default"](Object.assign(Object.assign({}, query), { type: 'follower' }));
         const cacheKey = ['follow', 'collection', queryStreamId];
         const paginationController = new FollowerPaginationController(query);
         super(paginationController, queryStreamId, cacheKey, callback);
@@ -11453,7 +11493,7 @@ const onFollowingUserDeleted = ({ userId }) => (callback) => {
 
 class FollowingLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
-        const queryStreamId = hash__default["default"](query);
+        const queryStreamId = hash__default["default"](Object.assign(Object.assign({}, query), { type: 'following' }));
         const cacheKey = ['follow', 'collection', queryStreamId];
         const paginationController = new FollowingPaginationController(query);
         super(paginationController, queryStreamId, cacheKey, callback);
@@ -12543,6 +12583,12 @@ const getReachedUsers = (params, callback) => {
     };
 };
 
+var AmityUserSearchMatchType;
+(function (AmityUserSearchMatchType) {
+    AmityUserSearchMatchType["DEFAULT"] = "default";
+    AmityUserSearchMatchType["PARTIAL"] = "partial";
+})(AmityUserSearchMatchType || (AmityUserSearchMatchType = {}));
+
 var index$j = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Relationship: index$k,
@@ -12562,7 +12608,8 @@ var index$j = /*#__PURE__*/Object.freeze({
   getBlockedUsers: getBlockedUsers$1,
   searchUserByDisplayName: searchUserByDisplayName,
   getViewedUsers: getViewedUsers,
-  getReachedUsers: getReachedUsers
+  getReachedUsers: getReachedUsers,
+  get AmityUserSearchMatchType () { return AmityUserSearchMatchType; }
 });
 
 /* begin_public_function
@@ -13359,16 +13406,19 @@ function isCurrentUserPartOfCommunity(c, m) {
 }
 /*
  * For mqtt events server will not send user specific data as it's broadcasted
- * to multiple users. Althought this can be calculated, it's not scalable. Hence
- * the client SDK needs to calculate this info
+ * to multiple users and it also does not include communityUser
+ *
+ * Client SDK needs to check for the existing isJoined field in cache data before calculating.
+ * Althought this can be calculated, it's not scalable.
  */
 function updateMembershipStatus(communities, communityUsers) {
     return communities.map(c => {
-        if (c.isJoined == null) {
-            const isJoined = communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
-            return Object.assign(Object.assign({}, c), { isJoined });
+        const cachedCommunity = pullFromCache(['community', 'get', c.communityId]);
+        if ((cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data) && (cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data.hasOwnProperty('isJoined'))) {
+            return Object.assign(Object.assign({}, cachedCommunity.data), c);
         }
-        return c;
+        const isJoined = communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
+        return Object.assign(Object.assign({}, c), { isJoined });
     });
 }
 
@@ -13469,7 +13519,7 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         referenceType,
         reactionName,
     });
-    await client.http.post('/api/v2/reactions', {
+    const { data } = await client.http.post('/api/v2/reactions', {
         referenceId,
         referenceType,
         reactionName,
@@ -13487,12 +13537,33 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         if (referenceType === 'comment') {
             fireEvent('local.comment.addReaction', {
                 comment: updatedModel,
+                reactor: {
+                    userId: client.userId,
+                    reactionName,
+                    reactionId: data.addedId,
+                },
             });
             return true;
         }
         if (referenceType === 'post') {
             fireEvent('local.post.addReaction', {
                 post: updatedModel,
+                reactor: {
+                    userId: client.userId,
+                    reactionName,
+                    reactionId: data.addedId,
+                },
+            });
+            return true;
+        }
+        if (referenceType === 'story') {
+            fireEvent('local.story.reactionAdded', {
+                story: updatedModel,
+                reactor: {
+                    userId: client.userId,
+                    reactionName,
+                    reactionId: data.addedId,
+                },
             });
             return true;
         }
@@ -13567,7 +13638,7 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
         referenceType,
         reactionName,
     });
-    await client.http.delete(`/api/v2/reactions`, {
+    const { data } = await client.http.delete(`/api/v2/reactions`, {
         data: {
             referenceId,
             referenceType,
@@ -13587,12 +13658,33 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
         if (referenceType === 'comment') {
             fireEvent('local.comment.removeReaction', {
                 comment: updatedModel,
+                reactor: {
+                    reactionId: data.removedId,
+                    reactionName,
+                    userId: client.userId,
+                },
             });
             return true;
         }
         if (referenceType === 'post') {
             fireEvent('local.post.removeReaction', {
                 post: updatedModel,
+                reactor: {
+                    reactionId: data.removedId,
+                    reactionName,
+                    userId: client.userId,
+                },
+            });
+            return true;
+        }
+        if (referenceType === 'story') {
+            fireEvent('local.story.reactionAdded', {
+                story: updatedModel,
+                reactor: {
+                    userId: client.userId,
+                    reactionName,
+                    reactionId: data.removedId,
+                },
             });
             return true;
         }
@@ -13616,7 +13708,7 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
  * @category Reaction API
  * */
 removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     const client = getActiveClient();
     client.log('reaction/removeReaction.optimistically', {
         referenceId,
@@ -13637,7 +13729,7 @@ removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
         cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
     });
     dispatchReactable(referenceType, reaction);
-    return (_e = !((_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName))) !== null && _e !== void 0 ? _e : false;
+    return !((_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName));
 };
 
 const getMatchPostSetting = (value) => {
@@ -14459,73 +14551,262 @@ const onReactorRemoved = (referenceType, referenceId, callback) => {
 
 const REFERENCE_API_V5 = 5;
 
+class ReactionPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const client = getActiveClient();
+        client.log('reaction/queryReactions', queryParams);
+        const path = '/api/v3/reactions';
+        const { data: queryResponse } = await this.http.get(path, {
+            params: Object.assign(Object.assign({}, params), { referenceVersion: REFERENCE_API_V5, // Need to put this param to make it can query reaction for message in sub-channel
+                options }),
+        });
+        return queryResponse;
+    }
+}
+
+class ReactionQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        var _a;
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            const { reactions } = processedPayload, restPayload = __rest(processedPayload, ["reactions"]);
+            ingestInCache(Object.assign(Object.assign({}, restPayload), { reactions, reactors: (_a = reactions[0]) === null || _a === void 0 ? void 0 : _a.reactors }), { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b, _c, _d;
+        const reactors = (_b = (_a = response.reactions[0]) === null || _a === void 0 ? void 0 : _a.reactors) !== null && _b !== void 0 ? _b : [];
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: reactors.map(getResolver('reactor')),
+            });
+        }
+        else {
+            const collection = (_c = pullFromCache(this.cacheKey)) === null || _c === void 0 ? void 0 : _c.data;
+            const reactions = (_d = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _d !== void 0 ? _d : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...reactions, ...reactors.map(getResolver('reactor'))])] }));
+        }
+    }
+    reactor(action) {
+        return (reaction) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === "onAdded" /* Amity.ReactionActionTypeEnum.OnAdded */) {
+                collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+            }
+            else if (action === "onRemoved" /* Amity.ReactionActionTypeEnum.OnRemoved */) {
+                collection.data = collection.data.filter(p => p !== reaction.reactionId);
+            }
+            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)));
+    }
+}
+
 /**
  * ```js
- * import { queryReactions } from '@amityco/ts-sdk-react-native'
- * const { data: reactions, prevPage, nextPage } = await queryReactions({
- *   referenceId: 'postId',
- *   referenceType: 'post',
+ * import { onReactorRemovedLocal } from '@amityco/ts-sdk'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
  * })
  * ```
  *
- * Queries a paginable list of {@link Amity.Reaction} objects
+ * Fired when an {@link Amity.InternalReactor} has been removed
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.Reaction} objects
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @reaction Reaction API
- * @async
+ * @category Events
  * */
-const queryReactions = async (query) => {
+const onReactorRemovedLocal = (referenceType, referenceId, callback) => {
     const client = getActiveClient();
-    client.log('reaction/queryReactions', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { page = { limit: 10 } } = _a, params = __rest(_a, ["page"]);
-    const { data } = await client.http.get(`/api/v3/reactions`, {
-        params: Object.assign(Object.assign({}, params), { referenceVersion: REFERENCE_API_V5, options: {
-                token: toToken(page, 'afterbeforeraw'),
-            } }),
-    });
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { reactions } = payload;
-    // FIXME: correct reactions type in model
-    // @ts-ignore
-    ingestInCache(Object.assign(Object.assign({}, payload), { reactions })); // Save reaction response into cache
-    ingestInCache(Object.assign(Object.assign({}, payload), { reactors: reactions[0].reactors })); // Save reactors data into cache for support reaction query
-    const nextPage = toPageRaw(paging.next);
-    const prevPage = toPageRaw(paging.previous);
-    return { data: reactions, prevPage, nextPage };
+    const callbackWrapper = (referenceType_, referenceId_, reaction) => {
+        if (referenceType_ === referenceType && referenceId_ === referenceId) {
+            callback(reaction);
+        }
+    };
+    if (referenceType === 'message') {
+        const filter = async (rawPayload) => {
+            const payload = await prepareMessagePayload(rawPayload);
+            if (!payload.reactions[0])
+                return;
+            ingestInCache(payload);
+            callbackWrapper('message', payload.messages[0].messageId, payload.reactions[0]);
+        };
+        return createEventSubscriber(client, 'reaction/onReactorRemoved', 'message.reactionRemoved', filter);
+    }
+    if (referenceType === 'post') {
+        const filter = (payload) => {
+            callbackWrapper('post', payload.post.postId, payload.reactor);
+        };
+        return createEventSubscriber(client, 'local.post.removeReaction', 'local.post.removeReaction', filter);
+    }
+    if (referenceType === 'story') {
+        const filter = (payload) => {
+            const { reactions } = payload, rest = __rest(payload, ["reactions"]);
+            ingestInCache(rest);
+            ingestInCache({ reactors: reactions });
+            if (payload.stories.length === 0 || payload.reactions.length === 0)
+                return;
+            callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+        };
+        return createEventSubscriber(client, 'story.reactionRemoved', 'story.reactionRemoved', filter);
+    }
+    const filter = (payload) => {
+        callbackWrapper('comment', payload.comment.commentId, payload.reactor);
+    };
+    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
 };
 
 /**
  * ```js
- * import { queryReactor } from '@amityco/ts-sdk-react-native'
- * const { data: reactions, prevPage, nextPage } = await queryReactor({
- *   referenceId: 'postId',
- *   referenceType: 'post',
+ * import { onReactorAddedLocal } from '@amityco/ts-sdk'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
  * })
  * ```
  *
- * Queries a paginable list of {@link Amity.InternalReactor} objects
+ * Fired when an {@link Amity.InternalReactor} has been added
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.InternalReactor} objects
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @reaction Reaction API
- * @async
+ * @category Events
  * */
-const queryReactor = async (query) => {
+const onReactorAddedLocal = (referenceType, referenceId, callback) => {
     const client = getActiveClient();
-    client.log('reaction/queryReactor', query);
-    const _a = await queryReactions(query), { data } = _a, response = __rest(_a, ["data"]);
-    return Object.assign(Object.assign({}, response), { data: data[0].reactors });
+    const callbackWrapper = (referenceType_, referenceId_, reaction) => {
+        if (referenceType_ === referenceType && referenceId_ === referenceId) {
+            callback(reaction);
+        }
+    };
+    if (referenceType === 'message') {
+        const filter = async (rawPayload) => {
+            const payload = await prepareMessagePayload(rawPayload);
+            if (!payload.reactions[0])
+                return;
+            ingestInCache(payload);
+            ingestInCache({ reactors: payload.reactions });
+            callbackWrapper('message', payload.messages[0].messageId, payload.reactions[0]);
+        };
+        return createEventSubscriber(client, 'reaction/onReactorAdded', 'message.reactionAdded', filter);
+    }
+    if (referenceType === 'post') {
+        const filter = (payload) => {
+            callbackWrapper('post', payload.post.postId, payload.reactor);
+        };
+        return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+    }
+    if (referenceType === 'story') {
+        const filter = (payload) => {
+            const { reactions } = payload, rest = __rest(payload, ["reactions"]);
+            ingestInCache(rest);
+            ingestInCache({ reactors: reactions });
+            if (payload.stories.length === 0 || payload.reactions.length === 0)
+                return;
+            callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+        };
+        return createEventSubscriber(client, 'story.reactionAdded', 'story.reactionAdded', filter);
+    }
+    const filter = (payload) => {
+        callbackWrapper('comment', payload.comment.commentId, payload.reactor);
+    };
+    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
 };
 
+class ReactionLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['reaction', 'collection', queryStreamId];
+        const paginationController = new ReactionPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new ReactionQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), payload => payload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: 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: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: callback => onReactorAdded(this.query.referenceType, this.query.referenceId, callback),
+                action: "onAdded" /* Amity.ReactionActionTypeEnum.OnAdded */,
+            },
+            {
+                fn: callback => onReactorRemoved(this.query.referenceType, this.query.referenceId, callback),
+                action: "onRemoved" /* Amity.ReactionActionTypeEnum.OnRemoved */,
+            },
+            {
+                fn: callback => onReactorRemovedLocal(this.query.referenceType, this.query.referenceId, callback),
+                action: "onRemoved" /* Amity.ReactionActionTypeEnum.OnRemoved */,
+            },
+            {
+                fn: callback => onReactorAddedLocal(this.query.referenceType, this.query.referenceId, callback),
+                action: "onRemoved" /* Amity.ReactionActionTypeEnum.OnRemoved */,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = (_b = collection.data
+            .map(reactorId => pullFromCache(['reactor', 'get', reactorId]))
+            .filter(Boolean)
+            .map(({ data }) => LinkedObject.reactor(data))) !== null && _b !== void 0 ? _b : [];
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* eslint-disable no-use-before-define */
 /* begin_public_function
   id: reaction.query
 */
 /**
  * ```js
- * import { getReactions } from '@amityco/ts-sdk-react-native'
+ * import { getReactions } from '@amityco/ts-sdk'
  *
  * let reactions = []
  * const unsub = liveReactions({
@@ -14545,73 +14826,19 @@ const queryReactor = async (query) => {
  */
 const getReactions = (params, callback, config) => {
     const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log('For using Live Collection feature you need to enable Cache!');
-    }
+    // if (!cache) {
+    //   console.log('For using Live Collection feature you need to enable Cache!');
+    // }
     const timestamp = Date.now();
-    log(`liveReactions(tmpid: ${timestamp}) > listen`);
-    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
-    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
-    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
-    const disposers = [];
-    const cacheKey = [
-        'reaction',
-        'collection',
-        { referenceId: params.referenceId, referenceType: params.referenceType },
-    ];
-    const responder = (data) => {
-        var _a, _b;
-        const reactions = (_a = data.data
-            .map(reactorId => pullFromCache(['reactor', 'get', reactorId]))
-            .filter(Boolean)
-            .map(({ data }) => LinkedObject.reactor(data))) !== null && _a !== void 0 ? _a : [];
-        callback({
-            onNextPage: onFetch,
-            data: reactions,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (action) => (reaction) => {
-        var _a;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        if (action === 'onAdded') {
-            collection.data = [...new Set([reaction.reactionId, ...collection.data])];
-        }
-        else if (action === 'onRemoved') {
-            collection.data = collection.data.filter(p => p !== reaction.reactionId);
-        }
-        pushToCache(cacheKey, collection);
-        responder(collection);
-    };
-    const onFetch = (initial = false) => {
-        var _a, _b, _c, _d;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        const reactions = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-        if (!initial && reactions.length > 0 && !((_c = collection === null || collection === void 0 ? void 0 : collection.params) === null || _c === void 0 ? void 0 : _c.page))
-            return;
-        const query = createQuery(queryReactor, Object.assign(Object.assign({}, queryParams), { page: (_d = (!initial ? collection === null || collection === void 0 ? void 0 : collection.params.page : undefined)) !== null && _d !== void 0 ? _d : { limit } }));
-        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
-            const data = {
-                loading,
-                error,
-                params: { page },
-                data: reactions,
-            };
-            if (result) {
-                data.data = [...new Set([...reactions, ...result.map(getResolver('reactor'))])];
-            }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy));
-    };
-    disposers.push(onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')), onReactorRemoved(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onRemoved')));
-    onFetch(true);
+    log(`getReactions(tmpid: ${timestamp}) > listen`);
+    const reactionLiveCollection = new ReactionLiveCollectionController(params, callback);
+    const disposers = reactionLiveCollection.startSubscription();
+    const cacheKey = reactionLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
     return () => {
-        log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+        log(`getReactions(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
@@ -15117,30 +15344,6 @@ const unmuteChannel = async (channelId) => {
 };
 /* end_public_function */
 
-const convertEventPayload = (eventHandler, sourceModelProp, destinationDomain) => (callback) => eventHandler(sourceModel => {
-    var _a, _b;
-    if (!sourceModel) {
-        return sourceModel;
-    }
-    const client = getActiveClient();
-    const { objectSyncMap } = client;
-    /*
-     * NOTE: For objects created locally (optimistic creation), the SDK stores them with their local ID as the cache key, which is used throughout the entire SDK session (in-memory) for syncing updates.
-     * If the payload or response only contains the remote ID of the same object, the SDK will look up the corresponding local ID to retrieve the object.
-     */
-    const resolvedId = isLocalId(sourceModel[sourceModelProp])
-        ? sourceModel[sourceModelProp]
-        : (_a = objectSyncMap.get(sourceModel[sourceModelProp])) !== null && _a !== void 0 ? _a : sourceModel[sourceModelProp];
-    const model = (_b = pullFromCache([
-        destinationDomain,
-        'get',
-        `${resolvedId}`,
-    ])) === null || _b === void 0 ? void 0 : _b.data;
-    if (!model)
-        return;
-    return callback(model);
-});
-
 /**
  * ```js
  * import { observeChannel } from '@amityco/ts-sdk-react-native'
@@ -19290,7 +19493,8 @@ const createCommunityMemberEventSubscriber = (event, callback) => {
             callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
         }
         else {
-            ingestInCache(preparedPayload);
+            // NOTE: The event payload should be merge with existing cache data
+            ingestInCache(preparedPayload, undefined, false);
             const community = pullFromCache([
                 'community',
                 'get',
@@ -19327,7 +19531,8 @@ const createLocalCommunityMemberEventSubscriber = (event, callback) => {
             callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
         }
         else {
-            ingestInCache(preparedPayload);
+            // NOTE: The event payload should be merge with existing cache data
+            ingestInCache(preparedPayload, undefined, false);
             const community = pullFromCache([
                 'community',
                 'get',
@@ -21417,9 +21622,10 @@ const queryGlobalFeed = async (query) => {
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
     const data = prepareMembershipPayload(payload, 'communityUsers');
     const { posts } = data;
+    const { communities: processedCommunity } = prepareCommunityPayload(data);
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(data);
+        ingestInCache(Object.assign(Object.assign({}, data), { communitis: processedCommunity }));
         const cacheKey = [
             'globalFeed',
             'query',
@@ -23734,6 +23940,145 @@ const getPinnedPosts = (params, callback, config) => {
     };
 };
 
+class GlobalPinnedPostPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        __rest(queryParams, ["limit"]);
+        const path = '/api/v1/pinned-posts/global';
+        const { data: queryResponse } = await this.http.get(path);
+        return queryResponse;
+    }
+}
+
+class GlobalPinnedPostQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async saveToMainDB(response) {
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(response, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.pins.map(getResolver('pin')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const pinnedPosts = (_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([...pinnedPosts, ...response.pins.map(getResolver('pin'))])] }));
+            this.notifyChange({
+                origin: "server" /* Amity.LiveDataOrigin.SERVER */,
+                loading: false,
+            });
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumPostActions.OnPostDeleted) {
+                collection.data = collection.data.filter(referenceId => referenceId !== `global#${post.postId}`);
+            }
+            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)));
+    }
+}
+
+class GlobalPinnedPostLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['pinnedPosts', 'collection', queryStreamId];
+        const paginationController = new GlobalPinnedPostPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new GlobalPinnedPostQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), response => response);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: 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: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
+            {
+                fn: onPostDeleted,
+                action: EnumPostActions.OnPostDeleted,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['pin', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.pinnedPost);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            data,
+            loading,
+            error,
+        });
+    }
+}
+
+/**
+ * Get global pinned posts
+ *
+ * @returns the global pinned post(s)
+ *
+ * @category Pined Posts Live Collection
+ *
+ */
+const getGlobalPinnedPosts = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    // if (!cache) {
+    //   console.log(ENABLE_CACHE_MESSAGE);
+    // }
+    const timestamp = Date.now();
+    log(`getGlobalPinnedPosts(tmpid: ${timestamp}) > listen`);
+    const globalPinnedPostLiveCollection = new GlobalPinnedPostLiveCollectionController(params, callback);
+    const disposers = globalPinnedPostLiveCollection.startSubscription();
+    const cacheKey = globalPinnedPostLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getGlobalPinnedPosts(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 class SemanticSearchPostPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
         const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
@@ -23995,6 +24340,7 @@ var index$5 = /*#__PURE__*/Object.freeze({
   getPost: getPost$1,
   getPosts: getPosts,
   getPinnedPosts: getPinnedPosts,
+  getGlobalPinnedPosts: getGlobalPinnedPosts,
   semanticSearchPosts: semanticSearchPosts
 });
 
@@ -25539,8 +25885,8 @@ const onStoryReactionAdded = (callback) => {
 const onStoryReactionAddedLocal = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
-        ingestInCache(payload);
-        callback(payload.stories);
+        ingestInCache({ stories: [payload.story] });
+        callback([payload.story]);
     };
     const disposers = [
         createEventSubscriber(client, 'onStoryReactionAdded', 'local.story.reactionAdded', filter),
@@ -25569,8 +25915,8 @@ const onStoryReactionRemoved = (callback) => {
 const onStoryReactionRemovedLocal = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
-        ingestInCache(payload);
-        callback(payload.stories);
+        ingestInCache({ stories: [payload.story] });
+        callback([payload.story]);
     };
     const disposers = [
         createEventSubscriber(client, 'onStoryReactionRemoved', 'local.story.reactionRemoved', filter),
@@ -26110,12 +26456,12 @@ const updateLocalList = (cacheKey, targetIds) => {
     pushToCache(cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...storyTargets, ...targetIds])] }));
 };
 class GlobalStoryQueryStreamController extends QueryStreamController {
-    constructor(query, cacheKey, notifyChange, paginationController) {
+    constructor(query, cacheKey, notifyChange, paginationController, preparePayload) {
         super(query, cacheKey);
         this.notifyChange = notifyChange;
         this.paginationController = paginationController;
         // Fix ESLint, "Expected 'this' to be used by class method"
-        this.preparePayload = payload => payload;
+        this.preparePayload = preparePayload;
     }
     saveToMainDB(response) {
         const client = getActiveClient();
@@ -26207,7 +26553,10 @@ class GlobalStoryLiveCollectionController extends LiveCollectionController {
         const paginationController = new GlobalStoryPageController(query);
         super(paginationController, queryStreamId, cacheKey, callback);
         this.query = query;
-        this.queryStreamController = new GlobalStoryQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), paginationController);
+        this.queryStreamController = new GlobalStoryQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), paginationController, (data) => {
+            const _a = prepareCommunityPayload(Object.assign(Object.assign({}, data), { feeds: [] })), rest = __rest(_a, ["feeds"]);
+            return Object.assign(Object.assign({}, data), rest);
+        });
         this.paginationController = paginationController;
         this.callback = callback.bind(this);
         this.loadPage({ initial: true });