@atlaskit/editor-plugin-annotation 2.8.2 → 2.9.0

package/dist/cjs/pm-plugins/plugin-factory.js

@@ -9,6 +9,7 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _utils = require("@atlaskit/editor-common/utils");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _view = require("@atlaskit/editor-prosemirror/view");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _reducer = _interopRequireDefault(require("./reducer"));
 var _utils2 = require("./utils");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -26,6 +27,10 @@ var handleDocChanged = function handleDocChanged(tr, prevPluginState) {
  * We clear bookmark on the following conditions:
  * 1. if current selection is an empty selection, or
  * 2. if the current selection and bookmark selection are different
+ * @param tr
+ * @param editorState
+ * @param bookmark
+ * @example
  */
 var shouldClearBookMarkCheck = exports.shouldClearBookMarkCheck = function shouldClearBookMarkCheck(tr, editorState, bookmark) {
   if (editorState.selection.empty || !bookmark) {
@@ -53,7 +58,7 @@ var shouldClearBookMarkCheck = exports.shouldClearBookMarkCheck = function shoul
   // by default we discard bookmark
   return true;
 };
-var getSelectionChangedHandler = function getSelectionChangedHandler(reopenCommentView) {
+var getSelectionChangeHandlerOld = function getSelectionChangeHandlerOld(reopenCommentView) {
   return function (tr, pluginState) {
     if (pluginState.skipSelectionHandling) {
       return _objectSpread(_objectSpread({}, pluginState), {}, {
@@ -93,6 +98,51 @@ var getSelectionChangedHandler = function getSelectionChangedHandler(reopenComme
     });
   };
 };
+var getSelectionChangeHandlerNew = function getSelectionChangeHandlerNew(reopenCommentView) {
+  return function (tr, pluginState) {
+    if (pluginState.skipSelectionHandling) {
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        skipSelectionHandling: false
+      }, reopenCommentView && {
+        isInlineCommentViewClosed: false
+      });
+    }
+    var selectedAnnotations = (0, _utils2.findAnnotationsInSelection)(tr.selection, tr.doc);
+
+    // NOTE: I've left this commented code here as a reference that the previous old code would reset the selected annotations
+    // if the selection is empty. If this is no longer needed, we can remove this code.
+    // clean up with platform_editor_comments_api_manager_select
+    // if (selectedAnnotations.length === 0) {
+    // 	return {
+    // 		...pluginState,
+    // 		pendingSelectedAnnotations: selectedAnnotations,
+    // 		pendingSelectedAnnotationsUpdateCount:
+    // 			pluginState.pendingSelectedAnnotationsUpdateCount + 1,
+    // 		isInlineCommentViewClosed: true,
+    // 		selectAnnotationMethod: undefined,
+    // 	};
+    // }
+
+    if ((0, _utils2.isSelectedAnnotationsChanged)(selectedAnnotations, pluginState.pendingSelectedAnnotations)) {
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        pendingSelectedAnnotations: selectedAnnotations,
+        pendingSelectedAnnotationsUpdateCount: pluginState.pendingSelectedAnnotationsUpdateCount + 1
+      }, reopenCommentView && {
+        isInlineCommentViewClosed: false
+      });
+    }
+    return _objectSpread(_objectSpread(_objectSpread({}, pluginState), reopenCommentView && {
+      isInlineCommentViewClosed: false
+    }), {}, {
+      selectAnnotationMethod: undefined
+    });
+  };
+};
+var getSelectionChangedHandler = function getSelectionChangedHandler(reopenCommentView) {
+  return function (tr, pluginState) {
+    return (0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select') ? getSelectionChangeHandlerNew(reopenCommentView)(tr, pluginState) : getSelectionChangeHandlerOld(reopenCommentView)(tr, pluginState);
+  };
+};
 var _pluginFactory = (0, _utils.pluginFactory)(_utils2.inlineCommentPluginKey, _reducer.default, {
     onSelectionChanged: getSelectionChangedHandler(true),
     onDocChanged: handleDocChanged,

package/dist/cjs/pm-plugins/reducer.js

@@ -32,12 +32,14 @@ var _default = exports.default = function _default(pluginState, action) {
         annotations: {}
       });
     case _types.ACTIONS.CLOSE_COMPONENT:
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), {}, {
         isInlineCommentViewClosed: true,
         isDrafting: false,
         isOpeningMediaCommentFromToolbar: false
       }, (0, _platformFeatureFlags.fg)('platform_editor_annotation_selected_annotation') && {
         selectedAnnotations: []
+      }), (0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select') && {
+        selectedAnnotations: []
       });
     case _types.ACTIONS.ADD_INLINE_COMMENT:
       var updatedPluginState = getNewDraftState(pluginState, action.data.drafting, action.data.editorState);
@@ -46,6 +48,8 @@ var _default = exports.default = function _default(pluginState, action) {
         annotations: _objectSpread(_objectSpread({}, pluginState.annotations), action.data.inlineComments),
         isInlineCommentViewClosed: false,
         selectAnnotationMethod: undefined
+      }, (0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager_select') && {
+        skipSelectionHandling: true
       });
     case _types.ACTIONS.INLINE_COMMENT_SET_VISIBLE:
       var isVisible = action.data.isVisible;
@@ -69,6 +73,19 @@ var _default = exports.default = function _default(pluginState, action) {
         skipSelectionHandling: true,
         isInlineCommentViewClosed: false
       });
+    case _types.ACTIONS.FLUSH_PENDING_SELECTIONS:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        selectedAnnotations: action.data.canSetAsSelectedAnnotations ? (0, _toConsumableArray2.default)(pluginState.pendingSelectedAnnotations) : pluginState.selectedAnnotations,
+        pendingSelectedAnnotations: [],
+        isInlineCommentViewClosed: false
+      });
+    case _types.ACTIONS.SET_PENDING_SELECTIONS:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        pendingSelectedAnnotations: (0, _toConsumableArray2.default)(action.data.selectedAnnotations),
+        pendingSelectedAnnotationsUpdateCount: pluginState.pendingSelectedAnnotationsUpdateCount + 1,
+        skipSelectionHandling: true,
+        isInlineCommentViewClosed: false
+      });
     default:
       return pluginState;
   }

package/dist/cjs/pm-plugins/toolbar.js

@@ -137,7 +137,7 @@ var buildToolbar = exports.buildToolbar = function buildToolbar(editorAnalyticsA
         }
         if ((0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager')) {
           if (!annotationManager) {
-            // TODO: EDITOR-188 - If we've reached here and the manager is not initialized, we should
+            // TODO: EDITOR-595 - If we've reached here and the manager is not initialized, we should
             // dispatch an analytics event to indicate that the user has clicked the button but
             // the action was not completed.
             return false;
@@ -151,16 +151,19 @@ var buildToolbar = exports.buildToolbar = function buildToolbar(editorAnalyticsA
                 }
               });
               createCommentExperience === null || createCommentExperience === void 0 || createCommentExperience.initExperience.start();
-              var _annotationManager$st = annotationManager.startDraft(),
-                success = _annotationManager$st.success;
-              if (!success) {
-                // TODO: EDITOR-188 - Report start draft attempt failed.
+              var result = annotationManager.startDraft();
+              if (result.success) {
+                // TODO: EDITOR-595 - Ensure and anlytic is fired to indicate that the user has started a draft.
+              } else {
+                // TODO: EDITOR-595 - Fire an analytics event to indicate that the user has clicked the button
+                // but the action was not completed, the result should contain a reason.
               }
             } else {
-              // TODO: EDITOR-188 - Dispatch analytics event
+              // TODO: EDITOR-595 - Track the toolbar comment button was clicked but the preemptive gate
+              // check returned false and the draft cannot be started.
             }
           }).catch(function () {
-            // TODO: EDITOR-188 - Handle preemptive gate check error and dispatch analytics event
+            // TODO: EDITOR-595 - Handle preemptive gate check error. Something went very wrong in the gate.
           });
           return true;
         } else {

package/dist/cjs/pm-plugins/types.js

@@ -14,5 +14,7 @@ var ACTIONS = exports.ACTIONS = /*#__PURE__*/function (ACTIONS) {
   ACTIONS[ACTIONS["CLOSE_COMPONENT"] = 6] = "CLOSE_COMPONENT";
   ACTIONS[ACTIONS["SET_SELECTED_ANNOTATION"] = 7] = "SET_SELECTED_ANNOTATION";
   ACTIONS[ACTIONS["SET_HOVERED_ANNOTATION"] = 8] = "SET_HOVERED_ANNOTATION";
+  ACTIONS[ACTIONS["FLUSH_PENDING_SELECTIONS"] = 9] = "FLUSH_PENDING_SELECTIONS";
+  ACTIONS[ACTIONS["SET_PENDING_SELECTIONS"] = 10] = "SET_PENDING_SELECTIONS";
   return ACTIONS;
 }({});

package/dist/cjs/ui/InlineCommentView.js

@@ -1,12 +1,13 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.InlineCommentView = InlineCommentView;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _react = _interopRequireDefault(require("react"));
+var _react = _interopRequireWildcard(require("react"));
 var _adfSchema = require("@atlaskit/adf-schema");
 var _analytics = require("@atlaskit/editor-common/analytics");
 var _hooks = require("@atlaskit/editor-common/hooks");
@@ -19,6 +20,8 @@ var _editorCommands = require("../editor-commands");
 var _utils3 = require("../pm-plugins/utils");
 var _types = require("../types");
 var _AnnotationViewWrapper = require("./AnnotationViewWrapper");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 var findPosForDOM = function findPosForDOM(sel) {
   var $from = sel.$from,
     from = sel.from;
@@ -79,6 +82,7 @@ function InlineCommentView(_ref3) {
   var inlineCommentProvider = providers.inlineComment;
   var state = editorView.state,
     dispatch = editorView.dispatch;
+  var lastSelectedAnnotationId = (0, _react.useRef)();
   var CreateComponent = inlineCommentProvider.createComponent,
     ViewComponent = inlineCommentProvider.viewComponent;
   var _useInlineCommentView = useInlineCommentViewPluginState({
@@ -131,9 +135,17 @@ function InlineCommentView(_ref3) {
 
   // Create Component
   if (bookmark) {
+    var _selectedAnnotations$;
     if (!CreateComponent) {
       return null;
     }
+    var currentlySelectedAnnotation = selectedAnnotations === null || selectedAnnotations === void 0 || (_selectedAnnotations$ = selectedAnnotations[0]) === null || _selectedAnnotations$ === void 0 ? void 0 : _selectedAnnotations$.id;
+    var isAnnotationSelectionChanged = currentlySelectedAnnotation !== lastSelectedAnnotationId.current;
+
+    // Update the last selected annotation ID if the selection was updated
+    if (isAnnotationSelectionChanged) {
+      lastSelectedAnnotationId.current = currentlySelectedAnnotation;
+    }
     var inlineNodeTypes = (0, _utils.getRangeInlineNodeNames)({
       doc: state.doc,
       pos: selection
@@ -147,6 +159,7 @@ function InlineCommentView(_ref3) {
     }, /*#__PURE__*/_react.default.createElement(CreateComponent, {
       dom: dom,
       textSelection: textSelection,
+      wasNewAnnotationSelected: !!currentlySelectedAnnotation && isAnnotationSelectionChanged,
       onCreate: function onCreate(id) {
         if (!(0, _platformFeatureFlags.fg)('platform_editor_comments_api_manager')) {
           var createAnnotationResult = (0, _editorCommands.createAnnotation)(editorAnalyticsAPI, editorAPI)(id, _adfSchema.AnnotationTypes.INLINE_COMMENT, inlineCommentProvider.supportedBlockNodes)(editorView.state, editorView.dispatch);

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

@@ -31,6 +31,21 @@ export const closeComponent = () => createCommand({
 export const clearDirtyMark = () => createCommand({
   type: ACTIONS.INLINE_COMMENT_CLEAR_DIRTY_MARK
 });
+export const flushPendingSelections = canSetAsSelectedAnnotations => createCommand({
+  type: ACTIONS.FLUSH_PENDING_SELECTIONS,
+  data: {
+    canSetAsSelectedAnnotations
+  }
+});
+export const setPendingSelectedAnnotation = id => createCommand({
+  type: ACTIONS.SET_PENDING_SELECTIONS,
+  data: {
+    selectedAnnotations: [{
+      id,
+      type: AnnotationTypes.INLINE_COMMENT
+    }]
+  }
+});
 const removeInlineCommentFromNode = (id, supportedBlockNodes = [], state, dispatch) => {
   const {
     tr,
@@ -94,6 +109,31 @@ export const removeInlineCommentNearSelection = (id, supportedNodes = []) => (st
   }
   return true;
 };
+export const removeInlineCommentFromDoc = (id, supportedNodes = []) => (state, dispatch) => {
+  const {
+    tr
+  } = state;
+  state.doc.descendants((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;
+    }
+    const isSupportedBlockNode = node.isBlock && (supportedNodes === null || supportedNodes === void 0 ? void 0 : supportedNodes.includes(node.type.name));
+    node.marks.filter(mark => mark.type === state.schema.marks.annotation && mark.attrs.id === id).forEach(mark => {
+      if (isSupportedBlockNode) {
+        tr.removeNodeMark(pos, mark);
+      } else {
+        tr.removeMark(pos, pos + node.nodeSize, mark);
+      }
+    });
+  });
+  if (dispatch) {
+    dispatch(tr);
+    return true;
+  }
+  return false;
+};
 const getDraftCommandAction = (drafting, targetType, targetNodeId, supportedBlockNodes, isOpeningMediaCommentFromToolbar) => {
   return editorState => {
     // validate selection only when entering draft mode
@@ -117,6 +157,8 @@ const getDraftCommandAction = (drafting, targetType, targetNodeId, supportedBloc
 /**
  * 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
  */
 export const showInlineCommentForBlockNode = (supportedBlockNodes = []) => (node, viewMethod, isOpeningMediaCommentFromToolbar) => (state, dispatch) => {
   const pluginState = getPluginState(state);

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

@@ -1,13 +1,15 @@
 import { AnnotationTypes } from '@atlaskit/adf-schema';
-import { getRangeInlineNodeNames } from '@atlaskit/editor-common/utils';
+import { getAnnotationInlineNodeTypes, getRangeInlineNodeNames } from '@atlaskit/editor-common/utils';
 import { findDomRefAtPos } from '@atlaskit/editor-prosemirror/utils';
-import { setInlineCommentDraftState, createAnnotation } from '../editor-commands';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { setInlineCommentDraftState, createAnnotation, setSelectedAnnotation, closeComponent, setHoveredAnnotation, removeInlineCommentFromDoc } from '../editor-commands';
 import { AnnotationSelectionType } from '../types';
 import { inlineCommentPluginKey, isSelectionValid } from './utils';
 const ERROR_REASON_DRAFT_NOT_STARTED = 'draft-not-started';
 const ERROR_REASON_DRAFT_IN_PROGRESS = 'draft-in-progress';
 const ERROR_REASON_RANGE_MISSING = 'range-no-longer-exists';
 const ERROR_REASON_RANGE_INVALID = 'invalid-range';
+const ERROR_REASON_ID_INVALID = 'id-not-valid';
 const domRefFromPos = (view, position) => {
   let dom;
   try {
@@ -38,9 +40,10 @@ export const allowAnnotation = (editorView, options) => () => {
   return isSelectionValid(editorView.state) === AnnotationSelectionType.VALID;
 };
 export const startDraft = (editorView, options) => () => {
-  var _getRangeInlineNodeNa, _options$annotationMa;
+  var _getRangeInlineNodeNa, _options$annotationMa2;
   const {
-    isDrafting
+    isDrafting,
+    selectedAnnotations
   } = inlineCommentPluginKey.getState(editorView.state) || {};
   if (isDrafting) {
     return {
@@ -48,6 +51,24 @@ export const startDraft = (editorView, options) => () => {
       reason: ERROR_REASON_DRAFT_IN_PROGRESS
     };
   }
+  if (!!(selectedAnnotations !== null && selectedAnnotations !== void 0 && selectedAnnotations.length) && 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.
+    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 ? void 0 : selectedAnnotations.forEach(annotation => {
+      var _options$annotationMa, _getAnnotationInlineN;
+      (_options$annotationMa = options.annotationManager) === null || _options$annotationMa === void 0 ? void 0 : _options$annotationMa.emit({
+        name: 'annotationSelectionChanged',
+        data: {
+          annotationId: annotation.id,
+          isSelected: false,
+          inlineNodeTypes: (_getAnnotationInlineN = getAnnotationInlineNodeTypes(editorView.state, annotation.id)) !== null && _getAnnotationInlineN !== void 0 ? _getAnnotationInlineN : []
+        }
+      });
+    });
+  }
   setInlineCommentDraftState(options.editorAnalyticsAPI)(true)(editorView.state, editorView.dispatch);
   const {
     draftDecorationSet
@@ -70,7 +91,7 @@ export const startDraft = (editorView, options) => () => {
       to: decorations[decorations.length - 1].to
     }
   })) !== null && _getRangeInlineNodeNa !== void 0 ? _getRangeInlineNodeNa : [];
-  (_options$annotationMa = options.annotationManager) === null || _options$annotationMa === void 0 ? void 0 : _options$annotationMa.emit({
+  (_options$annotationMa2 = options.annotationManager) === null || _options$annotationMa2 === void 0 ? void 0 : _options$annotationMa2.emit({
     name: 'draftAnnotationStarted',
     data: {
       targetElement,
@@ -111,6 +132,7 @@ export const clearDraft = (editorView, options) => () => {
   };
 };
 export const applyDraft = (editorView, options) => id => {
+  var _options$annotationMa3, _getAnnotationInlineN2;
   const {
     isDrafting,
     draftDecorationSet,
@@ -136,6 +158,17 @@ export const applyDraft = (editorView, options) => id => {
   // 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.
   const 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 ? void 0 : _options$annotationMa3.emit({
+    name: 'annotationSelectionChanged',
+    data: {
+      annotationId: id,
+      isSelected: true,
+      inlineNodeTypes: (_getAnnotationInlineN2 = 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.
@@ -178,4 +211,126 @@ export const getDraft = (editorView, options) => () => {
     targetElement,
     actionResult: undefined
   };
+};
+export const setIsAnnotationSelected = (editorView, options) => (id, isSelected) => {
+  var _selectedAnnotations$;
+  const {
+    annotations,
+    isDrafting,
+    selectedAnnotations
+  } = inlineCommentPluginKey.getState(editorView.state) || {};
+  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
+    };
+  }
+  const isCurrentlySelectedIndex = (_selectedAnnotations$ = selectedAnnotations === null || selectedAnnotations === void 0 ? void 0 : selectedAnnotations.findIndex(annotation => annotation.id === id)) !== null && _selectedAnnotations$ !== void 0 ? _selectedAnnotations$ : -1;
+  const 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.
+      closeComponent()(editorView.state, editorView.dispatch);
+      (_options$annotationMa4 = options.annotationManager) === null || _options$annotationMa4 === void 0 ? void 0 : _options$annotationMa4.emit({
+        name: 'annotationSelectionChanged',
+        data: {
+          annotationId: id,
+          isSelected: false,
+          inlineNodeTypes: (_getAnnotationInlineN3 = 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.
+      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 ? void 0 : selectedAnnotations.forEach(annotation => {
+        if (annotation.id !== id) {
+          var _options$annotationMa5, _getAnnotationInlineN4;
+          (_options$annotationMa5 = options.annotationManager) === null || _options$annotationMa5 === void 0 ? void 0 : _options$annotationMa5.emit({
+            name: 'annotationSelectionChanged',
+            data: {
+              annotationId: annotation.id,
+              isSelected: false,
+              inlineNodeTypes: (_getAnnotationInlineN4 = 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 ? void 0 : _options$annotationMa6.emit({
+        name: 'annotationSelectionChanged',
+        data: {
+          annotationId: id,
+          isSelected: true,
+          inlineNodeTypes: (_getAnnotationInlineN5 = getAnnotationInlineNodeTypes(editorView.state, id)) !== null && _getAnnotationInlineN5 !== void 0 ? _getAnnotationInlineN5 : []
+        }
+      });
+    }
+  }
+  return {
+    success: true,
+    isSelected
+  };
+};
+export const setIsAnnotationHovered = (editorView, options) => (id, isHovered) => {
+  var _hoveredAnnotations$f;
+  const {
+    annotations,
+    hoveredAnnotations
+  } = inlineCommentPluginKey.getState(editorView.state) || {};
+
+  // 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
+    };
+  }
+  const isCurrentlyHoveredIndex = (_hoveredAnnotations$f = hoveredAnnotations === null || hoveredAnnotations === void 0 ? void 0 : hoveredAnnotations.findIndex(annotation => annotation.id === id)) !== null && _hoveredAnnotations$f !== void 0 ? _hoveredAnnotations$f : -1;
+  const 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.
+      setHoveredAnnotation('')(editorView.state, editorView.dispatch);
+    } else if (!isCurrentlyHovered && isHovered) {
+      // the annotation is currently not hovered and is being hovered.
+      setHoveredAnnotation(id)(editorView.state, editorView.dispatch);
+    }
+  }
+  return {
+    success: true,
+    isHovered
+  };
+};
+export const clearAnnotation = (editorView, options) => id => {
+  const {
+    annotations
+  } = inlineCommentPluginKey.getState(editorView.state) || {};
+
+  // 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
+    };
+  }
+  removeInlineCommentFromDoc(id, options.provider.supportedBlockNodes)(editorView.state, editorView.dispatch);
+  return {
+    success: true,
+    actionResult: undefined
+  };
 };