@stream-io/feeds-client 0.2.0 → 0.2.2

package/dist/index-react-bindings.browser.cjs

@@ -277,7 +277,7 @@ function useStateStore(store, selector) {
 
 const decoders = {};
 const decodeDatetimeType = (input) => typeof input === 'number'
-    ? new Date(Math.floor(input / 1000000))
+    ? new Date(Math.floor(input / 1e6))
     : new Date(input);
 decoders.DatetimeType = decodeDatetimeType;
 const decode = (typeMappings, input) => {
@@ -613,6 +613,7 @@ decoders.Channel = (input) => {
         updated_at: { type: 'DatetimeType', isSingle: true },
         deleted_at: { type: 'DatetimeType', isSingle: true },
         last_message_at: { type: 'DatetimeType', isSingle: true },
+        message_count_updated_at: { type: 'DatetimeType', isSingle: true },
         active_live_locations: { type: 'SharedLocation', isSingle: false },
         invites: { type: 'ChannelMember', isSingle: false },
         members: { type: 'ChannelMember', isSingle: false },
@@ -890,6 +891,7 @@ decoders.FeedMemberResponse = (input) => {
         user: { type: 'UserResponse', isSingle: true },
         invite_accepted_at: { type: 'DatetimeType', isSingle: true },
         invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+        membership_level: { type: 'MembershipLevelResponse', isSingle: true },
     };
     return decode(typeMappings, input);
 };
@@ -1062,6 +1064,13 @@ decoders.ListDevicesResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.MembershipLevelResponse = (input) => {
+    const typeMappings = {
+        created_at: { type: 'DatetimeType', isSingle: true },
+        updated_at: { type: 'DatetimeType', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.Message = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
@@ -3812,6 +3821,7 @@ class ModerationApi {
             block_list_config: request?.block_list_config,
             bodyguard_config: request?.bodyguard_config,
             google_vision_config: request?.google_vision_config,
+            llm_config: request?.llm_config,
             rule_builder_config: request?.rule_builder_config,
             velocity_filter_config: request?.velocity_filter_config,
             video_call_rule_config: request?.video_call_rule_config,
@@ -4288,6 +4298,23 @@ function getStateUpdateQueueId(data, prefix) {
     throw new Error(`Cannot create state update queueId for data: ${JSON.stringify(data)}`);
 }
 
+function updateEntityInArray({ matcher, updater, entities, }) {
+    if (!entities || !entities.length) {
+        return { changed: false, entities };
+    }
+    const index = entities.findIndex(matcher);
+    if (index === -1) {
+        return { changed: false, entities };
+    }
+    const newEntity = updater(entities[index]);
+    if (newEntity === entities[index]) {
+        return { changed: false, entities };
+    }
+    const updatedEntities = [...entities];
+    updatedEntities[index] = newEntity;
+    return { changed: true, entities: updatedEntities };
+}
+
 const updateStateFollowCreated = (follow, currentState, currentFeedId, connectedUserId) => {
     // filter non-accepted follows (the way getOrCreate does by default)
     if (follow.status !== 'accepted') {
@@ -4478,20 +4505,29 @@ function handleCommentAdded(event) {
 function handleCommentDeleted({ comment }) {
     const entityId = comment.parent_id ?? comment.object_id;
     this.state.next((currentState) => {
-        const newCommentsByEntityId = {
-            ...currentState.comments_by_entity_id,
-            [entityId]: {
-                ...currentState.comments_by_entity_id[entityId],
-            },
-        };
+        let newCommentsByEntityId;
         const index = this.getCommentIndex(comment, currentState);
-        if (newCommentsByEntityId?.[entityId]?.comments?.length && index !== -1) {
+        if (index !== -1) {
+            newCommentsByEntityId ?? (newCommentsByEntityId = {
+                ...currentState.comments_by_entity_id,
+                [entityId]: {
+                    ...currentState.comments_by_entity_id[entityId],
+                },
+            });
             newCommentsByEntityId[entityId].comments = [
                 ...newCommentsByEntityId[entityId].comments,
             ];
             newCommentsByEntityId[entityId]?.comments?.splice(index, 1);
         }
-        delete newCommentsByEntityId[comment.id];
+        if (typeof currentState.comments_by_entity_id[comment.id] !== 'undefined') {
+            newCommentsByEntityId ?? (newCommentsByEntityId = {
+                ...currentState.comments_by_entity_id,
+            });
+            delete newCommentsByEntityId[comment.id];
+        }
+        if (!newCommentsByEntityId) {
+            return currentState;
+        }
         return {
             ...currentState,
             comments_by_entity_id: newCommentsByEntityId,
@@ -4623,6 +4659,179 @@ function handleFeedMemberRemoved(event) {
     });
 }
 
+const sharedUpdateActivity$5 = ({ currentActivity, event, eventBelongsToCurrentUser, }) => {
+    let newOwnBookmarks = currentActivity.own_bookmarks;
+    if (eventBelongsToCurrentUser) {
+        newOwnBookmarks = [...newOwnBookmarks, event.bookmark];
+    }
+    return {
+        ...event.bookmark.activity,
+        own_bookmarks: newOwnBookmarks,
+        own_reactions: currentActivity.own_reactions,
+    };
+};
+const addBookmarkToActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    updater: (matchedActivity) => sharedUpdateActivity$5({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+    }),
+});
+const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+    updater: (matchedPinnedActivity) => {
+        const newActivity = sharedUpdateActivity$5({
+            currentActivity: matchedPinnedActivity.activity,
+            event,
+            eventBelongsToCurrentUser,
+        });
+        if (newActivity === matchedPinnedActivity.activity) {
+            return matchedPinnedActivity;
+        }
+        return {
+            ...matchedPinnedActivity,
+            activity: newActivity,
+        };
+    },
+});
+function handleBookmarkAdded(event) {
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
+    const [result1, result2] = [
+        addBookmarkToActivities(event, currentActivities, eventBelongsToCurrentUser),
+        addBookmarkToPinnedActivities(event, currentPinnedActivities, eventBelongsToCurrentUser),
+    ];
+    if (result1.changed || result2.changed) {
+        this.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+        });
+    }
+}
+
+// Helper function to check if two bookmarks are the same
+// A bookmark is identified by activity_id + folder_id + user_id
+const isSameBookmark = (bookmark1, bookmark2) => {
+    return (bookmark1.user.id === bookmark2.user.id &&
+        bookmark1.activity.id === bookmark2.activity.id &&
+        bookmark1.folder?.id === bookmark2.folder?.id);
+};
+const sharedUpdateActivity$4 = ({ currentActivity, event, eventBelongsToCurrentUser, }) => {
+    let newOwnBookmarks = currentActivity.own_bookmarks;
+    if (eventBelongsToCurrentUser) {
+        newOwnBookmarks = currentActivity.own_bookmarks.filter((bookmark) => !isSameBookmark(bookmark, event.bookmark));
+    }
+    return {
+        ...event.bookmark.activity,
+        own_bookmarks: newOwnBookmarks,
+        own_reactions: currentActivity.own_reactions,
+    };
+};
+const removeBookmarkFromActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    updater: (matchedActivity) => sharedUpdateActivity$4({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+    }),
+});
+const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+    updater: (matchedPinnedActivity) => {
+        const newActivity = sharedUpdateActivity$4({
+            currentActivity: matchedPinnedActivity.activity,
+            event,
+            eventBelongsToCurrentUser,
+        });
+        if (newActivity === matchedPinnedActivity.activity) {
+            return matchedPinnedActivity;
+        }
+        return {
+            ...matchedPinnedActivity,
+            activity: newActivity,
+        };
+    },
+});
+function handleBookmarkDeleted(event) {
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
+    const [result1, result2] = [
+        removeBookmarkFromActivities(event, currentActivities, eventBelongsToCurrentUser),
+        removeBookmarkFromPinnedActivities(event, currentPinnedActivities, eventBelongsToCurrentUser),
+    ];
+    if (result1.changed || result2.changed) {
+        this.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+        });
+    }
+}
+
+const sharedUpdateActivity$3 = ({ currentActivity, event, eventBelongsToCurrentUser, }) => {
+    let newOwnBookmarks = currentActivity.own_bookmarks;
+    if (eventBelongsToCurrentUser) {
+        const bookmarkIndex = newOwnBookmarks.findIndex((bookmark) => isSameBookmark(bookmark, event.bookmark));
+        if (bookmarkIndex !== -1) {
+            newOwnBookmarks = [...newOwnBookmarks];
+            newOwnBookmarks[bookmarkIndex] = event.bookmark;
+        }
+    }
+    return {
+        ...event.bookmark.activity,
+        own_bookmarks: newOwnBookmarks,
+        own_reactions: currentActivity.own_reactions,
+    };
+};
+const updateBookmarkInActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    updater: (matchedActivity) => sharedUpdateActivity$3({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+    }),
+});
+const updateBookmarkInPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+    updater: (matchedPinnedActivity) => {
+        const newActivity = sharedUpdateActivity$3({
+            currentActivity: matchedPinnedActivity.activity,
+            event,
+            eventBelongsToCurrentUser,
+        });
+        if (newActivity === matchedPinnedActivity.activity) {
+            return matchedPinnedActivity;
+        }
+        return {
+            ...matchedPinnedActivity,
+            activity: newActivity,
+        };
+    },
+});
+function handleBookmarkUpdated(event) {
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
+    const [result1, result2] = [
+        updateBookmarkInActivities(event, currentActivities, eventBelongsToCurrentUser),
+        updateBookmarkInPinnedActivities(event, currentPinnedActivities, eventBelongsToCurrentUser),
+    ];
+    if (result1.changed || result2.changed) {
+        this.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+        });
+    }
+}
+
 const addActivitiesToState = (newActivities, activities, position) => {
     let result;
     if (activities === undefined) {
@@ -4667,7 +4876,8 @@ function handleActivityAdded(event) {
 }
 
 const removeActivityFromState = (activityResponse, activities) => {
-    const index = activities.findIndex((a) => a.id === activityResponse.id);
+    const index = activities?.findIndex((activity) => activity.id === activityResponse.id) ??
+        -1;
     if (index !== -1) {
         const newActivities = [...activities];
         newActivities.splice(index, 1);
@@ -4677,13 +4887,28 @@ const removeActivityFromState = (activityResponse, activities) => {
         return { changed: false, activities };
     }
 };
+const removePinnedActivityFromState = (activityResponse, pinnedActivities) => {
+    const index = pinnedActivities?.findIndex((pinnedActivity) => pinnedActivity.activity.id === activityResponse.id) ?? -1;
+    if (index !== -1) {
+        const newActivities = [...pinnedActivities];
+        newActivities.splice(index, 1);
+        return { changed: true, activities: newActivities };
+    }
+    else {
+        return { changed: false, pinned_activities: pinnedActivities };
+    }
+};
 function handleActivityDeleted(event) {
-    const currentActivities = this.currentState.activities;
-    if (currentActivities) {
-        const result = removeActivityFromState(event.activity, currentActivities);
-        if (result.changed) {
-            this.state.partialNext({ activities: result.activities });
-        }
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
+    const [result1, result2] = [
+        removeActivityFromState(event.activity, currentActivities),
+        removePinnedActivityFromState(event.activity, currentPinnedActivities),
+    ];
+    if (result1.changed || result2.changed) {
+        this.state.partialNext({
+            activities: result1.activities,
+            pinned_activities: result2.pinned_activities,
+        });
     }
 }
 
@@ -4697,233 +4922,242 @@ function handleActivityRemovedFromFeed(event) {
     }
 }
 
-const updateActivityInState = (updatedActivityResponse, activities, replaceCompletely = false) => {
-    const index = activities.findIndex((a) => a.id === updatedActivityResponse.id);
-    if (index !== -1) {
-        const newActivities = [...activities];
-        const activity = activities[index];
-        if (replaceCompletely) {
-            newActivities[index] = updatedActivityResponse;
-        }
-        else {
-            newActivities[index] = {
-                ...updatedActivityResponse,
-                own_reactions: activity.own_reactions,
-                own_bookmarks: activity.own_bookmarks,
-                latest_reactions: activity.latest_reactions,
-                reaction_groups: activity.reaction_groups,
-            };
+const sharedUpdateActivity$2 = ({ currentActivity, event, }) => {
+    return {
+        ...event.activity,
+        own_reactions: currentActivity.own_reactions,
+        own_bookmarks: currentActivity.own_bookmarks,
+    };
+};
+const updateActivityInState = (event, activities) => updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.activity.id,
+    updater: (matchedActivity) => sharedUpdateActivity$2({
+        currentActivity: matchedActivity,
+        event,
+    }),
+});
+const updatePinnedActivityInState = (event, pinnedActivities) => updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) => pinnedActivity.activity.id === event.activity.id,
+    updater: (matchedPinnedActivity) => {
+        const newActivity = sharedUpdateActivity$2({
+            currentActivity: matchedPinnedActivity.activity,
+            event,
+        });
+        if (newActivity === matchedPinnedActivity.activity) {
+            return matchedPinnedActivity;
         }
-        return { changed: true, activities: newActivities };
-    }
-    else {
-        return { changed: false, activities };
-    }
-};
+        return {
+            ...matchedPinnedActivity,
+            activity: newActivity,
+        };
+    },
+});
 function handleActivityUpdated(event) {
-    const currentActivities = this.currentState.activities;
-    if (currentActivities) {
-        const result = updateActivityInState(event.activity, currentActivities);
-        if (result.changed) {
-            this.client.hydratePollCache([event.activity]);
-            this.state.partialNext({ activities: result.activities });
-        }
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
+    const [result1, result2] = [
+        updateActivityInState(event, currentActivities),
+        updatePinnedActivityInState(event, currentPinnedActivities),
+    ];
+    if (result1.changed || result2.changed) {
+        this.client.hydratePollCache([event.activity]);
+        this.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+        });
     }
 }
 
-const addReactionToActivity = (event, activity, isCurrentUser) => {
-    // Update own_reactions if the reaction is from the current user
-    const ownReactions = [...(activity.own_reactions || [])];
-    if (isCurrentUser) {
-        ownReactions.push(event.reaction);
+// shared function to update the activity with the new reaction
+const sharedUpdateActivity$1 = ({ currentActivity, event, eventBelongsToCurrentUser, }) => {
+    let newOwnReactions = currentActivity.own_reactions;
+    if (eventBelongsToCurrentUser) {
+        newOwnReactions = [...currentActivity.own_reactions, event.reaction];
     }
     return {
-        ...activity,
-        own_reactions: ownReactions,
-        latest_reactions: event.activity.latest_reactions,
-        reaction_groups: event.activity.reaction_groups,
-        changed: true,
-    };
-};
-const addReactionToActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = addReactionToActivity(event, activity, isCurrentUser);
-    return updateActivityInState(updatedActivity, activities, true);
-};
+        ...event.activity,
+        own_reactions: newOwnReactions,
+        own_bookmarks: currentActivity.own_bookmarks,
+    };
+};
+const addReactionToActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.activity.id,
+    updater: (matchedActivity) => sharedUpdateActivity$1({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+    }),
+});
+const addReactionToPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) => pinnedActivity.activity.id === event.activity.id,
+    updater: (matchedPinnedActivity) => {
+        const newActivity = sharedUpdateActivity$1({
+            currentActivity: matchedPinnedActivity.activity,
+            event,
+            eventBelongsToCurrentUser,
+        });
+        // this should never happen, but just in case
+        if (newActivity === matchedPinnedActivity.activity) {
+            return matchedPinnedActivity;
+        }
+        return {
+            ...matchedPinnedActivity,
+            activity: newActivity,
+        };
+    },
+});
 function handleActivityReactionAdded(event) {
-    const currentActivities = this.currentState.activities;
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
     const connectedUser = this.client.state.getLatestValue().connected_user;
-    const isCurrentUser = Boolean(connectedUser && event.reaction.user.id === connectedUser.id);
-    const result = addReactionToActivities(event, currentActivities, isCurrentUser);
-    if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
+    const eventBelongsToCurrentUser = typeof connectedUser !== 'undefined' &&
+        event.reaction.user.id === connectedUser.id;
+    const [result1, result2] = [
+        addReactionToActivities(event, currentActivities, eventBelongsToCurrentUser),
+        addReactionToPinnedActivities(event, currentPinnedActivities, eventBelongsToCurrentUser),
+    ];
+    if (result1.changed || result2.changed) {
+        this.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+        });
     }
 }
 
-const removeReactionFromActivity = (event, activity, isCurrentUser) => {
-    // Update own_reactions if the reaction is from the current user
-    const ownReactions = isCurrentUser
-        ? (activity.own_reactions || []).filter((r) => !(r.type === event.reaction.type &&
-            r.user.id === event.reaction.user.id))
-        : activity.own_reactions;
-    return {
-        ...activity,
-        own_reactions: ownReactions,
-        latest_reactions: event.activity.latest_reactions,
-        reaction_groups: event.activity.reaction_groups,
-        changed: true,
-    };
-};
-const removeReactionFromActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
+const sharedUpdateActivity = ({ currentActivity, event, eventBelongsToCurrentUser, }) => {
+    let newOwnReactions = currentActivity.own_reactions;
+    if (eventBelongsToCurrentUser) {
+        newOwnReactions = currentActivity.own_reactions.filter((reaction) => !(reaction.type === event.reaction.type &&
+            reaction.user.id === event.reaction.user.id));
     }
-    const activity = activities[activityIndex];
-    const updatedActivity = removeReactionFromActivity(event, activity, isCurrentUser);
-    return updateActivityInState(updatedActivity, activities, true);
-};
+    return {
+        ...event.activity,
+        own_reactions: newOwnReactions,
+        own_bookmarks: currentActivity.own_bookmarks,
+    };
+};
+const removeReactionFromActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.activity.id,
+    updater: (matchedActivity) => sharedUpdateActivity({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+    }),
+});
+const removeReactionFromPinnedActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+    entities: activities,
+    matcher: (pinnedActivity) => pinnedActivity.activity.id === event.activity.id,
+    updater: (matchedPinnedActivity) => {
+        const newActivity = sharedUpdateActivity({
+            currentActivity: matchedPinnedActivity.activity,
+            event,
+            eventBelongsToCurrentUser,
+        });
+        if (newActivity === matchedPinnedActivity.activity) {
+            return matchedPinnedActivity;
+        }
+        return {
+            ...matchedPinnedActivity,
+            activity: newActivity,
+        };
+    },
+});
 function handleActivityReactionDeleted(event) {
-    const currentActivities = this.currentState.activities;
+    const { activities: currentActivities, pinned_activities: currentPinnedActivities, } = this.currentState;
     const connectedUser = this.client.state.getLatestValue().connected_user;
-    const isCurrentUser = Boolean(connectedUser && event.reaction.user.id === connectedUser.id);
-    const result = removeReactionFromActivities(event, currentActivities, isCurrentUser);
-    if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
+    const eventBelongsToCurrentUser = typeof connectedUser !== 'undefined' &&
+        event.reaction.user.id === connectedUser.id;
+    const [result1, result2] = [
+        removeReactionFromActivities(event, currentActivities, eventBelongsToCurrentUser),
+        removeReactionFromPinnedActivities(event, currentPinnedActivities, eventBelongsToCurrentUser),
+    ];
+    if (result1.changed || result2.changed) {
+        this.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+        });
     }
 }
 
-const addBookmarkToActivity = (event, activity, isCurrentUser) => {
-    // Update own_bookmarks if the bookmark is from the current user
-    const ownBookmarks = [...(activity.own_bookmarks || [])];
-    if (isCurrentUser) {
-        ownBookmarks.push(event.bookmark);
+const updateNotificationStatusFromActivityMarked = (event, currentNotificationStatus, aggregatedActivities = []) => {
+    if (!currentNotificationStatus) {
+        return {
+            changed: false,
+        };
     }
-    return {
-        ...activity,
-        own_bookmarks: ownBookmarks,
-        changed: true,
+    const newState = {
+        ...currentNotificationStatus,
     };
-};
-const addBookmarkToActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = addBookmarkToActivity(event, activity, isCurrentUser);
-    return updateActivityInState(updatedActivity, activities, true);
-};
-function handleBookmarkAdded(event) {
-    const currentActivities = this.currentState.activities;
-    const { connected_user: connectedUser } = this.client.state.getLatestValue();
-    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-    const result = addBookmarkToActivities(event, currentActivities, isCurrentUser);
-    if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
+    if (event.mark_all_read) {
+        const allGroupIds = aggregatedActivities.map((activity) => activity.group);
+        newState.read_activities = [
+            ...new Set([
+                ...(currentNotificationStatus.read_activities ?? []),
+                ...allGroupIds,
+            ]),
+        ];
     }
-}
-
-// Helper function to check if two bookmarks are the same
-// A bookmark is identified by activity_id + folder_id + user_id
-const isSameBookmark = (bookmark1, bookmark2) => {
-    return (bookmark1.user.id === bookmark2.user.id &&
-        bookmark1.activity.id === bookmark2.activity.id &&
-        bookmark1.folder?.id === bookmark2.folder?.id);
-};
-const removeBookmarkFromActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
+    if (event.mark_read && event.mark_read.length > 0) {
+        newState.read_activities = [
+            ...new Set([
+                ...(currentNotificationStatus?.read_activities ?? []),
+                ...event.mark_read,
+            ]),
+        ];
     }
-    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
+    if (event.mark_all_seen) {
+        newState.last_seen_at = new Date();
     }
-    const activity = activities[activityIndex];
-    const updatedActivity = removeBookmarkFromActivity(event, activity, isCurrentUser);
-    return updateActivityInState(updatedActivity, activities, true);
-};
-const removeBookmarkFromActivity = (event, activity, isCurrentUser) => {
-    // Update own_bookmarks if the bookmark is from the current user
-    const ownBookmarks = isCurrentUser
-        ? (activity.own_bookmarks || []).filter((bookmark) => !isSameBookmark(bookmark, event.bookmark))
-        : activity.own_bookmarks;
     return {
-        ...activity,
-        own_bookmarks: ownBookmarks,
         changed: true,
+        data: { notification_status: newState },
     };
 };
-function handleBookmarkDeleted(event) {
-    const currentActivities = this.currentState.activities;
-    const { connected_user: connectedUser } = this.client.state.getLatestValue();
-    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-    const result = removeBookmarkFromActivities(event, currentActivities, isCurrentUser);
+function handleActivityMarked(event) {
+    const result = updateNotificationStatusFromActivityMarked(event, this.currentState.notification_status, this.currentState.aggregated_activities);
     if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
+        this.state.partialNext({
+            notification_status: result.data?.notification_status,
+        });
     }
 }
 
-const updateBookmarkInActivity = (event, activity, isCurrentUser) => {
-    // Update own_bookmarks if the bookmark is from the current user
-    let ownBookmarks = activity.own_bookmarks || [];
-    if (isCurrentUser) {
-        const bookmarkIndex = ownBookmarks.findIndex((bookmark) => isSameBookmark(bookmark, event.bookmark));
-        if (bookmarkIndex !== -1) {
-            ownBookmarks = [...ownBookmarks];
-            ownBookmarks[bookmarkIndex] = event.bookmark;
-        }
+function handleFeedUpdated(event) {
+    this.state.partialNext({ ...event.feed });
+}
+
+const updateNotificationFeedFromEvent = (event) => {
+    const updates = {};
+    if (event.notification_status) {
+        updates.notification_status = event.notification_status;
     }
-    return {
-        ...activity,
-        own_bookmarks: ownBookmarks,
-        changed: true,
-    };
-};
-const updateBookmarkInActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
+    if (event.aggregated_activities) {
+        updates.aggregated_activities = event.aggregated_activities;
     }
-    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
+    // Only return changed if we have actual updates
+    if (Object.keys(updates).length > 0) {
+        return {
+            changed: true,
+            data: updates,
+        };
     }
-    const activity = activities[activityIndex];
-    const updatedActivity = updateBookmarkInActivity(event, activity, isCurrentUser);
-    return updateActivityInState(updatedActivity, activities, true);
+    return {
+        changed: false,
+    };
 };
-function handleBookmarkUpdated(event) {
-    const currentActivities = this.currentState.activities;
-    const { connected_user: connectedUser } = this.client.state.getLatestValue();
-    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-    const result = updateBookmarkInActivities(event, currentActivities, isCurrentUser);
+function handleNotificationFeedUpdated(event) {
+    const result = updateNotificationFeedFromEvent(event);
     if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
+        this.state.partialNext({
+            notification_status: result.data?.notification_status,
+            aggregated_activities: result.data?.aggregated_activities,
+        });
     }
 }
 
-function handleFeedUpdated(event) {
-    this.state.partialNext({ ...event.feed });
-}
-
-function handleNotificationFeedUpdated(event) {
-    console.info('notification feed updated', event);
-    // TODO: handle notification feed updates
-}
-
 function handleWatchStarted() {
     this.state.partialNext({ watch: true });
 }
@@ -4976,7 +5210,7 @@ class Feed extends FeedApi {
             'feeds.poll.vote_removed': Feed.noop,
             'feeds.activity.pinned': Feed.noop,
             'feeds.activity.unpinned': Feed.noop,
-            'feeds.activity.marked': Feed.noop,
+            'feeds.activity.marked': handleActivityMarked.bind(this),
             'moderation.custom_action': Feed.noop,
             'moderation.flagged': Feed.noop,
             'moderation.mark_reviewed': Feed.noop,
@@ -5848,10 +6082,10 @@ const useFeedsClient = () => {
  */
 const useClientConnectedUser = () => {
     const client = useFeedsClient();
-    const { user } = useStateStore(client?.state, selector$a) ?? {};
+    const { user } = useStateStore(client?.state, selector$c) ?? {};
     return user;
 };
-const selector$a = (nextState) => ({
+const selector$c = (nextState) => ({
     user: nextState.connected_user,
 });
 
@@ -5860,10 +6094,10 @@ const selector$a = (nextState) => ({
  */
 const useWsConnectionState = () => {
     const client = useFeedsClient();
-    const { is_healthy } = useStateStore(client?.state, selector$9) ?? {};
+    const { is_healthy } = useStateStore(client?.state, selector$b) ?? {};
     return { is_healthy };
 };
-const selector$9 = (nextState) => ({
+const selector$b = (nextState) => ({
     is_healthy: nextState.is_ws_connection_healthy,
 });
 
@@ -5913,7 +6147,7 @@ const useStableCallback = (callback) => {
 const useFeedActivities = (feedFromProps) => {
     const feedFromContext = useFeedContext();
     const feed = feedFromProps ?? feedFromContext;
-    const data = useStateStore(feed?.state, selector$8);
+    const data = useStateStore(feed?.state, selector$a);
     const loadNextPage = useStableCallback(async () => {
         if (!feed || !data?.has_next_page || data?.is_loading) {
             return;
@@ -5922,7 +6156,7 @@ const useFeedActivities = (feedFromProps) => {
     });
     return react.useMemo(() => ({ ...data, loadNextPage }), [data, loadNextPage]);
 };
-const selector$8 = ({ is_loading_activities, next, activities = [] }) => ({
+const selector$a = ({ is_loading_activities, next, activities = [] }) => ({
     is_loading: is_loading_activities,
     has_next_page: typeof next !== 'undefined',
     activities,
@@ -5995,13 +6229,13 @@ const FeedOwnCapability = {
 };
 
 const stableEmptyArray = [];
-const selector$7 = (currentState) => ({
+const selector$9 = (currentState) => ({
     oc: currentState.own_capabilities ?? stableEmptyArray,
 });
 const useOwnCapabilities = (feedFromProps) => {
     const feedFromContext = useFeedContext();
     const feed = feedFromProps ?? feedFromContext;
-    const { oc = stableEmptyArray } = useStateStore(feed?.state, selector$7) ?? {};
+    const { oc = stableEmptyArray } = useStateStore(feed?.state, selector$9) ?? {};
     return react.useMemo(() => ({
         can_add_activity: oc.indexOf(FeedOwnCapability.ADD_ACTIVITY) > -1,
         can_add_activity_reaction: oc.indexOf(FeedOwnCapability.ADD_ACTIVITY_REACTION) > -1,
@@ -6036,7 +6270,7 @@ const useOwnCapabilities = (feedFromProps) => {
     }), [oc]);
 };
 
-const selector$6 = ({ follower_count, followers, followers_pagination, }) => ({
+const selector$8 = ({ follower_count, followers, followers_pagination, }) => ({
     follower_count,
     followers,
     followers_pagination,
@@ -6044,7 +6278,7 @@ const selector$6 = ({ follower_count, followers, followers_pagination, }) => ({
 function useFollowers(feedFromProps) {
     const feedFromContext = useFeedContext();
     const feed = feedFromProps ?? feedFromContext;
-    const data = useStateStore(feed?.state, selector$6);
+    const data = useStateStore(feed?.state, selector$8);
     const loadNextPage = react.useCallback((...options) => feed?.loadNextPageFollowers(...options), [feed]);
     return react.useMemo(() => {
         if (!data) {
@@ -6059,7 +6293,7 @@ function useFollowers(feedFromProps) {
     }, [data, loadNextPage]);
 }
 
-const selector$5 = ({ following_count, following, following_pagination, }) => ({
+const selector$7 = ({ following_count, following, following_pagination, }) => ({
     following_count,
     following,
     following_pagination,
@@ -6067,7 +6301,7 @@ const selector$5 = ({ following_count, following, following_pagination, }) => ({
 function useFollowing(feedFromProps) {
     const feedFromContext = useFeedContext();
     const feed = feedFromProps ?? feedFromContext;
-    const data = useStateStore(feed?.state, selector$5);
+    const data = useStateStore(feed?.state, selector$7);
     const loadNextPage = react.useCallback((...options) => feed?.loadNextPageFollowing(...options), [feed]);
     return react.useMemo(() => {
         if (!data) {
@@ -6089,9 +6323,9 @@ function useFollowing(feedFromProps) {
 const useFeedMetadata = (feedFromProps) => {
     const feedFromContext = useFeedContext();
     const feed = feedFromProps ?? feedFromContext;
-    return useStateStore(feed?.state, selector$4);
+    return useStateStore(feed?.state, selector$6);
 };
-const selector$4 = ({ follower_count = 0, following_count = 0, created_by, created_at, updated_at, }) => ({
+const selector$6 = ({ follower_count = 0, following_count = 0, created_by, created_at, updated_at, }) => ({
     created_by,
     follower_count,
     following_count,
@@ -6106,12 +6340,57 @@ const selector$4 = ({ follower_count = 0, following_count = 0, created_by, creat
 const useOwnFollows = (feedFromProps) => {
     const feedFromContext = useFeedContext();
     const feed = feedFromProps ?? feedFromContext;
-    return useStateStore(feed?.state, selector$3);
+    return useStateStore(feed?.state, selector$5);
 };
-const selector$3 = ({ own_follows }) => ({
+const selector$5 = ({ own_follows }) => ({
     own_follows,
 });
 
+const selector$4 = ({ notification_status }) => ({
+    unread: notification_status?.unread ?? 0,
+    unseen: notification_status?.unseen ?? 0,
+    last_read_at: notification_status?.last_read_at,
+    last_seen_at: notification_status?.last_seen_at,
+    read_activities: notification_status?.read_activities,
+    seen_activities: notification_status?.seen_activities,
+});
+function useNotificationStatus(feedFromProps) {
+    const feedFromContext = useFeedContext();
+    const feed = feedFromProps ?? feedFromContext;
+    return useStateStore(feed?.state, selector$4);
+}
+
+const selector$3 = ({ aggregated_activities }) => ({
+    aggregated_activities,
+});
+function useAggregatedActivities(feedFromProps) {
+    const feedFromContext = useFeedContext();
+    const feed = feedFromProps ?? feedFromContext;
+    return useStateStore(feed?.state, selector$3);
+}
+
+const useIsAggregatedActivityRead = ({ feed: feedFromProps, aggregatedActivity, }) => {
+    const feedFromContext = useFeedContext();
+    const feed = feedFromProps ?? feedFromContext;
+    const { read_activities: readActivities, /* last_read_at: lastReadAt */ } = useNotificationStatus(feed) ?? {};
+    const group = aggregatedActivity.group;
+    return react.useMemo(() => 
+    // FIXME: This part of the condition does not work as marking individual groups as read also updates the last_read_at. Should be uncommented once it's fixed on the backend.
+    // (lastReadAt &&
+    //   aggregatedActivity.updated_at.getTime() <= lastReadAt.getTime()) ||
+    (readActivities ?? []).includes(group), [readActivities, group]);
+};
+
+const useIsAggregatedActivitySeen = ({ feed: feedFromProps, aggregatedActivity, }) => {
+    const feedFromContext = useFeedContext();
+    const feed = feedFromProps ?? feedFromContext;
+    const { seen_activities: seenActivities, last_seen_at: lastSeenAt } = useNotificationStatus(feed) ?? {};
+    const group = aggregatedActivity.group;
+    return react.useMemo(() => (lastSeenAt &&
+        aggregatedActivity.updated_at.getTime() < lastSeenAt.getTime()) ||
+        (seenActivities ?? []).includes(group), [lastSeenAt, aggregatedActivity.updated_at, seenActivities, group]);
+};
+
 const StreamSearchResultsContext = react.createContext(undefined);
 /**
  * Hook to access the nearest SearchSource instance.
@@ -6228,7 +6507,7 @@ const StreamFeeds = ({ client, children }) => {
 };
 StreamFeeds.displayName = 'StreamFeeds';
 
-const StreamFeed = ({ feed, children }) => {
+const StreamFeed = ({ feed, children, }) => {
     return (jsxRuntime.jsx(StreamFeedContext.Provider, { value: feed, children: children }));
 };
 StreamFeed.displayName = 'StreamFeed';
@@ -6251,6 +6530,7 @@ exports.StreamSearch = StreamSearch;
 exports.StreamSearchContext = StreamSearchContext;
 exports.StreamSearchResults = StreamSearchResults;
 exports.StreamSearchResultsContext = StreamSearchResultsContext;
+exports.useAggregatedActivities = useAggregatedActivities;
 exports.useBookmarkActions = useBookmarkActions;
 exports.useClientConnectedUser = useClientConnectedUser;
 exports.useComments = useComments;
@@ -6261,6 +6541,9 @@ exports.useFeedMetadata = useFeedMetadata;
 exports.useFeedsClient = useFeedsClient;
 exports.useFollowers = useFollowers;
 exports.useFollowing = useFollowing;
+exports.useIsAggregatedActivityRead = useIsAggregatedActivityRead;
+exports.useIsAggregatedActivitySeen = useIsAggregatedActivitySeen;
+exports.useNotificationStatus = useNotificationStatus;
 exports.useOwnCapabilities = useOwnCapabilities;
 exports.useOwnFollows = useOwnFollows;
 exports.useReactionActions = useReactionActions;