@atlaskit/editor-plugin-annotation 2.8.3 → 2.9.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @atlaskit/editor-plugin-annotation
 
+## 2.9.1
+
+### Patch Changes
+
+- Updated dependencies
+
+## 2.9.0
+
+### Minor Changes
+
+- [#157348](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/157348)
+  [`2745ba38d05fd`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/2745ba38d05fd) -
+  Implemented the new manager set selection and hover APIs. This will allow anyone with access to
+  the annotations manager the ability to control when/what annotation is selected/hovered.
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 2.8.3
 
 ### Patch Changes

package/dist/cjs/editor-commands/index.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.updateMouseState = exports.updateInlineCommentResolvedState = exports.showInlineCommentForBlockNode = exports.setSelectedAnnotation = exports.setInlineCommentsVisibility = exports.setInlineCommentDraftState = exports.setHoveredAnnotation = exports.removeInlineCommentNearSelection = exports.createAnnotation = exports.closeComponent = exports.clearDirtyMark = exports.addInlineComment = void 0;
+exports.updateMouseState = exports.updateInlineCommentResolvedState = exports.showInlineCommentForBlockNode = exports.setSelectedAnnotation = exports.setPendingSelectedAnnotation = exports.setInlineCommentsVisibility = exports.setInlineCommentDraftState = exports.setHoveredAnnotation = exports.removeInlineCommentNearSelection = exports.removeInlineCommentFromDoc = exports.flushPendingSelections = exports.createAnnotation = exports.closeComponent = exports.clearDirtyMark = exports.addInlineComment = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _adfSchema = require("@atlaskit/adf-schema");
 var _analytics = require("@atlaskit/editor-common/analytics");
@@ -51,6 +51,25 @@ var clearDirtyMark = exports.clearDirtyMark = function clearDirtyMark() {
     type: _types.ACTIONS.INLINE_COMMENT_CLEAR_DIRTY_MARK
   });
 };
+var flushPendingSelections = exports.flushPendingSelections = function flushPendingSelections(canSetAsSelectedAnnotations) {
+  return (0, _pluginFactory.createCommand)({
+    type: _types.ACTIONS.FLUSH_PENDING_SELECTIONS,
+    data: {
+      canSetAsSelectedAnnotations: canSetAsSelectedAnnotations
+    }
+  });
+};
+var setPendingSelectedAnnotation = exports.setPendingSelectedAnnotation = function setPendingSelectedAnnotation(id) {
+  return (0, _pluginFactory.createCommand)({
+    type: _types.ACTIONS.SET_PENDING_SELECTIONS,
+    data: {
+      selectedAnnotations: [{
+        id: id,
+        type: _adfSchema.AnnotationTypes.INLINE_COMMENT
+      }]
+    }
+  });
+};
 var removeInlineCommentFromNode = function removeInlineCommentFromNode(id) {
   var supportedBlockNodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   var state = arguments.length > 2 ? arguments[2] : undefined;
@@ -112,6 +131,34 @@ var removeInlineCommentNearSelection = exports.removeInlineCommentNearSelection
     return true;
   };
 };
+var removeInlineCommentFromDoc = exports.removeInlineCommentFromDoc = function removeInlineCommentFromDoc(id) {
+  var supportedNodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return function (state, dispatch) {
+    var tr = state.tr;
+    state.doc.descendants(function (node, pos) {
+      // Inline comment on mediaInline is not supported as part of comments on media project
+      // Thus, we skip the decoration for mediaInline node
+      if (node.type.name === 'mediaInline') {
+        return false;
+      }
+      var isSupportedBlockNode = node.isBlock && (supportedNodes === null || supportedNodes === void 0 ? void 0 : supportedNodes.includes(node.type.name));
+      node.marks.filter(function (mark) {
+        return mark.type === state.schema.marks.annotation && mark.attrs.id === id;
+      }).forEach(function (mark) {
+        if (isSupportedBlockNode) {
+          tr.removeNodeMark(pos, mark);
+        } else {
+          tr.removeMark(pos, pos + node.nodeSize, mark);
+        }
+      });
+    });
+    if (dispatch) {
+      dispatch(tr);
+      return true;
+    }
+    return false;
+  };
+};
 var getDraftCommandAction = function getDraftCommandAction(drafting, targetType, targetNodeId, supportedBlockNodes, isOpeningMediaCommentFromToolbar) {
   return function (editorState) {
     // validate selection only when entering draft mode
@@ -135,6 +182,8 @@ var getDraftCommandAction = function getDraftCommandAction(drafting, targetType,
 /**
  * Show active inline comments for a given block node, otherwise,
  * return false if the node has no comments or no unresolved comments.
+ * @param supportedBlockNodes
+ * @example
  */
 var showInlineCommentForBlockNode = exports.showInlineCommentForBlockNode = function showInlineCommentForBlockNode() {
   var supportedBlockNodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

package/dist/cjs/pm-plugins/annotation-manager-hooks.js

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.startDraft = exports.getDraft = exports.clearDraft = exports.applyDraft = exports.allowAnnotation = void 0;
+exports.startDraft = exports.setIsAnnotationSelected = exports.setIsAnnotationHovered = exports.getDraft = exports.clearDraft = exports.clearAnnotation = exports.applyDraft = exports.allowAnnotation = void 0;
 var _adfSchema = require("@atlaskit/adf-schema");
 var _utils = require("@atlaskit/editor-common/utils");
 var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _editorCommands = require("../editor-commands");
 var _types = require("../types");
 var _utils3 = require("./utils");
@@ -14,6 +15,7 @@ var ERROR_REASON_DRAFT_NOT_STARTED = 'draft-not-started';
 var ERROR_REASON_DRAFT_IN_PROGRESS = 'draft-in-progress';
 var ERROR_REASON_RANGE_MISSING = 'range-no-longer-exists';
 var ERROR_REASON_RANGE_INVALID = 'invalid-range';
+var ERROR_REASON_ID_INVALID = 'id-not-valid';
 var domRefFromPos = function domRefFromPos(view, position) {
   var dom;
   try {
@@ -46,15 +48,34 @@ var allowAnnotation = exports.allowAnnotation = function allowAnnotation(editorV
 };
 var startDraft = exports.startDraft = function startDraft(editorView, options) {
   return function () {
-    var _getRangeInlineNodeNa, _options$annotationMa;
+    var _getRangeInlineNodeNa, _options$annotationMa2;
     var _ref2 = _utils3.inlineCommentPluginKey.getState(editorView.state) || {},
-      isDrafting = _ref2.isDrafting;
+      isDrafting = _ref2.isDrafting,
+      selectedAnnotations = _ref2.selectedAnnotations;
     if (isDrafting) {
       return {
         success: false,
         reason: ERROR_REASON_DRAFT_IN_PROGRESS
       };
     }
+    if (!!(selectedAnnotations !== null && selectedAnnotations !== void 0 && selectedAnnotations.length) && (0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select')) {
+      // if there are selected annotations when starting a draft, we need to clear the selected annotations
+      // before we start the draft.
+      (0, _editorCommands.closeComponent)()(editorView.state, editorView.dispatch);
+
+      // not only that but we need to also deselect any other annotations that are currently selected.
+      selectedAnnotations === null || selectedAnnotations === void 0 || selectedAnnotations.forEach(function (annotation) {
+        var _options$annotationMa, _getAnnotationInlineN;
+        (_options$annotationMa = options.annotationManager) === null || _options$annotationMa === void 0 || _options$annotationMa.emit({
+          name: 'annotationSelectionChanged',
+          data: {
+            annotationId: annotation.id,
+            isSelected: false,
+            inlineNodeTypes: (_getAnnotationInlineN = (0, _utils.getAnnotationInlineNodeTypes)(editorView.state, annotation.id)) !== null && _getAnnotationInlineN !== void 0 ? _getAnnotationInlineN : []
+          }
+        });
+      });
+    }
     (0, _editorCommands.setInlineCommentDraftState)(options.editorAnalyticsAPI)(true)(editorView.state, editorView.dispatch);
     var _ref3 = _utils3.inlineCommentPluginKey.getState(editorView.state) || {},
       draftDecorationSet = _ref3.draftDecorationSet;
@@ -76,7 +97,7 @@ var startDraft = exports.startDraft = function startDraft(editorView, options) {
         to: decorations[decorations.length - 1].to
       }
     })) !== null && _getRangeInlineNodeNa !== void 0 ? _getRangeInlineNodeNa : [];
-    (_options$annotationMa = options.annotationManager) === null || _options$annotationMa === void 0 || _options$annotationMa.emit({
+    (_options$annotationMa2 = options.annotationManager) === null || _options$annotationMa2 === void 0 || _options$annotationMa2.emit({
       name: 'draftAnnotationStarted',
       data: {
         targetElement: targetElement,
@@ -120,6 +141,7 @@ var clearDraft = exports.clearDraft = function clearDraft(editorView, options) {
 };
 var applyDraft = exports.applyDraft = function applyDraft(editorView, options) {
   return function (id) {
+    var _options$annotationMa3, _getAnnotationInlineN2;
     var _ref5 = _utils3.inlineCommentPluginKey.getState(editorView.state) || {},
       isDrafting = _ref5.isDrafting,
       draftDecorationSet = _ref5.draftDecorationSet,
@@ -144,6 +166,17 @@ var applyDraft = exports.applyDraft = function applyDraft(editorView, options) {
     // Using the original decoration from position we should be able to locate the new target element.
     // This is because the new annotation will be created at the same position as the draft decoration.
     var targetElement = domRefFromPos(editorView, from);
+
+    // When a draft is applied it is automatically selected, so we need to set the selected annotation.
+    // emit the event for the selected annotation.
+    (_options$annotationMa3 = options.annotationManager) === null || _options$annotationMa3 === void 0 || _options$annotationMa3.emit({
+      name: 'annotationSelectionChanged',
+      data: {
+        annotationId: id,
+        isSelected: true,
+        inlineNodeTypes: (_getAnnotationInlineN2 = (0, _utils.getAnnotationInlineNodeTypes)(editorView.state, id)) !== null && _getAnnotationInlineN2 !== void 0 ? _getAnnotationInlineN2 : []
+      }
+    });
     return {
       success: true,
       // Get the dom element from the newly created annotation and return it here.
@@ -188,4 +221,133 @@ var getDraft = exports.getDraft = function getDraft(editorView, options) {
       actionResult: undefined
     };
   };
+};
+var setIsAnnotationSelected = exports.setIsAnnotationSelected = function setIsAnnotationSelected(editorView, options) {
+  return function (id, isSelected) {
+    var _selectedAnnotations$;
+    var _ref7 = _utils3.inlineCommentPluginKey.getState(editorView.state) || {},
+      annotations = _ref7.annotations,
+      isDrafting = _ref7.isDrafting,
+      selectedAnnotations = _ref7.selectedAnnotations;
+    if (isDrafting) {
+      return {
+        success: false,
+        reason: ERROR_REASON_DRAFT_IN_PROGRESS
+      };
+    }
+
+    // If there is no annotation state with this id then we can assume the annotation is invalid.
+    if (!(annotations !== null && annotations !== void 0 && annotations.hasOwnProperty(id))) {
+      return {
+        success: false,
+        reason: ERROR_REASON_ID_INVALID
+      };
+    }
+    var isCurrentlySelectedIndex = (_selectedAnnotations$ = selectedAnnotations === null || selectedAnnotations === void 0 ? void 0 : selectedAnnotations.findIndex(function (annotation) {
+      return annotation.id === id;
+    })) !== null && _selectedAnnotations$ !== void 0 ? _selectedAnnotations$ : -1;
+    var isCurrentlySelected = isCurrentlySelectedIndex !== -1;
+    if (isSelected !== isCurrentlySelected) {
+      // the annotation is selection is changing.
+      if (isCurrentlySelected && !isSelected) {
+        var _options$annotationMa4, _getAnnotationInlineN3;
+        // the selected annotaion is being unselected, so we need to close the view.
+        (0, _editorCommands.closeComponent)()(editorView.state, editorView.dispatch);
+        (_options$annotationMa4 = options.annotationManager) === null || _options$annotationMa4 === void 0 || _options$annotationMa4.emit({
+          name: 'annotationSelectionChanged',
+          data: {
+            annotationId: id,
+            isSelected: false,
+            inlineNodeTypes: (_getAnnotationInlineN3 = (0, _utils.getAnnotationInlineNodeTypes)(editorView.state, id)) !== null && _getAnnotationInlineN3 !== void 0 ? _getAnnotationInlineN3 : []
+          }
+        });
+      } else if (!isCurrentlySelected && isSelected) {
+        var _options$annotationMa6, _getAnnotationInlineN5;
+        // the annotation is currently not selected and is being selected, so we need to open the view.
+        (0, _editorCommands.setSelectedAnnotation)(id)(editorView.state, editorView.dispatch);
+
+        // the current annotations are going to be unselected. So we need to notify listeners of this change also.
+        selectedAnnotations === null || selectedAnnotations === void 0 || selectedAnnotations.forEach(function (annotation) {
+          if (annotation.id !== id) {
+            var _options$annotationMa5, _getAnnotationInlineN4;
+            (_options$annotationMa5 = options.annotationManager) === null || _options$annotationMa5 === void 0 || _options$annotationMa5.emit({
+              name: 'annotationSelectionChanged',
+              data: {
+                annotationId: annotation.id,
+                isSelected: false,
+                inlineNodeTypes: (_getAnnotationInlineN4 = (0, _utils.getAnnotationInlineNodeTypes)(editorView.state, annotation.id)) !== null && _getAnnotationInlineN4 !== void 0 ? _getAnnotationInlineN4 : []
+              }
+            });
+          }
+        });
+
+        // Lastly we need to emit the event for the selected annotation.
+        (_options$annotationMa6 = options.annotationManager) === null || _options$annotationMa6 === void 0 || _options$annotationMa6.emit({
+          name: 'annotationSelectionChanged',
+          data: {
+            annotationId: id,
+            isSelected: true,
+            inlineNodeTypes: (_getAnnotationInlineN5 = (0, _utils.getAnnotationInlineNodeTypes)(editorView.state, id)) !== null && _getAnnotationInlineN5 !== void 0 ? _getAnnotationInlineN5 : []
+          }
+        });
+      }
+    }
+    return {
+      success: true,
+      isSelected: isSelected
+    };
+  };
+};
+var setIsAnnotationHovered = exports.setIsAnnotationHovered = function setIsAnnotationHovered(editorView, options) {
+  return function (id, isHovered) {
+    var _hoveredAnnotations$f;
+    var _ref8 = _utils3.inlineCommentPluginKey.getState(editorView.state) || {},
+      annotations = _ref8.annotations,
+      hoveredAnnotations = _ref8.hoveredAnnotations;
+
+    // If there is no annotation state with this id then we can assume the annotation is invalid.
+    if (!(annotations !== null && annotations !== void 0 && annotations.hasOwnProperty(id))) {
+      return {
+        success: false,
+        reason: ERROR_REASON_ID_INVALID
+      };
+    }
+    var isCurrentlyHoveredIndex = (_hoveredAnnotations$f = hoveredAnnotations === null || hoveredAnnotations === void 0 ? void 0 : hoveredAnnotations.findIndex(function (annotation) {
+      return annotation.id === id;
+    })) !== null && _hoveredAnnotations$f !== void 0 ? _hoveredAnnotations$f : -1;
+    var isCurrentlyHovered = isCurrentlyHoveredIndex !== -1;
+    if (isHovered !== isCurrentlyHovered) {
+      // the annotation in hovered is changing.
+      if (isCurrentlyHovered && !isHovered) {
+        // the hovered annotaion is being unhovered, so we should remove the hover state.
+        (0, _editorCommands.setHoveredAnnotation)('')(editorView.state, editorView.dispatch);
+      } else if (!isCurrentlyHovered && isHovered) {
+        // the annotation is currently not hovered and is being hovered.
+        (0, _editorCommands.setHoveredAnnotation)(id)(editorView.state, editorView.dispatch);
+      }
+    }
+    return {
+      success: true,
+      isHovered: isHovered
+    };
+  };
+};
+var clearAnnotation = exports.clearAnnotation = function clearAnnotation(editorView, options) {
+  return function (id) {
+    var _ref9 = _utils3.inlineCommentPluginKey.getState(editorView.state) || {},
+      annotations = _ref9.annotations;
+
+    // If there is no annotation state with this id then we can assume the annotation is invalid.
+    if (!(annotations !== null && annotations !== void 0 && annotations.hasOwnProperty(id))) {
+      return {
+        success: false,
+        reason: ERROR_REASON_ID_INVALID
+      };
+    }
+    (0, _editorCommands.removeInlineCommentFromDoc)(id, options.provider.supportedBlockNodes)(editorView.state, editorView.dispatch);
+    return {
+      success: true,
+      actionResult: undefined
+    };
+  };
 };

package/dist/cjs/pm-plugins/inline-comment.js

@@ -11,13 +11,14 @@ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/
 var _adfSchema = require("@atlaskit/adf-schema");
 var _analytics = require("@atlaskit/editor-common/analytics");
 var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _utils = require("@atlaskit/editor-common/utils");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _editorCommands = require("../editor-commands");
 var _nodeviews = require("../nodeviews");
 var _annotationManagerHooks = require("./annotation-manager-hooks");
 var _pluginFactory = require("./plugin-factory");
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 var fetchProviderStates = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(provider, annotationIds) {
     var data, result;
@@ -104,7 +105,9 @@ var initialState = function initialState() {
     isVisible: true,
     skipSelectionHandling: false,
     featureFlagsPluginState: featureFlagsPluginState,
-    isDrafting: false
+    isDrafting: false,
+    pendingSelectedAnnotations: [],
+    pendingSelectedAnnotationsUpdateCount: 0
   };
 };
 var hideToolbar = function hideToolbar(state, dispatch) {
@@ -132,7 +135,7 @@ var onUnResolve = function onUnResolve(editorAnalyticsAPI) {
 };
 var onMouseUp = function onMouseUp(state, dispatch) {
   return function (e) {
-    var _ref3 = (0, _utils.getPluginState)(state) || {},
+    var _ref3 = (0, _utils2.getPluginState)(state) || {},
       mouseData = _ref3.mouseData;
     if (mouseData !== null && mouseData !== void 0 && mouseData.isSelecting) {
       (0, _editorCommands.updateMouseState)({
@@ -160,19 +163,40 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
     featureFlagsPluginState = options.featureFlagsPluginState,
     annotationManager = options.annotationManager;
   return new _safePlugin.SafePlugin({
-    key: _utils.inlineCommentPluginKey,
+    key: _utils2.inlineCommentPluginKey,
     state: (0, _pluginFactory.createPluginState)(options.dispatch, initialState(provider.disallowOnWhitespace, featureFlagsPluginState)),
     view: function view(editorView) {
+      var allowAnnotationFn;
+      var startDraftFn;
+      var clearDraftFn;
+      var applyDraftFn;
+      var getDraftFn;
+      var setIsAnnotationSelectedFn;
+      var setIsAnnotationHoveredFn;
+      var clearAnnotationFn;
       if (annotationManager && (0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager')) {
-        annotationManager.hook('allowAnnotation', (0, _annotationManagerHooks.allowAnnotation)(editorView, options));
-        annotationManager.hook('startDraft', (0, _annotationManagerHooks.startDraft)(editorView, options));
-        annotationManager.hook('clearDraft', (0, _annotationManagerHooks.clearDraft)(editorView, options));
-        annotationManager.hook('applyDraft', (0, _annotationManagerHooks.applyDraft)(editorView, options));
-        annotationManager.hook('getDraft', (0, _annotationManagerHooks.getDraft)(editorView, options));
+        allowAnnotationFn = (0, _annotationManagerHooks.allowAnnotation)(editorView, options);
+        startDraftFn = (0, _annotationManagerHooks.startDraft)(editorView, options);
+        clearDraftFn = (0, _annotationManagerHooks.clearDraft)(editorView, options);
+        applyDraftFn = (0, _annotationManagerHooks.applyDraft)(editorView, options);
+        getDraftFn = (0, _annotationManagerHooks.getDraft)(editorView, options);
+        annotationManager.hook('allowAnnotation', allowAnnotationFn);
+        annotationManager.hook('startDraft', startDraftFn);
+        annotationManager.hook('clearDraft', clearDraftFn);
+        annotationManager.hook('applyDraft', applyDraftFn);
+        annotationManager.hook('getDraft', getDraftFn);
+        if ((0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select')) {
+          setIsAnnotationSelectedFn = (0, _annotationManagerHooks.setIsAnnotationSelected)(editorView, options);
+          setIsAnnotationHoveredFn = (0, _annotationManagerHooks.setIsAnnotationHovered)(editorView, options);
+          clearAnnotationFn = (0, _annotationManagerHooks.clearAnnotation)(editorView, options);
+          annotationManager.hook('setIsAnnotationSelected', setIsAnnotationSelectedFn);
+          annotationManager.hook('setIsAnnotationHovered', setIsAnnotationHoveredFn);
+          annotationManager.hook('clearAnnotation', clearAnnotationFn);
+        }
       }
       // Get initial state
       // Need to pass `editorView` to mitigate editor state going stale
-      fetchState(provider, (0, _utils.getAllAnnotations)(editorView.state.doc), editorView, options.editorAnalyticsAPI);
+      fetchState(provider, (0, _utils2.getAllAnnotations)(editorView.state.doc), editorView, options.editorAnalyticsAPI);
       var resolve = function resolve(annotationId) {
         return onResolve(options.editorAnalyticsAPI)(editorView.state, editorView.dispatch)(annotationId);
       };
@@ -186,7 +210,7 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
         return onSetVisibility(editorView)(isVisible);
       };
       var setSelectedAnnotationFn = function setSelectedAnnotationFn(annotationId) {
-        var pluginState = (0, _utils.getPluginState)(editorView.state);
+        var pluginState = (0, _utils2.getPluginState)(editorView.state);
         if ((0, _platformFeatureFlags.fg)('platform_editor_listen_for_focussed_query_param')) {
           // When feature flag is true, only close if no annotationId
           if (!annotationId) {
@@ -226,13 +250,20 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
 
       // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
       editorView.root.addEventListener('mouseup', mouseUp);
+
+      /**
+       * This flag is used to prevent the preemptive gate from being called multiple times while a check is in-flight.
+       * If a check is still pending then it's most likely because the product is busy and trying to block the
+       * selection of an annotation.
+       */
+      var isPreemptiveGateActive = false;
       return {
         update: function update(view, _prevState) {
           var _prevSelectedAnnotati;
-          var _ref4 = (0, _utils.getPluginState)(view.state) || {},
+          var _ref4 = (0, _utils2.getPluginState)(view.state) || {},
             selectedAnnotations = _ref4.selectedAnnotations,
             annotations = _ref4.annotations;
-          var _ref5 = (0, _utils.getPluginState)(_prevState) || {},
+          var _ref5 = (0, _utils2.getPluginState)(_prevState) || {},
             prevSelectedAnnotations = _ref5.selectedAnnotations;
           var selectedAnnotationId = selectedAnnotations && selectedAnnotations.length !== 0 && selectedAnnotations[0].id ? selectedAnnotations[0].id : undefined;
           // If the new state has an unresolved selected annotation, and it's different from
@@ -246,13 +277,90 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
             // The selectComponentExperience is using a simplified object, which is why it's type asserted.
             (_options$selectCommen = options.selectCommentExperience) === null || _options$selectCommen === void 0 || _options$selectCommen.selectAnnotation.complete(selectedAnnotationId);
           }
-          var _ref6 = (0, _utils.getPluginState)(view.state) || {},
-            dirtyAnnotations = _ref6.dirtyAnnotations;
+          if ((0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select')) {
+            // In the Editor, Annotations can be selected in three ways:
+            // 1. By clicking on the annotation in the editor
+            // 2. By using the annotation manager to select the annotation
+            // 3. By moving the cursor to the annotation and using the keyboard to select it
+            // Item 1 & 3 need to be protected by the preemptive gate. This is because these actions could be performed by a user
+            // at a time when changing the selection could cause data loss.
+            // The following preemptive check is designed to cover these items.
+
+            var _ref6 = (0, _utils2.getPluginState)(view.state) || {},
+              pendingSelectedAnnotations = _ref6.pendingSelectedAnnotations,
+              pendingSelectedAnnotationsUpdateCount = _ref6.pendingSelectedAnnotationsUpdateCount;
+            var _ref7 = (0, _utils2.getPluginState)(_prevState) || {},
+              prevPendingSelectedAnnotationsUpdateCount = _ref7.pendingSelectedAnnotationsUpdateCount;
+            if (!isPreemptiveGateActive && pendingSelectedAnnotationsUpdateCount !== prevPendingSelectedAnnotationsUpdateCount && !!(pendingSelectedAnnotations !== null && pendingSelectedAnnotations !== void 0 && pendingSelectedAnnotations.length)) {
+              // Need to set a lock to avoid calling gate multiple times. The lock will be released
+              // when the preemptive gate is complete.
+              isPreemptiveGateActive = true;
+              annotationManager === null || annotationManager === void 0 || annotationManager.checkPreemptiveGate().then(function (canSelectAnnotation) {
+                var _ref8 = (0, _utils2.getPluginState)(view.state) || {},
+                  isDrafting = _ref8.isDrafting,
+                  latestPendingSelectedAnnotations = _ref8.pendingSelectedAnnotations,
+                  latestSelectedAnnotations = _ref8.selectedAnnotations;
+                if (canSelectAnnotation) {
+                  if (isDrafting) {
+                    // The user must have chosen to discard there draft. So before we flush the pending selections
+                    // we need to clear the draft if there is one.
+                    (0, _editorCommands.setInlineCommentDraftState)(options.editorAnalyticsAPI)(false)(view.state, view.dispatch);
+                  }
+
+                  // Flush the pending selections into the selected annotations list.
+                  (0, _editorCommands.flushPendingSelections)(true)(view.state, view.dispatch);
+                  latestSelectedAnnotations === null || latestSelectedAnnotations === void 0 || latestSelectedAnnotations.filter(function (annotation) {
+                    return (latestPendingSelectedAnnotations === null || latestPendingSelectedAnnotations === void 0 ? void 0 : latestPendingSelectedAnnotations.findIndex(function (pendingAnnotation) {
+                      return pendingAnnotation.id === annotation.id;
+                    })) === -1;
+                  }).forEach(function (annotation) {
+                    var _options$annotationMa, _getAnnotationInlineN;
+                    (_options$annotationMa = options.annotationManager) === null || _options$annotationMa === void 0 || _options$annotationMa.emit({
+                      name: 'annotationSelectionChanged',
+                      data: {
+                        annotationId: annotation.id,
+                        isSelected: false,
+                        inlineNodeTypes: (_getAnnotationInlineN = (0, _utils.getAnnotationInlineNodeTypes)(editorView.state, annotation.id)) !== null && _getAnnotationInlineN !== void 0 ? _getAnnotationInlineN : []
+                      }
+                    });
+                  });
+
+                  // Notify the annotation manager that the pending selection has changed.
+                  latestPendingSelectedAnnotations === null || latestPendingSelectedAnnotations === void 0 || latestPendingSelectedAnnotations.forEach(function (_ref9) {
+                    var _options$annotationMa2, _getAnnotationInlineN2;
+                    var id = _ref9.id;
+                    (_options$annotationMa2 = options.annotationManager) === null || _options$annotationMa2 === void 0 || _options$annotationMa2.emit({
+                      name: 'annotationSelectionChanged',
+                      data: {
+                        annotationId: id,
+                        isSelected: true,
+                        inlineNodeTypes: (_getAnnotationInlineN2 = (0, _utils.getAnnotationInlineNodeTypes)(view.state, id)) !== null && _getAnnotationInlineN2 !== void 0 ? _getAnnotationInlineN2 : []
+                      }
+                    });
+                  });
+                } else {
+                  // Clears the pending selections if the preemptive gate returns false.
+                  // We should need to worry about dispatching change events here because the pending selections
+                  // are being aborted and the selections will remain unchanged.
+                  (0, _editorCommands.flushPendingSelections)(false)(view.state, view.dispatch);
+                }
+              }).catch(function (error) {
+                // TODO: EDITOR-595 - Ensure and anlytic is fired to indicate which reports on the error.
+
+                // If an error has occured we will clear any pending selections to avoid accidentally setting the wrong thing.
+                (0, _editorCommands.flushPendingSelections)(false)(view.state, view.dispatch);
+              }).finally(function () {
+                isPreemptiveGateActive = false;
+              });
+            }
+          }
+          var _ref10 = (0, _utils2.getPluginState)(view.state) || {},
+            dirtyAnnotations = _ref10.dirtyAnnotations;
           if (!dirtyAnnotations) {
             return;
           }
           (0, _editorCommands.clearDirtyMark)()(view.state, view.dispatch);
-          fetchState(provider, (0, _utils.getAllAnnotations)(view.state.doc), view, options.editorAnalyticsAPI);
+          fetchState(provider, (0, _utils2.getAllAnnotations)(view.state.doc), view, options.editorAnalyticsAPI);
         },
         destroy: function destroy() {
           // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
@@ -260,13 +368,23 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
           if (updateSubscriber) {
             updateSubscriber.off('resolve', resolve).off('delete', resolve).off('unresolve', unResolve).off('create', unResolve).off('setvisibility', setVisibility).off('setselectedannotation', setSelectedAnnotationFn).off('sethoveredannotation', setHoveredAnnotationFn).off('removehoveredannotation', removeHoveredannotationFn).off('closeinlinecomment', closeInlineCommentFn);
           }
+          if (annotationManager && (0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager')) {
+            annotationManager.unhook('allowAnnotation', allowAnnotationFn);
+            annotationManager.unhook('startDraft', startDraftFn);
+            annotationManager.unhook('clearDraft', clearDraftFn);
+            annotationManager.unhook('applyDraft', applyDraftFn);
+            annotationManager.unhook('getDraft', getDraftFn);
+            annotationManager.unhook('setIsAnnotationSelected', setIsAnnotationSelectedFn);
+            annotationManager.unhook('setIsAnnotationHovered', setIsAnnotationHoveredFn);
+            annotationManager.unhook('clearAnnotation', clearAnnotationFn);
+          }
         }
       };
     },
     props: {
       handleDOMEvents: {
         mousedown: function mousedown(view) {
-          var pluginState = (0, _utils.getPluginState)(view.state);
+          var pluginState = (0, _utils2.getPluginState)(view.state);
           if (!(pluginState !== null && pluginState !== void 0 && pluginState.mouseData.isSelecting)) {
             hideToolbar(view.state, view.dispatch)();
           }
@@ -291,7 +409,7 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
           if (!annotationId) {
             return false;
           }
-          var pluginState = (0, _utils.getPluginState)(view.state);
+          var pluginState = (0, _utils2.getPluginState)(view.state);
           var isSelected = pluginState === null || pluginState === void 0 || (_pluginState$selected = pluginState.selectedAnnotations) === null || _pluginState$selected === void 0 ? void 0 : _pluginState$selected.some(function (selectedAnnotation) {
             return selectedAnnotation.id === annotationId;
           });
@@ -300,27 +418,48 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
           if (isSelected && !(pluginState !== null && pluginState !== void 0 && pluginState.isInlineCommentViewClosed)) {
             return false;
           }
-          var _ref7 = pluginState || {},
-            annotations = _ref7.annotations;
+          var _ref11 = pluginState || {},
+            annotations = _ref11.annotations;
           var isUnresolved = annotations && annotations[annotationId] === false;
           if (!isUnresolved) {
             return false;
           }
-          (0, _editorCommands.setSelectedAnnotation)(annotationId)(view.state, view.dispatch);
+          if ((0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select')) {
+            var _pluginState$pendingS;
+            // The manager disable setting the selected annotation on click because in the editor this is already
+            // handled by the selection update handler. When the manager is enabled, and a selection changes it's pushed into
+            // the pendingSelectedAnnotations array. This is then used to update the selection when the preemptive gate
+            // is released.
+            var isPendingSelection = pluginState === null || pluginState === void 0 || (_pluginState$pendingS = pluginState.pendingSelectedAnnotations) === null || _pluginState$pendingS === void 0 ? void 0 : _pluginState$pendingS.some(function (selectedAnnotation) {
+              return selectedAnnotation.id === annotationId;
+            });
+            // If the annotation is selected and the inline comment view is open, do nothing
+            // as the user is already in the comment view.
+            if (isPendingSelection) {
+              return false;
+            }
+            (0, _editorCommands.setPendingSelectedAnnotation)(annotationId)(view.state, view.dispatch);
+          } else {
+            (0, _editorCommands.setSelectedAnnotation)(annotationId)(view.state, view.dispatch);
+          }
           return true;
         }
       },
       decorations: function decorations(state) {
         // highlight comments, depending on state
-        var _ref8 = (0, _utils.getPluginState)(state) || {},
-          draftDecorationSet = _ref8.draftDecorationSet,
-          annotations = _ref8.annotations,
-          selectedAnnotations = _ref8.selectedAnnotations,
-          isVisible = _ref8.isVisible,
-          isInlineCommentViewClosed = _ref8.isInlineCommentViewClosed,
-          hoveredAnnotations = _ref8.hoveredAnnotations;
+        var _ref12 = (0, _utils2.getPluginState)(state) || {},
+          draftDecorationSet = _ref12.draftDecorationSet,
+          annotations = _ref12.annotations,
+          selectedAnnotations = _ref12.selectedAnnotations,
+          isVisible = _ref12.isVisible,
+          isInlineCommentViewClosed = _ref12.isInlineCommentViewClosed,
+          hoveredAnnotations = _ref12.hoveredAnnotations;
         var decorations = draftDecorationSet !== null && draftDecorationSet !== void 0 ? draftDecorationSet : _view.DecorationSet.empty;
         var focusDecorations = [];
+
+        // TODO: EDITOR-760 - This needs to be optimised, it's not a good idea to scan the entire document
+        // everytime we need to update the decorations. This handler will be called alot. We should be caching
+        // the decorations in plugin state and only updating them when required.
         state.doc.descendants(function (node, pos) {
           var _provider$supportedBl;
           // Inline comment on mediaInline is not supported as part of comments on media project
@@ -344,7 +483,7 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
                 focusDecorations.push(_view.Decoration.node(pos, pos + node.nodeSize, {
                   class: "".concat((0, _nodeviews.getBlockAnnotationViewClassname)(isUnresolved, isSelected), " ").concat(isUnresolved)
                 }, {
-                  key: _utils.decorationKey.block
+                  key: _utils2.decorationKey.block
                 }));
               } else {
                 if ((0, _platformFeatureFlags.fg)('editor_inline_comments_on_inline_nodes')) {
@@ -357,7 +496,7 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
                     focusDecorations.push(_view.Decoration.node(pos, pos + node.nodeSize, {
                       class: "".concat((0, _nodeviews.getAnnotationViewClassname)(isUnresolved, isSelected, isHovered), " ").concat(isUnresolved)
                     }, {
-                      key: _utils.decorationKey.block
+                      key: _utils2.decorationKey.block
                     }));
                   }
                 } else {