@amityco/ts-sdk 6.7.2 → 6.7.3-cbeeb97.0

package/dist/index.esm.js

@@ -20816,6 +20816,22 @@ const prepareMembershipPayload = (payload, memberProp, userIdProp = 'userId', us
     return Object.assign(Object.assign({}, rest), { [memberProp]: members });
 };
 
+function doConvert(markerResponses) {
+    return markerResponses.map((_a) => {
+        var { isMentioned } = _a, rest = __rest(_a, ["isMentioned"]);
+        return (Object.assign({ hasMentioned: isMentioned }, rest));
+    });
+}
+function convertUserMarkerResponse(userMarkerResponse) {
+    return doConvert(userMarkerResponse);
+}
+function convertChannelMarkerResponse(channelMarkerResponse) {
+    return doConvert(channelMarkerResponse);
+}
+function convertSubChannelMarkerResponse(subChannelMarkerResponse) {
+    return doConvert(subChannelMarkerResponse);
+}
+
 /**
  * ```js
  * import { getChannelMarker } from '@amityco/ts-sdk'
@@ -20844,18 +20860,22 @@ const getChannelMarkers = async (channelIds, page = { limit: 100 }) => {
         },
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const { userEntityMarkers, userMarkers } = payload;
+    const { userEntityMarkers: userEntityMarkersPayload, userMarkers: userMarkersPayload } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
-    fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+        ingestInCache({ userEntityMarkers, userMarkers }, { cachedAt });
+    fireEvent('local.channelMarker.fetched', {
+        userEntityMarkers,
+    });
     fireEvent('local.userMarker.fetched', { userMarkers });
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
     return { data: userEntityMarkers, cachedAt, prevPage, nextPage };
 };
 
-const getCachedMarker$1 = (entityId) => {
+const getCachedMarker$2 = (entityId) => {
     var _a;
     const key = {
         entityId,
@@ -20875,7 +20895,31 @@ const getChannelUnreadCount = (channel, marker) => {
         // from a channel or the channel is deleted the channel's unread count will reset to zero
         return 0;
     }
-    return (_c = (_a = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _a !== void 0 ? _a : (_b = getCachedMarker$1(channel.channelId)) === null || _b === void 0 ? void 0 : _b.unreadCount) !== null && _c !== void 0 ? _c : 0;
+    return (_c = (_a = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _a !== void 0 ? _a : (_b = getCachedMarker$2(channel.channelId)) === null || _b === void 0 ? void 0 : _b.unreadCount) !== null && _c !== void 0 ? _c : 0;
+};
+
+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;
+};
+/**
+ * The function use to get value of hasMentioned field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ * If not found in the cache, use `false` as defaul value.
+ */
+const getChannelHasMentioned = (channel, marker) => {
+    var _a, _b;
+    return (marker === null || marker === void 0 ? void 0 : marker.hasMentioned) !== undefined
+        ? marker === null || marker === void 0 ? void 0 : marker.hasMentioned
+        : (_b = (_a = getCachedMarker$1(channel.channelId)) === null || _a === void 0 ? void 0 : _a.hasMentioned) !== null && _b !== void 0 ? _b : false;
 };
 
 const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
@@ -20883,6 +20927,9 @@ const isUnreadCountSupport$1 = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includ
 function convertFromRaw$2(channel) {
     return Object.assign(Object.assign({ get unreadCount() {
             return getChannelUnreadCount(channel);
+        },
+        get hasMentioned() {
+            return getChannelHasMentioned(channel);
         } }, channel), { defaultSubChannelId: channel._id, isUnreadCountSupport: isUnreadCountSupport$1(channel) });
 }
 const preUpdateChannelCache = (rawPayload) => {
@@ -20987,6 +21034,20 @@ const setIntervalTask = (handler, timeout) => {
     return () => clearInterval(timer);
 };
 
+const onOnline = (callback) => {
+    if (typeof window !== 'undefined' && window.addEventListener) {
+        window.addEventListener('online', callback);
+        return () => window.removeEventListener('online', callback);
+    }
+    if (typeof document !== 'undefined' && document.addEventListener) {
+        document.addEventListener('online', callback);
+        return () => document.removeEventListener('online', callback);
+    }
+    // Handle unsupported environment
+    console.error('Unsupported environment');
+    return () => console.error('Unsupported environment');
+};
+
 /**
  * ```js
  * import { isInTombstone } from '@amityco/ts-sdk'
@@ -21070,10 +21131,11 @@ const getMessageMarkers = async (messageIds, page = { limit: 100 }) => {
         },
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const { contentMarkers, feedMarkers, userMarkers } = payload;
+    const { contentMarkers, feedMarkers, userMarkers: userMarkersPayload } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });
     fireEvent('local.feedMarker.fetched', { feedMarkers });
     fireEvent('local.messageMarker.fetched', { contentMarkers });
     fireEvent('local.userMarker.fetched', { userMarkers });
@@ -21110,10 +21172,13 @@ const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
         },
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const { userEntityMarkers, userFeedMarkers, userMarkers } = payload;
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, userMarkers: userMarkersPayload, } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ userEntityMarkers, userFeedMarkers, userMarkers }, { cachedAt });
     fireEvent('local.channelMarker.fetched', { userEntityMarkers });
     fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
     fireEvent('local.userMarker.fetched', { userMarkers });
@@ -21126,10 +21191,14 @@ 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 { userMarkers: UserMarkersPayload } = payload;
+    /*
+      change field isMentioned from backend to be hasMentioned
+    */
+    const userMarkers = convertUserMarkerResponse(UserMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ userMarkers }, { cachedAt });
     fireEvent('local.userMarker.fetched', { userMarkers });
     return { data: userMarkers[0], cachedAt };
 };
@@ -21299,6 +21368,30 @@ function getSubChannelUnreadCount(channelId, subChannelId, marker) {
     return 0;
 }
 
+function getSubChannelHasMentioned(channelId, subChannelId, marker) {
+    var _a;
+    // Look for `unreadCount` in the marker param first
+    if (marker) {
+        return marker.hasMentioned;
+    }
+    const key = {
+        entityId: channelId,
+        feedId: subChannelId,
+        userId: getActiveUser()._id,
+    };
+    // If the marker param is not set, look in the cache
+    const cachedMarker = (_a = pullFromCache([
+        'subChannelMarker',
+        'get',
+        getResolver('subChannelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (cachedMarker) {
+        return cachedMarker.hasMentioned;
+    }
+    // and if not found in cache use default value `false`
+    return false;
+}
+
 const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 /**
  * Filter sub channel by type. Only conversation, community and broadcast type are included.
@@ -21308,6 +21401,9 @@ function convertFromRaw(_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 getSubChannelHasMentioned(channelId, messageFeedId);
         } }, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId, isUnreadCountSupport: isUnreadCountSupport({ channelType }) });
 }
 const preUpdateSubChannelCache = (rawPayload) => {
@@ -21427,10 +21523,13 @@ const readingAPI = async (messageFeedIds) => {
     const client = getActiveClient();
     client.log('subChannel/readingAPI', messageFeedIds);
     const { data: payload } = await client.http.post(`/api/v1/markers/message-feeds/reading`, { messageFeedIds });
-    const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, feedMarkers, userMarkers: userMarkersPayload, } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { cachedAt });
     fireEvent('local.feedMarker.fetched', { feedMarkers });
     fireEvent('local.channelMarker.fetched', { userEntityMarkers });
     fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
@@ -21457,10 +21556,13 @@ const startReadingAPI = async (messageFeedId) => {
     const client = getActiveClient();
     client.log('subChannel/startReadingAPI', messageFeedId);
     const { data: payload } = await client.http.post(`/api/v1/markers/message-feeds/${messageFeedId}/start-reading`);
-    const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, feedMarkers, userMarkers: userMarkersPayload, } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { cachedAt });
     fireEvent('local.feedMarker.fetched', { feedMarkers });
     fireEvent('local.channelMarker.fetched', { userEntityMarkers });
     fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
@@ -21487,10 +21589,13 @@ const stopReadingAPI = async (messageFeedId) => {
     const client = getActiveClient();
     client.log('channel/stopReadingAPI', messageFeedId);
     const { data: payload } = await client.http.post(`/api/v1/markers/message-feeds/${messageFeedId}/stop-reading`);
-    const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, feedMarkers, userMarkers: userMarkersPayload, } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { cachedAt });
     fireEvent('local.feedMarker.fetched', { feedMarkers });
     fireEvent('local.channelMarker.fetched', { userEntityMarkers });
     fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
@@ -21547,17 +21652,6 @@ const markReadEngineOnLoginHandler = () => {
         stopIntervalTask();
     };
 };
-/**
- * the event callback when app is back to online
- */
-const onOnline$1 = () => {
-    const callback = () => {
-        // Start reading the reading subChannel again when resume from offline state
-        startReadingFromReadingList();
-    };
-    window.addEventListener('online', callback);
-    return () => window.removeEventListener('online', callback);
-};
 const getParentChannelId = async (subChannelId) => {
     const cached = getSubChannel$1.locally(subChannelId);
     if (cached) {
@@ -21567,7 +21661,10 @@ const getParentChannelId = async (subChannelId) => {
     return data.channelId;
 };
 const registerEventListeners$1 = () => {
-    disposers$1.push(onOnline$1());
+    disposers$1.push(onOnline(() => {
+        // Start reading the reading subChannel again when resume from offline state
+        startReadingFromReadingList();
+    }));
 };
 const registerTopicSubscribers = async (subChannelId) => {
     const channelId = await getParentChannelId(subChannelId);
@@ -22202,10 +22299,13 @@ const markerSync = async (deviceLastSyncAt) => {
     const client = getActiveClient();
     client.log('channel/markerSync');
     const { data: payload } = await client.http.post(`/api/v1/markers/sync`, { deviceLastSyncAt });
-    const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, feedMarkers, userMarkers: userMarkersPayload, } = payload;
+    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(payload, { cachedAt });
+        ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { cachedAt });
     fireEvent('local.feedMarker.fetched', { feedMarkers });
     fireEvent('local.channelMarker.fetched', { userEntityMarkers });
     fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
@@ -22561,6 +22661,8 @@ const liveObject = (id, callback, key, fetcher, eventHandlers, options) => {
 };
 
 /**
+ * @deprecated Please use unreadCount from `getUserUnread` instead.
+ *
  * ```js
  * import { getTotalUnreadCount } from '@amityco/ts-sdk';
  *
@@ -22586,6 +22688,39 @@ const getTotalUnreadCount = (callback) => {
     });
 };
 
+/**
+ *
+ * ```js
+ * import { getUserUnread } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = getUserUnread(response => {
+ *   userUnread = response.data;
+ * });
+ * ```
+ *
+ * Observe current user's unread including unreadCount and hasMentioned from {@link Amity.UserMarker}
+ *
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the events
+ *
+ * @category Message Live Object
+ */
+const getUserUnread = (callback) => {
+    const { _id: userId } = getActiveUser();
+    if (!userId)
+        throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    const callbackDataSelector = (data) => {
+        var _a;
+        return {
+            unreadCount: (_a = data === null || data === void 0 ? void 0 : data.unreadCount) !== null && _a !== void 0 ? _a : 0,
+            hasMentioned: !!(data === null || data === void 0 ? void 0 : data.hasMentioned),
+        };
+    };
+    return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
+        callbackDataSelector,
+    });
+};
+
 /**
  * ```js
  * import { getChannelByIds } from '@amityco/ts-sdk'
@@ -22959,9 +23094,10 @@ const markAsRead = async (channelId) => {
     const client = getActiveClient();
     client.log('channel/markAsRead', channelId);
     const { data } = await client.http.put(`/api/v1/markers/channels/${channelId}/mark-read`);
+    const { userMarkers: userMarkersPayload, userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload } = data, rest = __rest(data, ["userMarkers", "userEntityMarkers", "userFeedMarkers"]);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(data, { cachedAt });
+        ingestInCache(Object.assign({ userMarkers: convertUserMarkerResponse(userMarkersPayload), userEntityMarkers: convertChannelMarkerResponse(userEntityMarkersPayload), userFeedMarkers: convertSubChannelMarkerResponse(userFeedMarkersPayload) }, rest), { cachedAt });
     return true;
 };
 
@@ -23347,6 +23483,8 @@ const queryChannels = async (query) => {
     return { data: channels, cachedAt, prevPage, nextPage };
 };
 
+const uuid = () => nativeIdGenerator.v4().toString();
+
 /* begin_public_function
   id: channel.query
 */
@@ -23379,7 +23517,7 @@ const getChannels = (params, callback, config) => {
     const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
     const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
     const disposers = [];
-    const cacheKey = ['channel', 'collection', {}];
+    const cacheKey = ['channel', 'collection', uuid()];
     const responder = (data) => {
         var _a, _b;
         let channels = (_a = data.data
@@ -23465,7 +23603,7 @@ const getChannels = (params, callback, config) => {
     };
     disposers.push(onChannelCreated(realtimeRouter()), onChannelDeleted(realtimeRouter()), onChannelUpdated(realtimeRouter()), onChannelMuted(realtimeRouter()), onChannelJoined(realtimeRouter()), onChannelLeft(realtimeRouter()), onChannelMemberAdded(realtimeRouter()), onChannelMemberRemoved(realtimeRouter()), convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel')(realtimeRouter()));
     onFetch(true);
-    dropFromCache(cacheKey);
+    disposers.push(() => dropFromCache(cacheKey));
     return () => {
         log(`getChannels(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -23994,8 +24132,12 @@ var index$g = /*#__PURE__*/Object.freeze({
 const onUserMarkerSync = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.userMarkers[0]);
+        const { userMarkers: userMarkersPayload, userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload } = payload, rest = __rest(payload, ["userMarkers", "userEntityMarkers", "userFeedMarkers"]);
+        const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+        const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+        const userFeedMarker = convertSubChannelMarkerResponse(userFeedMarkersPayload);
+        ingestInCache(Object.assign({ userMarkers, userEntityMarkers, userFeedMarker }, rest));
+        callback(userMarkers[0]);
     };
     return createEventSubscriber(client, 'UserMarker/onUserMarkerSync', 'marker.user-sync', filter);
 };
@@ -24406,22 +24548,16 @@ const markerSyncTrigger = async () => {
     // eslint-disable-next-line require-atomic-updates
     isWaitingForResponse = false;
 };
-/**
- * the event callback when app is back to online
- */
-const onOnline = () => {
-    // should add RESUME to the event to trigger marker syncing again
-    const callback = () => events.push("resume" /* Amity.MarkerSyncEvent.RESUME */);
-    window.addEventListener('online', callback);
-    return () => window.removeEventListener('online', callback);
-};
 const registerEventListeners = () => {
     // based on the tech spec design, we designed a fetch marker in case of these events
     // - new message
     // - create channel
     // - remove channel
     // - app going to online again after offline
-    disposers.push(onOnline(), onMessageCreated(message => {
+    disposers.push(onOnline(() => {
+        // should add RESUME to the event to trigger marker syncing again
+        events.push("resume" /* Amity.MarkerSyncEvent.RESUME */);
+    }), onMessageCreated(message => {
         // only conversation, community and broadcast types can sync
         if (isUnreadCountSupport(message))
             events.push("new message" /* Amity.MarkerSyncEvent.NEW_MESSAGE */);
@@ -24508,6 +24644,7 @@ var index$f = /*#__PURE__*/Object.freeze({
   onClientBanned: onClientBanned,
   onSessionStateChange: onSessionStateChange,
   getTotalUnreadCount: getTotalUnreadCount,
+  getUserUnread: getUserUnread,
   getMarkerSyncEvents: getMarkerSyncEvents,
   setMarkerSyncEvents: setMarkerSyncEvents,
   pushMarkerSyncEvent: pushMarkerSyncEvent,
@@ -26985,16 +27122,45 @@ getPost$1.locally = (postId) => {
     };
 };
 
+const commentLinkedObject = (comment) => {
+    return Object.assign(Object.assign({}, comment), { get target() {
+            const commentTypes = {
+                type: comment.targetType,
+            };
+            if (comment.targetType === 'user') {
+                return Object.assign(Object.assign({}, commentTypes), { userId: comment.targetId });
+            }
+            if (commentTypes.type === 'content') {
+                return Object.assign(Object.assign({}, commentTypes), { contentId: comment.targetId });
+            }
+            if (commentTypes.type === 'community') {
+                const cacheData = pullFromCache([
+                    'communityUsers',
+                    'get',
+                    `${comment.targetId}#${comment.userId}`,
+                ]);
+                return Object.assign(Object.assign({}, commentTypes), { communityId: comment.targetId, creatorMember: cacheData === null || cacheData === void 0 ? void 0 : cacheData.data });
+            }
+            return {
+                type: 'unknown',
+            };
+        } });
+};
+
+const LinkedObject = {
+    comment: commentLinkedObject,
+};
+
 /**
  * ```js
  * import { CommentRepository } from '@amityco/ts-sdk'
  * const comment = await CommentRepository.getComment('foobar')
  * ```
  *
- * Fetches a {@link Amity.Comment} object
+ * Fetches a {@link Amity.InternalComment} object
  *
- * @param commentId the ID of the {@link Amity.Comment} to fetch
- * @returns the associated {@link Amity.Comment} object
+ * @param commentId the ID of the {@link Amity.InternalComment} to fetch
+ * @returns the associated {@link Amity.InternalComment} object
  *
  * @category Comment API
  * @async
@@ -27020,7 +27186,7 @@ const getComment$1 = async (commentId) => {
         ingestInCache(data, { cachedAt });
     const { comments } = data;
     return {
-        data: comments.find(comment => comment.commentId === commentId),
+        data: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)),
         cachedAt,
     };
 };
@@ -27030,10 +27196,10 @@ const getComment$1 = async (commentId) => {
  * const comment = getComment.locally('foobar')
  * ```
  *
- * Fetches a {@link Amity.Comment} object
+ * Fetches a {@link Amity.InternalComment} object
  *
- * @param commentId the ID of the {@link Amity.Comment} to fetch
- * @returns the associated {@link Amity.Comment} object
+ * @param commentId the ID of the {@link Amity.InternalComment} to fetch
+ * @returns the associated {@link Amity.InternalComment} object
  *
  * @category Comment API
  */
@@ -27534,12 +27700,12 @@ const createCommentEventSubscriber = (event, callback) => {
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been created
+ * Fired when a {@link Amity.InternalComment} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentCreated = (callback) => createCommentEventSubscriber('comment.created', callback);
 
@@ -27551,12 +27717,12 @@ const onCommentCreated = (callback) => createCommentEventSubscriber('comment.cre
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been updated
+ * Fired when a {@link Amity.InternalComment} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentUpdated = (callback) => createCommentEventSubscriber('comment.updated', callback);
 
@@ -27568,12 +27734,12 @@ const onCommentUpdated = (callback) => createCommentEventSubscriber('comment.upd
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been deleted
+ * Fired when a {@link Amity.InternalComment} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentDeleted = (callback) => createCommentEventSubscriber('comment.deleted', callback);
 
@@ -27585,12 +27751,12 @@ const onCommentDeleted = (callback) => createCommentEventSubscriber('comment.del
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been flagged
+ * Fired when a {@link Amity.InternalComment} has been flagged
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentFlagged = (callback) => createCommentEventSubscriber('comment.flagged', callback);
 
@@ -27602,12 +27768,12 @@ const onCommentFlagged = (callback) => createCommentEventSubscriber('comment.fla
  * })
  * ```
  *
- * Fired when a flag has been removed from a {@link Amity.Comment}
+ * Fired when a flag has been removed from a {@link Amity.InternalComment}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentUnflagged = (callback) => createCommentEventSubscriber('comment.unflagged', callback);
 
@@ -27619,12 +27785,12 @@ const onCommentUnflagged = (callback) => createCommentEventSubscriber('comment.u
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been reacted
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentReactionAdded = (callback) => {
     const client = getActiveClient();
@@ -27655,12 +27821,12 @@ const onCommentReactionAdded = (callback) => {
  * })
  * ```
  *
- * Fired when a reaction has been removed from a {@link Amity.Comment}
+ * Fired when a reaction has been removed from a {@link Amity.InternalComment}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 const onCommentReactionRemoved = (callback) => {
     const client = getActiveClient();
@@ -28265,8 +28431,6 @@ getMessages$1.locally = (messageIds) => {
     };
 };
 
-const uuid = () => nativeIdGenerator.v4().toString();
-
 const getLocalId = () => `LOCAL_${uuid()}`;
 // FIXME: temp solution
 let uniqueId;
@@ -28638,9 +28802,10 @@ const markAsDelivered = async (subChannelId, messageId) => {
     const client = getActiveClient();
     client.log('message/markAsDelivered', subChannelId, messageId);
     const { data } = await client.http.put(`/api/v1/markers/message-feeds/${subChannelId}/mark-delivering`, { messageId });
+    const { userMarkers, userEntityMarkers, userFeedMarkers } = data, rest = __rest(data, ["userMarkers", "userEntityMarkers", "userFeedMarkers"]);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(data, { cachedAt });
+        ingestInCache(Object.assign({ userMarkers: convertUserMarkerResponse(userMarkers), userEntityMarkers: convertChannelMarkerResponse(userEntityMarkers), userFeedMarkers: convertSubChannelMarkerResponse(userFeedMarkers) }, rest), { cachedAt });
     return true;
 };
 
@@ -28670,10 +28835,10 @@ const getReadUsers = async (query) => {
                 token: toToken(page, 'afterbeforeraw'),
             } }),
     });
-    const { paging, publicUserIds: readUsers } = data, payload = __rest(data, ["paging", "publicUserIds"]);
+    const { paging, publicUserIds: readUsers, userFeedMarkers } = data, payload = __rest(data, ["paging", "publicUserIds", "userFeedMarkers"]);
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload, { cachedAt });
+        ingestInCache(Object.assign(Object.assign({}, payload), { userFeedMarkers: convertSubChannelMarkerResponse(userFeedMarkers) }), { cachedAt });
         const cacheKey = [
             'read-user',
             'query',
@@ -28751,10 +28916,10 @@ const getDeliveredUsers = async (query) => {
                 token: toToken(page, 'afterbeforeraw'),
             } }),
     });
-    const { paging, publicUserIds: deliveredUsers } = data, payload = __rest(data, ["paging", "publicUserIds"]);
+    const { paging, publicUserIds: deliveredUsers, userFeedMarkers } = data, payload = __rest(data, ["paging", "publicUserIds", "userFeedMarkers"]);
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
-        ingestInCache(payload, { cachedAt });
+        ingestInCache(Object.assign(Object.assign({}, payload), { userFeedMarkers: convertSubChannelMarkerResponse(userFeedMarkers) }), { cachedAt });
         const cacheKey = [
             'delivered-user',
             'query',
@@ -32515,10 +32680,10 @@ var index$3 = /*#__PURE__*/Object.freeze({
  * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
  * ```
  *
- * Fetches a collection of {@link Amity.Comment} objects
+ * Fetches a collection of {@link Amity.InternalComment} objects
  *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
+ * @param commentIds the IDs of the {@link Amity.InternalComment} to fetch
+ * @returns the associated collection of {@link Amity.InternalComment} objects
  *
  * @category Comment API
  * @async
@@ -32558,10 +32723,10 @@ const getCommentByIds = async (commentIds) => {
  * const comments = getCommentByIds.locally(['foo', 'bar'])
  * ```
  *
- * Fetches a collection of {@link Amity.Comment} objects from cache
+ * Fetches a collection of {@link Amity.InternalComment} objects from cache
  *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
+ * @param commentIds the IDs of the {@link Amity.InternalComment} to fetch
+ * @returns the associated collection of {@link Amity.InternalComment} objects
  *
  * @category Comment API
  */
@@ -32593,10 +32758,10 @@ getCommentByIds.locally = (commentIds) => {
  * const newComment = await CommentRepository.createComment(bundle)
  * ```
  *
- * Creates an {@link Amity.Comment}
+ * Creates an {@link Amity.InternalComment}
  *
- * @param bundle The data necessary to create a new {@link Amity.Comment}
- * @returns The newly created {@link Amity.Comment}
+ * @param bundle The data necessary to create a new {@link Amity.InternalComment}
+ * @returns The newly created {@link Amity.InternalComment}
  *
  * @category Comment API
  * @async
@@ -32640,11 +32805,11 @@ const createComment = async (bundle) => {
  * })
  * ```
  *
- * Updates an {@link Amity.Comment}
+ * Updates an {@link Amity.InternalComment}
  *
- * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param commentId The ID of the {@link Amity.InternalComment} to edit
  * @param patch The patch data to apply
- * @returns the updated {@link Amity.Comment} object
+ * @returns the updated {@link Amity.InternalComment} object
  *
  * @category Comment API
  * @async
@@ -32674,10 +32839,10 @@ const updateComment = async (commentId, patch) => {
  * const success = await CommentRepository.deleteComment('foobar')
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Deletes a {@link Amity.InternalComment}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param commentId The {@link Amity.InternalComment} ID to delete
+ * @return A success boolean if the {@link Amity.InternalComment} was deleted
  *
  * @category Comment API
  * @async
@@ -32711,6 +32876,7 @@ const deleteComment = async (commentId, permanent = false) => {
         commentChildren: [],
         files: [],
         users: [],
+        communityUsers: [],
     });
     if (permanent) {
         scheduleTask(() => pushToTombstone('comment', commentId));
@@ -32731,10 +32897,10 @@ const deleteComment = async (commentId, permanent = false) => {
  * const success = await CommentRepository.softDeleteComment('foobar')
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Deletes a {@link Amity.InternalComment}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param commentId The {@link Amity.InternalComment} ID to delete
+ * @return A success boolean if the {@link Amity.InternalComment} was deleted
  *
  * @category Comment API
  * @async
@@ -32756,10 +32922,10 @@ const softDeleteComment = async (commentId) => {
  * const success = await CommentRepository.hardDeleteComment('foobar')
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Deletes a {@link Amity.InternalComment}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param commentId The {@link Amity.InternalComment} ID to delete
+ * @return A success boolean if the {@link Amity.InternalComment} was deleted
  *
  * @category Comment API
  * @async
@@ -32860,13 +33026,13 @@ const isCommentFlaggedByMe = async (commentId) => {
  * const unsub = observeComments(postId, comment => merge(comments, comment))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Comment} for a given {@link Amity.Post} object
+ * Observe all mutations on a list of {@link Amity.InternalComment} for a given {@link Amity.Post} object
  *
  * @param postId the ID of the post where to observe the comments
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comments
  *
- * @category Comment Observer
+ * @category InternalComment Observer
  */
 const observeComments = (postId, callback) => {
     const { log } = getActiveClient();
@@ -32897,13 +33063,13 @@ const observeComments = (postId, callback) => {
  * const dispose = observeComment(commentId, ({ data }) => comment = data)
  * ```
  *
- * Observe all mutation on a given {@link Amity.Comment}
+ * Observe all mutation on a given {@link Amity.InternalComment}
  *
  * @param commentId the ID of the comment to observe
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Comment Observer
+ * @category InternalComment Observer
  */
 const observeComment = (commentId, callback, policy = 'cache_then_server') => {
     const { log } = getActiveClient();
@@ -32947,13 +33113,13 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
  * });
  * ```
  *
- * Observe all mutation on a given {@link Amity.Comment}
+ * Observe all mutation on a given {@link Amity.InternalComment}
  *
  * @param commentId the ID of the comment to observe
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Comment Live Object
+ * @category InternalComment Live Object
  */
 const getComment = (commentId, callback) => {
     return liveObject(commentId, callback, 'commentId', getComment$1, [
@@ -32973,10 +33139,10 @@ const getComment = (commentId, callback) => {
  * const comments = await CommentRepository.queryComments({ referenceType: 'post', referenceId: 'foo' })
  * ```
  *
- * Queries a paginable list of {@link Amity.Comment} objects
+ * Queries a paginable list of {@link Amity.InternalComment} objects
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.Comment} objects
+ * @returns A page of {@link Amity.InternalComment} objects
  *
  * @category Comment API
  * @async
@@ -33026,12 +33192,12 @@ const queryComments = async (query) => {
  *
  * let comments = []
  * const unsub = getComments({
- *   referenceType: Amity.Comment['referenceType'];
- *   referenceId: Amity.Comment['referenceId'];
+ *   referenceType: Amity.InternalComment['referenceType'];
+ *   referenceId: Amity.InternalComment['referenceId'];
  * }, response => merge(comments, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Comment} for a given target object
+ * Observe all mutations on a list of {@link Amity.InternalComment} for a given target object
  *
  * @param referenceType the type of the target
  * @param referenceId the ID of the target
@@ -33061,7 +33227,7 @@ const getComments = (params, callback, config) => {
         let comments = (_a = data.data
             .map(commentId => pullFromCache(['comment', 'get', commentId]))
             .filter(Boolean)
-            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+            .map(({ data }) => LinkedObject.comment(data))) !== null && _a !== void 0 ? _a : [];
         if (!params.includeDeleted) {
             comments = filterByPropEquality(comments, 'isDeleted', false);
         }