@stream-io/feeds-client 0.2.18 → 0.2.20

package/dist/{index-Zde8UE5f.mjs → feeds-client-BObWT4vl.mjs}

@@ -3730,7 +3730,7 @@ const getRateLimitFromResponseHeader = (response_headers) => {
   };
   return result;
 };
-const version = "0.2.18";
+const version = "0.2.20";
 class ApiClient {
   constructor(apiKey, tokenManager, connectionIdManager, options) {
     this.apiKey = apiKey;
@@ -5330,7 +5330,12 @@ function handleActivityAdded(event) {
     this.currentState.addNewActivitiesTo
   );
   if (result.changed) {
-    this.client.hydratePollCache([event.activity]);
+    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 });
   }
 }
@@ -5442,6 +5447,9 @@ 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
@@ -6066,6 +6074,13 @@ const _Feed = class _Feed extends FeedApi {
     });
     try {
       const response = await super.getOrCreate(request);
+      const currentActivityFeeds = [];
+      for (const activity of response.activities) {
+        if (activity.current_feed) {
+          currentActivityFeeds.push(activity.current_feed);
+        }
+      }
+      this.client.hydrateCapabilitiesCache([response.feed, ...currentActivityFeeds]);
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
         const result = addActivitiesToState.bind(this)(
@@ -6475,11 +6490,16 @@ const _Feed = class _Feed extends FeedApi {
       limit: currentState.last_get_or_create_request_config?.limit ?? 20
     });
   }
-  addActivity(request) {
-    return this.feedsApi.addActivity({
+  async addActivity(request) {
+    const response = await this.client.addActivity({
       ...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];
@@ -6513,6 +6533,7 @@ function handleUserUpdated(event) {
 }
 var UnhandledErrorType = /* @__PURE__ */ ((UnhandledErrorType2) => {
   UnhandledErrorType2["ReconnectionReconciliation"] = "reconnection-reconciliation";
+  UnhandledErrorType2["FetchingOwnCapabilitiesOnNewActivity"] = "fetching-own-capabilities-on-new-activity";
   return UnhandledErrorType2;
 })(UnhandledErrorType || {});
 function updateCommentCount({
@@ -6543,6 +6564,91 @@ 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();
+}
 class FeedsClient extends FeedsApi {
   constructor(apiKey, options) {
     const tokenManager = new TokenManager();
@@ -6557,6 +6663,29 @@ class FeedsClient extends FeedsApi {
     this.eventDispatcher = new EventDispatcher();
     this.activeFeeds = {};
     this.healthyConnectionChangedEventCount = 0;
+    this.setGetBatchOwnCapabilitiesThrottlingInterval = (throttlingMs) => {
+      const {
+        throttledFn: throttledGetBatchOwnCapabilities,
+        cancelTimer: cancel
+      } = throttle(
+        (feeds, callback) => {
+          this.ownCapabilitiesBatch({
+            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;
+    };
     this.recoverOnReconnect = async () => {
       this.healthyConnectionChangedEventCount++;
       if (this.healthyConnectionChangedEventCount > 1) {
@@ -6580,6 +6709,9 @@ 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
+      );
       try {
         addConnectionEventListeners(this.updateNetworkConnectionStatus);
         this.wsConnection = new StableWSConnection(
@@ -6746,10 +6878,14 @@ class FeedsClient extends FeedsApi {
       removeConnectionEventListeners(this.updateNetworkConnectionStatus);
       this.connectionIdManager.reset();
       this.tokenManager.reset();
+      this.polls_by_id.clear();
       this.state.partialNext({
         connected_user: void 0,
-        is_ws_connection_healthy: false
+        is_ws_connection_healthy: false,
+        own_capabilities_by_fid: {}
       });
+      this.cancelGetBatchOwnCapabilitiesTimer();
+      clearQueuedFeeds();
     };
     this.on = this.eventDispatcher.on;
     this.off = this.eventDispatcher.off;
@@ -6790,12 +6926,14 @@ class FeedsClient extends FeedsApi {
     };
     this.state = new StateStore({
       connected_user: void 0,
-      is_ws_connection_healthy: false
+      is_ws_connection_healthy: false,
+      own_capabilities_by_fid: {}
     });
     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;
     configureLoggers(options?.configure_loggers_options);
     this.on("all", (event) => {
       const fid = event.fid;
@@ -6915,9 +7053,29 @@ 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 feeds = response.feeds.map(
+    const feedResponses = response.feeds;
+    const feeds = feedResponses.map(
       (feedResponse) => this.getOrCreateActiveFeed(
         feedResponse.group_id,
         feedResponse.id,
@@ -6925,6 +7083,7 @@ class FeedsClient extends FeedsApi {
         request?.watch
       )
     );
+    this.hydrateCapabilitiesCache(feedResponses);
     return {
       feeds,
       next: response.next,
@@ -6933,6 +7092,17 @@ class FeedsClient extends FeedsApi {
       duration: response.duration
     };
   }
+  async ownCapabilitiesBatch(request) {
+    const response = await super.ownCapabilitiesBatch(request);
+    const feedResponses = Object.entries(response.capabilities).map(
+      ([feed, own_capabilities]) => ({
+        feed,
+        own_capabilities
+      })
+    );
+    this.hydrateCapabilitiesCache(feedResponses);
+    return response;
+  }
   async updateFollow(request) {
     const response = await super.updateFollow(request);
     [
@@ -7000,98 +7170,27 @@ class FeedsClient extends FeedsApi {
     );
   }
 }
-const ChannelOwnCapability = {
-  BAN_CHANNEL_MEMBERS: "ban-channel-members",
-  CAST_POLL_VOTE: "cast-poll-vote",
-  CONNECT_EVENTS: "connect-events",
-  CREATE_ATTACHMENT: "create-attachment",
-  DELETE_ANY_MESSAGE: "delete-any-message",
-  DELETE_CHANNEL: "delete-channel",
-  DELETE_OWN_MESSAGE: "delete-own-message",
-  FLAG_MESSAGE: "flag-message",
-  FREEZE_CHANNEL: "freeze-channel",
-  JOIN_CHANNEL: "join-channel",
-  LEAVE_CHANNEL: "leave-channel",
-  MUTE_CHANNEL: "mute-channel",
-  PIN_MESSAGE: "pin-message",
-  QUERY_POLL_VOTES: "query-poll-votes",
-  QUOTE_MESSAGE: "quote-message",
-  READ_EVENTS: "read-events",
-  SEARCH_MESSAGES: "search-messages",
-  SEND_CUSTOM_EVENTS: "send-custom-events",
-  SEND_LINKS: "send-links",
-  SEND_MESSAGE: "send-message",
-  SEND_POLL: "send-poll",
-  SEND_REACTION: "send-reaction",
-  SEND_REPLY: "send-reply",
-  SEND_RESTRICTED_VISIBILITY_MESSAGE: "send-restricted-visibility-message",
-  SEND_TYPING_EVENTS: "send-typing-events",
-  SET_CHANNEL_COOLDOWN: "set-channel-cooldown",
-  SHARE_LOCATION: "share-location",
-  SKIP_SLOW_MODE: "skip-slow-mode",
-  SLOW_MODE: "slow-mode",
-  TYPING_EVENTS: "typing-events",
-  UPDATE_ANY_MESSAGE: "update-any-message",
-  UPDATE_CHANNEL: "update-channel",
-  UPDATE_CHANNEL_MEMBERS: "update-channel-members",
-  UPDATE_OWN_MESSAGE: "update-own-message",
-  UPDATE_THREAD: "update-thread",
-  UPLOAD_FILE: "upload-file"
-};
-const FeedOwnCapability = {
-  ADD_ACTIVITY: "add-activity",
-  ADD_ACTIVITY_BOOKMARK: "add-activity-bookmark",
-  ADD_ACTIVITY_REACTION: "add-activity-reaction",
-  ADD_COMMENT: "add-comment",
-  ADD_COMMENT_REACTION: "add-comment-reaction",
-  CREATE_FEED: "create-feed",
-  DELETE_ANY_ACTIVITY: "delete-any-activity",
-  DELETE_ANY_COMMENT: "delete-any-comment",
-  DELETE_FEED: "delete-feed",
-  DELETE_OWN_ACTIVITY: "delete-own-activity",
-  DELETE_OWN_ACTIVITY_BOOKMARK: "delete-own-activity-bookmark",
-  DELETE_OWN_ACTIVITY_REACTION: "delete-own-activity-reaction",
-  DELETE_OWN_COMMENT: "delete-own-comment",
-  DELETE_OWN_COMMENT_REACTION: "delete-own-comment-reaction",
-  FOLLOW: "follow",
-  PIN_ACTIVITY: "pin-activity",
-  QUERY_FEED_MEMBERS: "query-feed-members",
-  QUERY_FOLLOWS: "query-follows",
-  READ_ACTIVITIES: "read-activities",
-  READ_FEED: "read-feed",
-  UNFOLLOW: "unfollow",
-  UPDATE_ANY_ACTIVITY: "update-any-activity",
-  UPDATE_ANY_COMMENT: "update-any-comment",
-  UPDATE_FEED: "update-feed",
-  UPDATE_FEED_FOLLOWERS: "update-feed-followers",
-  UPDATE_FEED_MEMBERS: "update-feed-members",
-  UPDATE_OWN_ACTIVITY: "update-own-activity",
-  UPDATE_OWN_ACTIVITY_BOOKMARK: "update-own-activity-bookmark",
-  UPDATE_OWN_COMMENT: "update-own-comment"
-};
 export {
-  ChannelOwnCapability as C,
+  Constants as C,
   FeedsClient as F,
   StreamApiError as S,
   Feed as a,
-  FeedOwnCapability as b,
-  StreamPoll as c,
+  StreamPoll as b,
+  checkHasAnotherPage as c,
   debounce as d,
-  checkHasAnotherPage as e,
-  Constants as f,
-  isFollowResponse as g,
-  isReactionResponse as h,
+  isFollowResponse as e,
+  isReactionResponse as f,
+  isCommentResponse as g,
+  isImageFile as h,
   isVoteAnswer as i,
-  isCommentResponse as j,
-  isImageFile as k,
-  isVideoFile as l,
-  getStateUpdateQueueId as m,
-  updateEntityInArray as n,
-  configureLoggers as o,
-  getLogger as p,
-  ensureExhausted as q,
+  isVideoFile as j,
+  getStateUpdateQueueId as k,
+  updateEntityInArray as l,
+  configureLoggers as m,
+  getLogger as n,
+  ensureExhausted as o,
   replaceUniqueArrayMerge as r,
   shouldUpdateState as s,
   uniqueArrayMerge as u
 };
-//# sourceMappingURL=index-Zde8UE5f.mjs.map
+//# sourceMappingURL=feeds-client-BObWT4vl.mjs.map