@amityco/ts-sdk 6.7.2-bd796de.0 → 6.7.2-c5c263a.0

package/dist/index.cjs.js

@@ -4725,6 +4725,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'
@@ -4753,18 +4769,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,
@@ -4784,7 +4804,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'];
@@ -4792,6 +4836,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) => {
@@ -4993,10 +5040,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 });
@@ -5033,10 +5081,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 });
@@ -5049,10 +5100,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 };
 };
@@ -5222,6 +5277,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.
@@ -5231,6 +5310,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) => {
@@ -5350,10 +5432,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 });
@@ -5380,10 +5465,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 });
@@ -5410,10 +5498,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 });
@@ -6117,10 +6208,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 });
@@ -6454,6 +6548,8 @@ const liveObject = (id, callback, key, fetcher, eventHandlers, options) => {
 };
 
 /**
+ * @deprecated Please use unreadCount from `getUserUnread` instead.
+ *
  * ```js
  * import { getTotalUnreadCount } from '@amityco/ts-sdk';
  *
@@ -6479,6 +6575,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'
@@ -6852,9 +6981,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;
 };
 
@@ -7240,6 +7370,8 @@ const queryChannels = async (query) => {
     return { data: channels, cachedAt, prevPage, nextPage };
 };
 
+const uuid = () => nativeIdGenerator__default["default"].v4().toString();
+
 /* begin_public_function
   id: channel.query
 */
@@ -7272,7 +7404,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
@@ -7358,7 +7490,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());
@@ -7887,8 +8019,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);
 };
@@ -8395,6 +8531,7 @@ var index$f = /*#__PURE__*/Object.freeze({
   onClientBanned: onClientBanned,
   onSessionStateChange: onSessionStateChange,
   getTotalUnreadCount: getTotalUnreadCount,
+  getUserUnread: getUserUnread,
   getMarkerSyncEvents: getMarkerSyncEvents,
   setMarkerSyncEvents: setMarkerSyncEvents,
   pushMarkerSyncEvent: pushMarkerSyncEvent,
@@ -12152,8 +12289,6 @@ getMessages$1.locally = (messageIds) => {
     };
 };
 
-const uuid = () => nativeIdGenerator__default["default"].v4().toString();
-
 const getLocalId = () => `LOCAL_${uuid()}`;
 // FIXME: temp solution
 let uniqueId;
@@ -12525,9 +12660,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;
 };
 
@@ -12557,10 +12693,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',
@@ -12638,10 +12774,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',