@knocklabs/client 0.8.17 → 0.8.19

package/dist/esm/clients/feed/feed.js

@@ -1,666 +1,361 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-import { EventEmitter2 as EventEmitter } from "eventemitter2";
-import createStore from "./store";
-import { isRequestInFlight, NetworkStatus } from "../../networkStatus";
-// Default options to apply
-var feedClientDefaults = {
+var p = Object.defineProperty;
+var _ = (m, e, t) => e in m ? p(m, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : m[e] = t;
+var u = (m, e, t) => (_(m, typeof e != "symbol" ? e + "" : e, t), t);
+import { EventEmitter2 as k } from "eventemitter2";
+import { isRequestInFlight as S, NetworkStatus as f } from "../../networkStatus.js";
+import g from "./store.js";
+const v = {
   archived: "exclude"
-};
-var DEFAULT_DISCONNECT_DELAY = 2000;
-class Feed {
-  constructor(knock, feedId, options) {
-    this.knock = knock;
-    this.feedId = feedId;
-    _defineProperty(this, "apiClient", void 0);
-    _defineProperty(this, "userFeedId", void 0);
-    _defineProperty(this, "channel", void 0);
-    _defineProperty(this, "broadcaster", void 0);
-    _defineProperty(this, "defaultOptions", void 0);
-    _defineProperty(this, "broadcastChannel", void 0);
-    _defineProperty(this, "disconnectTimer", null);
+}, y = 2e3;
+class A {
+  constructor(e, t, s) {
+    u(this, "userFeedId");
+    u(this, "channel");
+    u(this, "broadcaster");
+    u(this, "defaultOptions");
+    u(this, "broadcastChannel");
+    u(this, "disconnectTimer", null);
+    u(this, "hasSubscribedToRealTimeUpdates", !1);
     // The raw store instance, used for binding in React and other environments
-    _defineProperty(this, "store", void 0);
-    this.apiClient = knock.client();
-    this.feedId = feedId;
-    this.userFeedId = this.buildUserFeedId();
-    this.store = createStore();
-    this.broadcaster = new EventEmitter({
-      wildcard: true,
-      delimiter: "."
-    });
-    this.defaultOptions = _objectSpread(_objectSpread({}, feedClientDefaults), options);
-
-    // In server environments we might not have a socket connection
-    if (this.apiClient.socket) {
-      this.channel = this.apiClient.socket.channel("feeds:".concat(this.userFeedId), this.defaultOptions);
-      this.channel.on("new-message", resp => this.onNewMessageReceived(resp));
-    }
-
-    // Attempt to bind to listen to other events from this feed in different tabs
-    // Note: here we ensure `self` is available (it's not in server rendered envs)
-    this.broadcastChannel = typeof self !== "undefined" && "BroadcastChannel" in self ? new BroadcastChannel("knock:feed:".concat(this.userFeedId)) : null;
-    if (options.auto_manage_socket_connection && this.apiClient.socket) {
-      this.setupAutoSocketManager(options.auto_manage_socket_connection_delay);
-    }
+    u(this, "store");
+    this.knock = e, this.feedId = t, this.feedId = t, this.userFeedId = this.buildUserFeedId(), this.store = g(), this.broadcaster = new k({ wildcard: !0, delimiter: "." }), this.defaultOptions = { ...v, ...s }, this.knock.log(`[Feed] Initialized a feed on channel ${t}`), this.initializeRealtimeConnection(), this.setupBroadcastChannel();
+  }
+  /**
+   * Used to reinitialize a current feed instance, which is useful when reauthenticating users
+   */
+  reinitialize() {
+    this.userFeedId = this.buildUserFeedId(), this.initializeRealtimeConnection(), this.setupBroadcastChannel();
   }
-
   /**
    * Cleans up a feed instance by destroying the store and disconnecting
    * an open socket connection.
    */
   teardown() {
-    if (this.channel) {
-      this.channel.leave();
-      this.channel.off("new-message");
-    }
-    this.broadcaster.removeAllListeners();
-    this.store.destroy();
-    if (this.broadcastChannel) {
-      this.broadcastChannel.close();
-    }
+    this.knock.log("[Feed] Tearing down feed instance"), this.channel && (this.channel.leave(), this.channel.off("new-message")), this.disconnectTimer && (clearTimeout(this.disconnectTimer), this.disconnectTimer = null), this.broadcastChannel && this.broadcastChannel.close();
+  }
+  /** Tears down an instance and removes it entirely from the feed manager */
+  dispose() {
+    this.knock.log("[Feed] Disposing of feed instance"), this.teardown(), this.broadcaster.removeAllListeners(), this.knock.feeds.removeInstance(this);
   }
-
   /*
     Initializes a real-time connection to Knock, connecting the websocket for the
     current ApiClient instance if the socket is not already connected.
   */
   listenForUpdates() {
-    // Connect the socket only if we don't already have a connection
-    if (this.apiClient.socket && !this.apiClient.socket.isConnected()) {
-      this.apiClient.socket.connect();
-    }
-
-    // Only join the channel if we're not already in a joining state
-    if (this.channel && ["closed", "errored"].includes(this.channel.state)) {
-      this.channel.join();
-    }
-
-    // Opt into receiving updates from _other tabs for the same user / feed_ via the broadcast
-    // channel (iff it's enabled and exists)
-    if (this.broadcastChannel && this.defaultOptions.__experimentalCrossBrowserUpdates === true) {
-      this.broadcastChannel.onmessage = e => {
-        switch (e.data.type) {
-          case "items:archived":
-          case "items:unarchived":
-          case "items:seen":
-          case "items:unseen":
-          case "items:read":
-          case "items:unread":
-          case "items:all_read":
-          case "items:all_seen":
-          case "items:all_archived":
-            // When items are updated in any other tab, simply refetch to get the latest state
-            // to make sure that the state gets updated accordingly. In the future here we could
-            // maybe do this optimistically without the fetch.
-            return this.fetch();
-            break;
-          default:
-            return null;
-        }
-      };
-    }
+    this.knock.log("[Feed] Connecting to real-time service"), this.hasSubscribedToRealTimeUpdates = !0;
+    const e = this.knock.client().socket;
+    e && !e.isConnected() && e.connect(), this.channel && ["closed", "errored"].includes(this.channel.state) && this.channel.join();
   }
-
   /* Binds a handler to be invoked when event occurs */
-  on(eventName, callback) {
-    this.broadcaster.on(eventName, callback);
+  on(e, t) {
+    this.broadcaster.on(e, t);
   }
-  off(eventName, callback) {
-    this.broadcaster.off(eventName, callback);
+  off(e, t) {
+    this.broadcaster.off(e, t);
   }
   getState() {
     return this.store.getState();
   }
-  markAsSeen(itemOrItems) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      var now = new Date().toISOString();
-      _this.optimisticallyPerformStatusUpdate(itemOrItems, "seen", {
-        seen_at: now
-      }, "unseen_count");
-      return _this.makeStatusUpdate(itemOrItems, "seen");
-    })();
+  async markAsSeen(e) {
+    const t = (/* @__PURE__ */ new Date()).toISOString();
+    return this.optimisticallyPerformStatusUpdate(
+      e,
+      "seen",
+      { seen_at: t },
+      "unseen_count"
+    ), this.makeStatusUpdate(e, "seen");
   }
-  markAllAsSeen() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      // To mark all of the messages as seen we:
-      // 1. Optimistically update *everything* we have in the store
-      // 2. We decrement the `unseen_count` to zero optimistically
-      // 3. We issue the API call to the endpoint
-      //
-      // Note: there is the potential for a race condition here because the bulk
-      // update is an async method, so if a new message comes in during this window before
-      // the update has been processed we'll effectively reset the `unseen_count` to be what it was.
-      //
-      // Note: here we optimistically handle the case whereby the feed is scoped to show only `unseen`
-      // items by removing everything from view.
-      var {
-        getState,
-        setState
-      } = _this2.store;
-      var {
-        metadata,
-        items
-      } = getState();
-      var isViewingOnlyUnseen = _this2.defaultOptions.status === "unseen";
-
-      // If we're looking at the unseen view, then we want to remove all of the items optimistically
-      // from the store given that nothing should be visible. We do this by resetting the store state
-      // and setting the current metadata counts to 0
-      if (isViewingOnlyUnseen) {
-        setState(store => store.resetStore(_objectSpread(_objectSpread({}, metadata), {}, {
+  async markAllAsSeen() {
+    const { getState: e, setState: t } = this.store, { metadata: s, items: a } = e();
+    if (this.defaultOptions.status === "unseen")
+      t(
+        (i) => i.resetStore({
+          ...s,
           total_count: 0,
           unseen_count: 0
-        })));
-      } else {
-        // Otherwise we want to update the metadata and mark all of the items in the store as seen
-        setState(store => store.setMetadata(_objectSpread(_objectSpread({}, metadata), {}, {
-          unseen_count: 0
-        })));
-        var attrs = {
-          seen_at: new Date().toISOString()
-        };
-        var itemIds = items.map(item => item.id);
-        setState(store => store.setItemAttrs(itemIds, attrs));
-      }
-
-      // Issue the API request to the bulk status change API
-      var result = yield _this2.makeBulkStatusUpdate("seen");
-      _this2.broadcaster.emit("items:all_seen", {
-        items
-      });
-      _this2.broadcastOverChannel("items:all_seen", {
-        items
-      });
-      return result;
-    })();
+        })
+      );
+    else {
+      t((o) => o.setMetadata({ ...s, unseen_count: 0 }));
+      const i = { seen_at: (/* @__PURE__ */ new Date()).toISOString() }, l = a.map((o) => o.id);
+      t((o) => o.setItemAttrs(l, i));
+    }
+    const n = await this.makeBulkStatusUpdate("seen");
+    return this.broadcaster.emit("items:all_seen", { items: a }), this.broadcastOverChannel("items:all_seen", { items: a }), n;
   }
-  markAsUnseen(itemOrItems) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      _this3.optimisticallyPerformStatusUpdate(itemOrItems, "unseen", {
-        seen_at: null
-      }, "unseen_count");
-      return _this3.makeStatusUpdate(itemOrItems, "unseen");
-    })();
+  async markAsUnseen(e) {
+    return this.optimisticallyPerformStatusUpdate(
+      e,
+      "unseen",
+      { seen_at: null },
+      "unseen_count"
+    ), this.makeStatusUpdate(e, "unseen");
   }
-  markAsRead(itemOrItems) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      var now = new Date().toISOString();
-      _this4.optimisticallyPerformStatusUpdate(itemOrItems, "read", {
-        read_at: now
-      }, "unread_count");
-      return _this4.makeStatusUpdate(itemOrItems, "read");
-    })();
+  async markAsRead(e) {
+    const t = (/* @__PURE__ */ new Date()).toISOString();
+    return this.optimisticallyPerformStatusUpdate(
+      e,
+      "read",
+      { read_at: t },
+      "unread_count"
+    ), this.makeStatusUpdate(e, "read");
   }
-  markAllAsRead() {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      // To mark all of the messages as read we:
-      // 1. Optimistically update *everything* we have in the store
-      // 2. We decrement the `unread_count` to zero optimistically
-      // 3. We issue the API call to the endpoint
-      //
-      // Note: there is the potential for a race condition here because the bulk
-      // update is an async method, so if a new message comes in during this window before
-      // the update has been processed we'll effectively reset the `unread_count` to be what it was.
-      //
-      // Note: here we optimistically handle the case whereby the feed is scoped to show only `unread`
-      // items by removing everything from view.
-      var {
-        getState,
-        setState
-      } = _this5.store;
-      var {
-        metadata,
-        items
-      } = getState();
-      var isViewingOnlyUnread = _this5.defaultOptions.status === "unread";
-
-      // If we're looking at the unread view, then we want to remove all of the items optimistically
-      // from the store given that nothing should be visible. We do this by resetting the store state
-      // and setting the current metadata counts to 0
-      if (isViewingOnlyUnread) {
-        setState(store => store.resetStore(_objectSpread(_objectSpread({}, metadata), {}, {
+  async markAllAsRead() {
+    const { getState: e, setState: t } = this.store, { metadata: s, items: a } = e();
+    if (this.defaultOptions.status === "unread")
+      t(
+        (i) => i.resetStore({
+          ...s,
           total_count: 0,
           unread_count: 0
-        })));
-      } else {
-        // Otherwise we want to update the metadata and mark all of the items in the store as seen
-        setState(store => store.setMetadata(_objectSpread(_objectSpread({}, metadata), {}, {
-          unread_count: 0
-        })));
-        var attrs = {
-          read_at: new Date().toISOString()
-        };
-        var itemIds = items.map(item => item.id);
-        setState(store => store.setItemAttrs(itemIds, attrs));
-      }
-
-      // Issue the API request to the bulk status change API
-      var result = yield _this5.makeBulkStatusUpdate("read");
-      _this5.broadcaster.emit("items:all_read", {
-        items
-      });
-      _this5.broadcastOverChannel("items:all_read", {
-        items
-      });
-      return result;
-    })();
+        })
+      );
+    else {
+      t((o) => o.setMetadata({ ...s, unread_count: 0 }));
+      const i = { read_at: (/* @__PURE__ */ new Date()).toISOString() }, l = a.map((o) => o.id);
+      t((o) => o.setItemAttrs(l, i));
+    }
+    const n = await this.makeBulkStatusUpdate("read");
+    return this.broadcaster.emit("items:all_read", { items: a }), this.broadcastOverChannel("items:all_read", { items: a }), n;
   }
-  markAsUnread(itemOrItems) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      _this6.optimisticallyPerformStatusUpdate(itemOrItems, "unread", {
-        read_at: null
-      }, "unread_count");
-      return _this6.makeStatusUpdate(itemOrItems, "unread");
-    })();
+  async markAsUnread(e) {
+    return this.optimisticallyPerformStatusUpdate(
+      e,
+      "unread",
+      { read_at: null },
+      "unread_count"
+    ), this.makeStatusUpdate(e, "unread");
   }
-  markAsInteracted(itemOrItems) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      var now = new Date().toISOString();
-      _this7.optimisticallyPerformStatusUpdate(itemOrItems, "interacted", {
-        read_at: now,
-        interacted_at: now
-      }, "unread_count");
-      return _this7.makeStatusUpdate(itemOrItems, "interacted");
-    })();
+  async markAsInteracted(e) {
+    const t = (/* @__PURE__ */ new Date()).toISOString();
+    return this.optimisticallyPerformStatusUpdate(
+      e,
+      "interacted",
+      {
+        read_at: t,
+        interacted_at: t
+      },
+      "unread_count"
+    ), this.makeStatusUpdate(e, "interacted");
   }
-
   /*
-  Marking one or more items as archived should:
-   - Decrement the badge count for any unread / unseen items
-  - Remove the item from the feed list when the `archived` flag is "exclude" (default)
-   TODO: how do we handle rollbacks?
-  */
-  markAsArchived(itemOrItems) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var {
-        getState,
-        setState
-      } = _this8.store;
-      var state = getState();
-      var shouldOptimisticallyRemoveItems = _this8.defaultOptions.archived === "exclude";
-      var normalizedItems = Array.isArray(itemOrItems) ? itemOrItems : [itemOrItems];
-      var itemIds = normalizedItems.map(item => item.id);
-
-      /*
-        In the code here we want to optimistically update counts and items
-        that are persisted such that we can display updates immediately on the feed
-        without needing to make a network request.
-         Note: right now this does *not* take into account offline handling or any extensive retry
-        logic, so rollbacks aren't considered. That probably needs to be a future consideration for
-        this library.
-         Scenarios to consider:
-         ## Feed scope to archived *only*
-         - Counts should not be decremented
-        - Items should not be removed
-         ## Feed scoped to exclude archived items (the default)
-         - Counts should be decremented
-        - Items should be removed
-         ## Feed scoped to include archived items as well
-         - Counts should not be decremented
-        - Items should not be removed
-      */
-
-      if (shouldOptimisticallyRemoveItems) {
-        // If any of the items are unseen or unread, then capture as we'll want to decrement
-        // the counts for these in the metadata we have
-        var unseenCount = normalizedItems.filter(i => !i.seen_at).length;
-        var unreadCount = normalizedItems.filter(i => !i.read_at).length;
-
-        // Build the new metadata
-        var updatedMetadata = _objectSpread(_objectSpread({}, state.metadata), {}, {
-          total_count: state.metadata.total_count - normalizedItems.length,
-          unseen_count: state.metadata.unseen_count - unseenCount,
-          unread_count: state.metadata.unread_count - unreadCount
-        });
-
-        // Remove the archiving entries
-        var entriesToSet = state.items.filter(item => !itemIds.includes(item.id));
-        setState(state => state.setResult({
-          entries: entriesToSet,
-          meta: updatedMetadata,
-          page_info: state.pageInfo
-        }));
-      } else {
-        // Mark all the entries being updated as archived either way so the state is correct
-        state.setItemAttrs(itemIds, {
-          archived_at: new Date().toISOString()
-        });
-      }
-      return _this8.makeStatusUpdate(itemOrItems, "archived");
-    })();
+    Marking one or more items as archived should:
+  
+    - Decrement the badge count for any unread / unseen items
+    - Remove the item from the feed list when the `archived` flag is "exclude" (default)
+  
+    TODO: how do we handle rollbacks?
+    */
+  async markAsArchived(e) {
+    const { getState: t, setState: s } = this.store, a = t(), r = this.defaultOptions.archived === "exclude", n = Array.isArray(e) ? e : [e], i = n.map((l) => l.id);
+    if (r) {
+      const l = n.filter((c) => !c.seen_at).length, o = n.filter((c) => !c.read_at).length, d = {
+        ...a.metadata,
+        total_count: a.metadata.total_count - n.length,
+        unseen_count: a.metadata.unseen_count - l,
+        unread_count: a.metadata.unread_count - o
+      }, h = a.items.filter(
+        (c) => !i.includes(c.id)
+      );
+      s(
+        (c) => c.setResult({
+          entries: h,
+          meta: d,
+          page_info: c.pageInfo
+        })
+      );
+    } else
+      a.setItemAttrs(i, { archived_at: (/* @__PURE__ */ new Date()).toISOString() });
+    return this.makeStatusUpdate(e, "archived");
   }
-  markAllAsArchived() {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      // Note: there is the potential for a race condition here because the bulk
-      // update is an async method, so if a new message comes in during this window before
-      // the update has been processed we'll effectively reset the `unseen_count` to be what it was.
-      var {
-        setState,
-        getState
-      } = _this9.store;
-      var {
-        items
-      } = getState();
-
-      // Here if we're looking at a feed that excludes all of the archived items by default then we
-      // will want to optimistically remove all of the items from the feed as they are now all excluded
-      var shouldOptimisticallyRemoveItems = _this9.defaultOptions.archived === "exclude";
-      if (shouldOptimisticallyRemoveItems) {
-        // Reset the store to clear out all of items and reset the badge count
-        setState(store => store.resetStore());
-      } else {
-        // Mark all the entries being updated as archived either way so the state is correct
-        setState(store => {
-          var itemIds = items.map(i => i.id);
-          store.setItemAttrs(itemIds, {
-            archived_at: new Date().toISOString()
-          });
-        });
-      }
-
-      // Issue the API request to the bulk status change API
-      var result = yield _this9.makeBulkStatusUpdate("archive");
-      _this9.broadcaster.emit("items:all_archived", {
-        items
-      });
-      _this9.broadcastOverChannel("items:all_archived", {
-        items
-      });
-      return result;
-    })();
+  async markAllAsArchived() {
+    const { setState: e, getState: t } = this.store, { items: s } = t(), a = this.defaultOptions.archived === "exclude";
+    e(a ? (n) => n.resetStore() : (n) => {
+      const i = s.map((l) => l.id);
+      n.setItemAttrs(i, { archived_at: (/* @__PURE__ */ new Date()).toISOString() });
+    });
+    const r = await this.makeBulkStatusUpdate("archive");
+    return this.broadcaster.emit("items:all_archived", { items: s }), this.broadcastOverChannel("items:all_archived", { items: s }), r;
   }
-  markAsUnarchived(itemOrItems) {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      _this10.optimisticallyPerformStatusUpdate(itemOrItems, "unarchived", {
-        archived_at: null
-      });
-      return _this10.makeStatusUpdate(itemOrItems, "unarchived");
-    })();
+  async markAsUnarchived(e) {
+    return this.optimisticallyPerformStatusUpdate(e, "unarchived", {
+      archived_at: null
+    }), this.makeStatusUpdate(e, "unarchived");
   }
-
   /* Fetches the feed content, appending it to the store */
-  fetch() {
-    var _arguments = arguments,
-      _this11 = this;
-    return _asyncToGenerator(function* () {
-      var options = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
-      var {
-        setState,
-        getState
-      } = _this11.store;
-      var {
-        networkStatus
-      } = getState();
-
-      // If there's an existing request in flight, then do nothing
-      if (isRequestInFlight(networkStatus)) {
-        return;
-      }
-
-      // Set the loading type based on the request type it is
-      setState(store => {
-        var _options$__loadingTyp;
-        return store.setNetworkStatus((_options$__loadingTyp = options.__loadingType) !== null && _options$__loadingTyp !== void 0 ? _options$__loadingTyp : NetworkStatus.loading);
-      });
-
-      // Always include the default params, if they have been set
-      var queryParams = _objectSpread(_objectSpread(_objectSpread({}, _this11.defaultOptions), options), {}, {
-        // Unset options that should not be sent to the API
-        __loadingType: undefined,
-        __fetchSource: undefined,
-        __experimentalCrossBrowserUpdates: undefined
-      });
-      var result = yield _this11.apiClient.makeRequest({
-        method: "GET",
-        url: "/v1/users/".concat(_this11.knock.userId, "/feeds/").concat(_this11.feedId),
-        params: queryParams
-      });
-      if (result.statusCode === "error" || !result.body) {
-        setState(store => store.setNetworkStatus(NetworkStatus.error));
-        return {
-          status: result.statusCode,
-          data: result.error || result.body
-        };
-      }
-      var response = {
-        entries: result.body.entries,
-        meta: result.body.meta,
-        page_info: result.body.page_info
-      };
-      if (options.before) {
-        var opts = {
-          shouldSetPage: false,
-          shouldAppend: true
-        };
-        setState(state => state.setResult(response, opts));
-      } else if (options.after) {
-        var _opts = {
-          shouldSetPage: true,
-          shouldAppend: true
-        };
-        setState(state => state.setResult(response, _opts));
-      } else {
-        setState(state => state.setResult(response));
-      }
-
-      // Legacy `messages.new` event, should be removed in a future version
-      _this11.broadcast("messages.new", response);
-
-      // Broadcast the appropriate event type depending on the fetch source
-      var feedEventType = options.__fetchSource === "socket" ? "items.received.realtime" : "items.received.page";
-      var eventPayload = {
-        items: response.entries,
-        metadata: response.meta,
-        event: feedEventType
-      };
-      _this11.broadcast(eventPayload.event, eventPayload);
-      return {
-        data: response,
-        status: result.statusCode
+  async fetch(e = {}) {
+    const { setState: t, getState: s } = this.store, { networkStatus: a } = s();
+    if (S(a))
+      return;
+    t(
+      (d) => d.setNetworkStatus(e.__loadingType ?? f.loading)
+    );
+    const r = {
+      ...this.defaultOptions,
+      ...e,
+      // Unset options that should not be sent to the API
+      __loadingType: void 0,
+      __fetchSource: void 0,
+      __experimentalCrossBrowserUpdates: void 0,
+      auto_manage_socket_connection: void 0,
+      auto_manage_socket_connection_delay: void 0
+    }, n = await this.knock.client().makeRequest({
+      method: "GET",
+      url: `/v1/users/${this.knock.userId}/feeds/${this.feedId}`,
+      params: r
+    });
+    if (n.statusCode === "error" || !n.body)
+      return t((d) => d.setNetworkStatus(f.error)), {
+        status: n.statusCode,
+        data: n.error || n.body
       };
-    })();
+    const i = {
+      entries: n.body.entries,
+      meta: n.body.meta,
+      page_info: n.body.page_info
+    };
+    if (e.before) {
+      const d = { shouldSetPage: !1, shouldAppend: !0 };
+      t((h) => h.setResult(i, d));
+    } else if (e.after) {
+      const d = { shouldSetPage: !0, shouldAppend: !0 };
+      t((h) => h.setResult(i, d));
+    } else
+      t((d) => d.setResult(i));
+    this.broadcast("messages.new", i);
+    const l = e.__fetchSource === "socket" ? "items.received.realtime" : "items.received.page", o = {
+      items: i.entries,
+      metadata: i.meta,
+      event: l
+    };
+    return this.broadcast(o.event, o), { data: i, status: n.statusCode };
   }
-  fetchNextPage() {
-    var _this12 = this;
-    return _asyncToGenerator(function* () {
-      // Attempts to fetch the next page of results (if we have any)
-      var {
-        getState
-      } = _this12.store;
-      var {
-        pageInfo
-      } = getState();
-      if (!pageInfo.after) {
-        // Nothing more to fetch
-        return;
-      }
-      _this12.fetch({
-        after: pageInfo.after,
-        __loadingType: NetworkStatus.fetchMore
-      });
-    })();
+  async fetchNextPage() {
+    const { getState: e } = this.store, { pageInfo: t } = e();
+    t.after && this.fetch({
+      after: t.after,
+      __loadingType: f.fetchMore
+    });
   }
-  broadcast(eventName, data) {
-    this.broadcaster.emit(eventName, data);
+  broadcast(e, t) {
+    this.broadcaster.emit(e, t);
   }
-
   // Invoked when a new real-time message comes in from the socket
-  onNewMessageReceived(_ref) {
-    var _this13 = this;
-    return _asyncToGenerator(function* () {
-      var {
-        metadata
-      } = _ref;
-      // Handle the new message coming in
-      var {
-        getState,
-        setState
-      } = _this13.store;
-      var {
-        items
-      } = getState();
-      var currentHead = items[0];
-      // Optimistically set the badge counts
-      setState(state => state.setMetadata(metadata));
-      // Fetch the items before the current head (if it exists)
-      _this13.fetch({
-        before: currentHead === null || currentHead === void 0 ? void 0 : currentHead.__cursor,
-        __fetchSource: "socket"
-      });
-    })();
+  async onNewMessageReceived({
+    metadata: e
+  }) {
+    this.knock.log("[Feed] Received new real-time message");
+    const { getState: t, setState: s } = this.store, { items: a } = t(), r = a[0];
+    s((n) => n.setMetadata(e)), this.fetch({ before: r == null ? void 0 : r.__cursor, __fetchSource: "socket" });
   }
   buildUserFeedId() {
-    return "".concat(this.feedId, ":").concat(this.knock.userId);
+    return `${this.feedId}:${this.knock.userId}`;
   }
-  optimisticallyPerformStatusUpdate(itemOrItems, type, attrs, badgeCountAttr) {
-    var {
-      getState,
-      setState
-    } = this.store;
-    var normalizedItems = Array.isArray(itemOrItems) ? itemOrItems : [itemOrItems];
-    var itemIds = normalizedItems.map(item => item.id);
-    if (badgeCountAttr) {
-      var {
-        metadata
-      } = getState();
-
-      // We only want to update the counts of items that have not already been counted towards the
-      // badge count total to avoid updating the badge count unnecessarily.
-      var itemsToUpdate = normalizedItems.filter(item => {
-        switch (type) {
+  optimisticallyPerformStatusUpdate(e, t, s, a) {
+    const { getState: r, setState: n } = this.store, i = Array.isArray(e) ? e : [e], l = i.map((o) => o.id);
+    if (a) {
+      const { metadata: o } = r(), d = i.filter((c) => {
+        switch (t) {
           case "seen":
-            return item.seen_at === null;
+            return c.seen_at === null;
           case "unseen":
-            return item.seen_at !== null;
+            return c.seen_at !== null;
           case "read":
           case "interacted":
-            return item.read_at === null;
+            return c.read_at === null;
           case "unread":
-            return item.read_at !== null;
+            return c.read_at !== null;
           default:
-            return true;
+            return !0;
         }
-      });
-
-      // Tnis is a hack to determine the direction of whether we're
-      // adding or removing from the badge count
-      var direction = type.startsWith("un") ? itemsToUpdate.length : -itemsToUpdate.length;
-      setState(store => store.setMetadata(_objectSpread(_objectSpread({}, metadata), {}, {
-        [badgeCountAttr]: Math.max(0, metadata[badgeCountAttr] + direction)
-      })));
+      }), h = t.startsWith("un") ? d.length : -d.length;
+      n(
+        (c) => c.setMetadata({
+          ...o,
+          [a]: Math.max(0, o[a] + h)
+        })
+      );
     }
-
-    // Update the items with the given attributes
-    setState(store => store.setItemAttrs(itemIds, attrs));
+    n((o) => o.setItemAttrs(l, s));
   }
-  makeStatusUpdate(itemOrItems, type) {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      // Always treat items as a batch to use the corresponding batch endpoint
-      var items = Array.isArray(itemOrItems) ? itemOrItems : [itemOrItems];
-      var itemIds = items.map(item => item.id);
-      var result = yield _this14.apiClient.makeRequest({
-        method: "POST",
-        url: "/v1/messages/batch/".concat(type),
-        data: {
-          message_ids: itemIds
-        }
-      });
-
-      // Emit the event that these items had their statuses changed
-      // Note: we do this after the update to ensure that the server event actually completed
-      _this14.broadcaster.emit("items:".concat(type), {
-        items
-      });
-      _this14.broadcastOverChannel("items:".concat(type), {
-        items
-      });
-      return result;
-    })();
+  async makeStatusUpdate(e, t) {
+    const s = Array.isArray(e) ? e : [e], a = s.map((n) => n.id), r = await this.knock.client().makeRequest({
+      method: "POST",
+      url: `/v1/messages/batch/${t}`,
+      data: { message_ids: a }
+    });
+    return this.broadcaster.emit(`items:${t}`, { items: s }), this.broadcastOverChannel(`items:${t}`, { items: s }), r;
   }
-  makeBulkStatusUpdate(type) {
-    var _this15 = this;
-    return _asyncToGenerator(function* () {
-      // The base scope for the call should take into account all of the options currently
-      // set on the feed, as well as being scoped for the current user. We do this so that
-      // we ONLY make changes to the messages that are currently in view on this feed, and not
-      // all messages that exist.
-      var options = {
-        user_ids: [_this15.knock.userId],
-        engagement_status: _this15.defaultOptions.status !== "all" ? _this15.defaultOptions.status : undefined,
-        archived: _this15.defaultOptions.archived,
-        has_tenant: _this15.defaultOptions.has_tenant,
-        tenants: _this15.defaultOptions.tenant ? [_this15.defaultOptions.tenant] : undefined
-      };
-      return yield _this15.apiClient.makeRequest({
-        method: "POST",
-        url: "/v1/channels/".concat(_this15.feedId, "/messages/bulk/").concat(type),
-        data: options
-      });
-    })();
+  async makeBulkStatusUpdate(e) {
+    const t = {
+      user_ids: [this.knock.userId],
+      engagement_status: this.defaultOptions.status !== "all" ? this.defaultOptions.status : void 0,
+      archived: this.defaultOptions.archived,
+      has_tenant: this.defaultOptions.has_tenant,
+      tenants: this.defaultOptions.tenant ? [this.defaultOptions.tenant] : void 0
+    };
+    return await this.knock.client().makeRequest({
+      method: "POST",
+      url: `/v1/channels/${this.feedId}/messages/bulk/${e}`,
+      data: t
+    });
   }
-  broadcastOverChannel(type, payload) {
-    // The broadcastChannel may not be available in non-browser environments
-    if (!this.broadcastChannel) {
-      return;
-    }
-
-    // Here we stringify our payload and try and send as JSON such that we
-    // don't get any `An object could not be cloned` errors when trying to broadcast
-    try {
-      var stringifiedPayload = JSON.parse(JSON.stringify(payload));
-      this.broadcastChannel.postMessage({
-        type,
-        payload: stringifiedPayload
-      });
-    } catch (e) {
-      console.warn("Could not broadcast ".concat(type, ", got error: ").concat(e));
-    }
+  setupBroadcastChannel() {
+    this.broadcastChannel = typeof self < "u" && "BroadcastChannel" in self ? new BroadcastChannel(`knock:feed:${this.userFeedId}`) : null, this.broadcastChannel && this.defaultOptions.__experimentalCrossBrowserUpdates === !0 && (this.broadcastChannel.onmessage = (e) => {
+      switch (e.data.type) {
+        case "items:archived":
+        case "items:unarchived":
+        case "items:seen":
+        case "items:unseen":
+        case "items:read":
+        case "items:unread":
+        case "items:all_read":
+        case "items:all_seen":
+        case "items:all_archived":
+          return this.fetch();
+        default:
+          return null;
+      }
+    });
+  }
+  broadcastOverChannel(e, t) {
+    if (this.broadcastChannel)
+      try {
+        const s = JSON.parse(JSON.stringify(t));
+        this.broadcastChannel.postMessage({
+          type: e,
+          payload: s
+        });
+      } catch (s) {
+        console.warn(`Could not broadcast ${e}, got error: ${s}`);
+      }
+  }
+  initializeRealtimeConnection() {
+    const { socket: e } = this.knock.client();
+    e && (this.channel = e.channel(
+      `feeds:${this.userFeedId}`,
+      this.defaultOptions
+    ), this.channel.on("new-message", (t) => this.onNewMessageReceived(t)), this.defaultOptions.auto_manage_socket_connection && this.setupAutoSocketManager(
+      this.defaultOptions.auto_manage_socket_connection_delay
+    ), this.hasSubscribedToRealTimeUpdates && (e.isConnected() || e.connect(), this.channel.join()));
   }
-
   /**
    * Listen for changes to document visibility and automatically disconnect
    * or reconnect the socket after a delay
    */
-  setupAutoSocketManager(autoManageSocketConnectionDelay) {
-    var disconnectDelay = autoManageSocketConnectionDelay !== null && autoManageSocketConnectionDelay !== void 0 ? autoManageSocketConnectionDelay : DEFAULT_DISCONNECT_DELAY;
+  setupAutoSocketManager(e) {
+    const t = e ?? y;
     document.addEventListener("visibilitychange", () => {
-      if (document.visibilityState === "hidden") {
-        // When the tab is hidden, clean up the socket connection after a delay
-        this.disconnectTimer = setTimeout(() => {
-          this.apiClient.disconnectSocket();
-          this.disconnectTimer = null;
-        }, disconnectDelay);
-      } else if (document.visibilityState === "visible") {
-        var _this$apiClient$socke;
-        // When the tab is visible, clear the disconnect timer if active to cancel disconnecting
-        // This handles cases where the tab is only briefly hidden to avoid unnecessary disconnects
-        if (this.disconnectTimer) {
-          clearTimeout(this.disconnectTimer);
-          this.disconnectTimer = null;
-        }
-
-        // If the socket is not connected, try to reconnect
-        if (!((_this$apiClient$socke = this.apiClient.socket) !== null && _this$apiClient$socke !== void 0 && _this$apiClient$socke.isConnected())) {
-          this.apiClient.reconnectSocket();
-          this.fetch();
-        }
-      }
+      var a;
+      const s = this.knock.client();
+      document.visibilityState === "hidden" ? this.disconnectTimer = setTimeout(() => {
+        var r;
+        (r = s.socket) == null || r.disconnect(), this.disconnectTimer = null;
+      }, t) : document.visibilityState === "visible" && (this.disconnectTimer && (clearTimeout(this.disconnectTimer), this.disconnectTimer = null), (a = s.socket) != null && a.isConnected() || this.initializeRealtimeConnection());
     });
   }
 }
-export default Feed;
-//# sourceMappingURL=feed.js.map
+export {
+  A as default
+};
+//# sourceMappingURL=feed.js.map