@stream-io/feeds-client 0.3.32 → 0.3.34

package/src/feed/feed.ts

@@ -14,6 +14,7 @@ import type {
   FollowRequest,
   QueryCommentsRequest,
   ActivityAddedEvent,
+  EnrichmentOptions,
 } from '../gen/models';
 import type { StreamResponse } from '../gen-imports';
 import { StateStore } from '@stream-io/state-store';
@@ -63,16 +64,16 @@ import {
   checkHasAnotherPage,
   Constants,
   feedsLoggerSystem,
-  ownFeedFields,
   uniqueArrayMerge,
 } from '../utils';
 import { handleActivityFeedback } from './event-handlers/activity/handle-activity-feedback';
 import { deepEqual } from '../utils/deep-equal';
 import { getOrCreateActiveFeed } from '../feeds-client/get-or-create-active-feed';
+import { queueBatchedOwnFields } from '../utils/throttling';
 
 export type FeedState = Omit<
   Partial<GetOrCreateFeedResponse & FeedResponse>,
-  'feed' | 'own_capabilities' | 'duration'
+  'feed' | 'duration'
 > & {
   /**
    * True when loading state using `getOrCreate`
@@ -333,11 +334,6 @@ export class Feed extends FeedApi {
         }
       }
 
-      this.client.hydrateCapabilitiesCache([
-        response.feed,
-        ...currentActivityFeeds,
-      ]);
-
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
 
@@ -919,10 +915,7 @@ export class Feed extends FeedApi {
       ...request,
       feeds: [this.feed],
     });
-    const currentFeed = response.activity.current_feed;
-    if (currentFeed) {
-      this.client.hydrateCapabilitiesCache([currentFeed]);
-    }
+
     return response;
   }
 
@@ -934,34 +927,19 @@ export class Feed extends FeedApi {
 
     // no need to run noop function
     if (eventHandler !== Feed.noop) {
-      if ('activity' in event && this.hasActivity(event.activity.id)) {
+      // Backfill current_feed if activity is posted to multiple feeds
+      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,
         );
 
-        // Backfill current_feed if activity is posted to multiple feeds
-        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;
         }
-
-        // Backfill own_ fields if activity is posted to a single feed
-        if (
-          event.activity.feeds.length === 1 &&
-          event.activity.current_feed &&
-          currentActivity?.current_feed
-        ) {
-          ownFeedFields.forEach((field) => {
-            if (field in currentActivity.current_feed!) {
-              // @ts-expect-error TODO: fix this
-              event.activity.current_feed![field] =
-                currentActivity.current_feed![field];
-            }
-          });
-        }
       }
       // @ts-expect-error intersection of handler arguments results to never
       eventHandler?.(event);
@@ -994,10 +972,7 @@ export class Feed extends FeedApi {
   ) {
     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 = new Map<string, FeedResponse>();
       activities.forEach((activity) => {
         if (
@@ -1010,14 +985,53 @@ export class Feed extends FeedApi {
           );
         }
       });
-      Array.from(feedsToGetOrCreate.values()).forEach((feed) => {
+      const newFeeds = Array.from(feedsToGetOrCreate.values());
+      const fieldsToUpdate: Array<
+        'own_capabilities' | 'own_follows' | 'own_followings' | 'own_membership'
+      > = [];
+      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);
+          // own_capabilities can only be undefined if we haven't fetched it yet
+          return feed.currentState.own_capabilities === undefined;
+        });
+        if (uninitializedFeeds.length > 0) {
+          queueBatchedOwnFields.bind(this.client)({
+            feeds: uninitializedFeeds.map((feed) => feed.feed),
+          });
+        }
+      }
+    }
+  }
+
+  private shouldAddToActiveFeeds(enrichmentOptions?: EnrichmentOptions) {
+    if (!enrichmentOptions) {
+      return true;
     }
+    return (
+      !enrichmentOptions?.skip_activity &&
+      !enrichmentOptions?.skip_activity_current_feed &&
+      !enrichmentOptions?.skip_all
+    );
   }
 }

package/src/feeds-client/active-activity.ts

@@ -1,3 +1,4 @@
+import type { ActivityWithStateUpdates } from '../activity-with-state-updates/activity-with-state-updates';
 import { Feed } from '../feed';
 import type { FeedsClient } from './feeds-client';
 
@@ -34,9 +35,12 @@ export function isAnyFeedWatched(this: FeedsClient, fids: string[]) {
   return false;
 }
 
-export function disconnectActivityFromFeed(this: FeedsClient, id: string) {
-  const activeFeed = this.activeActivities[id];
-  if (activeFeed) {
-    delete this.activeActivities[id];
+export function disconnectActivityFromFeed(
+  this: FeedsClient,
+  activity: ActivityWithStateUpdates,
+) {
+  const index = this.activeActivities.indexOf(activity);
+  if (index !== -1) {
+    this.activeActivities.splice(index, 1);
   }
 }

package/src/feeds-client/feeds-client.ts

@@ -60,6 +60,7 @@ import { ModerationClient } from '../moderation-client';
 import { StreamPoll } from '../common/Poll';
 import {
   Feed,
+  type FeedState,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
   handleActivityReactionUpdated,
@@ -86,15 +87,16 @@ import { feedsLoggerSystem } from '../utils';
 import { handleCommentReactionUpdated } from '../feed/event-handlers/comment/handle-comment-reaction-updated';
 import {
   throttle,
-  DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL,
-  type GetBatchedOwnCapabilitiesThrottledCallback,
-  queueBatchedOwnCapabilities,
-  type ThrottledGetBatchedOwnCapabilities,
   clearQueuedFeeds,
+  type ThrottledGetBatchedOwnFields,
+  type GetBatchedOwnFieldsThrottledCallback,
+  DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL,
 } from '../utils/throttling';
 import { ActivityWithStateUpdates } from '../activity-with-state-updates/activity-with-state-updates';
 import { getFeed } from '../activity-with-state-updates/get-feed';
 import {
+  isOwnCapabilitiesEqual,
+  isOwnFollowingsEqual,
   isOwnFollowsEqual,
   isOwnMembershipEqual,
 } from '../utils/check-own-fields-equality';
@@ -102,7 +104,6 @@ import {
 export type FeedsClientState = {
   connected_user: ConnectedUser | undefined;
   is_ws_connection_healthy: boolean;
-  own_capabilities_by_fid: Record<string, FeedResponse['own_capabilities']>;
 };
 
 type FID = string;
@@ -123,14 +124,14 @@ export class FeedsClient extends FeedsApi {
 
   private readonly polls_by_id: Map<string, StreamPoll>;
 
-  protected activeActivities: Record<ActivityId, ActivityWithStateUpdates> = {};
+  protected activeActivities: ActivityWithStateUpdates[] = [];
   protected activeFeeds: Record<FID, Feed> = {};
 
   private healthyConnectionChangedEventCount = 0;
 
-  protected throttledGetBatchOwnCapabilities!: ThrottledGetBatchedOwnCapabilities;
-  private cancelGetBatchOwnCapabilitiesTimer!: () => void;
-  private query_batch_own_capabilties_throttling_interval!: number;
+  protected throttledGetBatchOwnFields!: ThrottledGetBatchedOwnFields;
+  private cancelGetBatchOwnFieldsTimer!: () => void;
+  private query_batch_own_fields_throttling_interval!: number;
 
   constructor(apiKey: string, options?: FeedsClientOptions) {
     const tokenManager = new TokenManager();
@@ -145,16 +146,15 @@ export class FeedsClient extends FeedsApi {
     this.state = new StateStore<FeedsClientState>({
       connected_user: undefined,
       is_ws_connection_healthy: false,
-      own_capabilities_by_fid: {},
     });
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
     this.polls_by_id = 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);
 
@@ -184,6 +184,7 @@ export class FeedsClient extends FeedsApi {
             group: event.feed.group_id,
             id: event.feed.id,
             data: event.feed,
+            fieldsToUpdate: [],
           });
 
           break;
@@ -192,12 +193,9 @@ export class FeedsClient extends FeedsApi {
           feeds.forEach((f) => f.handleWSEvent(event as unknown as WSEvent));
           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;
         }
@@ -277,37 +275,36 @@ export class FeedsClient extends FeedsApi {
         default: {
           feeds.forEach((f) => f.handleWSEvent(event as unknown as WSEvent));
           if (event.type === 'feeds.activity.deleted') {
-            delete this.activeActivities[event.activity.id];
+            this.activeActivities = this.activeActivities.filter(
+              (activity) => activity.id !== event.activity.id,
+            );
           }
         }
       }
     });
   }
 
-  private setGetBatchOwnCapabilitiesThrottlingInterval = (
-    throttlingMs: number,
-  ) => {
-    const {
-      throttledFn: throttledGetBatchOwnCapabilities,
-      cancelTimer: cancel,
-    } = throttle<GetBatchedOwnCapabilitiesThrottledCallback>(
-      (feeds, callback) => {
-        this.ownBatch({
-          feeds,
-        }).catch((error) => {
-          this.eventDispatcher.dispatch({
-            type: 'errors.unhandled',
-            error_type: UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
-            error,
+  private setGetBatchOwnFieldsThrottlingInterval = (throttlingMs: number) => {
+    const { throttledFn: throttledGetBatchOwnFields, cancelTimer: cancel } =
+      throttle<GetBatchedOwnFieldsThrottledCallback>(
+        (feeds, callback) => {
+          this.ownBatch({
+            feeds,
+          }).catch((error) => {
+            this.eventDispatcher.dispatch({
+              type: 'errors.unhandled',
+              error_type:
+                UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
+              error,
+            });
           });
-        });
-        callback(feeds);
-      },
-      throttlingMs,
-      { trailing: true },
-    );
-    this.throttledGetBatchOwnCapabilities = throttledGetBatchOwnCapabilities;
-    this.cancelGetBatchOwnCapabilitiesTimer = cancel;
+          callback(feeds);
+        },
+        throttlingMs,
+        { trailing: true },
+      );
+    this.throttledGetBatchOwnFields = throttledGetBatchOwnFields;
+    this.cancelGetBatchOwnFieldsTimer = cancel;
   };
 
   private recoverOnReconnect = async () => {
@@ -316,18 +313,17 @@ export class FeedsClient extends FeedsApi {
     // we skip the first event as we could potentially be querying twice
     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: SyncFailure[] = 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);
 
@@ -369,34 +365,6 @@ export class FeedsClient extends FeedsApi {
     }
   }
 
-  public hydrateCapabilitiesCache(
-    feedResponses: Array<Pick<FeedResponse, 'feed' | 'own_capabilities'>>,
-  ) {
-    let ownCapabilitiesCache =
-      this.state.getLatestValue().own_capabilities_by_fid;
-
-    const capabilitiesToFetchQueue: string[] = [];
-
-    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 });
-  }
-
   connectUser = async (user: UserRequest, tokenProvider?: TokenOrProvider) => {
     if (
       this.state.getLatestValue().connected_user !== undefined ||
@@ -407,8 +375,8 @@ export class FeedsClient extends FeedsApi {
 
     this.tokenManager.setTokenOrProvider(tokenProvider);
 
-    this.setGetBatchOwnCapabilitiesThrottlingInterval(
-      this.query_batch_own_capabilties_throttling_interval,
+    this.setGetBatchOwnFieldsThrottlingInterval(
+      this.query_batch_own_fields_throttling_interval,
     );
 
     try {
@@ -643,16 +611,15 @@ export class FeedsClient extends FeedsApi {
     // clear all caches
     this.polls_by_id.clear();
 
-    this.activeActivities = {};
+    this.activeActivities = [];
     this.activeFeeds = {};
 
     this.state.partialNext({
       connected_user: undefined,
       is_ws_connection_healthy: false,
-      own_capabilities_by_fid: {},
     });
 
-    this.cancelGetBatchOwnCapabilitiesTimer();
+    this.cancelGetBatchOwnFieldsTimer();
     clearQueuedFeeds();
   };
 
@@ -680,6 +647,7 @@ export class FeedsClient extends FeedsApi {
       group: groupId,
       id,
       options,
+      fieldsToUpdate: [],
     });
   };
 
@@ -691,12 +659,14 @@ export class FeedsClient extends FeedsApi {
    * @param id - The id of the activity
    * @returns The activity with state updates
    */
-  activityWithStateUpdates = (id: ActivityId) => {
-    let activity = this.activeActivities[id];
-    if (!activity) {
-      activity = new ActivityWithStateUpdates(id, this);
-      this.activeActivities[id] = activity;
-    }
+  activityWithStateUpdates = (
+    id: ActivityId,
+    { fromResponse }: { fromResponse?: ActivityResponse } = {
+      fromResponse: undefined,
+    },
+  ) => {
+    const activity = new ActivityWithStateUpdates(id, this, { fromResponse });
+    this.activeActivities.push(activity);
     return activity;
   };
 
@@ -711,11 +681,15 @@ export class FeedsClient extends FeedsApi {
         id: feedResponse.id,
         data: feedResponse,
         watch: request?.watch,
+        fieldsToUpdate: [
+          'own_capabilities',
+          'own_follows',
+          'own_membership',
+          'own_followings',
+        ],
       }),
     );
 
-    this.hydrateCapabilitiesCache(feedResponses);
-
     return {
       feeds,
       next: response.next,
@@ -727,13 +701,12 @@ export class FeedsClient extends FeedsApi {
 
   async ownBatch(request: OwnBatchRequest) {
     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;
   }
 
@@ -826,7 +799,6 @@ export class FeedsClient extends FeedsApi {
     },
   ) {
     const response = await super.getOrCreateFeed(request);
-    this.hydrateCapabilitiesCache([response.feed]);
 
     if (request.watch) {
       const feeds = this.findAllActiveFeedsByFid(
@@ -840,19 +812,24 @@ export class FeedsClient extends FeedsApi {
 
   async getFollowSuggestions(
     ...params: Parameters<FeedsApi['getFollowSuggestions']>
-  ): Promise<StreamResponse<GetFollowSuggestionsResponse>> {
+  ): Promise<StreamResponse<GetFollowSuggestionsResponse & { feeds: Feed[] }>> {
     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,
+        fieldsToUpdate: [
+          'own_capabilities',
+          'own_follows',
+          'own_membership',
+          'own_followings',
+        ],
       });
     });
 
-    // TODO: return feed instance here https://linear.app/stream/issue/REACT-669/return-feed-instance-from-followsuggestions-breaking
-    return response;
+    return { ...response, feeds };
   }
 
   protected readonly getOrCreateActiveFeed = ({
@@ -861,7 +838,7 @@ export class FeedsClient extends FeedsApi {
     data,
     watch,
     options,
-    fromWebSocket = false,
+    fieldsToUpdate,
   }: {
     group: string;
     id: string;
@@ -871,7 +848,9 @@ export class FeedsClient extends FeedsApi {
       addNewActivitiesTo?: 'start' | 'end';
       activityAddedEventFilter?: (event: ActivityAddedEvent) => boolean;
     };
-    fromWebSocket?: boolean;
+    fieldsToUpdate: Array<
+      'own_capabilities' | 'own_follows' | 'own_followings' | 'own_membership'
+    >;
   }) => {
     const fid = `${group}:${id}`;
     let isCreated = false;
@@ -909,18 +888,35 @@ export class FeedsClient extends FeedsApi {
           handleFeedUpdated.call(feed, { feed: data });
         } else if (
           (feed.currentState.updated_at?.getTime() ?? 0) ===
-            data.updated_at.getTime() &&
-          !fromWebSocket
+          data.updated_at.getTime()
         ) {
-          const fieldsToUpdate: Array<keyof FeedResponse> = [];
-          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(
+          const fieldsToUpdateData: Array<keyof FeedResponse> = [];
+          const fieldChecks: Array<
+            [
+              (
+                | 'own_capabilities'
+                | 'own_follows'
+                | 'own_membership'
+                | 'own_followings'
+              ),
+              (currentState: FeedState, newState: FeedResponse) => boolean,
+            ]
+          > = [
+            ['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: Partial<FeedResponse>, field) => {
                 // @ts-expect-error TODO: fix this
                 acc[field] = data[field];
@@ -928,7 +924,7 @@ export class FeedsClient extends FeedsApi {
               },
               {},
             );
-            feed.state.partialNext(fieldsToUpdateData);
+            feed.state.partialNext(fieldsToUpdatePayload);
           }
         }
       }

package/src/utils/check-own-fields-equality.ts

@@ -1,25 +1,25 @@
 import type { FeedState } from '../feed';
-import type { FeedResponse } from '../gen/models';
+import type { FeedResponse, FollowResponse } from '../gen/models';
 
-export const isOwnFollowsEqual = (
-  currentState: FeedState,
-  newState: FeedResponse,
-) => {
+const areFollowArraysEqual = (
+  currentFollows: FollowResponse[] | undefined,
+  newFollows: FollowResponse[] | undefined,
+): boolean => {
   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),
+      newFollowsSet.has(f),
     );
     if (areEqual) {
       return true;
@@ -29,6 +29,13 @@ export const isOwnFollowsEqual = (
   return false;
 };
 
+export const isOwnFollowsEqual = (
+  currentState: FeedState,
+  newState: FeedResponse,
+) => {
+  return areFollowArraysEqual(currentState.own_follows, newState.own_follows);
+};
+
 export const isOwnMembershipEqual = (
   currentState: FeedState,
   newState: FeedResponse,
@@ -38,3 +45,23 @@ export const isOwnMembershipEqual = (
     (newState.own_membership?.updated_at.getTime() ?? 0)
   );
 };
+
+export const isOwnCapabilitiesEqual = (
+  currentState: FeedState,
+  newState: FeedResponse,
+) => {
+  return (
+    [...(currentState.own_capabilities ?? [])].sort().join(',') ===
+    [...(newState.own_capabilities ?? [])].sort().join(',')
+  );
+};
+
+export const isOwnFollowingsEqual = (
+  currentState: FeedState,
+  newState: FeedResponse,
+) => {
+  return areFollowArraysEqual(
+    currentState.own_followings,
+    newState.own_followings,
+  );
+};

package/src/utils/throttling/index.ts

@@ -1,2 +1,2 @@
 export * from './throttle';
-export * from './throttled-get-batched-own-capabilities'
+export * from './throttled-get-batched-own-fields';