@amityco/ts-sdk-react-native 6.35.2-412ed8b.0 → 6.35.3-38f774d.0

package/dist/index.cjs.js

@@ -123,8 +123,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v6.35.1-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v6.35.1-cjs';
+        // the string ''v6.35.2-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.35.2-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -6149,268 +6149,66 @@ function updateSubChannelCache(subChannelId, subChannel, params) {
     shallowClone(subChannel, params));
 }
 
-const handleMessageCreated = async (message) => {
-    var _a, _b, _c, _d;
-    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
-    /**
-     * SubChannel Case
-     *
-     */
-    const messagePreviewSubChannelCache = (_a = pullFromCache([
-        'messagePreviewSubChannel',
-        'get',
-        message.subChannelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (!messagePreviewSubChannelCache ||
-        messagePreviewSubChannelCache.segment <= message.channelSegment) {
-        const subChannelCache = (_b = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _b === void 0 ? void 0 : _b.data;
-        pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
-            data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
-            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
-        });
-        updateSubChannelCache(message.subChannelId, subChannelCache, {
-            messagePreviewId,
-        });
-    }
-    /**
-     * Channel Case
-     */
-    const messagePreviewChannelCache = (_c = pullFromCache([
-        'messagePreviewChannel',
-        'get',
-        message.channelId,
-    ])) === null || _c === void 0 ? void 0 : _c.data;
-    if (!messagePreviewChannelCache ||
-        new Date(messagePreviewChannelCache.createdAt).valueOf() <=
-            new Date(message.createdAt).valueOf()) {
-        const subChannelCache = (_d = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _d === void 0 ? void 0 : _d.data;
-        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
-            data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
-            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
-        });
-    }
-};
-const handleMessageUpdated = async (message) => {
-    var _a, _b, _c, _d;
-    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
-    /**
-     * SubChannel Case
-     *
-     */
-    const messagePreviewSubChannelCache = (_a = pullFromCache([
-        'messagePreviewSubChannel',
-        'get',
-        message.subChannelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (messagePreviewSubChannelCache &&
-        messagePreviewSubChannelCache.messagePreviewId === message.messageId) {
-        /**
-         * subChannelCache not have messagePreviewId so update it directly
-         * because this function allow only corresponding subChannel
-         */
-        const subChannelCache = (_b = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _b === void 0 ? void 0 : _b.data;
-        updateSubChannelCache(message.subChannelId, subChannelCache, {
-            messagePreviewId,
-        });
-        pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
-            data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: message === null || message === void 0 ? void 0 : message.updatedAt,
-            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
-        });
-    }
-    /**
-     * Channel Case
-     */
-    const messagePreviewChannelCache = (_c = pullFromCache([
-        'messagePreviewChannel',
-        'get',
-        message.channelId,
-    ])) === null || _c === void 0 ? void 0 : _c.data;
-    if (messagePreviewChannelCache &&
-        messagePreviewChannelCache.messagePreviewId === message.messageId) {
-        const subChannelCache = (_d = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _d === void 0 ? void 0 : _d.data;
-        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
-            data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
-            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
-        });
-    }
-};
-const handleSubChannelUpdated = async (subChannel) => {
-    var _a, _b, _c, _d;
-    const { channelId, subChannelId } = subChannel;
-    /** Channel Case */
-    const messagePreviewChannelCache = (_a = pullFromCache([
-        'messagePreviewChannel',
-        'get',
-        channelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.subChannelId) === subChannelId) {
-        const subChannelCache = (_b = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _b === void 0 ? void 0 : _b.data;
-        pushToCache(['messagePreviewChannel', 'get', channelId], Object.assign(Object.assign({}, messagePreviewChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
-    }
-    /** SubChannel Case */
-    const messagePreviewSubChannelCache = (_c = pullFromCache([
-        'messagePreviewSubChannel',
-        'get',
-        subChannelId,
-    ])) === null || _c === void 0 ? void 0 : _c.data;
-    if (messagePreviewSubChannelCache &&
-        new Date(messagePreviewSubChannelCache.updatedAt).valueOf() >
-            new Date(subChannel.updatedAt).valueOf()) {
-        const subChannelCache = (_d = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _d === void 0 ? void 0 : _d.data;
-        pushToCache(['messagePreviewSubChannel', 'get', subChannelId], Object.assign(Object.assign({}, messagePreviewSubChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
-    }
-};
-
-function convertRawUserToInternalUser(rawUser) {
-    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
-}
-
-const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
-const isUnreadCountSupport$2 = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
-function convertFromRaw$2(channel, options = { isMessagePreviewUpdated: true }) {
-    var _a;
-    let { messagePreviewId } = channel;
-    const messagePreviewChannelCache = (_a = pullFromCache([
-        'messagePreviewChannel',
-        'get',
-        channel.channelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.messagePreviewId) && !options.isMessagePreviewUpdated) {
-        messagePreviewId = messagePreviewChannelCache.messagePreviewId;
-    }
-    return Object.assign(Object.assign({}, channel), { defaultSubChannelId: channel.channelInternalId, isUnreadCountSupport: isUnreadCountSupport$2(channel), messagePreviewId });
-}
-const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated: true }) => {
-    ingestInCache({
-        channels: rawPayload.channels.map(channel => convertFromRaw$2(channel, { isMessagePreviewUpdated: options.isMessagePreviewUpdated })),
-    });
-};
-const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpdated: true }) => {
-    const client = getActiveClient();
-    const networkPreviewSetting = await client.getMessagePreviewSetting(false);
-    if (options.isMessagePreviewUpdated &&
-        networkPreviewSetting !== "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */ &&
-        rawPayload.messagePreviews &&
-        rawPayload.messagePreviews.length > 0) {
-        updateChannelMessagePreviewCache(rawPayload);
-    }
-    const markerIds = rawPayload.channels
-        // filter channel by type. Only conversation, community and broadcast type are included.
-        .filter(isUnreadCountSupport$2)
-        .map(({ channelInternalId }) => channelInternalId);
-    if (markerIds.length > 0) {
-        // since the get markers method requires a channel cache to function with the reducer.
-        preUpdateChannelCache(rawPayload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated });
-        try {
-            await getChannelMarkers(markerIds);
-        }
-        catch (e) {
-            // empty block (from the spec, allow marker fetch to fail without having to do anything)
-        }
+/**
+ * ```js
+ * import { isInTombstone } from '@amityco/ts-sdk-react-native'
+ * const user = isInTombstone(["message", "messageId"])
+ * ```
+ *
+ * Checks if the {@link Amity.TombstoneCacheOptions} exists
+ * in cache and it's not expired means it's in tombstone
+ * and we throw an Error
+ *
+ * @param model the model to check
+ * @param modelId the object id to check
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+const isInTombstone = (model, modelId) => {
+    const { log, cache } = getActiveClient();
+    const key = [model, CACHE_KEY_TOMBSTONE, modelId];
+    if (!cache)
+        return;
+    log('cache/api/isInTombstone', key);
+    const isInTombstone = pullFromCache(key);
+    const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
+    if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
+        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
     }
-    // attach marker to channel
-    const channels = rawPayload.channels.map(payload => convertFromRaw$2(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }));
-    // user marker to channel users
-    const channelUsers = rawPayload.channelUsers.map(channelUser => {
-        return convertRawMembershipToMembership(channelUser);
-    });
-    const users = rawPayload.users.map(convertRawUserToInternalUser);
-    const restRawPayload = __rest(rawPayload, ["messageFeedsInfo", "messagePreviews"]);
-    return Object.assign(Object.assign({}, restRawPayload), { users,
-        channels,
-        channelUsers });
 };
 
 /**
  * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk-react-native'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * import { getMessageMarkers } from '@amityco/ts-sdk-react-native'
+ * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
  * ```
  *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ * Fetches a list of {@link Amity.MessageMarker} by messageIds
  *
- * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.SubChannelMarker} objects
+ * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
+ * @returns A list of {@link Amity.MessageMarker} by messageIds
  *
  * @category Channel API
  * @async
  * @private
  */
-const getUserMessageFeedMakers = async (channelIds) => {
+const getMessageMarkers = async (messageIds) => {
     const client = getActiveClient();
-    client.log('channel/getUserMessageFeedMakers', channelIds);
-    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
+    client.log('channel/getMessageMarkers', messageIds);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/messages`, {
         params: {
-            channelIds,
+            messageIds,
         },
     });
-    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
-    return data;
+    const { contentMarkers, feedMarkers, userMarkers } = queryPayload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });
+    fireEvent('local.feedMarker.fetched', { feedMarkers });
+    fireEvent('local.messageMarker.fetched', { contentMarkers });
+    fireEvent('local.userMarker.fetched', { userMarkers });
+    return { data: contentMarkers, cachedAt };
 };
 
 const persistUnreadCountInfo = (payload) => {
@@ -6444,229 +6242,687 @@ const persistUnreadCountInfo = (payload) => {
                 }
             }
         });
-        // re-calculate channel unread info in cache
-        channelIds.forEach(channelId => {
-            reCalculateChannelUnreadInfo(channelId);
+        // re-calculate channel unread info in cache
+        channelIds.forEach(channelId => {
+            reCalculateChannelUnreadInfo(channelId);
+        });
+    }
+};
+
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk-react-native'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannelMarkers', messageFeedIds, page);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/message-feeds`, {
+        params: {
+            messageFeedIds,
+            options: {
+                token: toToken(page, 'skiplimit'),
+            },
+        },
+    });
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, userMarkers, feedMarkers: feedMarkersPayload, } = payload;
+    // if consistent mode is enabled, persist the unread count info to the cache
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        persistUnreadCountInfo({
+            feedMarkers: feedMarkersPayload,
+            userFeedMarkers: userFeedMarkersPayload,
+        });
+    }
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ userEntityMarkers, userFeedMarkers, userMarkers }, { cachedAt });
+    fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+    fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+    fireEvent('local.userMarker.fetched', { userMarkers });
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: userFeedMarkers, cachedAt, prevPage, nextPage };
+};
+
+const getUserMarker = async () => {
+    const client = getActiveClient();
+    client.log('channel/getUserMarker');
+    const { data: payload } = await client.http.get(`/api/v1/markers/userMarker`);
+    const { userMarkers } = payload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ userMarkers }, { cachedAt });
+    fireEvent('local.userMarker.fetched', { userMarkers });
+    const latestUserMarker = userMarkers.reduce((maxUserMarker, userMarker) => {
+        if (maxUserMarker == null ||
+            new Date(maxUserMarker.lastSyncAt).getTime() < new Date(userMarker.lastSyncAt).getTime()) {
+            return userMarker;
+        }
+        return maxUserMarker;
+    }, undefined);
+    return { data: latestUserMarker, cachedAt };
+};
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+const prepareMessagePayloadForCache = (payload, reactors, event) => {
+    const client = getActiveClient();
+    const cached = pullFromCache(['message', 'get', payload.messageId]);
+    // '[]' in cases where the new reaction is the first one
+    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
+    // add myReactions to the payload
+    Object.assign(payload, { myReactions });
+    // check if there are any updates to the reactions
+    const latestReaction = reactors[0];
+    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+    if (!isLatestReactionMine) {
+        return;
+    }
+    // new reaction added
+    if (event === 'message.reactionAdded' && !myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: [...myReactions, latestReaction.reactionName],
+        });
+    }
+    // existing reaction removed
+    if (event === 'message.reactionRemoved' && myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
         });
     }
 };
 
-const prepareUnreadCountInfo = async (rawPayload) => {
-    const client = getActiveClient();
-    // if consistent mode is enabled, persist the unread count info to the cache
-    // Marker service API uses channelInternalId as channelId
-    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelInternalId }) => channelInternalId));
-    const { feedMarkers, userFeedMarkers } = queryPayload;
-    persistUnreadCountInfo({
-        feedMarkers,
-        userFeedMarkers,
-    });
-    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
-};
+/*
+ * This is a simple utility that infers the value of isDeleted based on the
+ * value of includeDeleted
+ *
+ * There are two important things to note here:
+ *  1. `includeDeleted` is purely client side query param and not recognized by
+ *  the server
+ *  2. The only values we wish to expose with regards to `isDeleted` (the server
+ *  param for queries) is false | undefined and want to disallow users to query
+ *  for deleted entities
+ *
+ *  Although this is a very simple utility, it's only purpose is to keep things
+ *  DRY
+ */
+const inferIsDeleted = (includeDeleted) => includeDeleted === true ? undefined : false;
 
-const getCachedMarker$1 = (entityId) => {
-    var _a;
+function getSubChannelIsMentioned(channelId, subChannelId, marker) {
+    var _a, _b;
+    // Look for `unreadCount` in the marker param first
+    if (marker) {
+        return marker.hasMentioned;
+    }
+    const client = getActiveClient();
+    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        const cachedUnreadCount = (_a = pullFromCache([
+            'subChannelUnreadInfo',
+            'get',
+            subChannelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (cachedUnreadCount) {
+            return cachedUnreadCount.isMentioned;
+        }
+        return false;
+    }
     const key = {
-        entityId,
+        entityId: channelId,
+        feedId: subChannelId,
         userId: getActiveUser()._id,
     };
-    return (_a = pullFromCache([
-        'channelMarker',
+    // If the marker param is not set, look in the cache
+    const cachedMarker = (_b = pullFromCache([
+        'subChannelMarker',
         'get',
-        getResolver('channelMarker')(key),
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-};
-const getUnreadInfoCached$1 = (channelId) => {
-    var _a;
-    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
-};
-/**
- * The function use to get value of hasMentioned or isMentioned field.
- * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
- *
- * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
- * If not, the function will return the value from the channelMarker cache.
- * If not found in the both cache, use `false` as defaul value.
- */
-const getChannelIsMentioned = (channel, marker) => {
-    var _a, _b, _c, _d;
+        getResolver('subChannelMarker')(key),
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+    if (cachedMarker) {
+        return cachedMarker.hasMentioned;
+    }
+    // and if not found in cache use default value `false`
+    return false;
+}
+
+function getSubChannelUnreadCount(channelId, subChannelId, marker) {
+    var _a, _b;
+    // Look for `unreadCount` in the marker param first
+    if (marker) {
+        return marker.unreadCount;
+    }
     const client = getActiveClient();
+    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
     if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        return (_b = (_a = getUnreadInfoCached$1(channel.channelPublicId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
+        const cachedUnreadCount = (_a = pullFromCache([
+            'subChannelUnreadInfo',
+            'get',
+            subChannelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (cachedUnreadCount) {
+            return cachedUnreadCount.isDeleted ? 0 : cachedUnreadCount.unreadCount;
+        }
+        return 0;
     }
-    return (marker === null || marker === void 0 ? void 0 : marker.hasMentioned) !== undefined
-        ? marker === null || marker === void 0 ? void 0 : marker.hasMentioned
-        : (_d = (_c = getCachedMarker$1(channel.channelPublicId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
-};
-
-const getCachedMarker = (entityId) => {
-    var _a;
     const key = {
-        entityId,
+        entityId: channelId,
+        feedId: subChannelId,
         userId: getActiveUser()._id,
     };
-    return (_a = pullFromCache([
-        'channelMarker',
+    // If the marker param is not set, look in the cache
+    const cachedMarker = (_b = pullFromCache([
+        'subChannelMarker',
         'get',
-        getResolver('channelMarker')(key),
-    ])) === null || _a === void 0 ? void 0 : _a.data;
+        getResolver('subChannelMarker')(key),
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+    if (cachedMarker) {
+        return cachedMarker.unreadCount;
+    }
+    // and if not found in cache use default value `0`
+    return 0;
+}
+
+const MARKER_INCLUDED_SUB_CHANNEL_TYPE$1 = ['broadcast', 'conversation', 'community'];
+const isUnreadCountSupport$2 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE$1.includes(channelType);
+function convertFromRaw$2(_a) {
+    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
+    return Object.assign(Object.assign({ get unreadCount() {
+            return getSubChannelUnreadCount(channelId, messageFeedId);
+        },
+        get hasMentioned() {
+            return getSubChannelIsMentioned(channelId, messageFeedId);
+        },
+        get isMentioned() {
+            return getSubChannelIsMentioned(channelId, messageFeedId);
+        } }, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId, isUnreadCountSupport: isUnreadCountSupport$2({ channelType }) });
+}
+
+const addLocalReferenceId = (payload) => {
+    const client = getActiveClient();
+    const { objectSyncMap } = client;
+    return Object.assign(Object.assign({}, payload), { 
+        /* NOTE: This logic is used to get local referenceId for each message.
+         *
+         * if messageId is a local reference id, use it as referenceId else get referenceId from objectSyncMap.
+         * if find referenceId in objectSyncMap, this means this message is a local created message. The referenceId will be local reference id.
+         * if cannot find referenceId in objectSyncMap, referenceId will be undefined.
+         *
+         * The referenceId is undefined means this message is not a local created message (optimistic creation message).
+         */
+        referenceId: isLocalId(payload.messageId)
+            ? payload.messageId
+            : objectSyncMap.get(payload.messageId) });
 };
-const getUnreadInfoCached = (channelId) => {
+function convertFromRaw$1(message, reactors, event) {
     var _a;
-    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+    const messageWithReferenceId = addLocalReferenceId(message);
+    const { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment, messageId, creatorId } = messageWithReferenceId, rest = __rest(messageWithReferenceId, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment", "messageId", "creatorId"]);
+    let cache;
+    if (referenceId) {
+        cache = pullFromCache(['message', 'get', referenceId]);
+    }
+    if (!cache) {
+        cache = pullFromCache(['message', 'get', messageId]);
+    }
+    const out = Object.assign(Object.assign({}, rest), { messageId, channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, creatorPrivateId: message.creatorId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, 
+        /*
+         * Previously, myReactions were added only if it was part of the payload.
+         * So empty myReactions were not present. So I've edited the payload to add
+         * a default for those cases.
+         *
+         * Check git blame for previous iteration
+         */
+        myReactions: myReactions || ((_a = cache === null || cache === void 0 ? void 0 : cache.data.myReactions) !== null && _a !== void 0 ? _a : []), reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : messageId, referenceId, syncState: "synced" /* Amity.SyncState.Synced */ });
+    if (mentionedUsers) {
+        out.mentionees = mentionedUsers.map(mention => {
+            if (mention.type === 'channel') {
+                return mention;
+            }
+            return { type: 'user', userIds: mention.userPublicIds };
+        });
+    }
+    if (reactors && reactors.length && event) {
+        // mqtt event
+        prepareMessagePayloadForCache(out, reactors, event);
+    }
+    return out;
+}
+const preUpdateMessageCache = (rawPayload) => {
+    ingestInCache({
+        messages: rawPayload.messages.map(message => convertFromRaw$1(message, rawPayload.reactions)),
+    });
 };
-/**
- * The function use to get value of unreadCount field.
- * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
- *
- * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
- * If not, the function will return the value from the channelMarker cache.
- * If not found in the both cache, use `0` as defaul value.
- */
-const getSubChannelsUnreadCount = (channel, marker) => {
-    var _a, _b, _c, _d, _e;
-    const client = getActiveClient();
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        // Marker service API uses channelInternalId as channelId
-        return (_b = (_a = getUnreadInfoCached(channel.channelInternalId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
+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);
+        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
+    if (messageFeeds && messageFeeds.length > 0) {
+        messageFeeds === null || messageFeeds === void 0 ? void 0 : messageFeeds.forEach(messageFeed => {
+            var _a, _b;
+            const subChannelCache = (_b = (_a = pullFromCache(['subChannel', 'get', messageFeed.messageFeedId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {};
+            // exclude getter properties from existing subChannel cache, update only other properties to existing subChannel cache
+            const _c = convertFromRaw$2(messageFeed), restSubChannel = __rest(_c, ["unreadCount", "hasMentioned", "isMentioned"]);
+            updateSubChannelCache(messageFeed.messageFeedId, subChannelCache, restSubChannel);
+        });
+    }
+    return Object.assign(Object.assign({}, restPayload), { messages: payload.messages.map(m => convertFromRaw$1(m, payload.reactions, event)) });
+};
+function convertParams(_a) {
+    var { subChannelId, mentionees, dataType, data } = _a, rest = __rest(_a, ["subChannelId", "mentionees", "dataType", "data"]);
+    if (dataType === MessageContentType.IMAGE || dataType === MessageContentType.FILE) {
+        return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data: Object.assign({ caption: '' }, data) }, rest);
+    }
+    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data }, rest);
+}
+function convertQueryParams$1(_a) {
+    var { sortBy, subChannelId, tags, includingTags, excludingTags, includeDeleted, aroundMessageId, limit, type } = _a, rest = __rest(_a, ["sortBy", "subChannelId", "tags", "includingTags", "excludingTags", "includeDeleted", "aroundMessageId", "limit", "type"]);
+    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, isDeleted: inferIsDeleted(includeDeleted), options: {
+            sortBy,
+            limit: limit || COLLECTION_DEFAULT_PAGINATION_LIMIT,
+            around: aroundMessageId,
+        } });
+    if (tags) {
+        out.includeTags = tags;
     }
-    if (marker === null || marker === void 0 ? void 0 : marker.isDeleted) {
-        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
-        // leave the channel because currently backend can't handle this, so every time a user is banned
-        // from a channel or the channel is deleted the channel's unread count will reset to zero
-        return 0;
+    if (includingTags) {
+        out.includeTags = includingTags;
     }
-    return (_e = (_c = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _c !== void 0 ? _c : (_d = getCachedMarker(channel.channelInternalId)) === null || _d === void 0 ? void 0 : _d.unreadCount) !== null && _e !== void 0 ? _e : 0;
-};
+    if (type) {
+        out.dataType = type;
+    }
+    if (excludingTags) {
+        out.excludeTags = excludingTags;
+    }
+    return out;
+}
 
-const constructChannelDynamicValue = (channel) => {
-    return shallowClone(channel, {
-        get unreadCount() {
-            return getSubChannelsUnreadCount(channel);
-        },
-        get hasMentioned() {
-            return getChannelIsMentioned(channel);
-        },
-        get isMentioned() {
-            return getChannelIsMentioned(channel);
-        },
-        get subChannelsUnreadCount() {
-            return getSubChannelsUnreadCount(channel);
-        },
+const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+/**
+ * Filter sub channel by type. Only conversation, community and broadcast type are included.
+ */
+const isUnreadCountSupport$1 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
+const preUpdateSubChannelCache = (rawPayload) => {
+    ingestInCache({
+        messageFeeds: rawPayload.messageFeeds.map(messageFeed => convertFromRaw$2(messageFeed)),
     });
-};
+};
+const prepareSubChannelPayload = async (rawPayload) => {
+    const markerIds = rawPayload.messageFeeds
+        .filter(isUnreadCountSupport$1)
+        .map(({ messageFeedId }) => messageFeedId);
+    if (markerIds.length > 0) {
+        // since the get markers method requires a channel cache to function with the reducer.
+        preUpdateSubChannelCache(rawPayload);
+        try {
+            await getSubChannelMarkers(markerIds);
+        }
+        catch (e) {
+            // empty block (from the spec, allow marker fetch to fail without having to do anything)
+        }
+    }
+    updateSubChannelMessagePreviewCache(rawPayload);
+    // attach marker to sub channel
+    const messageFeeds = rawPayload.messageFeeds.map(convertFromRaw$2);
+    const messages = rawPayload.messages.map(m => convertFromRaw$1(m));
+    return Object.assign(Object.assign({}, rawPayload), { messageFeeds,
+        messages });
+};
+function convertQueryParams(_a) {
+    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
+    const out = Object.assign({}, rest);
+    if (excludeDefaultSubChannel !== undefined) {
+        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+    }
+    return out;
+}
 
 /**
  * ```js
- * import { getChannelByIds } from '@amityco/ts-sdk-react-native'
- * const channels = await getChannelByIds(['foo', 'bar'])
+ * import { getSubChannel } from '@amityco/ts-sdk-react-native'
+ * const subChannel = await getSubChannel('foobar')
  * ```
  *
- * Fetches a collection of {@link Amity.Channel} objects
+ * Fetches a {@link Amity.SubChannel} object
  *
- * @param channelIds the IDs of the {@link Amity.Channel} to fetch
- * @returns the associated collection of {@link Amity.Channel} objects
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
  *
  * @category Channel API
  * @async
  */
-const getChannelByIds = async (channelIds) => {
+const getSubChannel$1 = async (subChannelId) => {
     const client = getActiveClient();
-    client.log('channel/getChannelByIds', channelIds);
-    const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
-    let payload;
+    client.log('channel/getSubChannel', subChannelId);
+    isInTombstone('subChannel', subChannelId);
     try {
-        // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/channels/list`, {
-            params: { channelIds: encodedChannelIds },
-        });
-        payload = response.data;
+        const response = await client.http.get(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`);
+        const data = await prepareSubChannelPayload(response.data);
+        const cachedAt = client.cache && Date.now();
+        if (client.cache)
+            ingestInCache(data, { cachedAt });
+        fireEvent('local.message-feed.fetched', data);
+        return {
+            data: data.messageFeeds[0],
+            cachedAt,
+        };
     }
     catch (error) {
-        channelIds.forEach(channelId => {
-            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
-                pushToTombstone('channel', channelId);
-            }
-        });
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('subChannel', subChannelId);
+        }
         throw error;
     }
-    const data = await prepareChannelPayload(payload);
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        await prepareUnreadCountInfo(payload);
-    }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    fireEvent('local.channel.fetched', data.channels);
-    return {
-        data: data.channels.map(channel => LinkedObject.channel(constructChannelDynamicValue(channel))),
-        cachedAt,
-    };
 };
 /**
  * ```js
- * import { getChannelByIds } from '@amityco/ts-sdk-react-native'
- * const channels = getChannelByIds.locally(['foo', 'bar']) ?? []
+ * import { getSubChannel } from '@amityco/ts-sdk-react-native'
+ * const subChannel = getSubChannel.locally('foobar')
  * ```
  *
- * Fetches a collection of {@link Amity.Channel} objects from cache
+ * Fetches a {@link Amity.SubChannel} object from cache
  *
- * @param channelIds the IDs of the {@link Amity.Channel} to fetch
- * @returns the associated collection of {@link Amity.Channel} objects
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
  *
  * @category Channel API
  */
-getChannelByIds.locally = (channelIds) => {
-    var _a, _b;
+getSubChannel$1.locally = (subChannelId) => {
     const client = getActiveClient();
-    client.log('channel/getChannelByIds.locally', channelIds);
+    client.log('channel/getSubChannel.locally', subChannelId);
     if (!client.cache)
         return;
-    const cached = (_a = queryCache(['channel', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
-        return channelIds.includes(data.channelPublicId);
-    });
-    if (!cached || (cached === null || cached === void 0 ? void 0 : cached.length) < channelIds.length)
+    const cached = pullFromCache(['subChannel', 'get', subChannelId]);
+    if (!cached)
         return;
-    const channels = cached.map(({ data }) => data);
-    const oldest = (_b = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _b === void 0 ? void 0 : _b[0];
     return {
-        data: channels.map(channel => LinkedObject.channel(channel)),
-        cachedAt: oldest.cachedAt,
+        data: cached.data,
+        cachedAt: cached.cachedAt,
     };
 };
 
-/**
- * ```js
- * import { getMessageMarkers } from '@amityco/ts-sdk-react-native'
- * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
- * ```
- *
- * Fetches a list of {@link Amity.MessageMarker} by messageIds
- *
- * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
- * @returns A list of {@link Amity.MessageMarker} by messageIds
- *
- * @category Channel API
- * @async
- * @private
- */
-const getMessageMarkers = async (messageIds) => {
+const convertDateStringToTimestamp = (dateString) => {
+    return new Date(dateString).getTime();
+};
+
+const getMessagePreviewSetting$1 = async () => {
+    const client = getActiveClient();
+    return client.getMessagePreviewSetting(false);
+};
+const getSubChannelCache = async (subChannelId) => {
+    var _a;
+    let subChannelCache = (_a = pullFromCache(['subChannel', 'get', subChannelId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!subChannelCache) {
+        subChannelCache = (await getSubChannel$1(subChannelId)).data;
+    }
+    return subChannelCache;
+};
+const isLastestMessageOnSubchannel = (message) => {
+    var _a;
+    const cache = (_a = pullFromCache([
+        'messagePreviewSubChannel',
+        'get',
+        message.subChannelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    // The message payload from optimistic created event has no segment, so we check createdAt instead.
+    return (!cache ||
+        cache.segment <= message.channelSegment ||
+        convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
+};
+const isLastestMessageOnChannel = (message) => {
+    var _a;
+    const cache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        message.channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    return (!cache ||
+        convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
+};
+const handleMessageCreatedOnSubChannel = async (message) => {
+    const messagePreviewSetting = await getMessagePreviewSetting$1();
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    // 1. get subChannel from cache, if not exist fetch from server
+    const subChannelCache = await getSubChannelCache(subChannelId);
+    // 2. if messagePreviewSetting is NO_MESSAGE_PREVEIW, update only lastActiviy in subChannel cache
+    if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */) {
+        // 2.1 if the message is the latest message, update lastActivity to be createdAt in subChannel cache
+        if (convertDateStringToTimestamp(subChannelCache.lastActivity) <
+            convertDateStringToTimestamp(createdAt))
+            updateSubChannelCache(message.subChannelId, subChannelCache, {
+                lastActivity: createdAt,
+            });
+        return;
+    }
+    // 3. if messagePreviewSetting is `NOT` NO_MESSAGE_PREVEIW, update messagePreviewSubChannel and subChannel cache
+    // 3.1 check if the message is the latest message, if not ignore the message.
+    if (!isLastestMessageOnSubchannel(message))
+        return;
+    // 3.2 if the message is the latest message, update messagePreviewSubChannel and subChannel cache
+    pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
+        channelId,
+        creatorId,
+        messagePreviewId,
+        createdAt,
+        updatedAt,
+        subChannelId,
+        data,
+        dataType,
+        segment,
+        isDeleted,
+        subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
+        subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
+    });
+    updateSubChannelCache(message.subChannelId, subChannelCache, {
+        lastActivity: createdAt,
+        messagePreviewId,
+    });
+};
+const handleMessageUpdatedOnSubChannel = async (message) => {
+    var _a;
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    const messagePreviewSubChannelCache = (_a = pullFromCache([
+        'messagePreviewSubChannel',
+        'get',
+        message.subChannelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    // if messagePreviewSubChannel is not exist, ignore the message.
+    if (messagePreviewSubChannelCache &&
+        messagePreviewSubChannelCache.messagePreviewId === message.messageId) {
+        const subChannelCache = await getSubChannelCache(subChannelId);
+        pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
+            channelId,
+            creatorId,
+            messagePreviewId,
+            createdAt,
+            updatedAt,
+            subChannelId,
+            data,
+            dataType,
+            segment,
+            isDeleted,
+            subChannelUpdatedAt: subChannelCache.updatedAt,
+            subChannelName: messagePreviewSubChannelCache.subChannelName,
+        });
+    }
+};
+const handleMessageCreated = async (message) => {
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    if (isLastestMessageOnChannel(message)) {
+        const subChannelCache = await getSubChannelCache(subChannelId);
+        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
+            channelId,
+            creatorId,
+            messagePreviewId,
+            createdAt,
+            updatedAt,
+            subChannelId,
+            data,
+            dataType,
+            segment,
+            isDeleted,
+            subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
+            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
+        });
+    }
+};
+const handleMessageUpdated = async (message) => {
+    /**
+     * Channel Case
+     */
+    var _a;
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    const messagePreviewChannelCache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        message.channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (messagePreviewChannelCache &&
+        messagePreviewChannelCache.messagePreviewId === message.messageId) {
+        const subChannelCache = await getSubChannelCache(subChannelId);
+        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
+            channelId,
+            creatorId,
+            messagePreviewId,
+            createdAt,
+            updatedAt,
+            subChannelId,
+            data,
+            dataType,
+            segment,
+            isDeleted,
+            subChannelUpdatedAt: subChannelCache.updatedAt,
+            subChannelName: messagePreviewChannelCache.subChannelName,
+        });
+    }
+};
+const handleSubChannelUpdated = async (subChannel) => {
+    var _a, _b, _c, _d;
+    const { channelId, subChannelId } = subChannel;
+    /** Channel Case */
+    const messagePreviewChannelCache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.subChannelId) === subChannelId) {
+        const subChannelCache = (_b = pullFromCache([
+            'subChannel',
+            'get',
+            subChannelId,
+        ])) === null || _b === void 0 ? void 0 : _b.data;
+        pushToCache(['messagePreviewChannel', 'get', channelId], Object.assign(Object.assign({}, messagePreviewChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
+    }
+    /** SubChannel Case */
+    const messagePreviewSubChannelCache = (_c = pullFromCache([
+        'messagePreviewSubChannel',
+        'get',
+        subChannelId,
+    ])) === null || _c === void 0 ? void 0 : _c.data;
+    if (messagePreviewSubChannelCache &&
+        new Date(messagePreviewSubChannelCache.updatedAt).valueOf() >
+            new Date(subChannel.updatedAt).valueOf()) {
+        const subChannelCache = (_d = pullFromCache([
+            'subChannel',
+            'get',
+            subChannelId,
+        ])) === null || _d === void 0 ? void 0 : _d.data;
+        pushToCache(['messagePreviewSubChannel', 'get', subChannelId], Object.assign(Object.assign({}, messagePreviewSubChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
+    }
+};
+
+function convertRawUserToInternalUser(rawUser) {
+    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
+}
+
+const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+const isUnreadCountSupport = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
+function convertFromRaw(channel, options = { isMessagePreviewUpdated: true }) {
+    var _a;
+    let { messagePreviewId } = channel;
+    const messagePreviewChannelCache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        channel.channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.messagePreviewId) && !options.isMessagePreviewUpdated) {
+        messagePreviewId = messagePreviewChannelCache.messagePreviewId;
+    }
+    return Object.assign(Object.assign({}, channel), { defaultSubChannelId: channel.channelInternalId, isUnreadCountSupport: isUnreadCountSupport(channel), messagePreviewId });
+}
+const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated: true }) => {
+    ingestInCache({
+        channels: rawPayload.channels.map(channel => convertFromRaw(channel, { isMessagePreviewUpdated: options.isMessagePreviewUpdated })),
+    });
+};
+const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpdated: true }) => {
     const client = getActiveClient();
-    client.log('channel/getMessageMarkers', messageIds);
-    const { data: queryPayload } = await client.http.get(`/api/v1/markers/messages`, {
-        params: {
-            messageIds,
-        },
+    const networkPreviewSetting = await client.getMessagePreviewSetting(false);
+    if (options.isMessagePreviewUpdated &&
+        networkPreviewSetting !== "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */ &&
+        rawPayload.messagePreviews &&
+        rawPayload.messagePreviews.length > 0) {
+        updateChannelMessagePreviewCache(rawPayload);
+    }
+    const markerIds = rawPayload.channels
+        // filter channel by type. Only conversation, community and broadcast type are included.
+        .filter(isUnreadCountSupport)
+        .map(({ channelInternalId }) => channelInternalId);
+    if (markerIds.length > 0) {
+        // since the get markers method requires a channel cache to function with the reducer.
+        preUpdateChannelCache(rawPayload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated });
+        try {
+            await getChannelMarkers(markerIds);
+        }
+        catch (e) {
+            // empty block (from the spec, allow marker fetch to fail without having to do anything)
+        }
+    }
+    // attach marker to channel
+    const channels = rawPayload.channels.map(payload => convertFromRaw(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }));
+    // user marker to channel users
+    const channelUsers = rawPayload.channelUsers.map(channelUser => {
+        return convertRawMembershipToMembership(channelUser);
     });
-    const { contentMarkers, feedMarkers, userMarkers } = queryPayload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });
-    fireEvent('local.feedMarker.fetched', { feedMarkers });
-    fireEvent('local.messageMarker.fetched', { contentMarkers });
-    fireEvent('local.userMarker.fetched', { userMarkers });
-    return { data: contentMarkers, cachedAt };
+    const users = rawPayload.users.map(convertRawUserToInternalUser);
+    const restRawPayload = __rest(rawPayload, ["messageFeedsInfo", "messagePreviews"]);
+    return Object.assign(Object.assign({}, restRawPayload), { users,
+        channels,
+        channelUsers });
 };
 
 /**
@@ -6685,351 +6941,202 @@ const getMessageMarkers = async (messageIds) => {
  * @async
  * @private
  */
-const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
+const getUserMessageFeedMakers = async (channelIds) => {
     const client = getActiveClient();
-    client.log('channel/getSubChannelMarkers', messageFeedIds, page);
-    const { data: queryPayload } = await client.http.get(`/api/v1/markers/message-feeds`, {
+    client.log('channel/getUserMessageFeedMakers', channelIds);
+    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
         params: {
-            messageFeedIds,
-            options: {
-                token: toToken(page, 'skiplimit'),
-            },
+            channelIds,
         },
     });
-    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, userMarkers, feedMarkers: feedMarkersPayload, } = payload;
-    // if consistent mode is enabled, persist the unread count info to the cache
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        persistUnreadCountInfo({
-            feedMarkers: feedMarkersPayload,
-            userFeedMarkers: userFeedMarkersPayload,
-        });
-    }
-    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
-    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache({ userEntityMarkers, userFeedMarkers, userMarkers }, { cachedAt });
-    fireEvent('local.channelMarker.fetched', { userEntityMarkers });
-    fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
-    fireEvent('local.userMarker.fetched', { userMarkers });
-    const nextPage = toPage(paging.next);
-    const prevPage = toPage(paging.previous);
-    return { data: userFeedMarkers, cachedAt, prevPage, nextPage };
-};
-
-const getUserMarker = async () => {
-    const client = getActiveClient();
-    client.log('channel/getUserMarker');
-    const { data: payload } = await client.http.get(`/api/v1/markers/userMarker`);
-    const { userMarkers } = payload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache({ userMarkers }, { cachedAt });
-    fireEvent('local.userMarker.fetched', { userMarkers });
-    const latestUserMarker = userMarkers.reduce((maxUserMarker, userMarker) => {
-        if (maxUserMarker == null ||
-            new Date(maxUserMarker.lastSyncAt).getTime() < new Date(userMarker.lastSyncAt).getTime()) {
-            return userMarker;
-        }
-        return maxUserMarker;
-    }, undefined);
-    return { data: latestUserMarker, cachedAt };
+    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
+    return data;
 };
 
-/** @hidden */
-/*
- * @param message payload from http request without myReactions
- * add myReactions to http response if the event was a reaction event
- */
-const prepareMessagePayloadForCache = (payload, reactors, event) => {
+const prepareUnreadCountInfo = async (rawPayload) => {
     const client = getActiveClient();
-    const cached = pullFromCache(['message', 'get', payload.messageId]);
-    // '[]' in cases where the new reaction is the first one
-    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
-    // add myReactions to the payload
-    Object.assign(payload, { myReactions });
-    // check if there are any updates to the reactions
-    const latestReaction = reactors[0];
-    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
-    if (!isLatestReactionMine) {
-        return;
-    }
-    // new reaction added
-    if (event === 'message.reactionAdded' && !myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: [...myReactions, latestReaction.reactionName],
-        });
-    }
-    // existing reaction removed
-    if (event === 'message.reactionRemoved' && myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
-        });
-    }
+    // if consistent mode is enabled, persist the unread count info to the cache
+    // Marker service API uses channelInternalId as channelId
+    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelInternalId }) => channelInternalId));
+    const { feedMarkers, userFeedMarkers } = queryPayload;
+    persistUnreadCountInfo({
+        feedMarkers,
+        userFeedMarkers,
+    });
+    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
 };
 
-/*
- * This is a simple utility that infers the value of isDeleted based on the
- * value of includeDeleted
- *
- * There are two important things to note here:
- *  1. `includeDeleted` is purely client side query param and not recognized by
- *  the server
- *  2. The only values we wish to expose with regards to `isDeleted` (the server
- *  param for queries) is false | undefined and want to disallow users to query
- *  for deleted entities
+const getCachedMarker$1 = (entityId) => {
+    var _a;
+    const key = {
+        entityId,
+        userId: getActiveUser()._id,
+    };
+    return (_a = pullFromCache([
+        'channelMarker',
+        'get',
+        getResolver('channelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+};
+const getUnreadInfoCached$1 = (channelId) => {
+    var _a;
+    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+};
+/**
+ * The function use to get value of hasMentioned or isMentioned field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
  *
- *  Although this is a very simple utility, it's only purpose is to keep things
- *  DRY
- */
-const inferIsDeleted = (includeDeleted) => includeDeleted === true ? undefined : false;
-
-function getSubChannelIsMentioned(channelId, subChannelId, marker) {
-    var _a, _b;
-    // Look for `unreadCount` in the marker param first
-    if (marker) {
-        return marker.hasMentioned;
-    }
-    const client = getActiveClient();
-    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        const cachedUnreadCount = (_a = pullFromCache([
-            'subChannelUnreadInfo',
-            'get',
-            subChannelId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (cachedUnreadCount) {
-            return cachedUnreadCount.isMentioned;
-        }
-        return false;
+ * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
+ * If not, the function will return the value from the channelMarker cache.
+ * If not found in the both cache, use `false` as defaul value.
+ */
+const getChannelIsMentioned = (channel, marker) => {
+    var _a, _b, _c, _d;
+    const client = getActiveClient();
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        return (_b = (_a = getUnreadInfoCached$1(channel.channelPublicId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
     }
+    return (marker === null || marker === void 0 ? void 0 : marker.hasMentioned) !== undefined
+        ? marker === null || marker === void 0 ? void 0 : marker.hasMentioned
+        : (_d = (_c = getCachedMarker$1(channel.channelPublicId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
+};
+
+const getCachedMarker = (entityId) => {
+    var _a;
     const key = {
-        entityId: channelId,
-        feedId: subChannelId,
+        entityId,
         userId: getActiveUser()._id,
     };
-    // If the marker param is not set, look in the cache
-    const cachedMarker = (_b = pullFromCache([
-        'subChannelMarker',
+    return (_a = pullFromCache([
+        'channelMarker',
         'get',
-        getResolver('subChannelMarker')(key),
-    ])) === null || _b === void 0 ? void 0 : _b.data;
-    if (cachedMarker) {
-        return cachedMarker.hasMentioned;
-    }
-    // and if not found in cache use default value `false`
-    return false;
-}
-
-function getSubChannelUnreadCount(channelId, subChannelId, marker) {
-    var _a, _b;
-    // Look for `unreadCount` in the marker param first
-    if (marker) {
-        return marker.unreadCount;
-    }
+        getResolver('channelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+};
+const getUnreadInfoCached = (channelId) => {
+    var _a;
+    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+};
+/**
+ * The function use to get value of unreadCount field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ *
+ * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
+ * If not, the function will return the value from the channelMarker cache.
+ * If not found in the both cache, use `0` as defaul value.
+ */
+const getSubChannelsUnreadCount = (channel, marker) => {
+    var _a, _b, _c, _d, _e;
     const client = getActiveClient();
-    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
     if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        const cachedUnreadCount = (_a = pullFromCache([
-            'subChannelUnreadInfo',
-            'get',
-            subChannelId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (cachedUnreadCount) {
-            return cachedUnreadCount.isDeleted ? 0 : cachedUnreadCount.unreadCount;
-        }
-        return 0;
+        // Marker service API uses channelInternalId as channelId
+        return (_b = (_a = getUnreadInfoCached(channel.channelInternalId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
     }
-    const key = {
-        entityId: channelId,
-        feedId: subChannelId,
-        userId: getActiveUser()._id,
-    };
-    // If the marker param is not set, look in the cache
-    const cachedMarker = (_b = pullFromCache([
-        'subChannelMarker',
-        'get',
-        getResolver('subChannelMarker')(key),
-    ])) === null || _b === void 0 ? void 0 : _b.data;
-    if (cachedMarker) {
-        return cachedMarker.unreadCount;
+    if (marker === null || marker === void 0 ? void 0 : marker.isDeleted) {
+        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
+        // leave the channel because currently backend can't handle this, so every time a user is banned
+        // from a channel or the channel is deleted the channel's unread count will reset to zero
+        return 0;
     }
-    // and if not found in cache use default value `0`
-    return 0;
-}
+    return (_e = (_c = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _c !== void 0 ? _c : (_d = getCachedMarker(channel.channelInternalId)) === null || _d === void 0 ? void 0 : _d.unreadCount) !== null && _e !== void 0 ? _e : 0;
+};
 
-const MARKER_INCLUDED_SUB_CHANNEL_TYPE$1 = ['broadcast', 'conversation', 'community'];
-const isUnreadCountSupport$1 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE$1.includes(channelType);
-function convertFromRaw$1(_a) {
-    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
-    return Object.assign(Object.assign({ get unreadCount() {
-            return getSubChannelUnreadCount(channelId, messageFeedId);
+const constructChannelDynamicValue = (channel) => {
+    return shallowClone(channel, {
+        get unreadCount() {
+            return getSubChannelsUnreadCount(channel);
         },
         get hasMentioned() {
-            return getSubChannelIsMentioned(channelId, messageFeedId);
+            return getChannelIsMentioned(channel);
         },
         get isMentioned() {
-            return getSubChannelIsMentioned(channelId, messageFeedId);
-        } }, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId, isUnreadCountSupport: isUnreadCountSupport$1({ channelType }) });
-}
+            return getChannelIsMentioned(channel);
+        },
+        get subChannelsUnreadCount() {
+            return getSubChannelsUnreadCount(channel);
+        },
+    });
+};
 
-const addLocalReferenceId = (payload) => {
+/**
+ * ```js
+ * import { getChannelByIds } from '@amityco/ts-sdk-react-native'
+ * const channels = await getChannelByIds(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getChannelByIds = async (channelIds) => {
     const client = getActiveClient();
-    const { objectSyncMap } = client;
-    return Object.assign(Object.assign({}, payload), { 
-        /* NOTE: This logic is used to get local referenceId for each message.
-         *
-         * if messageId is a local reference id, use it as referenceId else get referenceId from objectSyncMap.
-         * if find referenceId in objectSyncMap, this means this message is a local created message. The referenceId will be local reference id.
-         * if cannot find referenceId in objectSyncMap, referenceId will be undefined.
-         *
-         * The referenceId is undefined means this message is not a local created message (optimistic creation message).
-         */
-        referenceId: isLocalId(payload.messageId)
-            ? payload.messageId
-            : objectSyncMap.get(payload.messageId) });
-};
-function convertFromRaw(message, reactors, event) {
-    var _a;
-    const messageWithReferenceId = addLocalReferenceId(message);
-    const { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment, messageId, creatorId } = messageWithReferenceId, rest = __rest(messageWithReferenceId, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment", "messageId", "creatorId"]);
-    let cache;
-    if (referenceId) {
-        cache = pullFromCache(['message', 'get', referenceId]);
-    }
-    if (!cache) {
-        cache = pullFromCache(['message', 'get', messageId]);
-    }
-    const out = Object.assign(Object.assign({}, rest), { messageId, channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, creatorPrivateId: message.creatorId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, 
-        /*
-         * Previously, myReactions were added only if it was part of the payload.
-         * So empty myReactions were not present. So I've edited the payload to add
-         * a default for those cases.
-         *
-         * Check git blame for previous iteration
-         */
-        myReactions: myReactions || ((_a = cache === null || cache === void 0 ? void 0 : cache.data.myReactions) !== null && _a !== void 0 ? _a : []), reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : messageId, referenceId, syncState: "synced" /* Amity.SyncState.Synced */ });
-    if (mentionedUsers) {
-        out.mentionees = mentionedUsers.map(mention => {
-            if (mention.type === 'channel') {
-                return mention;
-            }
-            return { type: 'user', userIds: mention.userPublicIds };
+    client.log('channel/getChannelByIds', channelIds);
+    const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
+    let payload;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/channels/list`, {
+            params: { channelIds: encodedChannelIds },
         });
+        payload = response.data;
     }
-    if (reactors && reactors.length && event) {
-        // mqtt event
-        prepareMessagePayloadForCache(out, reactors, event);
-    }
-    return out;
-}
-const preUpdateMessageCache = (rawPayload) => {
-    ingestInCache({
-        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);
-        const markerIdsKey = markerIds.join('');
-        if (currentDebounceMap[markerIdsKey]) {
-            clearTimeout(currentDebounceMap[markerIdsKey]);
-        }
-        currentDebounceMap[markerIdsKey] = setTimeout(() => {
-            try {
-                getMessageMarkers(markerIds);
-            }
-            catch (_error) {
-                // do nothing
+    catch (error) {
+        channelIds.forEach(channelId => {
+            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+                // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
+                pushToTombstone('channel', channelId);
             }
-        }, DEBOUNCE_TIME);
-    }
-    const { messageFeeds } = payload, restPayload = __rest(payload, ["messageFeeds"]);
-    // upsert messageFeeds to subchannel cache because messageFeeds from event payload not include messagePreviewId
-    if (messageFeeds && messageFeeds.length > 0) {
-        messageFeeds === null || messageFeeds === void 0 ? void 0 : messageFeeds.forEach(messageFeed => {
-            var _a, _b;
-            const subChannelCache = (_b = (_a = pullFromCache(['subChannel', 'get', messageFeed.messageFeedId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {};
-            // exclude getter properties from existing subChannel cache, update only other properties to existing subChannel cache
-            const _c = convertFromRaw$1(messageFeed), restSubChannel = __rest(_c, ["unreadCount", "hasMentioned", "isMentioned"]);
-            updateSubChannelCache(messageFeed.messageFeedId, subChannelCache, restSubChannel);
         });
+        throw error;
     }
-    return Object.assign(Object.assign({}, restPayload), { messages: payload.messages.map(m => convertFromRaw(m, payload.reactions, event)) });
-};
-function convertParams(_a) {
-    var { subChannelId, mentionees, dataType, data } = _a, rest = __rest(_a, ["subChannelId", "mentionees", "dataType", "data"]);
-    if (dataType === MessageContentType.IMAGE || dataType === MessageContentType.FILE) {
-        return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data: Object.assign({ caption: '' }, data) }, rest);
-    }
-    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data }, rest);
-}
-function convertQueryParams$1(_a) {
-    var { sortBy, subChannelId, tags, includingTags, excludingTags, includeDeleted, aroundMessageId, limit, type } = _a, rest = __rest(_a, ["sortBy", "subChannelId", "tags", "includingTags", "excludingTags", "includeDeleted", "aroundMessageId", "limit", "type"]);
-    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, isDeleted: inferIsDeleted(includeDeleted), options: {
-            sortBy,
-            limit: limit || COLLECTION_DEFAULT_PAGINATION_LIMIT,
-            around: aroundMessageId,
-        } });
-    if (tags) {
-        out.includeTags = tags;
-    }
-    if (includingTags) {
-        out.includeTags = includingTags;
-    }
-    if (type) {
-        out.dataType = type;
-    }
-    if (excludingTags) {
-        out.excludeTags = excludingTags;
+    const data = await prepareChannelPayload(payload);
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        await prepareUnreadCountInfo(payload);
     }
-    return out;
-}
-
-const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('local.channel.fetched', data.channels);
+    return {
+        data: data.channels.map(channel => LinkedObject.channel(constructChannelDynamicValue(channel))),
+        cachedAt,
+    };
+};
 /**
- * Filter sub channel by type. Only conversation, community and broadcast type are included.
+ * ```js
+ * import { getChannelByIds } from '@amityco/ts-sdk-react-native'
+ * const channels = getChannelByIds.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects from cache
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
  */
-const isUnreadCountSupport = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
-const preUpdateSubChannelCache = (rawPayload) => {
-    ingestInCache({
-        messageFeeds: rawPayload.messageFeeds.map(messageFeed => convertFromRaw$1(messageFeed)),
+getChannelByIds.locally = (channelIds) => {
+    var _a, _b;
+    const client = getActiveClient();
+    client.log('channel/getChannelByIds.locally', channelIds);
+    if (!client.cache)
+        return;
+    const cached = (_a = queryCache(['channel', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
+        return channelIds.includes(data.channelPublicId);
     });
-};
-const prepareSubChannelPayload = async (rawPayload) => {
-    const markerIds = rawPayload.messageFeeds
-        .filter(isUnreadCountSupport)
-        .map(({ messageFeedId }) => messageFeedId);
-    if (markerIds.length > 0) {
-        // since the get markers method requires a channel cache to function with the reducer.
-        preUpdateSubChannelCache(rawPayload);
-        try {
-            await getSubChannelMarkers(markerIds);
-        }
-        catch (e) {
-            // empty block (from the spec, allow marker fetch to fail without having to do anything)
-        }
-    }
-    updateSubChannelMessagePreviewCache(rawPayload);
-    // attach marker to sub channel
-    const messageFeeds = rawPayload.messageFeeds.map(convertFromRaw$1);
-    const messages = rawPayload.messages.map(m => convertFromRaw(m));
-    return Object.assign(Object.assign({}, rawPayload), { messageFeeds,
-        messages });
-};
-function convertQueryParams(_a) {
-    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
-    const out = Object.assign({}, rest);
-    if (excludeDefaultSubChannel !== undefined) {
-        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
-    }
-    return out;
-}
+    if (!cached || (cached === null || cached === void 0 ? void 0 : cached.length) < channelIds.length)
+        return;
+    const channels = cached.map(({ data }) => data);
+    const oldest = (_b = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _b === void 0 ? void 0 : _b[0];
+    return {
+        data: channels.map(channel => LinkedObject.channel(channel)),
+        cachedAt: oldest.cachedAt,
+    };
+};
 
 class SessionWatcher {
     constructor() {
@@ -7113,99 +7220,6 @@ const onOnline = (callback) => {
     return () => console.error('Unsupported environment');
 };
 
-/**
- * ```js
- * import { isInTombstone } from '@amityco/ts-sdk-react-native'
- * const user = isInTombstone(["message", "messageId"])
- * ```
- *
- * Checks if the {@link Amity.TombstoneCacheOptions} exists
- * in cache and it's not expired means it's in tombstone
- * and we throw an Error
- *
- * @param model the model to check
- * @param modelId the object id to check
- * @returns the matching cache entry, or undefined.
- *
- * @category Cache API
- */
-const isInTombstone = (model, modelId) => {
-    const { log, cache } = getActiveClient();
-    const key = [model, CACHE_KEY_TOMBSTONE, modelId];
-    if (!cache)
-        return;
-    log('cache/api/isInTombstone', key);
-    const isInTombstone = pullFromCache(key);
-    const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
-    if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
-        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
-    }
-};
-
-/**
- * ```js
- * import { getSubChannel } from '@amityco/ts-sdk-react-native'
- * const subChannel = await getSubChannel('foobar')
- * ```
- *
- * Fetches a {@link Amity.SubChannel} object
- *
- * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
- * @returns the associated {@link Amity.SubChannel} object
- *
- * @category Channel API
- * @async
- */
-const getSubChannel$1 = async (subChannelId) => {
-    const client = getActiveClient();
-    client.log('channel/getSubChannel', subChannelId);
-    isInTombstone('subChannel', subChannelId);
-    try {
-        const response = await client.http.get(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`);
-        const data = await prepareSubChannelPayload(response.data);
-        const cachedAt = client.cache && Date.now();
-        if (client.cache)
-            ingestInCache(data, { cachedAt });
-        fireEvent('local.message-feed.fetched', data);
-        return {
-            data: data.messageFeeds[0],
-            cachedAt,
-        };
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('subChannel', subChannelId);
-        }
-        throw error;
-    }
-};
-/**
- * ```js
- * import { getSubChannel } from '@amityco/ts-sdk-react-native'
- * const subChannel = getSubChannel.locally('foobar')
- * ```
- *
- * Fetches a {@link Amity.SubChannel} object from cache
- *
- * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
- * @returns the associated {@link Amity.SubChannel} object
- *
- * @category Channel API
- */
-getSubChannel$1.locally = (subChannelId) => {
-    const client = getActiveClient();
-    client.log('channel/getSubChannel.locally', subChannelId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['subChannel', 'get', subChannelId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
-};
-
 /**
  * ```js
  * import { SubChannel } from '@amityco/ts-sdk-react-native'
@@ -9087,7 +9101,7 @@ const registerEventListeners = () => {
     }), onMessageCreatedMqtt(message => {
         // only conversation, community and broadcast types can sync
         const client = getActiveClient();
-        if (isUnreadCountSupport(message) && message.creatorId !== client.userId)
+        if (isUnreadCountSupport$1(message) && message.creatorId !== client.userId)
             events.push("new message" /* Amity.MarkerSyncEvent.NEW_MESSAGE */);
     }), 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(() => 
     /*
@@ -17030,7 +17044,7 @@ var index$g = /*#__PURE__*/Object.freeze({
   getMessages: getMessages,
   observeMessage: observeMessage,
   observeMessages: observeMessages,
-  convertFromRaw: convertFromRaw,
+  convertFromRaw: convertFromRaw$1,
   prepareMessagePayload: prepareMessagePayload,
   convertParams: convertParams,
   convertQueryParams: convertQueryParams$1,
@@ -17128,52 +17142,18 @@ const getSubChannel = (subChannelId, callback) => {
             });
         },
         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);
+            return onMessageCreatedMqtt(async (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,
-                });
-            };
-            return onMessageCreatedMqtt(async (message) => {
-                await updateMessagePreview(message);
+                await handleMessageCreatedOnSubChannel(message);
                 callback(message);
             });
         }, '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);
+            return onMessageCreatedLocal(async (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,
-                });
-            };
-            return onMessageCreatedLocal(async (message) => {
-                await updateMessagePreview(message);
+                await handleMessageCreatedOnSubChannel(message);
                 callback(message);
             });
         }, 'subChannelId', 'subChannel'),
@@ -17184,7 +17164,7 @@ const getSubChannel = (subChannelId, callback) => {
                     return;
                 if (message.subChannelId !== subChannelId)
                     return;
-                handleMessageUpdated(message);
+                handleMessageUpdatedOnSubChannel(message);
                 callback(message);
                 // TODO: messageFeeds on onMessageUpdated event does not have messagePreviewId and it will save before that cause messagePreview
             };
@@ -17198,7 +17178,7 @@ const getSubChannel = (subChannelId, callback) => {
                 if (message.subChannelId !== subChannelId)
                     return;
                 if (messagePreviewSetting === "message-preview-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED */)
-                    await handleMessageUpdated(message);
+                    await handleMessageUpdatedOnSubChannel(message);
                 if (messagePreviewSetting ===
                     "message-preview-not-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED */) {
                     await getSubChannel$1(message.subChannelId);
@@ -17322,15 +17302,15 @@ class SubChannelLiveCollectionController extends LiveCollectionController {
             {
                 fn: callback => {
                     return onSubChannelUpdated(async (subChannel) => {
-                        var _a;
-                        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!collection || !collection.data.includes(subChannel.subChannelId))
+                        if (!this.isRelatedCollection(subChannel.subChannelId))
                             return;
                         const client = getActiveClient();
                         const messagePreviewSetting = await client.getMessagePreviewSetting(false);
                         if (messagePreviewSetting !== "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */) {
                             const messagePreview = getSubChannelMessagePreview(subChannel.subChannelId);
-                            if ((messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.subChannelId) === subChannel.subChannelId) {
+                            if ((messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.subChannelId) === subChannel.subChannelId &&
+                                convertDateStringToTimestamp(subChannel.updatedAt) >
+                                    convertDateStringToTimestamp(messagePreview.subChannelUpdatedAt)) {
                                 pushToCache(['messagePreviewSubChannel', 'get', subChannel.subChannelId], Object.assign(Object.assign({}, messagePreview), { subChannelName: subChannel.displayName, subChannelUpdatedAt: subChannel.updatedAt }));
                             }
                         }
@@ -17340,76 +17320,27 @@ class SubChannelLiveCollectionController extends LiveCollectionController {
                 action: 'onUpdate',
             },
             {
-                fn: callback => {
-                    const updateMessagePreview = async (message) => {
-                        const client = getActiveClient();
-                        const messagePreviewSetting = await client.getMessagePreviewSetting(false);
-                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
-                            return;
-                        handleMessageCreated(message);
-                    };
+                fn: convertEventPayload((callback) => {
                     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;
-                        await updateMessagePreview(message);
-                        const subChannelCache = (_b = pullFromCache([
-                            'subChannel',
-                            'get',
-                            message.subChannelId,
-                        ])) === null || _b === void 0 ? void 0 : _b.data;
-                        if (!subChannelCache)
+                        if (!this.isRelatedCollection(message.subChannelId))
                             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 }));
+                        //  Update related cache including message preview and subChannel cache (lastActivity, messagePreviewId)
+                        await handleMessageCreatedOnSubChannel(message);
+                        callback(message);
                     });
-                },
+                }, 'subChannelId', 'subChannel'),
                 action: 'onUpdate',
             },
             {
-                fn: callback => {
+                fn: convertEventPayload((callback) => {
                     return onMessageCreatedLocal(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)
+                        if (!this.isRelatedCollection(message.subChannelId))
                             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 }));
+                        //  Update related cache including message preview and subChannel cache (lastActivity, messagePreviewId)
+                        await handleMessageCreatedOnSubChannel(message);
+                        callback(message);
                     });
-                },
+                }, 'subChannelId', 'subChannel'),
                 action: 'onUpdate',
             },
             {
@@ -17442,7 +17373,7 @@ class SubChannelLiveCollectionController extends LiveCollectionController {
                         const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
                         if (!collection || !collection.data.includes(message.subChannelId))
                             return;
-                        handleMessageUpdated(message);
+                        handleMessageUpdatedOnSubChannel(message);
                         callback(message);
                     };
                     return onMessageUpdated(updateMessagePreview);
@@ -17452,20 +17383,18 @@ class SubChannelLiveCollectionController extends LiveCollectionController {
             {
                 fn: convertEventPayload((callback) => {
                     const updateMessagePreview = async (message) => {
-                        var _a;
                         const client = getActiveClient();
                         const messagePreviewSetting = await client.getMessagePreviewSetting(false);
                         if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
                             return;
-                        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!collection || !collection.data.includes(message.subChannelId))
+                        if (!this.isRelatedCollection(message.subChannelId))
                             return;
                         if (messagePreviewSetting ===
                             "message-preview-not-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED */) {
                             await getSubChannel$1(message.subChannelId);
                         }
                         else {
-                            await handleMessageUpdated(message);
+                            await handleMessageUpdatedOnSubChannel(message);
                         }
                         callback(message);
                     };
@@ -17507,6 +17436,11 @@ class SubChannelLiveCollectionController extends LiveCollectionController {
         subChannels.sort(sortByLastActivity);
         return subChannels;
     }
+    isRelatedCollection(subChannelId) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        return collection && collection.data.includes(subChannelId);
+    }
 }
 
 /* eslint-disable no-use-before-define */
@@ -19022,8 +18956,8 @@ var index$c = /*#__PURE__*/Object.freeze({
   getChannel: getChannel,
   getChannels: getChannels,
   MARKER_INCLUDED_CHANNEL_TYPE: MARKER_INCLUDED_CHANNEL_TYPE,
-  isUnreadCountSupport: isUnreadCountSupport$2,
-  convertFromRaw: convertFromRaw$2,
+  isUnreadCountSupport: isUnreadCountSupport,
+  convertFromRaw: convertFromRaw,
   preUpdateChannelCache: preUpdateChannelCache,
   prepareChannelPayload: prepareChannelPayload
 });