@stream-io/feeds-client 1.0.0 → 1.1.0

package/dist/{feeds-client-tw63OGrd.js → feeds-client-C1c6lcS3.js}

@@ -1141,6 +1141,12 @@ decoders.QueryBookmarksResponse = (input) => {
   };
   return decode(typeMappings, input);
 };
+decoders.QueryCollectionsResponse = (input) => {
+  const typeMappings = {
+    collections: { type: "CollectionResponse", isSingle: false }
+  };
+  return decode(typeMappings, input);
+};
 decoders.QueryCommentReactionsResponse = (input) => {
   const typeMappings = {
     reactions: { type: "FeedsReactionResponse", isSingle: false }
@@ -1715,6 +1721,21 @@ class FeedsApi {
     decoders.DeleteActivitiesResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
+  async trackActivityMetrics(request) {
+    const body = {
+      events: request?.events
+    };
+    const response = await this.apiClient.sendRequest(
+      "POST",
+      "/api/v2/feeds/activities/metrics/track",
+      void 0,
+      void 0,
+      body,
+      "application/json"
+    );
+    decoders.TrackActivityMetricsResponse?.(response.body);
+    return { ...response.body, metadata: response.metadata };
+  }
   async queryActivities(request) {
     const body = {
       enrich_own_fields: request?.enrich_own_fields,
@@ -2127,6 +2148,25 @@ class FeedsApi {
     decoders.CreateCollectionsResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
+  async queryCollections(request) {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter
+    };
+    const response = await this.apiClient.sendRequest(
+      "POST",
+      "/api/v2/feeds/collections/query",
+      void 0,
+      void 0,
+      body,
+      "application/json"
+    );
+    decoders.QueryCollectionsResponse?.(response.body);
+    return { ...response.body, metadata: response.metadata };
+  }
   async getComments(request) {
     const queryParams = {
       object_id: request?.object_id,
@@ -2186,6 +2226,7 @@ class FeedsApi {
   async queryComments(request) {
     const body = {
       filter: request?.filter,
+      id_around: request?.id_around,
       limit: request?.limit,
       next: request?.next,
       prev: request?.prev,
@@ -3217,15 +3258,26 @@ class FeedsApi {
     decoders.UpdateUserGroupResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
-  async removeUserGroupMembers(request) {
+  async addUserGroupMembers(request) {
     const pathParams = {
       id: request?.id
     };
-    const response = await this.apiClient.sendRequest("DELETE", "/api/v2/usergroups/{id}/members", pathParams, void 0);
-    decoders.RemoveUserGroupMembersResponse?.(response.body);
+    const body = {
+      member_ids: request?.member_ids,
+      team_id: request?.team_id
+    };
+    const response = await this.apiClient.sendRequest(
+      "POST",
+      "/api/v2/usergroups/{id}/members",
+      pathParams,
+      void 0,
+      body,
+      "application/json"
+    );
+    decoders.AddUserGroupMembersResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
-  async addUserGroupMembers(request) {
+  async removeUserGroupMembers(request) {
     const pathParams = {
       id: request?.id
     };
@@ -3235,13 +3287,13 @@ class FeedsApi {
     };
     const response = await this.apiClient.sendRequest(
       "POST",
-      "/api/v2/usergroups/{id}/members",
+      "/api/v2/usergroups/{id}/members/delete",
       pathParams,
       void 0,
       body,
       "application/json"
     );
-    decoders.AddUserGroupMembersResponse?.(response.body);
+    decoders.RemoveUserGroupMembersResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
   async queryUsers(request) {
@@ -4129,7 +4181,7 @@ const getRateLimitFromResponseHeader = (response_headers) => {
   };
   return result;
 };
-const version = "1.0.0";
+const version = "1.1.0";
 const axios = axiosImport.default ?? axiosImport;
 class ApiClient {
   constructor(apiKey, tokenManager, connectionIdManager, options) {
@@ -4945,7 +4997,7 @@ const uniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
   });
   return existingArray.concat(filteredArrayToMerge);
 };
-const replaceUniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
+const replaceUniqueArrayMerge = (existingArray, arrayToMerge, getKey, position) => {
   const existingMap = /* @__PURE__ */ new Map();
   (existingArray ?? []).forEach((item) => {
     existingMap.set(getKey(item), item);
@@ -4961,9 +5013,14 @@ const replaceUniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
       existingMap.delete(getKey(originalItem));
     }
   });
-  existingMap.forEach((item) => {
-    result.push(item);
-  });
+  const newItemsInOrder = arrayToMerge.filter(
+    (item) => existingMap.has(getKey(item))
+  );
+  if (position === "end") {
+    newItemsInOrder.forEach((item) => result.push(item));
+  } else {
+    result.unshift(...newItemsInOrder);
+  }
   return result;
 };
 const Constants = {
@@ -5010,24 +5067,25 @@ function getStateUpdateQueueId(...args) {
   const [data, prefix] = args;
   const toJoin = [prefix];
   switch (prefix) {
+    case "activity-deleted": {
+      return toJoin.concat([data.activity.id]).join("-");
+    }
+    case "activity-pinned":
+    case "activity-unpinned": {
+      return toJoin.concat([data.pinned_activity.activity.id]).join("-");
+    }
     case "activity-updated": {
       return toJoin.concat([data.activity.id]).join("-");
     }
     case "activity-reaction-created":
     case "activity-reaction-deleted":
     case "activity-reaction-updated": {
-      return toJoin.concat([
-        data.activity.id,
-        data.reaction.type
-      ]).join("-");
+      return toJoin.concat([data.activity.id, data.reaction.type]).join("-");
     }
     case "comment-reaction-created":
     case "comment-reaction-deleted":
     case "comment-reaction-updated": {
-      return toJoin.concat([
-        data.comment.id,
-        data.reaction.type
-      ]).join("-");
+      return toJoin.concat([data.comment.id, data.reaction.type]).join("-");
     }
     case "comment-created":
     case "comment-deleted":
@@ -5039,6 +5097,13 @@ function getStateUpdateQueueId(...args) {
     case "follow-updated": {
       return toJoin.concat([data.source_feed.feed, data.target_feed.feed]).join("-");
     }
+    case "feed-member-added":
+    case "feed-member-updated": {
+      return toJoin.concat([data.member.user.id]).join("-");
+    }
+    case "feed-member-removed": {
+      return toJoin.concat([data.member_id]).join("-");
+    }
     default: {
       ensureExhausted(data, "Encountered unknown state update queue prefix.");
     }
@@ -5207,7 +5272,12 @@ function handleFollowUpdated(eventOrResponse, fromWs) {
       newState ?? (newState = {
         ...currentState,
         // Update FeedResponse fields, that has the new follower/following count
-        ...follow.source_feed
+        ...follow.source_feed,
+        ...follow.source_feed.own_capabilities !== void 0 ? {
+          own_capabilities: follow.source_feed.own_capabilities,
+          own_follows: follow.source_feed.own_follows,
+          own_followings: follow.source_feed.own_followings
+        } : {}
       });
       const index = currentState.following?.findIndex(
         (f) => f.target_feed.feed === follow.target_feed.feed
@@ -5224,7 +5294,12 @@ function handleFollowUpdated(eventOrResponse, fromWs) {
       newState ?? (newState = {
         ...currentState,
         // Update FeedResponse fields, that has the new follower/following count
-        ...follow.target_feed
+        ...follow.target_feed,
+        ...follow.target_feed.own_capabilities !== void 0 ? {
+          own_capabilities: follow.target_feed.own_capabilities,
+          own_follows: follow.target_feed.own_follows,
+          own_followings: follow.target_feed.own_followings
+        } : {}
       });
       if (source.created_by.id === connectedUserId && currentState.own_follows) {
         const index2 = currentState.own_follows.findIndex(
@@ -5519,7 +5594,19 @@ function handleCommentReactionUpdated(payload, fromWs) {
     };
   });
 }
-function handleFeedMemberAdded(event) {
+function handleFeedMemberAdded(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "feed-member-added"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   this.state.next((currentState) => {
     let newState;
@@ -5538,7 +5625,19 @@ function handleFeedMemberAdded(event) {
     return newState ?? currentState;
   });
 }
-function handleFeedMemberUpdated(event) {
+function handleFeedMemberUpdated(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "feed-member-updated"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   this.state.next((currentState) => {
     const memberIndex = currentState.members?.findIndex(
@@ -5562,7 +5661,19 @@ function handleFeedMemberUpdated(event) {
     return newState ?? currentState;
   });
 }
-function handleFeedMemberRemoved(event) {
+function handleFeedMemberRemoved(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "feed-member-removed"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   this.state.next((currentState) => {
     let newState;
@@ -5582,6 +5693,9 @@ function handleFeedMemberRemoved(event) {
     return newState ?? currentState;
   });
 }
+const isSameBookmark = (bookmark1, bookmark2) => {
+  return bookmark1.user.id === bookmark2.user.id && bookmark1.activity.id === bookmark2.activity.id && bookmark1.folder?.id === bookmark2.folder?.id && bookmark1.updated_at.getTime() === bookmark2.updated_at.getTime();
+};
 const sharedUpdateActivity$6 = ({
   currentActivity,
   event,
@@ -5589,7 +5703,9 @@ const sharedUpdateActivity$6 = ({
 }) => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
   if (eventBelongsToCurrentUser) {
-    newOwnBookmarks = [...newOwnBookmarks, event.bookmark];
+    newOwnBookmarks = currentActivity.own_bookmarks.filter(
+      (bookmark) => !isSameBookmark(bookmark, event.bookmark)
+    );
   }
   return {
     ...currentActivity,
@@ -5597,18 +5713,20 @@ const sharedUpdateActivity$6 = ({
     own_bookmarks: newOwnBookmarks
   };
 };
-const addBookmarkToActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+const removeBookmarkFromActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: activities,
-  matcher: (activity) => activity.id === event.bookmark.activity.id,
+  matcher: (activity) => activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
   updater: (matchedActivity) => sharedUpdateActivity$6({
     currentActivity: matchedActivity,
     event,
     eventBelongsToCurrentUser
   })
 });
-const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: pinnedActivities,
-  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || pinnedActivity.activity.own_bookmarks.some(
+    (b) => isSameBookmark(b, event.bookmark)
+  )),
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$6({
       currentActivity: matchedPinnedActivity.activity,
@@ -5624,7 +5742,7 @@ const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCu
     };
   }
 });
-function handleBookmarkAdded(event) {
+function handleBookmarkDeleted(event) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5632,12 +5750,12 @@ function handleBookmarkAdded(event) {
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
   const [result1, result2] = [
-    addBookmarkToActivities(
+    removeBookmarkFromActivities(
       event,
       currentActivities,
       eventBelongsToCurrentUser
     ),
-    addBookmarkToPinnedActivities(
+    removeBookmarkFromPinnedActivities(
       event,
       currentPinnedActivities,
       eventBelongsToCurrentUser
@@ -5650,9 +5768,6 @@ function handleBookmarkAdded(event) {
     });
   }
 }
-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$5 = ({
   currentActivity,
   event,
@@ -5660,9 +5775,7 @@ const sharedUpdateActivity$5 = ({
 }) => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
   if (eventBelongsToCurrentUser) {
-    newOwnBookmarks = currentActivity.own_bookmarks.filter(
-      (bookmark) => !isSameBookmark(bookmark, event.bookmark)
-    );
+    newOwnBookmarks = [...newOwnBookmarks, event.bookmark];
   }
   return {
     ...currentActivity,
@@ -5670,18 +5783,20 @@ const sharedUpdateActivity$5 = ({
     own_bookmarks: newOwnBookmarks
   };
 };
-const removeBookmarkFromActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+const addBookmarkToActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: activities,
-  matcher: (activity) => activity.id === event.bookmark.activity.id,
+  matcher: (activity) => activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
   updater: (matchedActivity) => sharedUpdateActivity$5({
     currentActivity: matchedActivity,
     event,
     eventBelongsToCurrentUser
   })
 });
-const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: pinnedActivities,
-  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !pinnedActivity.activity.own_bookmarks.some(
+    (b) => isSameBookmark(b, event.bookmark)
+  )),
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$5({
       currentActivity: matchedPinnedActivity.activity,
@@ -5697,7 +5812,7 @@ const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelong
     };
   }
 });
-function handleBookmarkDeleted(event) {
+function handleBookmarkAdded(event) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5705,12 +5820,12 @@ function handleBookmarkDeleted(event) {
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
   const [result1, result2] = [
-    removeBookmarkFromActivities(
+    addBookmarkToActivities(
       event,
       currentActivities,
       eventBelongsToCurrentUser
     ),
-    removeBookmarkFromPinnedActivities(
+    addBookmarkToPinnedActivities(
       event,
       currentPinnedActivities,
       eventBelongsToCurrentUser
@@ -5731,7 +5846,7 @@ const sharedUpdateActivity$4 = ({
   let newOwnBookmarks = currentActivity.own_bookmarks;
   if (eventBelongsToCurrentUser) {
     const bookmarkIndex = newOwnBookmarks.findIndex(
-      (bookmark) => isSameBookmark(bookmark, event.bookmark)
+      (bookmark) => bookmark.user.id === event.bookmark.user.id && bookmark.activity.id === event.bookmark.activity.id && bookmark.folder?.id === event.bookmark.folder?.id
     );
     if (bookmarkIndex !== -1) {
       newOwnBookmarks = [...newOwnBookmarks];
@@ -5746,7 +5861,7 @@ const sharedUpdateActivity$4 = ({
 };
 const updateBookmarkInActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: activities,
-  matcher: (activity) => activity.id === event.bookmark.activity.id,
+  matcher: (activity) => activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
   updater: (matchedActivity) => sharedUpdateActivity$4({
     currentActivity: matchedActivity,
     event,
@@ -5755,7 +5870,9 @@ const updateBookmarkInActivities = (event, activities, eventBelongsToCurrentUser
 });
 const updateBookmarkInPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: pinnedActivities,
-  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !pinnedActivity.activity.own_bookmarks.some(
+    (b) => isSameBookmark(b, event.bookmark)
+  )),
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$4({
       currentActivity: matchedPinnedActivity.activity,
@@ -5882,7 +5999,19 @@ const removePinnedActivityFromState = (activityResponse, pinnedActivities) => {
     return { changed: false, pinned_activities: pinnedActivities };
   }
 };
-function handleActivityDeleted(event) {
+function handleActivityDeleted(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "activity-deleted"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -6228,53 +6357,133 @@ function handleActivityReactionUpdated(payload, fromWs) {
     });
   }
 }
-const updateNotificationStatusFromActivityMarked = (event, currentNotificationStatus, aggregatedActivities = []) => {
-  if (!currentNotificationStatus) {
-    return {
-      changed: false
-    };
-  }
-  const newState = {
-    ...currentNotificationStatus
-  };
-  if (event.mark_all_read) {
-    const allGroupIds = aggregatedActivities.map((activity) => activity.group);
-    newState.read_activities = [
-      .../* @__PURE__ */ new Set([
-        ...currentNotificationStatus.read_activities ?? [],
-        ...allGroupIds
-      ])
-    ];
+function handleActivityPinned(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "activity-pinned"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
   }
-  if (event.mark_read && event.mark_read.length > 0) {
-    newState.read_activities = [
-      .../* @__PURE__ */ new Set([
-        ...currentNotificationStatus?.read_activities ?? [],
-        ...event.mark_read
-      ])
-    ];
+  this.state.next((currentState) => {
+    const newState = {
+      ...currentState
+    };
+    const pinnedActivity = {
+      ...event.pinned_activity,
+      user: event.user,
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    newState.pinned_activities = currentState.pinned_activities ? [pinnedActivity, ...currentState.pinned_activities] : [pinnedActivity];
+    return newState;
+  });
+}
+function handleActivityUnpinned(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "activity-unpinned"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
   }
-  if (event.mark_all_seen) {
-    newState.last_seen_at = /* @__PURE__ */ new Date();
+  this.state.next((currentState) => {
+    let newState;
+    const index = currentState.pinned_activities?.findIndex(
+      (pinnedActivity) => pinnedActivity.activity.id === event.pinned_activity.activity.id
+    ) ?? -1;
+    if (index >= 0) {
+      newState ?? (newState = {
+        ...currentState
+      });
+      const newPinnedActivities = [...currentState.pinned_activities];
+      newPinnedActivities.splice(index, 1);
+      newState.pinned_activities = newPinnedActivities;
+    }
+    return newState ?? currentState;
+  });
+}
+const isPin = (entity) => {
+  return "activity" in entity;
+};
+const updateActivityFromFeedback = (feedback, activities) => {
+  if (!activities) {
+    return {
+      changed: false,
+      entities: []
+    };
   }
-  return {
-    changed: true,
-    data: { notification_status: newState }
-  };
+  return updateEntityInArray({
+    entities: activities,
+    matcher: (e) => {
+      const newHidden = feedback.value === "true";
+      if (isPin(e)) {
+        return e.activity.id === feedback.activity_id && e.activity.hidden !== newHidden;
+      }
+      return e.id === feedback.activity_id && e.hidden !== newHidden;
+    },
+    updater: (e) => {
+      if (isPin(e)) {
+        return {
+          ...e,
+          activity: {
+            ...e.activity,
+            hidden: feedback.value === "true"
+          }
+        };
+      } else {
+        return {
+          ...e,
+          hidden: feedback.value === "true"
+        };
+      }
+    }
+  });
 };
-function handleActivityMarked(event) {
-  const result = updateNotificationStatusFromActivityMarked(
-    event,
-    this.currentState.notification_status,
-    this.currentState.aggregated_activities
-  );
-  if (result.changed) {
+function handleActivityFeedback(event) {
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities
+  } = this.currentState;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const eventBelongsToCurrentUser = event.activity_feedback.user.id === connectedUser?.id;
+  if (!eventBelongsToCurrentUser || event.activity_feedback.action !== "hide") {
+    return;
+  }
+  const [result1, result2] = [
+    updateActivityFromFeedback(event.activity_feedback, currentActivities),
+    updateActivityFromFeedback(
+      event.activity_feedback,
+      currentPinnedActivities
+    )
+  ];
+  if (result1.changed || result2.changed) {
     this.state.partialNext({
-      notification_status: result.data?.notification_status
+      activities: result1.entities,
+      pinned_activities: result2.entities
     });
   }
 }
+function handleFeedDeleted(event) {
+  if (this.currentState.deleted_at) {
+    return;
+  }
+  this.state.partialNext({ deleted_at: event.created_at });
+}
 function handleFeedUpdated(event) {
+  const currentUpdatedAt = this.currentState.updated_at;
+  if (currentUpdatedAt && event.feed.updated_at && currentUpdatedAt.getTime() >= event.feed.updated_at.getTime()) {
+    return;
+  }
   this.state.partialNext({ ...event.feed });
 }
 const addAggregatedActivitiesToState = (newAggregatedActivities, aggregatedActivities, position) => {
@@ -6323,11 +6532,20 @@ const addAggregatedActivitiesToState = (newAggregatedActivities, aggregatedActiv
           (a) => a.group
         );
         break;
-      case "replace":
+      case "replace-then-end":
         result.aggregated_activities = replaceUniqueArrayMerge(
           aggregatedActivities ?? [],
           newAggregatedActivities,
-          (a) => a.group
+          (a) => a.group,
+          "end"
+        );
+        break;
+      case "replace-then-start":
+        result.aggregated_activities = replaceUniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+          "start"
         );
         break;
     }
@@ -6354,7 +6572,7 @@ const updateNotificationStatus = (newNotificationStatus, currentNotificationStat
     };
   }
 };
-const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, currentNotificationStatus) => {
+const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, currentNotificationStatus, currentActivities) => {
   const updates = {};
   if (event.notification_status) {
     const notificationStatusResult = updateNotificationStatus(
@@ -6365,11 +6583,47 @@ const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, cur
       updates.notification_status = notificationStatusResult.notification_status;
     }
   }
+  const effectiveStatus = event.notification_status ?? currentNotificationStatus;
+  const lastReadAt = effectiveStatus?.last_read_at;
+  const lastSeenAt = effectiveStatus?.last_seen_at;
+  const readActivities = effectiveStatus?.read_activities ?? [];
+  const seenActivities = effectiveStatus?.seen_activities ?? [];
+  if (currentActivities?.length && !currentAggregatedActivities?.length && effectiveStatus) {
+    let anyChanged = false;
+    const updatedActivities = currentActivities.map((activity) => {
+      const isRead = lastReadAt != null && activity.updated_at.getTime() < lastReadAt.getTime() || readActivities.includes(activity.id);
+      const isSeen = lastSeenAt != null && activity.updated_at.getTime() < lastSeenAt.getTime() || seenActivities.includes(activity.id);
+      if (activity.is_read !== isRead || activity.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...activity, is_read: isRead, is_seen: isSeen };
+      }
+      return activity;
+    });
+    if (anyChanged) {
+      updates.activities = updatedActivities;
+    }
+  }
+  if (currentAggregatedActivities?.length && effectiveStatus) {
+    const baseAggregated = currentAggregatedActivities;
+    let anyChanged = false;
+    const updatedAggregated = baseAggregated.map((group) => {
+      const isRead = lastReadAt != null && group.updated_at.getTime() < lastReadAt.getTime() || readActivities.includes(group.group);
+      const isSeen = lastSeenAt != null && group.updated_at.getTime() < lastSeenAt.getTime() || seenActivities.includes(group.group);
+      if (group.is_read !== isRead || group.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...group, is_read: isRead, is_seen: isSeen };
+      }
+      return group;
+    });
+    if (anyChanged) {
+      updates.aggregated_activities = updatedAggregated;
+    }
+  }
   if (event.aggregated_activities && currentAggregatedActivities) {
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
-      currentAggregatedActivities,
-      "start"
+      updates.aggregated_activities ?? currentAggregatedActivities,
+      "replace-then-start"
     );
     if (aggregatedActivitiesResult.changed) {
       updates.aggregated_activities = aggregatedActivitiesResult.aggregated_activities;
@@ -6389,12 +6643,14 @@ function handleNotificationFeedUpdated(event) {
   const result = updateNotificationFeedFromEvent(
     event,
     this.currentState.aggregated_activities,
-    this.currentState.notification_status
+    this.currentState.notification_status,
+    this.currentState.activities
   );
   if (result.changed) {
     this.state.partialNext({
       notification_status: result.data?.notification_status,
-      aggregated_activities: result.data?.aggregated_activities
+      aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities ?? this.currentState.activities
     });
   }
 }
@@ -6444,7 +6700,7 @@ function updateStoriesFeedFromEvent(aggregatedActivities, activities, event) {
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
       aggregatedActivities,
-      "replace"
+      "replace-then-end"
     );
     if (aggregatedActivitiesResult.changed) {
       result.data.aggregated_activities = aggregatedActivitiesResult.aggregated_activities;
@@ -6538,61 +6794,6 @@ async function withRetry(fn, options = {}) {
   }
   throw lastError;
 }
-const isPin = (entity) => {
-  return "activity" in entity;
-};
-const updateActivityFromFeedback = (feedback, activities) => {
-  if (!activities) {
-    return {
-      changed: false,
-      entities: []
-    };
-  }
-  return updateEntityInArray({
-    entities: activities,
-    matcher: (e) => isPin(e) ? e.activity.id === feedback.activity_id : e.id === feedback.activity_id,
-    updater: (e) => {
-      if (isPin(e)) {
-        return {
-          ...e,
-          activity: {
-            ...e.activity,
-            hidden: feedback.value === "true"
-          }
-        };
-      } else {
-        return {
-          ...e,
-          hidden: feedback.value === "true"
-        };
-      }
-    }
-  });
-};
-function handleActivityFeedback(event) {
-  const {
-    activities: currentActivities,
-    pinned_activities: currentPinnedActivities
-  } = this.currentState;
-  const { connected_user: connectedUser } = this.client.state.getLatestValue();
-  const eventBelongsToCurrentUser = event.activity_feedback.user.id === connectedUser?.id;
-  if (!eventBelongsToCurrentUser || event.activity_feedback.action !== "hide") {
-    return;
-  }
-  const [result1, result2] = [
-    updateActivityFromFeedback(event.activity_feedback, currentActivities),
-    updateActivityFromFeedback(
-      event.activity_feedback,
-      currentPinnedActivities
-    )
-  ];
-  if (result1.changed || result2.changed) {
-    this.state.partialNext({
-      activities: result1.entities,
-      pinned_activities: result2.entities
-    });
-  }
-}
 const deepEqual = (x, y) => {
   if (x === y) {
     return true;
@@ -6719,7 +6920,7 @@ const _Feed = class _Feed extends FeedApi {
       "feeds.comment.deleted": handleCommentDeleted.bind(this),
       "feeds.comment.updated": handleCommentUpdated.bind(this),
       "feeds.feed.created": _Feed.noop,
-      "feeds.feed.deleted": _Feed.noop,
+      "feeds.feed.deleted": handleFeedDeleted.bind(this),
       "feeds.feed.updated": handleFeedUpdated.bind(this),
       "feeds.feed_group.changed": _Feed.noop,
       "feeds.feed_group.deleted": _Feed.noop,
@@ -6742,9 +6943,9 @@ const _Feed = class _Feed extends FeedApi {
       "feeds.poll.vote_casted": _Feed.noop,
       "feeds.poll.vote_changed": _Feed.noop,
       "feeds.poll.vote_removed": _Feed.noop,
-      "feeds.activity.pinned": _Feed.noop,
-      "feeds.activity.unpinned": _Feed.noop,
-      "feeds.activity.marked": handleActivityMarked.bind(this),
+      "feeds.activity.pinned": handleActivityPinned.bind(this),
+      "feeds.activity.unpinned": handleActivityUnpinned.bind(this),
+      "feeds.activity.marked": _Feed.noop,
       "moderation.custom_action": _Feed.noop,
       "moderation.flagged": _Feed.noop,
       "moderation.mark_reviewed": _Feed.noop,
@@ -7858,6 +8059,53 @@ class FeedsClient extends FeedsApi {
       }
       return response;
     };
+    this.updateActivityPartial = async (...args) => {
+      const response = await super.updateActivityPartial(...args);
+      for (const feed of this.allActiveFeeds) {
+        handleActivityUpdated.bind(feed)(response, false);
+      }
+      return response;
+    };
+    this.deleteActivity = async (...args) => {
+      const response = await super.deleteActivity(...args);
+      const activityId = args[0].id;
+      for (const feed of this.allActiveFeeds) {
+        handleActivityDeleted.bind(feed)(
+          { activity: { id: activityId } },
+          false
+        );
+      }
+      this.activeActivities = this.activeActivities.filter(
+        (activity) => activity.id !== activityId
+      );
+      return response;
+    };
+    this.activityFeedback = async (request) => {
+      const response = await super.activityFeedback(request);
+      if (request.hide !== void 0) {
+        const feedback = {
+          activity_id: request.activity_id,
+          value: request.hide ? "true" : "false"
+        };
+        for (const feed of this.allActiveFeeds) {
+          const {
+            activities: currentActivities,
+            pinned_activities: currentPinnedActivities
+          } = feed.currentState;
+          const [result1, result2] = [
+            updateActivityFromFeedback(feedback, currentActivities),
+            updateActivityFromFeedback(feedback, currentPinnedActivities)
+          ];
+          if (result1.changed || result2.changed) {
+            feed.state.partialNext({
+              activities: result1.entities,
+              pinned_activities: result2.entities
+            });
+          }
+        }
+      }
+      return response;
+    };
     this.addComment = async (request) => {
       const response = await super.addComment(request);
       const { comment } = response;
@@ -7943,6 +8191,121 @@ class FeedsClient extends FeedsApi {
       }
       return response;
     };
+    this.addBookmark = async (request) => {
+      const response = await super.addBookmark(request);
+      for (const feed of this.allActiveFeeds) {
+        handleBookmarkAdded.bind(feed)(response);
+      }
+      return response;
+    };
+    this.updateBookmark = async (request) => {
+      const response = await super.updateBookmark(request);
+      for (const feed of this.allActiveFeeds) {
+        handleBookmarkUpdated.bind(feed)(response);
+      }
+      return response;
+    };
+    this.deleteBookmark = async (request) => {
+      const response = await super.deleteBookmark(request);
+      for (const feed of this.allActiveFeeds) {
+        handleBookmarkDeleted.bind(feed)(response);
+      }
+      return response;
+    };
+    this.pinActivity = async (...args) => {
+      const response = await super.pinActivity(...args);
+      const feedIds = response.activity?.feeds ?? (response.feed ? [response.feed] : []);
+      for (const fid of feedIds) {
+        const feed = this.activeFeeds[fid];
+        if (feed) {
+          handleActivityPinned.bind(feed)(
+            { pinned_activity: response },
+            false
+          );
+        }
+      }
+      return response;
+    };
+    this.unpinActivity = async (...args) => {
+      const response = await super.unpinActivity(...args);
+      const feedIds = response.activity?.feeds ?? (response.feed ? [response.feed] : []);
+      for (const fid of feedIds) {
+        const feed = this.activeFeeds[fid];
+        if (feed) {
+          handleActivityUnpinned.bind(feed)(
+            {
+              pinned_activity: {
+                ...response,
+                created_at: /* @__PURE__ */ new Date()
+              }
+            },
+            false
+          );
+        }
+      }
+      return response;
+    };
+    this.updateFeed = async (...args) => {
+      const response = await super.updateFeed(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedUpdated.call(feed, { feed: response.feed });
+      }
+      return response;
+    };
+    this.deleteFeed = async (...args) => {
+      const response = await super.deleteFeed(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedDeleted.call(feed, {
+          created_at: /* @__PURE__ */ new Date()
+        });
+        if (!feed.currentState.watch) {
+          delete this.activeFeeds[fid];
+          this.activeActivities = this.activeActivities.filter(
+            (activity) => getFeed.call(activity)?.feed !== fid
+          );
+        }
+      }
+      return response;
+    };
+    this.updateFeedMembers = async (...args) => {
+      const response = await super.updateFeedMembers(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        for (const member of response.added) {
+          handleFeedMemberAdded.call(feed, { member }, false);
+        }
+        for (const member of response.updated) {
+          handleFeedMemberUpdated.call(feed, { member }, false);
+        }
+        for (const memberId of response.removed_ids) {
+          handleFeedMemberRemoved.call(feed, { member_id: memberId }, false);
+        }
+      }
+      return response;
+    };
+    this.acceptFeedMemberInvite = async (...args) => {
+      const response = await super.acceptFeedMemberInvite(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedMemberUpdated.call(feed, { member: response.member }, false);
+      }
+      return response;
+    };
+    this.rejectFeedMemberInvite = async (...args) => {
+      const response = await super.rejectFeedMemberInvite(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedMemberUpdated.call(feed, { member: response.member }, false);
+      }
+      return response;
+    };
     this.queryPollAnswers = async (request) => {
       const filter2 = request.filter ?? {};
       const queryPollAnswersFilter = {
@@ -8258,6 +8621,17 @@ class FeedsClient extends FeedsApi {
     });
     return response;
   }
+  async acceptFollow(...args) {
+    const response = await super.acceptFollow(...args);
+    [
+      response.follow.source_feed.feed,
+      response.follow.target_feed.feed
+    ].forEach((fid) => {
+      const feeds = this.findAllActiveFeedsByFid(fid);
+      feeds.forEach((f) => handleFollowUpdated.bind(f)(response, false));
+    });
+    return response;
+  }
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
   async follow(request) {
     const response = await super.follow(request);
@@ -8422,4 +8796,4 @@ exports.replaceUniqueArrayMerge = replaceUniqueArrayMerge;
 exports.shouldUpdateState = shouldUpdateState;
 exports.uniqueArrayMerge = uniqueArrayMerge;
 exports.updateEntityInArray = updateEntityInArray;
-//# sourceMappingURL=feeds-client-tw63OGrd.js.map
+//# sourceMappingURL=feeds-client-C1c6lcS3.js.map