@amityco/ts-sdk 7.1.1-c8d4edca.0 → 7.1.1-dbdbe662.0

package/dist/index.esm.js

@@ -21719,7 +21719,6 @@ class MessageReadReceiptSyncEngine {
         if (this.jobQueue.length === 0 || this.isActive === false)
             return;
         const readReceipts = this.getReadReceipts();
-        console.log('[New 🌟 readReceipts] Sync read receipts', readReceipts);
         if (readReceipts) {
             this.markReadApi(readReceipts);
         }
@@ -21821,8 +21820,9 @@ class MessageReadReceiptSyncEngine {
         // Step 1: Optimistic update of channelUnread.readToSegment to message.segment and update unreadCount value
         const cacheKey = ['channelUnread', 'get', channelId];
         const channelUnread = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        console.log('[New 🌟] Mark read => channel unread', channelUnread);
-        if (channelUnread && segment > channelUnread.readToSegment) {
+        if (typeof (channelUnread === null || channelUnread === void 0 ? void 0 : channelUnread.readToSegment) === 'number' &&
+            channelUnread &&
+            segment > channelUnread.readToSegment) {
             channelUnread.readToSegment = segment;
             channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
             pushToCache(cacheKey, channelUnread);
@@ -23155,17 +23155,24 @@ const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated:
 const updateChannelUnread = ({ currentUserId, channels, channelUsers, }) => {
     for (let i = 0; i < channels.length; i += 1) {
         const cacheKey = ['channelUnread', 'get', channels[i].channelId];
-        const { readToSegment, lastMentionedSegment } = channelUsers.find(channelUser => channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId) || {
-            readToSegment: 0,
-            lastMentionedSegment: 0,
-        };
+        const channelUser = channelUsers.find(channelUser => channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId);
+        let unreadCount = 0;
+        let readToSegment = null;
+        let lastMentionedSegment = null;
+        let isMentioned = false;
+        if (channelUser) {
+            readToSegment = channelUser.readToSegment;
+            lastMentionedSegment = channelUser.lastMentionedSegment;
+            unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
+            isMentioned = lastMentionedSegment > readToSegment;
+        }
         pushToCache(cacheKey, {
             channelId: channels[i].channelId,
             lastSegment: channels[i].messageCount,
             readToSegment,
             lastMentionedSegment,
-            unreadCount: channels[i].messageCount - readToSegment,
-            isMentioned: lastMentionedSegment > readToSegment,
+            unreadCount,
+            isMentioned,
             isDeleted: channels[i].isDeleted,
         });
     }
@@ -24011,12 +24018,21 @@ const onChannelDeleted = (callback) => {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
-            if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-                data.channels.forEach(channel => {
+            const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+            const isLegacyUnreadCount = client.useLegacyUnreadCount;
+            data.channels.forEach(channel => {
+                if (isConsistentMode) {
                     addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
                     deleteChannelUnreadByChannelId(channel.channelId);
-                });
-            }
+                }
+                else if (isLegacyUnreadCount) {
+                    const cacheKey = ['channelUnread', 'get', channel.channelId];
+                    const cache = pullFromCache(cacheKey);
+                    if (cache) {
+                        pushToCache(cacheKey, Object.assign(Object.assign({}, cache), { isDeleted: true }));
+                    }
+                }
+            });
             ingestInCache(data);
             callbacks$b.forEach(cb => cb(data.channels[0]));
         };
@@ -24715,10 +24731,17 @@ const onChannelLeft = (callback) => {
             const preparedPayload = await prepareChannelPayload(payload, {
                 isMessagePreviewUpdated: isLeftByMe,
             });
-            if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
+            const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+            const isLegacyUnreadCount = client.useLegacyUnreadCount;
+            if (isLeftByMe) {
                 preparedPayload.channels.forEach(channel => {
-                    addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-                    deleteChannelUnreadByChannelId(channel.channelId);
+                    if (isConsistentMode) {
+                        addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+                        deleteChannelUnreadByChannelId(channel.channelId);
+                    }
+                    else if (isLegacyUnreadCount) {
+                        dropFromCache(['channelUnread', 'get', channel.channelId]);
+                    }
                 });
             }
             const { channels, channelUsers } = preparedPayload;
@@ -24986,6 +25009,34 @@ const onMessageCreatedMqtt = (callback) => {
                 reCalculateChannelUnreadInfo(message.channelId);
             });
         }
+        if (client.useLegacyUnreadCount) {
+            rawPayload.messages.forEach(message => {
+                var _a, _b;
+                const channelUnread = (_a = pullFromCache([
+                    'channelUnread',
+                    'get',
+                    message.channelId,
+                ])) === null || _a === void 0 ? void 0 : _a.data;
+                if (!channelUnread ||
+                    channelUnread.lastSegment >= message.segment ||
+                    typeof channelUnread.readToSegment !== 'number' ||
+                    typeof channelUnread.lastMentionSegment !== 'number')
+                    return;
+                const lastSegment = message.segment;
+                const isMentionedInMessage = (_b = message.mentionedUsers) === null || _b === void 0 ? void 0 : _b.some(mention => {
+                    return (mention.type === 'channel' ||
+                        (mention.type === 'user' &&
+                            client.userId &&
+                            mention.userPublicIds.includes(client.userId)));
+                });
+                const lastMentionSegment = isMentionedInMessage
+                    ? message.segment
+                    : channelUnread.lastMentionSegment;
+                const updatedChannelUnread = Object.assign(Object.assign({}, channelUnread), { lastSegment, unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0), lastMentionSegment, isMentioned: !(channelUnread.readToSegment >= lastMentionSegment) });
+                pushToCache(['channelUnread', 'get', message.channelId], updatedChannelUnread);
+                fireEvent('local.channelUnread.updated', updatedChannelUnread);
+            });
+        }
         // Update in cache
         ingestInCache(payload);
         payload.messages.forEach(message => {
@@ -32828,12 +32879,12 @@ var index$f = /*#__PURE__*/Object.freeze({
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ * Fired when an {@link Amity.channelUnreadInfo} has been updated.
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category MessageMarker Events
+ * @category ChannelMarker Events
  */
 const onChannelUnreadInfoUpdatedLocal = (callback) => {
     const client = getActiveClient();
@@ -32846,12 +32897,12 @@ const onChannelUnreadInfoUpdatedLocal = (callback) => {
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ * Fired when an {@link Amity.ChannelUnread} has been updated.
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category MessageMarker Events
+ * @category Channel Events
  */
 const onChannelUnreadUpdatedLocal = (callback) => {
     const client = getActiveClient();
@@ -33643,6 +33694,120 @@ const getChannels = (params, callback, config) => {
 };
 /* end_public_function */
 
+/**
+ *
+ * Calculate user unread from {@link Amity.ChannelUnread} objects
+ *
+ * @returns the {@link Amity.UserUnread} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getTotalChannelsUnread$1 = () => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/getTotalChannelsUnread.locally');
+    const cachedChannelsUnread = ((_a = queryCache(['channelUnread', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
+        return !data.isDeleted;
+    })) || [];
+    const totalChannelsUnread = (cachedChannelsUnread === null || cachedChannelsUnread === void 0 ? void 0 : cachedChannelsUnread.reduce((acc, { data }) => {
+        acc.unreadCount += data.unreadCount;
+        acc.isMentioned = acc.isMentioned || data.isMentioned;
+        return acc;
+    }, { unreadCount: 0, isMentioned: false })) || { unreadCount: 0, isMentioned: false };
+    const cachedAt = client.cache && Date.now();
+    return {
+        data: totalChannelsUnread,
+        cachedAt,
+    };
+};
+
+/* begin_public_function
+  id: totalChannelsUnread.get
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk';
+ *
+ * let totalChannelsUnread;
+ *
+ * const unsubscribe = ChannelRepository.getTotalChannelsUnread(response => {
+ *   unread = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.UserUnread}
+ *
+ * @returns An {@link Amity.UserUnread} function to run when willing to stop observing the message
+ *
+ * @category User Unread Live Object
+ *
+ */
+const getTotalChannelsUnread = (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 { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Object feature you need to enable Cache!');
+    }
+    const timestamp = Date.now();
+    log(`liveTotalChannelsUnread(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    let isUnsyncedModel = false; // for messages
+    let model;
+    const dispatcher = (data) => {
+        const { data: userUnread } = data;
+        const callbackModel = userUnread
+            ? {
+                unreadCount: userUnread.unreadCount,
+                isMentioned: userUnread.isMentioned,
+            }
+            : undefined;
+        model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
+        callback({
+            data: callbackModel
+                ? Object.assign(Object.assign({}, callbackModel), { isMentioned: callbackModel.isMentioned }) : callbackModel,
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (userUnread) => {
+        if (isEqual(model, userUnread))
+            return;
+        dispatcher({
+            loading: false,
+            data: userUnread,
+        });
+    };
+    const onFetch = () => {
+        const query = createQuery(async () => getTotalChannelsUnread$1());
+        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedModel = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedModel) {
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(onChannelUnreadUpdatedLocal(realtimeRouter));
+    onFetch();
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
 /* begin_public_function
   id: channel.member.add
 */
@@ -34246,6 +34411,7 @@ var index$c = /*#__PURE__*/Object.freeze({
   onChannelMemberRoleRemoved: onChannelMemberRoleRemoved,
   getChannel: getChannel,
   getChannels: getChannels,
+  getTotalChannelsUnread: getTotalChannelsUnread,
   MARKER_INCLUDED_CHANNEL_TYPE: MARKER_INCLUDED_CHANNEL_TYPE,
   isUnreadCountSupport: isUnreadCountSupport,
   convertFromRaw: convertFromRaw,