@stream-io/feeds-client 0.3.32 → 0.3.34

package/dist/{feeds-client-BNhvggk2.mjs → feeds-client-C-2_fdH1.mjs}

@@ -3923,7 +3923,7 @@ const getRateLimitFromResponseHeader = (response_headers) => {
   };
   return result;
 };
-const version = "0.3.32";
+const version = "0.3.34";
 const axios = axiosImport.default ?? axiosImport;
 class ApiClient {
   constructor(apiKey, tokenManager, connectionIdManager, options) {
@@ -4785,7 +4785,6 @@ function updateEntityInArray({
   updatedEntities[index] = newEntity;
   return { changed: true, entities: updatedEntities };
 }
-const ownFeedFields = ["own_capabilities", "own_follows", "own_membership"];
 const updateStateFollowCreated = (follow, currentState, currentFeedId, connectedUserId) => {
   if (follow.status !== "accepted") {
     return { changed: false, data: currentState };
@@ -5536,10 +5535,6 @@ function handleActivityAdded(event) {
   if (result.changed) {
     const activity = event.activity;
     this.client.hydratePollCache([activity]);
-    const currentFeed = activity.current_feed;
-    if (currentFeed) {
-      this.client.hydrateCapabilitiesCache([currentFeed]);
-    }
     this.state.partialNext({ activities: result.activities });
   }
 }
@@ -5651,9 +5646,6 @@ function handleActivityUpdated(payload, fromWs) {
   ];
   if (result1?.changed || result2.changed) {
     this.client.hydratePollCache([payload.activity]);
-    if (payload.activity.current_feed) {
-      this.client.hydrateCapabilitiesCache([payload.activity.current_feed]);
-    }
     this.state.partialNext({
       activities: result1?.changed ? result1.entities : currentActivities,
       pinned_activities: result2.entities
@@ -6238,6 +6230,91 @@ const deepEqual = (x, y) => {
 function getOrCreateActiveFeed(...args) {
   return this.getOrCreateActiveFeed(...args);
 }
+const throttle = (fn, timeout = 200, {
+  leading = true,
+  trailing = false
+} = {}) => {
+  let timer = null;
+  let storedArgs = null;
+  let storedThis = null;
+  let lastInvokeTime;
+  const invoke = (args, thisArg) => {
+    lastInvokeTime = Date.now();
+    fn.apply(thisArg, args);
+  };
+  const scheduleTrailing = (delay) => {
+    if (timer) return;
+    timer = setTimeout(() => {
+      timer = null;
+      if (trailing && storedArgs) {
+        invoke(storedArgs, storedThis);
+        storedArgs = null;
+        storedThis = null;
+      }
+    }, delay);
+  };
+  return {
+    throttledFn: function(...args) {
+      const now = Date.now();
+      const hasBeenInvoked = lastInvokeTime != null;
+      if (!hasBeenInvoked && !leading) lastInvokeTime = now;
+      const timeSinceLast = hasBeenInvoked ? now - lastInvokeTime : timeout;
+      const remaining = timeout - timeSinceLast;
+      if (trailing) {
+        storedArgs = args;
+        storedThis = this;
+      }
+      if (remaining <= 0) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        if (leading) {
+          if (trailing) {
+            if (storedArgs === args) {
+              storedArgs = null;
+              storedThis = null;
+            }
+          }
+          invoke(args, this);
+        } else {
+          if (trailing) scheduleTrailing(timeout);
+        }
+        return;
+      }
+      if (trailing && !timer) {
+        scheduleTrailing(remaining);
+      }
+    },
+    cancelTimer: () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+};
+const BATCH_OWN_FIELDS_API_LIMIT = 100;
+const DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL = 2e3;
+const queuedFeeds = /* @__PURE__ */ new Set();
+function queueBatchedOwnFields({ feeds }) {
+  for (const feed of feeds) {
+    queuedFeeds.add(feed);
+  }
+  if (queuedFeeds.size > 0) {
+    this.throttledGetBatchOwnFields(
+      [...queuedFeeds].slice(0, BATCH_OWN_FIELDS_API_LIMIT),
+      (feedsToClear) => {
+        for (const feed of feedsToClear) {
+          queuedFeeds.delete(feed);
+        }
+      }
+    );
+  }
+}
+function clearQueuedFeeds() {
+  queuedFeeds.clear();
+}
 const _Feed = class _Feed extends FeedApi {
   constructor(client, groupId, id, data, watch = false, addNewActivitiesTo = "start", activityAddedEventFilter) {
     super(client, groupId, id);
@@ -6372,10 +6449,6 @@ const _Feed = class _Feed extends FeedApi {
           currentActivityFeeds.push(activity.current_feed);
         }
       }
-      this.client.hydrateCapabilitiesCache([
-        response.feed,
-        ...currentActivityFeeds
-      ]);
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
         const result = addActivitiesToState.bind(this)(
@@ -6802,29 +6875,18 @@ const _Feed = class _Feed extends FeedApi {
       ...request,
       feeds: [this.feed]
     });
-    const currentFeed = response.activity.current_feed;
-    if (currentFeed) {
-      this.client.hydrateCapabilitiesCache([currentFeed]);
-    }
     return response;
   }
   handleWSEvent(event) {
     const eventHandler = this.eventHandlers[event.type];
     if (eventHandler !== _Feed.noop) {
-      if ("activity" in event && this.hasActivity(event.activity.id)) {
+      if ("activity" in event && event.activity.feeds.length > 1 && this.hasActivity(event.activity.id)) {
         const currentActivity = this.currentState.activities?.find(
           (a) => a.id === event.activity.id
         );
-        if (event.activity.feeds.length > 1 && !event.activity.current_feed && currentActivity?.current_feed) {
+        if (!event.activity.current_feed && currentActivity?.current_feed) {
           event.activity.current_feed = currentActivity.current_feed;
         }
-        if (event.activity.feeds.length === 1 && event.activity.current_feed && currentActivity?.current_feed) {
-          ownFeedFields.forEach((field) => {
-            if (field in currentActivity.current_feed) {
-              event.activity.current_feed[field] = currentActivity.current_feed[field];
-            }
-          });
-        }
       }
       eventHandler?.(event);
     }
@@ -6839,7 +6901,7 @@ const _Feed = class _Feed extends FeedApi {
   }
   getOrCreateFeeds(activities, options) {
     const enrichmentOptions = this.currentState.last_get_or_create_request_config?.enrichment_options;
-    if (!enrichmentOptions?.skip_activity_current_feed && !enrichmentOptions?.skip_all) {
+    if (this.shouldAddToActiveFeeds(enrichmentOptions)) {
       const feedsToGetOrCreate = /* @__PURE__ */ new Map();
       activities.forEach((activity) => {
         if (activity.current_feed && !feedsToGetOrCreate.has(activity.current_feed.feed)) {
@@ -6849,16 +6911,47 @@ const _Feed = class _Feed extends FeedApi {
           );
         }
       });
-      Array.from(feedsToGetOrCreate.values()).forEach((feed) => {
+      const newFeeds = Array.from(feedsToGetOrCreate.values());
+      const fieldsToUpdate = [];
+      if (!options.fromWebSocket) {
+        fieldsToUpdate.push("own_membership");
+        if (!enrichmentOptions?.skip_own_capabilities) {
+          fieldsToUpdate.push("own_capabilities");
+        }
+        if (!enrichmentOptions?.skip_own_follows) {
+          fieldsToUpdate.push("own_follows");
+        }
+        if (enrichmentOptions?.enrich_own_followings) {
+          fieldsToUpdate.push("own_followings");
+        }
+      }
+      newFeeds.forEach((feed) => {
         getOrCreateActiveFeed.bind(this.client)({
           group: feed.group_id,
           id: feed.id,
           data: feed,
-          fromWebSocket: options.fromWebSocket
+          fieldsToUpdate
         });
       });
+      if (options.fromWebSocket) {
+        const uninitializedFeeds = newFeeds.filter((feedResponse) => {
+          const feed = this.client.feed(feedResponse.group_id, feedResponse.id);
+          return feed.currentState.own_capabilities === void 0;
+        });
+        if (uninitializedFeeds.length > 0) {
+          queueBatchedOwnFields.bind(this.client)({
+            feeds: uninitializedFeeds.map((feed) => feed.feed)
+          });
+        }
+      }
     }
   }
+  shouldAddToActiveFeeds(enrichmentOptions) {
+    if (!enrichmentOptions) {
+      return true;
+    }
+    return !enrichmentOptions?.skip_activity && !enrichmentOptions?.skip_activity_current_feed && !enrichmentOptions?.skip_all;
+  }
 };
 _Feed.noop = () => {
 };
@@ -6912,91 +7005,6 @@ function updateCommentCount({
     }, false);
   }
 }
-const throttle = (fn, timeout = 200, {
-  leading = true,
-  trailing = false
-} = {}) => {
-  let timer = null;
-  let storedArgs = null;
-  let storedThis = null;
-  let lastInvokeTime;
-  const invoke = (args, thisArg) => {
-    lastInvokeTime = Date.now();
-    fn.apply(thisArg, args);
-  };
-  const scheduleTrailing = (delay) => {
-    if (timer) return;
-    timer = setTimeout(() => {
-      timer = null;
-      if (trailing && storedArgs) {
-        invoke(storedArgs, storedThis);
-        storedArgs = null;
-        storedThis = null;
-      }
-    }, delay);
-  };
-  return {
-    throttledFn: function(...args) {
-      const now = Date.now();
-      const hasBeenInvoked = lastInvokeTime != null;
-      if (!hasBeenInvoked && !leading) lastInvokeTime = now;
-      const timeSinceLast = hasBeenInvoked ? now - lastInvokeTime : timeout;
-      const remaining = timeout - timeSinceLast;
-      if (trailing) {
-        storedArgs = args;
-        storedThis = this;
-      }
-      if (remaining <= 0) {
-        if (timer) {
-          clearTimeout(timer);
-          timer = null;
-        }
-        if (leading) {
-          if (trailing) {
-            if (storedArgs === args) {
-              storedArgs = null;
-              storedThis = null;
-            }
-          }
-          invoke(args, this);
-        } else {
-          if (trailing) scheduleTrailing(timeout);
-        }
-        return;
-      }
-      if (trailing && !timer) {
-        scheduleTrailing(remaining);
-      }
-    },
-    cancelTimer: () => {
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-    }
-  };
-};
-const BATCH_OWN_CAPABILITIES_API_LIMIT = 100;
-const DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL = 2e3;
-const queuedFeeds = /* @__PURE__ */ new Set();
-function queueBatchedOwnCapabilities({ feeds }) {
-  for (const feed of feeds) {
-    queuedFeeds.add(feed);
-  }
-  if (queuedFeeds.size > 0) {
-    this.throttledGetBatchOwnCapabilities(
-      [...queuedFeeds].slice(0, BATCH_OWN_CAPABILITIES_API_LIMIT),
-      (feedsToClear) => {
-        for (const feed of feedsToClear) {
-          queuedFeeds.delete(feed);
-        }
-      }
-    );
-  }
-}
-function clearQueuedFeeds() {
-  queuedFeeds.clear();
-}
 function connectActivityToFeed({
   fid
 }) {
@@ -7020,14 +7028,14 @@ function isAnyFeedWatched(fids) {
   }
   return false;
 }
-function disconnectActivityFromFeed(id) {
-  const activeFeed = this.activeActivities[id];
-  if (activeFeed) {
-    delete this.activeActivities[id];
+function disconnectActivityFromFeed(activity) {
+  const index = this.activeActivities.indexOf(activity);
+  if (index !== -1) {
+    this.activeActivities.splice(index, 1);
   }
 }
 class ActivityWithStateUpdates {
-  constructor(id, feedsClient) {
+  constructor(id, feedsClient, { fromResponse } = { fromResponse: void 0 }) {
     this.id = id;
     this.feedsClient = feedsClient;
     this.state = new StateStore({
@@ -7035,6 +7043,13 @@ class ActivityWithStateUpdates {
       comments_by_entity_id: {},
       is_loading: false
     });
+    if (fromResponse) {
+      this.setFeed({
+        fid: fromResponse.feeds[0],
+        initialState: fromResponse
+      });
+      this.subscribeToFeedState();
+    }
   }
   get currentState() {
     return this.state.getLatestValue();
@@ -7103,7 +7118,7 @@ class ActivityWithStateUpdates {
   }
   dispose() {
     this.unsubscribeFromFeedState?.();
-    disconnectActivityFromFeed.call(this.feedsClient, this.id);
+    disconnectActivityFromFeed.call(this.feedsClient, this);
   }
   /**
    * @internal
@@ -7121,8 +7136,13 @@ class ActivityWithStateUpdates {
     initialState
   }) {
     this.feed = connectActivityToFeed.call(this.feedsClient, { fid });
+    const { activities } = addActivitiesToState.bind(this.feed)(
+      [initialState],
+      [],
+      "start"
+    );
     this.feed?.state.partialNext({
-      activities: [initialState]
+      activities
     });
   }
   subscribeToFeedState() {
@@ -7147,20 +7167,20 @@ class ActivityWithStateUpdates {
 function getFeed() {
   return this.feed;
 }
-const isOwnFollowsEqual = (currentState, newState) => {
+const areFollowArraysEqual = (currentFollows, newFollows) => {
   const existingFollows = new Set(
-    currentState.own_follows?.map(
+    currentFollows?.map(
       (f) => `${f.source_feed.feed}:${f.target_feed.feed}:${f.updated_at.getTime()}`
     )
   );
-  const newFollows = new Set(
-    newState.own_follows?.map(
+  const newFollowsSet = new Set(
+    newFollows?.map(
       (f) => `${f.source_feed.feed}:${f.target_feed.feed}:${f.updated_at.getTime()}`
     )
   );
-  if (existingFollows.size === newFollows.size) {
+  if (existingFollows.size === newFollowsSet.size) {
     const areEqual = Array.from(existingFollows).every(
-      (f) => newFollows.has(f)
+      (f) => newFollowsSet.has(f)
     );
     if (areEqual) {
       return true;
@@ -7168,9 +7188,21 @@ const isOwnFollowsEqual = (currentState, newState) => {
   }
   return false;
 };
+const isOwnFollowsEqual = (currentState, newState) => {
+  return areFollowArraysEqual(currentState.own_follows, newState.own_follows);
+};
 const isOwnMembershipEqual = (currentState, newState) => {
   return (currentState.own_membership?.updated_at.getTime() ?? 0) === (newState.own_membership?.updated_at.getTime() ?? 0);
 };
+const isOwnCapabilitiesEqual = (currentState, newState) => {
+  return [...currentState.own_capabilities ?? []].sort().join(",") === [...newState.own_capabilities ?? []].sort().join(",");
+};
+const isOwnFollowingsEqual = (currentState, newState) => {
+  return areFollowArraysEqual(
+    currentState.own_followings,
+    newState.own_followings
+  );
+};
 class FeedsClient extends FeedsApi {
   constructor(apiKey, options) {
     const tokenManager = new TokenManager();
@@ -7183,14 +7215,11 @@ class FeedsClient extends FeedsApi {
     );
     super(apiClient);
     this.eventDispatcher = new EventDispatcher();
-    this.activeActivities = {};
+    this.activeActivities = [];
     this.activeFeeds = {};
     this.healthyConnectionChangedEventCount = 0;
-    this.setGetBatchOwnCapabilitiesThrottlingInterval = (throttlingMs) => {
-      const {
-        throttledFn: throttledGetBatchOwnCapabilities,
-        cancelTimer: cancel
-      } = throttle(
+    this.setGetBatchOwnFieldsThrottlingInterval = (throttlingMs) => {
+      const { throttledFn: throttledGetBatchOwnFields, cancelTimer: cancel } = throttle(
         (feeds, callback) => {
           this.ownBatch({
             feeds
@@ -7206,23 +7235,22 @@ class FeedsClient extends FeedsApi {
         throttlingMs,
         { trailing: true }
       );
-      this.throttledGetBatchOwnCapabilities = throttledGetBatchOwnCapabilities;
-      this.cancelGetBatchOwnCapabilitiesTimer = cancel;
+      this.throttledGetBatchOwnFields = throttledGetBatchOwnFields;
+      this.cancelGetBatchOwnFieldsTimer = cancel;
     };
     this.recoverOnReconnect = async () => {
       this.healthyConnectionChangedEventCount++;
       if (this.healthyConnectionChangedEventCount > 1) {
         const feedEntries = Object.entries(this.activeFeeds);
-        const activityEntries = Object.entries(this.activeActivities);
         const results = await Promise.allSettled([
           ...feedEntries.map(([, feed]) => feed.synchronize()),
-          ...activityEntries.map(([, activity]) => activity.synchronize())
+          ...this.activeActivities.map((activity) => activity.synchronize())
         ]);
         const failures = results.flatMap((result, index) => {
           if (result.status === "fulfilled") {
             return [];
           }
-          const activity = activityEntries[index - feedEntries.length]?.[1];
+          const activity = this.activeActivities[index - feedEntries.length];
           const feed = feedEntries[index]?.[0] ?? (activity && getFeed.call(activity)?.feed);
           return [{ feed, reason: result.reason, activity_id: activity?.id }];
         });
@@ -7239,8 +7267,8 @@ class FeedsClient extends FeedsApi {
         throw new Error(`Can't connect a new user, call "disconnectUser" first`);
       }
       this.tokenManager.setTokenOrProvider(tokenProvider);
-      this.setGetBatchOwnCapabilitiesThrottlingInterval(
-        this.query_batch_own_capabilties_throttling_interval
+      this.setGetBatchOwnFieldsThrottlingInterval(
+        this.query_batch_own_fields_throttling_interval
       );
       try {
         addConnectionEventListeners(this.updateNetworkConnectionStatus);
@@ -7408,14 +7436,13 @@ class FeedsClient extends FeedsApi {
       this.connectionIdManager.reset();
       this.tokenManager.reset();
       this.polls_by_id.clear();
-      this.activeActivities = {};
+      this.activeActivities = [];
       this.activeFeeds = {};
       this.state.partialNext({
         connected_user: void 0,
-        is_ws_connection_healthy: false,
-        own_capabilities_by_fid: {}
+        is_ws_connection_healthy: false
       });
-      this.cancelGetBatchOwnCapabilitiesTimer();
+      this.cancelGetBatchOwnFieldsTimer();
       clearQueuedFeeds();
     };
     this.on = this.eventDispatcher.on;
@@ -7424,15 +7451,15 @@ class FeedsClient extends FeedsApi {
       return this.getOrCreateActiveFeed({
         group: groupId,
         id,
-        options: options2
+        options: options2,
+        fieldsToUpdate: []
       });
     };
-    this.activityWithStateUpdates = (id) => {
-      let activity = this.activeActivities[id];
-      if (!activity) {
-        activity = new ActivityWithStateUpdates(id, this);
-        this.activeActivities[id] = activity;
-      }
+    this.activityWithStateUpdates = (id, { fromResponse } = {
+      fromResponse: void 0
+    }) => {
+      const activity = new ActivityWithStateUpdates(id, this, { fromResponse });
+      this.activeActivities.push(activity);
       return activity;
     };
     this.updateNetworkConnectionStatus = (event) => {
@@ -7448,7 +7475,7 @@ class FeedsClient extends FeedsApi {
       data,
       watch,
       options: options2,
-      fromWebSocket = false
+      fieldsToUpdate
     }) => {
       const fid = `${group}:${id}`;
       let isCreated = false;
@@ -7477,23 +7504,28 @@ class FeedsClient extends FeedsApi {
         if (!isCreated && data) {
           if ((feed.currentState.updated_at?.getTime() ?? 0) < data.updated_at.getTime()) {
             handleFeedUpdated.call(feed, { feed: data });
-          } else if ((feed.currentState.updated_at?.getTime() ?? 0) === data.updated_at.getTime() && !fromWebSocket) {
-            const fieldsToUpdate = [];
-            if (!isOwnFollowsEqual(feed.currentState, data)) {
-              fieldsToUpdate.push("own_follows");
-            }
-            if (!isOwnMembershipEqual(feed.currentState, data)) {
-              fieldsToUpdate.push("own_membership");
-            }
-            if (fieldsToUpdate.length > 0) {
-              const fieldsToUpdateData = fieldsToUpdate.reduce(
+          } else if ((feed.currentState.updated_at?.getTime() ?? 0) === data.updated_at.getTime()) {
+            const fieldsToUpdateData = [];
+            const fieldChecks = [
+              ["own_capabilities", isOwnCapabilitiesEqual],
+              ["own_follows", isOwnFollowsEqual],
+              ["own_membership", isOwnMembershipEqual],
+              ["own_followings", isOwnFollowingsEqual]
+            ];
+            fieldChecks.forEach(([field, isEqual]) => {
+              if (fieldsToUpdate.includes(field) && !isEqual(feed.currentState, data)) {
+                fieldsToUpdateData.push(field);
+              }
+            });
+            if (fieldsToUpdateData.length > 0) {
+              const fieldsToUpdatePayload = fieldsToUpdateData.reduce(
                 (acc, field) => {
                   acc[field] = data[field];
                   return acc;
                 },
                 {}
               );
-              feed.state.partialNext(fieldsToUpdateData);
+              feed.state.partialNext(fieldsToUpdatePayload);
             }
           }
         }
@@ -7503,14 +7535,13 @@ class FeedsClient extends FeedsApi {
     };
     this.state = new StateStore({
       connected_user: void 0,
-      is_ws_connection_healthy: false,
-      own_capabilities_by_fid: {}
+      is_ws_connection_healthy: false
     });
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
     this.polls_by_id = /* @__PURE__ */ new Map();
-    this.query_batch_own_capabilties_throttling_interval = options?.query_batch_own_capabilties_throttling_interval ?? DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL;
+    this.query_batch_own_fields_throttling_interval = options?.query_batch_own_fields_throttling_interval ?? DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL;
     feedsLoggerSystem.configureLoggers(options?.configure_loggers_options);
     this.on("all", (event) => {
       const fid = event.fid;
@@ -7533,7 +7564,8 @@ class FeedsClient extends FeedsApi {
           this.getOrCreateActiveFeed({
             group: event.feed.group_id,
             id: event.feed.id,
-            data: event.feed
+            data: event.feed,
+            fieldsToUpdate: []
           });
           break;
         }
@@ -7541,12 +7573,9 @@ class FeedsClient extends FeedsApi {
           feeds.forEach((f) => f.handleWSEvent(event));
           if (typeof fid === "string") {
             delete this.activeFeeds[fid];
-            Object.keys(this.activeActivities).forEach((activityId) => {
-              const activity = this.activeActivities[activityId];
-              if (getFeed.call(activity)?.feed === fid) {
-                delete this.activeActivities[activityId];
-              }
-            });
+            this.activeActivities = this.activeActivities.filter(
+              (activity) => getFeed.call(activity)?.feed !== fid
+            );
           }
           break;
         }
@@ -7624,7 +7653,9 @@ class FeedsClient extends FeedsApi {
         default: {
           feeds.forEach((f) => f.handleWSEvent(event));
           if (event.type === "feeds.activity.deleted") {
-            delete this.activeActivities[event.activity.id];
+            this.activeActivities = this.activeActivities.filter(
+              (activity) => activity.id !== event.activity.id
+            );
           }
         }
       }
@@ -7651,25 +7682,6 @@ class FeedsClient extends FeedsApi {
       }
     }
   }
-  hydrateCapabilitiesCache(feedResponses) {
-    let ownCapabilitiesCache = this.state.getLatestValue().own_capabilities_by_fid;
-    const capabilitiesToFetchQueue = [];
-    for (const feedResponse of feedResponses) {
-      const { feed, own_capabilities } = feedResponse;
-      if (!Object.prototype.hasOwnProperty.call(ownCapabilitiesCache, feed)) {
-        if (own_capabilities) {
-          ownCapabilitiesCache = {
-            ...ownCapabilitiesCache,
-            [feed]: own_capabilities
-          };
-        } else {
-          capabilitiesToFetchQueue.push(feed);
-        }
-      }
-    }
-    queueBatchedOwnCapabilities.bind(this)({ feeds: capabilitiesToFetchQueue });
-    this.state.partialNext({ own_capabilities_by_fid: ownCapabilitiesCache });
-  }
   async queryFeeds(request) {
     const response = await this._queryFeeds(request);
     const feedResponses = response.feeds;
@@ -7678,10 +7690,15 @@ class FeedsClient extends FeedsApi {
         group: feedResponse.group_id,
         id: feedResponse.id,
         data: feedResponse,
-        watch: request?.watch
+        watch: request?.watch,
+        fieldsToUpdate: [
+          "own_capabilities",
+          "own_follows",
+          "own_membership",
+          "own_followings"
+        ]
       })
     );
-    this.hydrateCapabilitiesCache(feedResponses);
     return {
       feeds,
       next: response.next,
@@ -7692,13 +7709,12 @@ class FeedsClient extends FeedsApi {
   }
   async ownBatch(request) {
     const response = await super.ownBatch(request);
-    const feedResponses = Object.entries(response.data).map(
-      ([feed, ownFields]) => ({
-        feed,
-        own_capabilities: ownFields.own_capabilities
-      })
-    );
-    this.hydrateCapabilitiesCache(feedResponses);
+    Object.entries(response.data).forEach(([fid, ownFields]) => {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        feed.state.partialNext(ownFields);
+      }
+    });
     return response;
   }
   async updateFollow(request) {
@@ -7757,7 +7773,6 @@ class FeedsClient extends FeedsApi {
   }
   async getOrCreateFeed(request) {
     const response = await super.getOrCreateFeed(request);
-    this.hydrateCapabilitiesCache([response.feed]);
     if (request.watch) {
       const feeds = this.findAllActiveFeedsByFid(
         `${request.feed_group_id}:${request.feed_id}`
@@ -7768,14 +7783,20 @@ class FeedsClient extends FeedsApi {
   }
   async getFollowSuggestions(...params) {
     const response = await super.getFollowSuggestions(...params);
-    response.suggestions.forEach((suggestion) => {
-      this.getOrCreateActiveFeed({
+    const feeds = response.suggestions.map((suggestion) => {
+      return this.getOrCreateActiveFeed({
         group: suggestion.group_id,
         id: suggestion.id,
-        data: suggestion
+        data: suggestion,
+        fieldsToUpdate: [
+          "own_capabilities",
+          "own_follows",
+          "own_membership",
+          "own_followings"
+        ]
       });
     });
-    return response;
+    return { ...response, feeds };
   }
   findAllActiveFeedsByActivityId(activityId) {
     return [
@@ -7854,9 +7875,8 @@ export {
   updateEntityInArray as l,
   feedsLoggerSystem as m,
   ensureExhausted as n,
-  ownFeedFields as o,
   replaceUniqueArrayMerge as r,
   shouldUpdateState as s,
   uniqueArrayMerge as u
 };
-//# sourceMappingURL=feeds-client-BNhvggk2.mjs.map
+//# sourceMappingURL=feeds-client-C-2_fdH1.mjs.map