@stream-io/feeds-client 0.2.0 → 0.2.2

package/dist/index.browser.cjs

@@ -4,7 +4,7 @@ var axios = require('axios');
 
 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) => {
@@ -340,6 +340,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 },
@@ -617,6 +618,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);
 };
@@ -789,6 +791,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 },
@@ -3820,6 +3829,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,
@@ -4303,6 +4313,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') {
@@ -4493,20 +4520,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,
@@ -4638,6 +4674,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) {
@@ -4682,7 +4891,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);
@@ -4692,13 +4902,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,
+        });
     }
 }
 
@@ -4712,233 +4937,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 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 activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    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 });
 }
@@ -4991,7 +5225,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,
@@ -6238,4 +6472,5 @@ exports.isVideoFile = isVideoFile;
 exports.isVoteAnswer = isVoteAnswer;
 exports.shouldUpdateState = shouldUpdateState;
 exports.uniqueArrayMerge = uniqueArrayMerge;
+exports.updateEntityInArray = updateEntityInArray;
 //# sourceMappingURL=index.browser.cjs.map