box-ui-elements 16.0.0-beta.9 → 16.0.0

package/es/api/Feed.js

@@ -6,22 +6,10 @@ function _nonIterableRest() { throw new TypeError("Invalid attempt to destructur
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-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) { _defineProperty(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; }
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
@@ -42,8 +30,24 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+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) { _defineProperty(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; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
 /**
  * 
  * @file Helper for activity feed API's
@@ -51,22 +55,46 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  */
 import uniqueId from 'lodash/uniqueId';
 import noop from 'lodash/noop';
-import { getBadItemError, getBadUserError, isUserCorrectableError } from '../utils/error';
+import { getBadItemError, getBadUserError, getMissingItemTextOrStatus, isUserCorrectableError } from '../utils/error';
 import commonMessages from '../elements/common/messages';
 import messages from './messages';
 import { sortFeedItems } from '../utils/sorter';
+import { FEED_FILE_VERSIONS_FIELDS_TO_FETCH } from '../utils/fields';
 import Base from './Base';
 import AnnotationsAPI from './Annotations';
 import CommentsAPI from './Comments';
+import ThreadedCommentsAPI from './ThreadedComments';
 import VersionsAPI from './Versions';
 import TasksNewAPI from './tasks/TasksNew';
 import GroupsAPI from './Groups';
 import TaskCollaboratorsAPI from './tasks/TaskCollaborators';
 import TaskLinksAPI from './tasks/TaskLinks';
 import AppActivityAPI from './AppActivity';
-import { ERROR_CODE_CREATE_TASK, ERROR_CODE_UPDATE_TASK, ERROR_CODE_GROUP_EXCEEDS_LIMIT, HTTP_STATUS_CODE_CONFLICT, IS_ERROR_DISPLAYED, TASK_NEW_APPROVED, TASK_NEW_COMPLETED, TASK_NEW_REJECTED, TASK_NEW_NOT_STARTED, TYPED_ID_FEED_PREFIX, TASK_MAX_GROUP_ASSIGNEES } from '../constants';
+import { ERROR_CODE_CREATE_TASK, ERROR_CODE_UPDATE_TASK, ERROR_CODE_GROUP_EXCEEDS_LIMIT, FEED_ITEM_TYPE_ANNOTATION, FEED_ITEM_TYPE_COMMENT, FEED_ITEM_TYPE_TASK, HTTP_STATUS_CODE_CONFLICT, IS_ERROR_DISPLAYED, TASK_NEW_APPROVED, TASK_NEW_COMPLETED, TASK_NEW_REJECTED, TASK_NEW_NOT_STARTED, TYPED_ID_FEED_PREFIX, TASK_MAX_GROUP_ASSIGNEES } from '../constants';
 var TASK_NEW_INITIAL_STATUS = TASK_NEW_NOT_STARTED;
-var TASK = 'task';
+
+var getItemWithFilteredReplies = function getItemWithFilteredReplies(item, replyId) {
+  var _item$replies = item.replies,
+      replies = _item$replies === void 0 ? [] : _item$replies,
+      rest = _objectWithoutProperties(item, ["replies"]);
+
+  return _objectSpread({
+    replies: replies.filter(function (_ref) {
+      var id = _ref.id;
+      return id !== replyId;
+    })
+  }, rest);
+};
+
+var getItemWithPendingReply = function getItemWithPendingReply(item, reply) {
+  var _item$replies2 = item.replies,
+      replies = _item$replies2 === void 0 ? [] : _item$replies2,
+      rest = _objectWithoutProperties(item, ["replies"]);
+
+  return _objectSpread({
+    replies: [].concat(_toConsumableArray(replies), [reply])
+  }, rest);
+};
 
 var Feed =
 /*#__PURE__*/
@@ -101,6 +129,10 @@ function (_Base) {
    * @property {TaskLinksAPI}
    */
 
+  /**
+   * @property {ThreadedCommentsAPI}
+   */
+
   /**
    * @property {BoxItem}
    */
@@ -115,23 +147,33 @@ function (_Base) {
 
     _this = _possibleConstructorReturn(this, _getPrototypeOf(Feed).call(this, options));
 
-    _defineProperty(_assertThisInitialized(_this), "updateAnnotation", function (file, annotationId, text, permissions, successCallback, errorCallback) {
+    _defineProperty(_assertThisInitialized(_this), "updateAnnotation", function (file, annotationId, text, status, permissions, successCallback, errorCallback) {
       if (!file.id) {
         throw getBadItemError();
       }
 
+      if (!text && !status) {
+        throw getMissingItemTextOrStatus();
+      }
+
       _this.annotationsAPI = new AnnotationsAPI(_this.options);
       _this.file = file;
       _this.errorCallback = errorCallback;
+      var feedItemChanges = {};
 
-      _this.updateFeedItem({
-        message: text,
+      if (text) {
+        feedItemChanges.message = text;
+      }
+
+      if (status) {
+        feedItemChanges.status = status;
+      }
+
+      _this.updateFeedItem(_objectSpread({}, feedItemChanges, {
         isPending: true
-      }, annotationId);
+      }), annotationId);
 
-      _this.annotationsAPI.updateAnnotation(_this.file.id, annotationId, permissions, {
-        message: text
-      }, function (annotation) {
+      _this.annotationsAPI.updateAnnotation(_this.file.id, annotationId, permissions, feedItemChanges, function (annotation) {
         _this.updateFeedItem(_objectSpread({}, annotation, {
           isPending: false
         }), annotationId);
@@ -150,6 +192,18 @@ function (_Base) {
       _this.feedErrorCallback(true, e, code);
     });
 
+    _defineProperty(_assertThisInitialized(_this), "updateReplyErrorCallback", function (error, code, id, parentId) {
+      _this.updateReplyItem(_this.createFeedError(messages.commentUpdateErrorMessage), parentId, id);
+
+      _this.feedErrorCallback(true, error, code);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "fetchRepliesErrorCallback", function (error, code, id) {
+      _this.updateFeedItem(_this.createFeedError(messages.repliesFetchErrorMessage), id);
+
+      _this.feedErrorCallback(true, error, code);
+    });
+
     _defineProperty(_assertThisInitialized(_this), "deleteAnnotation", function (file, annotationId, permissions, successCallBack, errorCallback) {
       _this.annotationsAPI = new AnnotationsAPI(_this.options);
 
@@ -246,7 +300,7 @@ function (_Base) {
     _defineProperty(_assertThisInitialized(_this), "updateTaskNew",
     /*#__PURE__*/
     function () {
-      var _ref = _asyncToGenerator(
+      var _ref2 = _asyncToGenerator(
       /*#__PURE__*/
       regeneratorRuntime.mark(function _callee(file, task) {
         var successCallback,
@@ -380,7 +434,7 @@ function (_Base) {
       }));
 
       return function (_x6, _x7) {
-        return _ref.apply(this, arguments);
+        return _ref2.apply(this, arguments);
       };
     }());
 
@@ -409,12 +463,68 @@ function (_Base) {
       });
     });
 
+    _defineProperty(_assertThisInitialized(_this), "deleteThreadedComment", function (file, commentId, permissions, successCallback, errorCallback) {
+      if (!file.id) {
+        throw getBadItemError();
+      }
+
+      _this.file = file;
+      _this.errorCallback = errorCallback;
+
+      _this.updateFeedItem({
+        isPending: true
+      }, commentId);
+
+      _this.threadedCommentsAPI = new ThreadedCommentsAPI(_this.options);
+
+      _this.threadedCommentsAPI.deleteComment({
+        fileId: file.id,
+        commentId: commentId,
+        permissions: permissions,
+        successCallback: _this.deleteFeedItem.bind(_assertThisInitialized(_this), commentId, successCallback),
+        errorCallback: function errorCallback(e, code) {
+          _this.deleteCommentErrorCallback(e, code, commentId);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "deleteReply", function (file, id, parentId, permissions, successCallback, errorCallback) {
+      if (!file.id) {
+        throw getBadItemError();
+      }
+
+      _this.file = file;
+      _this.errorCallback = errorCallback;
+
+      _this.updateReplyItem({
+        isPending: true
+      }, parentId, id);
+
+      _this.threadedCommentsAPI = new ThreadedCommentsAPI(_this.options);
+
+      _this.threadedCommentsAPI.deleteComment({
+        fileId: file.id,
+        commentId: id,
+        permissions: permissions,
+        successCallback: _this.deleteReplyItem.bind(_assertThisInitialized(_this), id, parentId, successCallback),
+        errorCallback: function errorCallback(e, code) {
+          _this.deleteReplyErrorCallback(e, code, id, parentId);
+        }
+      });
+    });
+
     _defineProperty(_assertThisInitialized(_this), "deleteCommentErrorCallback", function (e, code, commentId) {
       _this.updateFeedItem(_this.createFeedError(messages.commentDeleteErrorMessage), commentId);
 
       _this.feedErrorCallback(true, e, code);
     });
 
+    _defineProperty(_assertThisInitialized(_this), "deleteReplyErrorCallback", function (error, code, id, parentId) {
+      _this.updateReplyItem(_this.createFeedError(messages.commentDeleteErrorMessage), parentId, id);
+
+      _this.feedErrorCallback(true, error, code);
+    });
+
     _defineProperty(_assertThisInitialized(_this), "createTaskNew", function (file, currentUser, message, assignees, taskType, dueAt, completionRule, _successCallback3, errorCallback) {
       if (!file.id) {
         throw getBadItemError();
@@ -444,7 +554,7 @@ function (_Base) {
         due_at: dueAtString,
         id: uuid,
         description: message,
-        type: TASK,
+        type: FEED_ITEM_TYPE_TASK,
         assigned_to: {
           entries: assignees.map(function (assignee) {
             return {
@@ -604,6 +714,35 @@ function (_Base) {
       }
     });
 
+    _defineProperty(_assertThisInitialized(_this), "deleteReplyItem", function (id, parentId) {
+      var successCallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noop;
+      var cachedItems = _this.getCachedItems(_this.file.id) || {
+        items: [],
+        errors: []
+      };
+      var feedItems = cachedItems.items.map(function (item) {
+        if (item.id !== parentId) {
+          return item;
+        }
+
+        if (item.type === FEED_ITEM_TYPE_ANNOTATION) {
+          return getItemWithFilteredReplies(item, id);
+        }
+
+        if (item.type === FEED_ITEM_TYPE_COMMENT) {
+          return getItemWithFilteredReplies(item, id);
+        }
+
+        return item;
+      });
+
+      _this.setCachedItems(_this.file.id, feedItems);
+
+      if (!_this.isDestroyed()) {
+        successCallback(id, parentId);
+      }
+    });
+
     _defineProperty(_assertThisInitialized(_this), "feedErrorCallback", function () {
       var hasError = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
       var e = arguments.length > 1 ? arguments[1] : undefined;
@@ -648,6 +787,45 @@ function (_Base) {
       return pendingFeedItem;
     });
 
+    _defineProperty(_assertThisInitialized(_this), "addPendingReply", function (parentId, currentUser, commentBase) {
+      if (!_this.file.id) {
+        throw getBadItemError();
+      }
+
+      if (!currentUser) {
+        throw getBadUserError();
+      }
+
+      var date = new Date().toISOString();
+
+      var pendingReply = _objectSpread({
+        created_at: date,
+        created_by: currentUser,
+        modified_at: date,
+        isPending: true
+      }, commentBase);
+
+      var cachedItems = _this.getCachedItems(_this.file.id);
+
+      if (cachedItems) {
+        var updatedFeedItems = cachedItems.items.map(function (item) {
+          if (item.id === parentId && item.type === FEED_ITEM_TYPE_COMMENT) {
+            return getItemWithPendingReply(item, pendingReply);
+          }
+
+          if (item.id === parentId && item.type === FEED_ITEM_TYPE_ANNOTATION) {
+            return getItemWithPendingReply(item, pendingReply);
+          }
+
+          return item;
+        });
+
+        _this.setCachedItems(_this.file.id, updatedFeedItems);
+      }
+
+      return pendingReply;
+    });
+
     _defineProperty(_assertThisInitialized(_this), "createCommentSuccessCallback", function (commentData, id, successCallback) {
       var _commentData$message = commentData.message,
           message = _commentData$message === void 0 ? '' : _commentData$message,
@@ -673,6 +851,24 @@ function (_Base) {
       _this.feedErrorCallback(false, e, code);
     });
 
+    _defineProperty(_assertThisInitialized(_this), "createReplySuccessCallback", function (commentData, parentId, id, successCallback) {
+      _this.updateReplyItem(_objectSpread({}, commentData, {
+        isPending: false
+      }), parentId, id);
+
+      if (!_this.isDestroyed()) {
+        successCallback(commentData);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "createReplyErrorCallback", function (error, code, parentId, id) {
+      var errorMessage = error.status === HTTP_STATUS_CODE_CONFLICT ? messages.commentCreateConflictMessage : messages.commentCreateErrorMessage;
+
+      _this.updateReplyItem(_this.createFeedError(errorMessage), parentId, id);
+
+      _this.feedErrorCallback(false, error, code);
+    });
+
     _defineProperty(_assertThisInitialized(_this), "updateFeedItem", function (updates, id) {
       if (!_this.file.id) {
         throw getBadItemError();
@@ -697,12 +893,52 @@ function (_Base) {
       return null;
     });
 
+    _defineProperty(_assertThisInitialized(_this), "updateReplyItem", function (replyUpdates, parentId, id) {
+      if (!_this.file.id) {
+        throw getBadItemError();
+      }
+
+      var getItemWithUpdatedReply = function getItemWithUpdatedReply(item, replyId, updates) {
+        var updatedItem = _objectSpread({}, item);
+
+        if (updatedItem.replies) {
+          updatedItem.replies = updatedItem.replies.map(function (reply) {
+            if (reply.id === replyId) {
+              return _objectSpread({}, reply, {}, updates);
+            }
+
+            return reply;
+          });
+        }
+
+        return updatedItem;
+      };
+
+      var cachedItems = _this.getCachedItems(_this.file.id);
+
+      if (cachedItems) {
+        var updatedFeedItems = cachedItems.items.map(function (item) {
+          if (item.id === parentId && item.type === FEED_ITEM_TYPE_COMMENT) {
+            return getItemWithUpdatedReply(item, id, replyUpdates);
+          }
+
+          if (item.id === parentId && item.type === FEED_ITEM_TYPE_ANNOTATION) {
+            return getItemWithUpdatedReply(item, id, replyUpdates);
+          }
+
+          return item;
+        });
+
+        _this.setCachedItems(_this.file.id, updatedFeedItems);
+      }
+    });
+
     _defineProperty(_assertThisInitialized(_this), "createComment", function (file, currentUser, text, hasMention, _successCallback4, errorCallback) {
       var uuid = uniqueId('comment_');
       var commentData = {
         id: uuid,
         tagged_message: text,
-        type: 'comment'
+        type: FEED_ITEM_TYPE_COMMENT
       };
 
       if (!file.id) {
@@ -736,7 +972,37 @@ function (_Base) {
       }));
     });
 
-    _defineProperty(_assertThisInitialized(_this), "updateComment", function (file, commentId, text, hasMention, permissions, _successCallback5, errorCallback) {
+    _defineProperty(_assertThisInitialized(_this), "createThreadedComment", function (file, currentUser, text, _successCallback5, errorCallback) {
+      if (!file.id) {
+        throw getBadItemError();
+      }
+
+      var uuid = uniqueId('comment_');
+      var commentData = {
+        id: uuid,
+        tagged_message: text,
+        type: FEED_ITEM_TYPE_COMMENT
+      };
+      _this.file = file;
+      _this.errorCallback = errorCallback;
+
+      _this.addPendingItem(_this.file.id, currentUser, commentData);
+
+      _this.threadedCommentsAPI = new ThreadedCommentsAPI(_this.options);
+
+      _this.threadedCommentsAPI.createComment({
+        file: file,
+        message: text,
+        successCallback: function successCallback(comment) {
+          _this.createCommentSuccessCallback(comment, uuid, _successCallback5);
+        },
+        errorCallback: function errorCallback(e, code) {
+          _this.createCommentErrorCallback(e, code, uuid);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "updateComment", function (file, commentId, text, hasMention, permissions, _successCallback6, errorCallback) {
       var commentData = {
         tagged_message: text
       };
@@ -776,7 +1042,7 @@ function (_Base) {
           }), commentId);
 
           if (!_this.isDestroyed()) {
-            _successCallback5(comment);
+            _successCallback6(comment);
           }
         },
         errorCallback: function errorCallback(e, code) {
@@ -785,6 +1051,91 @@ function (_Base) {
       }));
     });
 
+    _defineProperty(_assertThisInitialized(_this), "updateThreadedComment", function (file, commentId, text, status, permissions, _successCallback7, errorCallback) {
+      if (!file.id) {
+        throw getBadItemError();
+      }
+
+      if (!text && !status) {
+        throw getMissingItemTextOrStatus();
+      }
+
+      var commentData = {};
+
+      if (text) {
+        commentData.tagged_message = text;
+      }
+
+      if (status) {
+        commentData.status = status;
+      }
+
+      _this.file = file;
+      _this.errorCallback = errorCallback;
+
+      _this.updateFeedItem(_objectSpread({}, commentData, {
+        isPending: true
+      }), commentId);
+
+      _this.threadedCommentsAPI = new ThreadedCommentsAPI(_this.options);
+
+      _this.threadedCommentsAPI.updateComment({
+        fileId: file.id,
+        commentId: commentId,
+        permissions: permissions,
+        message: text,
+        status: status,
+        successCallback: function successCallback(comment) {
+          _this.updateFeedItem(_objectSpread({}, comment, {
+            isPending: false
+          }), commentId);
+
+          if (!_this.isDestroyed()) {
+            _successCallback7(comment);
+          }
+        },
+        errorCallback: function errorCallback(e, code) {
+          _this.updateCommentErrorCallback(e, code, commentId);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "updateReply", function (file, id, parentId, text, permissions, _successCallback8, errorCallback) {
+      if (!file.id) {
+        throw getBadItemError();
+      }
+
+      _this.file = file;
+      _this.errorCallback = errorCallback;
+
+      _this.updateReplyItem({
+        tagged_message: text,
+        isPending: true
+      }, parentId, id);
+
+      _this.threadedCommentsAPI = new ThreadedCommentsAPI(_this.options);
+
+      _this.threadedCommentsAPI.updateComment({
+        fileId: file.id,
+        commentId: id,
+        permissions: permissions,
+        message: text,
+        undefined: undefined,
+        successCallback: function successCallback(comment) {
+          _this.updateReplyItem(_objectSpread({}, comment, {
+            isPending: false
+          }), parentId, id);
+
+          if (!_this.isDestroyed()) {
+            _successCallback8(comment);
+          }
+        },
+        errorCallback: function errorCallback(error, code) {
+          _this.updateReplyErrorCallback(error, code, id, parentId);
+        }
+      });
+    });
+
     _defineProperty(_assertThisInitialized(_this), "deleteAppActivity", function (file, appActivityId, successCallback, errorCallback) {
       var id = file.id;
 
@@ -844,7 +1195,7 @@ function (_Base) {
         var newAnnotation = _objectSpread({}, annotation, {
           created_by: currentUser,
           id: id,
-          type: 'annotation'
+          type: FEED_ITEM_TYPE_ANNOTATION
         });
 
         this.addPendingItem(this.file.id, currentUser, newAnnotation);
@@ -925,15 +1276,17 @@ function (_Base) {
     }(function (file, shouldRefreshCache, successCallback, errorCallback, onError) {
       var _this2 = this;
 
-      var _ref2 = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {},
-          _ref2$shouldShowAnnot = _ref2.shouldShowAnnotations,
-          shouldShowAnnotations = _ref2$shouldShowAnnot === void 0 ? false : _ref2$shouldShowAnnot,
-          _ref2$shouldShowAppAc = _ref2.shouldShowAppActivity,
-          shouldShowAppActivity = _ref2$shouldShowAppAc === void 0 ? false : _ref2$shouldShowAppAc,
-          _ref2$shouldShowTasks = _ref2.shouldShowTasks,
-          shouldShowTasks = _ref2$shouldShowTasks === void 0 ? true : _ref2$shouldShowTasks,
-          _ref2$shouldShowVersi = _ref2.shouldShowVersions,
-          shouldShowVersions = _ref2$shouldShowVersi === void 0 ? true : _ref2$shouldShowVersi;
+      var _ref3 = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {},
+          _ref3$shouldShowAnnot = _ref3.shouldShowAnnotations,
+          shouldShowAnnotations = _ref3$shouldShowAnnot === void 0 ? false : _ref3$shouldShowAnnot,
+          _ref3$shouldShowAppAc = _ref3.shouldShowAppActivity,
+          shouldShowAppActivity = _ref3$shouldShowAppAc === void 0 ? false : _ref3$shouldShowAppAc,
+          _ref3$shouldShowRepli = _ref3.shouldShowReplies,
+          shouldShowReplies = _ref3$shouldShowRepli === void 0 ? false : _ref3$shouldShowRepli,
+          _ref3$shouldShowTasks = _ref3.shouldShowTasks,
+          shouldShowTasks = _ref3$shouldShowTasks === void 0 ? true : _ref3$shouldShowTasks,
+          _ref3$shouldShowVersi = _ref3.shouldShowVersions,
+          shouldShowVersions = _ref3$shouldShowVersi === void 0 ? true : _ref3$shouldShowVersi;
 
       var id = file.id,
           _file$permissions = file.permissions,
@@ -958,17 +1311,17 @@ function (_Base) {
       this.file = file;
       this.errors = [];
       this.errorCallback = onError;
-      var annotationsPromise = shouldShowAnnotations ? this.fetchAnnotations(permissions) : Promise.resolve();
+      var annotationsPromise = shouldShowAnnotations ? this.fetchAnnotations(permissions, shouldShowReplies) : Promise.resolve();
       var versionsPromise = shouldShowVersions ? this.fetchVersions() : Promise.resolve();
       var currentVersionPromise = shouldShowVersions ? this.fetchCurrentVersion() : Promise.resolve();
-      var commentsPromise = this.fetchComments(permissions);
+      var commentsPromise = shouldShowReplies ? this.fetchThreadedComments(permissions) : this.fetchComments(permissions);
       var tasksPromise = shouldShowTasks ? this.fetchTasksNew() : Promise.resolve();
       var appActivityPromise = shouldShowAppActivity ? this.fetchAppActivity(permissions) : Promise.resolve();
-      Promise.all([versionsPromise, currentVersionPromise, commentsPromise, tasksPromise, appActivityPromise, annotationsPromise]).then(function (_ref3) {
-        var _ref4 = _toArray(_ref3),
-            versions = _ref4[0],
-            currentVersion = _ref4[1],
-            feedItems = _ref4.slice(2);
+      Promise.all([versionsPromise, currentVersionPromise, commentsPromise, tasksPromise, appActivityPromise, annotationsPromise]).then(function (_ref4) {
+        var _ref5 = _toArray(_ref4),
+            versions = _ref5[0],
+            currentVersion = _ref5[1],
+            feedItems = _ref5.slice(2);
 
         var versionsWithCurrent = currentVersion ? _this2.versionsAPI.addCurrentVersion(currentVersion, versions, _this2.file) : undefined;
         var sortedFeedItems = sortFeedItems.apply(void 0, [versionsWithCurrent].concat(_toConsumableArray(feedItems)));
@@ -986,12 +1339,12 @@ function (_Base) {
     })
   }, {
     key: "fetchAnnotations",
-    value: function fetchAnnotations(permissions) {
+    value: function fetchAnnotations(permissions, shouldFetchReplies) {
       var _this3 = this;
 
       this.annotationsAPI = new AnnotationsAPI(this.options);
       return new Promise(function (resolve) {
-        _this3.annotationsAPI.getAnnotations(_this3.file.id, undefined, permissions, resolve, _this3.fetchFeedItemErrorCallback.bind(_this3, resolve));
+        _this3.annotationsAPI.getAnnotations(_this3.file.id, undefined, permissions, resolve, _this3.fetchFeedItemErrorCallback.bind(_this3, resolve), undefined, undefined, shouldFetchReplies);
       });
     }
     /**
@@ -1011,6 +1364,84 @@ function (_Base) {
         _this4.commentsAPI.getComments(_this4.file.id, permissions, resolve, _this4.fetchFeedItemErrorCallback.bind(_this4, resolve));
       });
     }
+    /**
+     * Fetches the comments with replies for a file
+     *
+     * @param {Object} permissions - the file permissions
+     * @return {Promise} - the file comments
+     */
+
+  }, {
+    key: "fetchThreadedComments",
+    value: function fetchThreadedComments(permissions) {
+      var _this5 = this;
+
+      this.threadedCommentsAPI = new ThreadedCommentsAPI(this.options);
+      return new Promise(function (resolve) {
+        _this5.threadedCommentsAPI.getComments({
+          errorCallback: _this5.fetchFeedItemErrorCallback.bind(_this5, resolve),
+          fileId: _this5.file.id,
+          permissions: permissions,
+          successCallback: resolve
+        });
+      });
+    }
+    /**
+     * Fetches replies (comments) of a comment or annotation
+     *
+     * @param {BoxItem} file - The file to which the comment or annotation belongs to
+     * @param {string} commentFeedItemId - ID of the comment or annotation
+     * @param {CommentFeedItemType} commentFeedItemType - Type of the comment or annotation
+     * @param {Function} successCallback
+     * @param {ErrorCallback} errorCallback
+     * @return {void}
+     */
+
+  }, {
+    key: "fetchReplies",
+    value: function fetchReplies(file, commentFeedItemId, commentFeedItemType, successCallback, errorCallback) {
+      var _this6 = this;
+
+      var id = file.id,
+          permissions = file.permissions;
+
+      if (!id || !permissions) {
+        throw getBadItemError();
+      }
+
+      this.file = file;
+      this.errorCallback = errorCallback;
+      this.updateFeedItem({
+        isRepliesLoading: true
+      }, commentFeedItemId);
+
+      var successCallbackFn = function successCallbackFn(comments) {
+        _this6.updateFeedItem({
+          isRepliesLoading: false,
+          replies: comments.entries
+        }, commentFeedItemId);
+
+        successCallback(comments.entries);
+      };
+
+      var errorCallbackFn = function errorCallbackFn(error, code) {
+        _this6.fetchRepliesErrorCallback(error, code, commentFeedItemId);
+      };
+
+      if (commentFeedItemType === FEED_ITEM_TYPE_ANNOTATION) {
+        this.annotationsAPI = new AnnotationsAPI(this.options);
+        this.annotationsAPI.getAnnotationReplies(file.id, commentFeedItemId, permissions, successCallbackFn, errorCallbackFn);
+      } else if (commentFeedItemType === FEED_ITEM_TYPE_COMMENT) {
+        this.threadedCommentsAPI = new ThreadedCommentsAPI(this.options);
+        this.threadedCommentsAPI.getCommentReplies({
+          fileId: file.id,
+          commentId: commentFeedItemId,
+          permissions: permissions,
+          successCallback: successCallbackFn,
+          errorCallback: errorCallbackFn
+        });
+      }
+    }
     /**
      * Fetches the versions for a file
      *
@@ -1020,11 +1451,11 @@ function (_Base) {
   }, {
     key: "fetchVersions",
     value: function fetchVersions() {
-      var _this5 = this;
+      var _this7 = this;
 
       this.versionsAPI = new VersionsAPI(this.options);
       return new Promise(function (resolve) {
-        _this5.versionsAPI.getVersions(_this5.file.id, resolve, _this5.fetchFeedItemErrorCallback.bind(_this5, resolve));
+        _this7.versionsAPI.getVersions(_this7.file.id, resolve, _this7.fetchFeedItemErrorCallback.bind(_this7, resolve), undefined, undefined, FEED_FILE_VERSIONS_FIELDS_TO_FETCH);
       });
     }
     /**
@@ -1036,14 +1467,14 @@ function (_Base) {
   }, {
     key: "fetchCurrentVersion",
     value: function fetchCurrentVersion() {
-      var _this6 = this;
+      var _this8 = this;
 
       this.versionsAPI = new VersionsAPI(this.options);
       return new Promise(function (resolve) {
-        var _this6$file$file_vers = _this6.file.file_version,
-            file_version = _this6$file$file_vers === void 0 ? {} : _this6$file$file_vers;
+        var _this8$file$file_vers = _this8.file.file_version,
+            file_version = _this8$file$file_vers === void 0 ? {} : _this8$file$file_vers;
 
-        _this6.versionsAPI.getVersion(_this6.file.id, file_version.id, resolve, _this6.fetchFeedItemErrorCallback.bind(_this6, resolve));
+        _this8.versionsAPI.getVersion(_this8.file.id, file_version.id, resolve, _this8.fetchFeedItemErrorCallback.bind(_this8, resolve));
       });
     }
     /**
@@ -1055,17 +1486,17 @@ function (_Base) {
   }, {
     key: "fetchTasksNew",
     value: function fetchTasksNew() {
-      var _this7 = this;
+      var _this9 = this;
 
       this.tasksNewAPI = new TasksNewAPI(this.options);
       return new Promise(function (resolve) {
-        _this7.tasksNewAPI.getTasksForFile({
+        _this9.tasksNewAPI.getTasksForFile({
           file: {
-            id: _this7.file.id
+            id: _this9.file.id
           },
           successCallback: resolve,
           errorCallback: function errorCallback(err, code) {
-            return _this7.fetchFeedItemErrorCallback(resolve, err, code);
+            return _this9.fetchFeedItemErrorCallback(resolve, err, code);
           }
         });
       });
@@ -1113,7 +1544,7 @@ function (_Base) {
      * @return {Promise<TaskAssignment>}
      */
     value: function createTaskCollaboratorsforGroup(file, task, assignee) {
-      var _this8 = this;
+      var _this10 = this;
 
       if (!file.id) {
         throw getBadItemError();
@@ -1121,9 +1552,9 @@ function (_Base) {
 
       this.file = file;
       return new Promise(function (resolve, reject) {
-        var taskCollaboratorsAPI = new TaskCollaboratorsAPI(_this8.options);
+        var taskCollaboratorsAPI = new TaskCollaboratorsAPI(_this10.options);
 
-        _this8.taskCollaboratorsAPI.push(taskCollaboratorsAPI);
+        _this10.taskCollaboratorsAPI.push(taskCollaboratorsAPI);
 
         taskCollaboratorsAPI.createTaskCollaboratorsforGroup({
           file: file,
@@ -1149,7 +1580,7 @@ function (_Base) {
   }, {
     key: "createTaskCollaborator",
     value: function createTaskCollaborator(file, task, assignee) {
-      var _this9 = this;
+      var _this11 = this;
 
       if (!file.id) {
         throw getBadItemError();
@@ -1157,9 +1588,9 @@ function (_Base) {
 
       this.file = file;
       return new Promise(function (resolve, reject) {
-        var taskCollaboratorsAPI = new TaskCollaboratorsAPI(_this9.options);
+        var taskCollaboratorsAPI = new TaskCollaboratorsAPI(_this11.options);
 
-        _this9.taskCollaboratorsAPI.push(taskCollaboratorsAPI);
+        _this11.taskCollaboratorsAPI.push(taskCollaboratorsAPI);
 
         taskCollaboratorsAPI.createTaskCollaborator({
           file: file,
@@ -1185,7 +1616,7 @@ function (_Base) {
   }, {
     key: "deleteTaskCollaborator",
     value: function deleteTaskCollaborator(file, task, assignee) {
-      var _this10 = this;
+      var _this12 = this;
 
       if (!file.id) {
         throw getBadItemError();
@@ -1193,9 +1624,9 @@ function (_Base) {
 
       this.file.id = file.id;
       return new Promise(function (resolve, reject) {
-        var taskCollaboratorsAPI = new TaskCollaboratorsAPI(_this10.options);
+        var taskCollaboratorsAPI = new TaskCollaboratorsAPI(_this12.options);
 
-        _this10.taskCollaboratorsAPI.push(taskCollaboratorsAPI);
+        _this12.taskCollaboratorsAPI.push(taskCollaboratorsAPI);
 
         taskCollaboratorsAPI.deleteTaskCollaborator({
           file: file,
@@ -1222,7 +1653,7 @@ function (_Base) {
   }, {
     key: "createTaskLink",
     value: function createTaskLink(file, task) {
-      var _this11 = this;
+      var _this13 = this;
 
       if (!file.id) {
         throw getBadItemError();
@@ -1230,9 +1661,9 @@ function (_Base) {
 
       this.file = file;
       return new Promise(function (resolve, reject) {
-        var taskLinksAPI = new TaskLinksAPI(_this11.options);
+        var taskLinksAPI = new TaskLinksAPI(_this13.options);
 
-        _this11.taskLinksAPI.push(taskLinksAPI);
+        _this13.taskLinksAPI.push(taskLinksAPI);
 
         taskLinksAPI.createTaskLink({
           file: file,
@@ -1279,6 +1710,77 @@ function (_Base) {
      * @return {void}
      */
 
+  }, {
+    key: "createReply",
+
+    /**
+     * Create a reply to annotation or comment, and make a pending item to be replaced once the API is successful.
+     *
+     * @param {BoxItem} file - The file to which the task is assigned
+     * @param {Object} currentUser - the user who performed the action
+     * @param {string} parentId - id of the parent item
+     * @param {CommentFeedItemType} parentType - type of the parent item
+     * @param {string} text - the comment text
+     * @param {Function} successCallback - the success callback
+     * @param {Function} errorCallback - the error callback
+     * @return {void}
+     */
+    value: function createReply(file, currentUser, parentId, parentType, text, successCallback, errorCallback) {
+      var _this14 = this;
+
+      var id = file.id,
+          permissions = file.permissions;
+
+      if (!id || !permissions) {
+        throw getBadItemError();
+      }
+
+      var uuid = uniqueId('comment_');
+      var commentData = {
+        id: uuid,
+        tagged_message: text,
+        type: FEED_ITEM_TYPE_COMMENT
+      };
+      this.file = file;
+      this.errorCallback = errorCallback;
+      this.addPendingReply(parentId, currentUser, commentData);
+
+      var successCallbackFn = function successCallbackFn(comment) {
+        _this14.createReplySuccessCallback(comment, parentId, uuid, successCallback);
+      };
+
+      var errorCallbackFn = function errorCallbackFn(error, code) {
+        _this14.createReplyErrorCallback(error, code, parentId, uuid);
+      };
+
+      if (parentType === FEED_ITEM_TYPE_ANNOTATION) {
+        this.annotationsAPI = new AnnotationsAPI(this.options);
+        this.annotationsAPI.createAnnotationReply(file.id, parentId, permissions, text, successCallbackFn, errorCallbackFn);
+      } else if (parentType === FEED_ITEM_TYPE_COMMENT) {
+        this.threadedCommentsAPI = new ThreadedCommentsAPI(this.options);
+        this.threadedCommentsAPI.createCommentReply({
+          fileId: file.id,
+          commentId: parentId,
+          permissions: permissions,
+          message: text,
+          successCallback: successCallbackFn,
+          errorCallback: errorCallbackFn
+        });
+      }
+    }
+    /**
+     * Update a comment
+     *
+     * @param {BoxItem} file - The file to which the task is assigned
+     * @param {string} commentId - Comment ID
+     * @param {string} text - the comment text
+     * @param {boolean} hasMention - true if there is an @mention in the text
+     * @param {BoxCommentPermission} permissions - Permissions to attach to the app activity items
+     * @param {Function} successCallback - the success callback
+     * @param {Function} errorCallback - the error callback
+     * @return {void}
+     */
+
   }, {
     key: "destroyTaskCollaborators",
     value: function destroyTaskCollaborators() {
@@ -1309,11 +1811,11 @@ function (_Base) {
   }, {
     key: "fetchAppActivity",
     value: function fetchAppActivity(permissions) {
-      var _this12 = this;
+      var _this15 = this;
 
       this.appActivityAPI = new AppActivityAPI(this.options);
       return new Promise(function (resolve) {
-        _this12.appActivityAPI.getAppActivity(_this12.file.id, permissions, resolve, _this12.fetchFeedItemErrorCallback.bind(_this12, resolve));
+        _this15.appActivityAPI.getAppActivity(_this15.file.id, permissions, resolve, _this15.fetchFeedItemErrorCallback.bind(_this15, resolve));
       });
     }
     /**
@@ -1347,6 +1849,11 @@ function (_Base) {
         delete this.commentsAPI;
       }
 
+      if (this.threadedCommentsAPI) {
+        this.threadedCommentsAPI.destroy();
+        delete this.threadedCommentsAPI;
+      }
+
       if (this.versionsAPI) {
         this.versionsAPI.destroy();
         delete this.versionsAPI;