@knocklabs/client 0.4.5-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Knock Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# Knock Javascript client library
+
+A client-side Javascript library to interact with user-facing Knock features, such as feeds.
+
+**Note: this is a lower level library designed for building UI on top of**
+
+## Documentation
+
+See the [documentation](https://docs.knock.app/notification-feeds/bring-your-own-ui) for usage examples.
+
+## Installation
+
+Via NPM:
+
+```bash
+npm install @knocklabs/client
+```
+
+Via Yarn:
+
+```bash
+yarn add @knocklabs/client
+```
+
+## Configuration
+
+To configure the client library you will need:
+
+1. A public API key (found in the Knock dashboard)
+2. A feed channel ID (found in the Knock dashboard)
+3. A user ID, and optionally an auth token for production environments
+
+```typescript
+import Knock from "@knocklabs/client";
+
+const knockClient = new Knock(process.env.KNOCK_API_KEY);
+
+knockClient.authenticate(
+  // The id of the user you want to authenticate against
+  currentUser.id,
+  // You only need this in production environments
+  currentUser.knockToken,
+);
+```
+
+## Usage
+
+You can find an example usage in a React application in the [example/App.js](https://github.com/knocklabs/client-js/blob/main/example/src/App.js) file, which is a plain-old Create React App.
+
+### Retrieving new items from the feed
+
+```typescript
+import Knock from "@knocklabs/client";
+
+const knockClient = new Knock(process.env.KNOCK_API_KEY);
+
+// Authenticate the user
+knockClient.authenticate(currentUser.id, currentUser.knockToken);
+
+// Initialize the feed
+const feedClient = knockClient.feeds.initialize(
+  process.env.KNOCK_FEED_CHANNEL_ID,
+  // Optionally you can provide a default scope here:
+  // { tenant: "jurassic-park", source: "new-comment" },
+);
+
+// Connect to the real-time socket
+const teardown = feedClient.listenForUpdates();
+
+// Setup a callback for when a batch of messages is received (including on first load)
+feedClient.on("messages.new", ({ entries }) => {
+  console.log(entries);
+});
+
+// Fetch the feed items
+feedClient.fetch({
+  // Fetch a particular status only (defaults to all)
+  status: "all" | "unread" | "unseen",
+  // Pagination options
+  after: lastItem.__cursor,
+  before: firstItem.__cursor,
+  // Defaults to 50
+  page_size: 10,
+  // Filter by a specific source
+  source: "notification-key",
+  // Filter by a specific tenant
+  tenant: "jurassic-park",
+});
+
+teardown();
+```
+
+### Reading the feed store state (programmatically)
+
+```typescript
+// Initialize the feed as in above examples
+const feedClient = knockClient.feeds.initialize(
+  process.env.KNOCK_FEED_CHANNEL_ID,
+);
+
+// Gives you all of the items currently in the store
+const { items } = feedClient.store.getState();
+```
+
+### Reading the feed store state (in React)
+
+```typescript
+// The feed store uses zustand
+import create from "zustand";
+
+// Initialize the feed as in above examples
+const feedClient = knockClient.feeds.initialize(
+  process.env.KNOCK_FEED_CHANNEL_ID,
+);
+
+const useFeedStore = create(feedClient.store);
+
+// Retrieves all of the items
+const items = useFeedStore((state) => state.items);
+
+// Retrieve the badge counts
+const meta = useFeedStore((state) => state.metadata);
+```
+
+### Marking items as read, seen, or archived
+
+```typescript
+// Initialize the feed as in above examples
+const feedClient = knockClient.feeds.initialize(
+  process.env.KNOCK_FEED_CHANNEL_ID,
+);
+
+// Mark one or more items as read
+feedClient.markAsRead(feedItemOrItems);
+// Mark one or more items as seen
+feedClient.markAsSeen(feedItemOrItems);
+// Mark one or more items as archived
+feedClient.markAsArchived(feedItemOrItems);
+
+// Mark one or more items as unread
+feedClient.markAsUnread(feedItemOrItems);
+// Mark one or more items as unseen
+feedClient.markAsUnseen(feedItemOrItems);
+// Mark one or more items as unarchived
+feedClient.markAsUnarchived(feedItemOrItems);
+```
+
+### Managing user preferences
+
+```typescript
+// Set an entire preference set
+await knockClient.preferences.set({
+  channel_types: { email: true, sms: false },
+  workflows: {
+    "dinosaurs-loose": {
+      channel_types: { email: false, in_app_feed: true },
+    },
+  },
+});
+
+// Retrieve a whole preference set
+const preferences = await knockClient.preferences.get();
+
+// Granular preference setting for channel types
+await knockClient.preferences.setChannelType("email", false);
+
+// Granular preference setting for workflows
+await knockClient.preferences.setWorkflow("dinosaurs-loose", {
+  channel_types: {
+    email: true,
+    in_app_feed: false,
+  },
+});
+```

package/dist/cjs/api.js

@@ -0,0 +1,165 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _axiosRetry = _interopRequireDefault(require("axios-retry"));
+
+var _phoenix = require("phoenix");
+
+var ApiClient = /*#__PURE__*/function () {
+  function ApiClient(options) {
+    (0, _classCallCheck2["default"])(this, ApiClient);
+    (0, _defineProperty2["default"])(this, "host", void 0);
+    (0, _defineProperty2["default"])(this, "apiKey", void 0);
+    (0, _defineProperty2["default"])(this, "userToken", void 0);
+    (0, _defineProperty2["default"])(this, "axiosClient", void 0);
+    (0, _defineProperty2["default"])(this, "socket", void 0);
+    (0, _defineProperty2["default"])(this, "socketConnected", false);
+    this.host = options.host;
+    this.apiKey = options.apiKey;
+    this.userToken = options.userToken || null; // Create a retryable axios client
+
+    this.axiosClient = _axios["default"].create({
+      baseURL: this.host,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: "Bearer ".concat(this.apiKey),
+        "X-Knock-User-Token": this.userToken
+      }
+    });
+    this.socket = new _phoenix.Socket("".concat(this.host.replace("http", "ws"), "/ws/v1"), {
+      params: {
+        user_token: this.userToken,
+        api_key: this.apiKey
+      }
+    });
+    (0, _axiosRetry["default"])(this.axiosClient, {
+      retries: 3,
+      retryCondition: this.canRetryRequest,
+      retryDelay: _axiosRetry["default"].exponentialDelay
+    });
+  }
+
+  (0, _createClass2["default"])(ApiClient, [{
+    key: "connectSocket",
+    value: function connectSocket() {
+      var _this = this;
+
+      if (this.socketConnected) {
+        return;
+      }
+
+      this.socket.connect();
+      this.socket.onOpen(function () {
+        _this.socketConnected = true;
+      });
+    }
+  }, {
+    key: "disconnectSocket",
+    value: function disconnectSocket() {
+      this.socket.disconnect();
+      return;
+    }
+  }, {
+    key: "createChannel",
+    value: function createChannel(name, params) {
+      return this.socket.channel(name, params);
+    }
+  }, {
+    key: "makeRequest",
+    value: function () {
+      var _makeRequest = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(req) {
+        var result;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
+                _context.next = 3;
+                return this.axiosClient(req);
+
+              case 3:
+                result = _context.sent;
+                return _context.abrupt("return", {
+                  statusCode: result.status < 300 ? "ok" : "error",
+                  body: result.data,
+                  error: undefined,
+                  status: result.status
+                });
+
+              case 7:
+                _context.prev = 7;
+                _context.t0 = _context["catch"](0);
+                // tslint:disable-next-line
+                console.error(_context.t0);
+                return _context.abrupt("return", {
+                  statusCode: "error",
+                  status: 500,
+                  body: undefined,
+                  error: _context.t0
+                });
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[0, 7]]);
+      }));
+
+      function makeRequest(_x) {
+        return _makeRequest.apply(this, arguments);
+      }
+
+      return makeRequest;
+    }()
+  }, {
+    key: "canRetryRequest",
+    value: function canRetryRequest(error) {
+      // Retry Network Errors.
+      if (_axiosRetry["default"].isNetworkError(error)) {
+        return true;
+      }
+
+      if (!error.response) {
+        // Cannot determine if the request can be retried
+        return false;
+      } // Retry Server Errors (5xx).
+
+
+      if (error.response.status >= 500 && error.response.status <= 599) {
+        return true;
+      } // Retry if rate limited.
+
+
+      if (error.response.status === 429) {
+        return true;
+      }
+
+      return false;
+    }
+  }]);
+  return ApiClient;
+}();
+
+var _default = ApiClient;
+exports["default"] = _default;
+//# sourceMappingURL=api.js.map

package/dist/cjs/api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api.ts"],"names":["ApiClient","options","host","apiKey","userToken","axiosClient","axios","create","baseURL","headers","Accept","Authorization","socket","Socket","replace","params","user_token","api_key","retries","retryCondition","canRetryRequest","retryDelay","axiosRetry","exponentialDelay","socketConnected","connect","onOpen","disconnect","name","channel","req","result","statusCode","status","body","data","error","undefined","console","isNetworkError","response"],"mappings":"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","sourcesContent":["import axios, { AxiosInstance, AxiosRequestConfig } from \"axios\";\nimport axiosRetry from \"axios-retry\";\nimport { Socket } from \"phoenix\";\nimport { AxiosError } from \"axios\";\n\ntype ApiClientOptions = {\n  host: string;\n  apiKey: string;\n  userToken: string | undefined;\n};\n\nexport interface ApiResponse {\n  error?: any;\n  body?: any;\n  statusCode: \"ok\" | \"error\";\n  status: number;\n}\n\nclass ApiClient {\n  private host: string;\n  private apiKey: string;\n  private userToken: string | null;\n  private axiosClient: AxiosInstance;\n  private socket: Socket;\n  public socketConnected: boolean = false;\n\n  constructor(options: ApiClientOptions) {\n    this.host = options.host;\n    this.apiKey = options.apiKey;\n    this.userToken = options.userToken || null;\n\n    // Create a retryable axios client\n    this.axiosClient = axios.create({\n      baseURL: this.host,\n      headers: {\n        Accept: \"application/json\",\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.apiKey}`,\n        \"X-Knock-User-Token\": this.userToken,\n      },\n    });\n\n    this.socket = new Socket(`${this.host.replace(\"http\", \"ws\")}/ws/v1`, {\n      params: {\n        user_token: this.userToken,\n        api_key: this.apiKey,\n      },\n    });\n\n    axiosRetry(this.axiosClient, {\n      retries: 3,\n      retryCondition: this.canRetryRequest,\n      retryDelay: axiosRetry.exponentialDelay,\n    });\n  }\n\n  connectSocket() {\n    if (this.socketConnected) {\n      return;\n    }\n\n    this.socket.connect();\n    this.socket.onOpen(() => {\n      this.socketConnected = true;\n    });\n  }\n\n  disconnectSocket() {\n    this.socket.disconnect();\n    return;\n  }\n\n  createChannel(name: string, params?: object) {\n    return this.socket.channel(name, params);\n  }\n\n  async makeRequest(req: AxiosRequestConfig): Promise<ApiResponse> {\n    try {\n      const result = await this.axiosClient(req);\n\n      return {\n        statusCode: result.status < 300 ? \"ok\" : \"error\",\n        body: result.data,\n        error: undefined,\n        status: result.status,\n      };\n    } catch (e) {\n      // tslint:disable-next-line\n      console.error(e);\n\n      return {\n        statusCode: \"error\",\n        status: 500,\n        body: undefined,\n        error: e,\n      };\n    }\n  }\n\n  private canRetryRequest(error: AxiosError) {\n    // Retry Network Errors.\n    if (axiosRetry.isNetworkError(error)) {\n      return true;\n    }\n\n    if (!error.response) {\n      // Cannot determine if the request can be retried\n      return false;\n    }\n\n    // Retry Server Errors (5xx).\n    if (error.response.status >= 500 && error.response.status <= 599) {\n      return true;\n    }\n\n    // Retry if rate limited.\n    if (error.response.status === 429) {\n      return true;\n    }\n\n    return false;\n  }\n}\n\nexport default ApiClient;\n"],"file":"api.js"}

package/dist/cjs/clients/feed/feed.js

@@ -0,0 +1,557 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _eventemitter = _interopRequireDefault(require("eventemitter3"));
+
+var _store = _interopRequireDefault(require("./store"));
+
+var _networkStatus = require("../../networkStatus");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var Feed = /*#__PURE__*/function () {
+  // The raw store instance, used for binding in React and other environments
+  function Feed(knock, feedId, options) {
+    (0, _classCallCheck2["default"])(this, Feed);
+    this.knock = knock;
+    this.feedId = feedId;
+    (0, _defineProperty2["default"])(this, "apiClient", void 0);
+    (0, _defineProperty2["default"])(this, "userFeedId", void 0);
+    (0, _defineProperty2["default"])(this, "channelConnected", false);
+    (0, _defineProperty2["default"])(this, "channel", void 0);
+    (0, _defineProperty2["default"])(this, "broadcaster", void 0);
+    (0, _defineProperty2["default"])(this, "defaultOptions", void 0);
+    (0, _defineProperty2["default"])(this, "store", void 0);
+    this.apiClient = knock.client();
+    this.feedId = feedId;
+    this.userFeedId = this.buildUserFeedId();
+    this.store = (0, _store["default"])();
+    this.broadcaster = new _eventemitter["default"]();
+    this.defaultOptions = options; // Try and connect to the socket
+
+    this.apiClient.connectSocket();
+    this.channel = this.apiClient.createChannel("feeds:".concat(this.userFeedId), this.defaultOptions);
+  }
+  /*
+    Returns a socket to listen for feed updates
+  */
+
+
+  (0, _createClass2["default"])(Feed, [{
+    key: "listenForUpdates",
+    value: function listenForUpdates() {
+      var _this = this;
+
+      if (!this.channelConnected) {
+        this.channel.join().receive("ok", function () {
+          _this.channelConnected = true;
+        });
+        this.channel.on("new-message", function (resp) {
+          return _this.onNewMessageReceived(resp);
+        });
+      }
+
+      return function () {
+        try {
+          _this.channel.leave();
+        } catch (e) {
+          // tslint:disable-next-line
+          console.error("error while leaving channel", e);
+        }
+      };
+    }
+    /* Binds a handler to be invoked when event occurs */
+
+  }, {
+    key: "on",
+    value: function on(eventName, callback) {
+      this.broadcaster.on(eventName, callback);
+    }
+  }, {
+    key: "off",
+    value: function off(eventName, callback) {
+      this.broadcaster.off(eventName, callback);
+    }
+  }, {
+    key: "getState",
+    value: function getState() {
+      return this.store.getState();
+    }
+  }, {
+    key: "markAsSeen",
+    value: function () {
+      var _markAsSeen = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(itemOrItems) {
+        var now;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                now = new Date().toISOString();
+                this.optimisticallyPerformStatusUpdate(itemOrItems, "seen", {
+                  seen_at: now
+                }, "unseen_count");
+                return _context.abrupt("return", this.makeStatusUpdate(itemOrItems, "seen"));
+
+              case 3:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function markAsSeen(_x) {
+        return _markAsSeen.apply(this, arguments);
+      }
+
+      return markAsSeen;
+    }()
+  }, {
+    key: "markAsUnseen",
+    value: function () {
+      var _markAsUnseen = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(itemOrItems) {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                this.optimisticallyPerformStatusUpdate(itemOrItems, "unseen", {
+                  seen_at: null
+                }, "unseen_count");
+                return _context2.abrupt("return", this.makeStatusUpdate(itemOrItems, "unseen"));
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function markAsUnseen(_x2) {
+        return _markAsUnseen.apply(this, arguments);
+      }
+
+      return markAsUnseen;
+    }()
+  }, {
+    key: "markAsRead",
+    value: function () {
+      var _markAsRead = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(itemOrItems) {
+        var now;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                now = new Date().toISOString();
+                this.optimisticallyPerformStatusUpdate(itemOrItems, "read", {
+                  read_at: now
+                }, "unread_count");
+                return _context3.abrupt("return", this.makeStatusUpdate(itemOrItems, "read"));
+
+              case 3:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function markAsRead(_x3) {
+        return _markAsRead.apply(this, arguments);
+      }
+
+      return markAsRead;
+    }()
+  }, {
+    key: "markAsUnread",
+    value: function () {
+      var _markAsUnread = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(itemOrItems) {
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                this.optimisticallyPerformStatusUpdate(itemOrItems, "unread", {
+                  read_at: null
+                }, "unread_count");
+                return _context4.abrupt("return", this.makeStatusUpdate(itemOrItems, "unread"));
+
+              case 2:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function markAsUnread(_x4) {
+        return _markAsUnread.apply(this, arguments);
+      }
+
+      return markAsUnread;
+    }()
+  }, {
+    key: "markAsArchived",
+    value: function () {
+      var _markAsArchived = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(itemOrItems) {
+        var now;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                now = new Date().toISOString();
+                this.optimisticallyPerformStatusUpdate(itemOrItems, "archived", {
+                  archived_at: now
+                });
+                return _context5.abrupt("return", this.makeStatusUpdate(itemOrItems, "archived"));
+
+              case 3:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function markAsArchived(_x5) {
+        return _markAsArchived.apply(this, arguments);
+      }
+
+      return markAsArchived;
+    }()
+  }, {
+    key: "markAsUnarchived",
+    value: function () {
+      var _markAsUnarchived = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(itemOrItems) {
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                this.optimisticallyPerformStatusUpdate(itemOrItems, "unarchived", {
+                  archived_at: null
+                });
+                return _context6.abrupt("return", this.makeStatusUpdate(itemOrItems, "unarchived"));
+
+              case 2:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function markAsUnarchived(_x6) {
+        return _markAsUnarchived.apply(this, arguments);
+      }
+
+      return markAsUnarchived;
+    }()
+    /* Fetches the feed content, appending it to the store */
+
+  }, {
+    key: "fetch",
+    value: function () {
+      var _fetch = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+        var options,
+            _this$store,
+            setState,
+            getState,
+            _getState,
+            networkStatus,
+            queryParams,
+            result,
+            response,
+            opts,
+            _opts,
+            _args7 = arguments;
+
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                options = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : {};
+                _this$store = this.store, setState = _this$store.setState, getState = _this$store.getState;
+                _getState = getState(), networkStatus = _getState.networkStatus; // If there's an existing request in flight, then do nothing
+
+                if (!(0, _networkStatus.isRequestInFlight)(networkStatus)) {
+                  _context7.next = 5;
+                  break;
+                }
+
+                return _context7.abrupt("return");
+
+              case 5:
+                // Set the loading type based on the request type it is
+                setState(function (store) {
+                  var _options$__loadingTyp;
+
+                  return store.setNetworkStatus((_options$__loadingTyp = options.__loadingType) !== null && _options$__loadingTyp !== void 0 ? _options$__loadingTyp : _networkStatus.NetworkStatus.loading);
+                }); // Always include the default params, if they have been set
+
+                queryParams = _objectSpread(_objectSpread({}, this.defaultOptions), options);
+                _context7.next = 9;
+                return this.apiClient.makeRequest({
+                  method: "GET",
+                  url: "/v1/users/".concat(this.knock.userId, "/feeds/").concat(this.feedId),
+                  params: queryParams
+                });
+
+              case 9:
+                result = _context7.sent;
+
+                if (!(result.statusCode === "error")) {
+                  _context7.next = 13;
+                  break;
+                }
+
+                setState(function (store) {
+                  return store.setNetworkStatus(_networkStatus.NetworkStatus.error);
+                });
+                return _context7.abrupt("return", {
+                  status: result.statusCode,
+                  data: result.error || result.body
+                });
+
+              case 13:
+                response = {
+                  entries: result.body.entries,
+                  meta: result.body.meta,
+                  page_info: result.body.page_info
+                };
+
+                if (options.before) {
+                  opts = {
+                    shouldSetPage: false,
+                    shouldAppend: true
+                  };
+                  setState(function (state) {
+                    return state.setResult(response, opts);
+                  });
+                } else if (options.after) {
+                  _opts = {
+                    shouldSetPage: true,
+                    shouldAppend: true
+                  };
+                  setState(function (state) {
+                    return state.setResult(response, _opts);
+                  });
+                } else {
+                  setState(function (state) {
+                    return state.setResult(response);
+                  });
+                }
+
+                this.broadcast("messages.new", response);
+                return _context7.abrupt("return", {
+                  data: response,
+                  status: result.statusCode
+                });
+
+              case 17:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function fetch() {
+        return _fetch.apply(this, arguments);
+      }
+
+      return fetch;
+    }()
+  }, {
+    key: "fetchNextPage",
+    value: function () {
+      var _fetchNextPage = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+        var getState, _getState2, pageInfo;
+
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                // Attempts to fetch the next page of results (if we have any)
+                getState = this.store.getState;
+                _getState2 = getState(), pageInfo = _getState2.pageInfo;
+
+                if (pageInfo.after) {
+                  _context8.next = 4;
+                  break;
+                }
+
+                return _context8.abrupt("return");
+
+              case 4:
+                this.fetch({
+                  after: pageInfo.after,
+                  __loadingType: _networkStatus.NetworkStatus.fetchMore
+                });
+
+              case 5:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function fetchNextPage() {
+        return _fetchNextPage.apply(this, arguments);
+      }
+
+      return fetchNextPage;
+    }()
+  }, {
+    key: "broadcast",
+    value: function broadcast(eventName, data) {
+      this.broadcaster.emit(eventName, data);
+    } // Invoked when a new real-time message comes in from the socket
+
+  }, {
+    key: "onNewMessageReceived",
+    value: function () {
+      var _onNewMessageReceived = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(_ref) {
+        var metadata, _this$store2, getState, setState, currentHead;
+
+        return _regenerator["default"].wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                metadata = _ref.metadata;
+                // Handle the new message coming in
+                _this$store2 = this.store, getState = _this$store2.getState, setState = _this$store2.setState;
+                currentHead = getState().items[0]; // Optimistically set the badge counts
+
+                setState(function (state) {
+                  return state.setMetadata(metadata);
+                }); // Fetch the items before the current head (if it exists)
+
+                this.fetch({
+                  before: currentHead === null || currentHead === void 0 ? void 0 : currentHead.__cursor
+                });
+
+              case 5:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function onNewMessageReceived(_x7) {
+        return _onNewMessageReceived.apply(this, arguments);
+      }
+
+      return onNewMessageReceived;
+    }()
+  }, {
+    key: "buildUserFeedId",
+    value: function buildUserFeedId() {
+      return "".concat(this.feedId, ":").concat(this.knock.userId);
+    }
+  }, {
+    key: "optimisticallyPerformStatusUpdate",
+    value: function optimisticallyPerformStatusUpdate(itemOrItems, type, attrs, badgeCountAttr) {
+      var _this$store3 = this.store,
+          getState = _this$store3.getState,
+          setState = _this$store3.setState;
+      var itemIds = Array.isArray(itemOrItems) ? itemOrItems.map(function (item) {
+        return item.id;
+      }) : [itemOrItems.id];
+
+      if (badgeCountAttr) {
+        var _getState3 = getState(),
+            metadata = _getState3.metadata; // Tnis is a hack to determine the direction of whether we're
+        // adding or removing from the badge count
+
+
+        var direction = type.startsWith("un") ? itemIds.length : -itemIds.length;
+        setState(function (store) {
+          return store.setMetadata(_objectSpread(_objectSpread({}, metadata), {}, (0, _defineProperty2["default"])({}, badgeCountAttr, Math.max(0, metadata[badgeCountAttr] + direction))));
+        });
+      } // Update the items with the given attributes
+
+
+      setState(function (store) {
+        return store.setItemAttrs(itemIds, attrs);
+      });
+    }
+  }, {
+    key: "makeStatusUpdate",
+    value: function () {
+      var _makeStatusUpdate = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10(itemOrItems, type) {
+        var itemIds, result;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                if (!Array.isArray(itemOrItems)) {
+                  _context10.next = 5;
+                  break;
+                }
+
+                itemIds = itemOrItems.map(function (item) {
+                  return item.id;
+                });
+                _context10.next = 4;
+                return this.apiClient.makeRequest({
+                  method: "POST",
+                  url: "/v1/messages/batch/".concat(type),
+                  data: {
+                    message_ids: itemIds
+                  }
+                });
+
+              case 4:
+                return _context10.abrupt("return", _context10.sent);
+
+              case 5:
+                _context10.next = 7;
+                return this.apiClient.makeRequest({
+                  method: type.startsWith("un") ? "DELETE" : "PUT",
+                  url: "/v1/messages/".concat(itemOrItems.id, "/").concat(type)
+                });
+
+              case 7:
+                result = _context10.sent;
+                return _context10.abrupt("return", result);
+
+              case 9:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this);
+      }));
+
+      function makeStatusUpdate(_x8, _x9) {
+        return _makeStatusUpdate.apply(this, arguments);
+      }
+
+      return makeStatusUpdate;
+    }()
+  }]);
+  return Feed;
+}();
+
+var _default = Feed;
+exports["default"] = _default;
+//# sourceMappingURL=feed.js.map