@atlaskit/editor-plugin-annotation 2.8.3 → 2.9.0

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

@@ -4,11 +4,12 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { AnnotationTypes } from '@atlaskit/adf-schema';
 import { RESOLVE_METHOD } from '@atlaskit/editor-common/analytics';
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { getAnnotationInlineNodeTypes } from '@atlaskit/editor-common/utils';
 import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags';
-import { clearDirtyMark, closeComponent, setHoveredAnnotation, setInlineCommentsVisibility, setSelectedAnnotation, updateInlineCommentResolvedState, updateMouseState } from '../editor-commands';
+import { clearDirtyMark, closeComponent, setHoveredAnnotation, setInlineCommentsVisibility, setSelectedAnnotation, flushPendingSelections, updateInlineCommentResolvedState, updateMouseState, setPendingSelectedAnnotation, setInlineCommentDraftState } from '../editor-commands';
 import { getAnnotationViewClassname, getBlockAnnotationViewClassname } from '../nodeviews';
-import { allowAnnotation, applyDraft, clearDraft, getDraft, startDraft } from './annotation-manager-hooks';
+import { allowAnnotation, applyDraft, clearDraft, clearAnnotation, getDraft, setIsAnnotationHovered, setIsAnnotationSelected, startDraft } from './annotation-manager-hooks';
 import { createPluginState } from './plugin-factory';
 import { decorationKey, getAllAnnotations, getPluginState, inlineCommentPluginKey } from './utils';
 var fetchProviderStates = /*#__PURE__*/function () {
@@ -97,7 +98,9 @@ var initialState = function initialState() {
     isVisible: true,
     skipSelectionHandling: false,
     featureFlagsPluginState: featureFlagsPluginState,
-    isDrafting: false
+    isDrafting: false,
+    pendingSelectedAnnotations: [],
+    pendingSelectedAnnotationsUpdateCount: 0
   };
 };
 var hideToolbar = function hideToolbar(state, dispatch) {
@@ -156,12 +159,33 @@ export var inlineCommentPlugin = function inlineCommentPlugin(options) {
     key: inlineCommentPluginKey,
     state: 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 && fg('platform_editor_comments_api_manager')) {
-        annotationManager.hook('allowAnnotation', allowAnnotation(editorView, options));
-        annotationManager.hook('startDraft', startDraft(editorView, options));
-        annotationManager.hook('clearDraft', clearDraft(editorView, options));
-        annotationManager.hook('applyDraft', applyDraft(editorView, options));
-        annotationManager.hook('getDraft', getDraft(editorView, options));
+        allowAnnotationFn = allowAnnotation(editorView, options);
+        startDraftFn = startDraft(editorView, options);
+        clearDraftFn = clearDraft(editorView, options);
+        applyDraftFn = applyDraft(editorView, options);
+        getDraftFn = getDraft(editorView, options);
+        annotationManager.hook('allowAnnotation', allowAnnotationFn);
+        annotationManager.hook('startDraft', startDraftFn);
+        annotationManager.hook('clearDraft', clearDraftFn);
+        annotationManager.hook('applyDraft', applyDraftFn);
+        annotationManager.hook('getDraft', getDraftFn);
+        if (fg('platform_editor_comments_api_manager_select')) {
+          setIsAnnotationSelectedFn = setIsAnnotationSelected(editorView, options);
+          setIsAnnotationHoveredFn = setIsAnnotationHovered(editorView, options);
+          clearAnnotationFn = 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
@@ -219,6 +243,13 @@ export var inlineCommentPlugin = function inlineCommentPlugin(options) {
 
       // 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;
@@ -239,8 +270,85 @@ export var inlineCommentPlugin = function inlineCommentPlugin(options) {
             // 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 = getPluginState(view.state) || {},
-            dirtyAnnotations = _ref6.dirtyAnnotations;
+          if (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 = getPluginState(view.state) || {},
+              pendingSelectedAnnotations = _ref6.pendingSelectedAnnotations,
+              pendingSelectedAnnotationsUpdateCount = _ref6.pendingSelectedAnnotationsUpdateCount;
+            var _ref7 = 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 = 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.
+                    setInlineCommentDraftState(options.editorAnalyticsAPI)(false)(view.state, view.dispatch);
+                  }
+
+                  // Flush the pending selections into the selected annotations list.
+                  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 = 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 = 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.
+                  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.
+                flushPendingSelections(false)(view.state, view.dispatch);
+              }).finally(function () {
+                isPreemptiveGateActive = false;
+              });
+            }
+          }
+          var _ref10 = getPluginState(view.state) || {},
+            dirtyAnnotations = _ref10.dirtyAnnotations;
           if (!dirtyAnnotations) {
             return;
           }
@@ -253,6 +361,16 @@ export var inlineCommentPlugin = function inlineCommentPlugin(options) {
           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 && 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);
+          }
         }
       };
     },
@@ -293,27 +411,48 @@ export var inlineCommentPlugin = function inlineCommentPlugin(options) {
           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;
           }
-          setSelectedAnnotation(annotationId)(view.state, view.dispatch);
+          if (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;
+            }
+            setPendingSelectedAnnotation(annotationId)(view.state, view.dispatch);
+          } else {
+            setSelectedAnnotation(annotationId)(view.state, view.dispatch);
+          }
           return true;
         }
       },
       decorations: function decorations(state) {
         // highlight comments, depending on state
-        var _ref8 = getPluginState(state) || {},
-          draftDecorationSet = _ref8.draftDecorationSet,
-          annotations = _ref8.annotations,
-          selectedAnnotations = _ref8.selectedAnnotations,
-          isVisible = _ref8.isVisible,
-          isInlineCommentViewClosed = _ref8.isInlineCommentViewClosed,
-          hoveredAnnotations = _ref8.hoveredAnnotations;
+        var _ref12 = 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 : 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

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

@@ -4,6 +4,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import { pluginFactory } from '@atlaskit/editor-common/utils';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { fg } from '@atlaskit/platform-feature-flags';
 import reducer from './reducer';
 import { decorationKey, findAnnotationsInSelection, inlineCommentPluginKey, isBlockNodeAnnotationsSelected, isSelectedAnnotationsChanged } from './utils';
 var handleDocChanged = function handleDocChanged(tr, prevPluginState) {
@@ -19,6 +20,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
  */
 export var shouldClearBookMarkCheck = function shouldClearBookMarkCheck(tr, editorState, bookmark) {
   if (editorState.selection.empty || !bookmark) {
@@ -46,7 +51,7 @@ export var shouldClearBookMarkCheck = function shouldClearBookMarkCheck(tr, edit
   // 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), {}, {
@@ -86,6 +91,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 = 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 (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 fg('platform_editor_comments_api_manager_select') ? getSelectionChangeHandlerNew(reopenCommentView)(tr, pluginState) : getSelectionChangeHandlerOld(reopenCommentView)(tr, pluginState);
+  };
+};
 var _pluginFactory = pluginFactory(inlineCommentPluginKey, reducer, {
     onSelectionChanged: getSelectionChangedHandler(true),
     onDocChanged: handleDocChanged,

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

@@ -25,12 +25,14 @@ export default (function (pluginState, action) {
         annotations: {}
       });
     case ACTIONS.CLOSE_COMPONENT:
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
+      return _objectSpread(_objectSpread(_objectSpread({}, pluginState), {}, {
         isInlineCommentViewClosed: true,
         isDrafting: false,
         isOpeningMediaCommentFromToolbar: false
       }, fg('platform_editor_annotation_selected_annotation') && {
         selectedAnnotations: []
+      }), fg('platform_editor_comments_api_manager_select') && {
+        selectedAnnotations: []
       });
     case ACTIONS.ADD_INLINE_COMMENT:
       var updatedPluginState = getNewDraftState(pluginState, action.data.drafting, action.data.editorState);
@@ -39,6 +41,8 @@ export default (function (pluginState, action) {
         annotations: _objectSpread(_objectSpread({}, pluginState.annotations), action.data.inlineComments),
         isInlineCommentViewClosed: false,
         selectAnnotationMethod: undefined
+      }, fg('platform_editor_comments_api_manager_select') && {
+        skipSelectionHandling: true
       });
     case ACTIONS.INLINE_COMMENT_SET_VISIBLE:
       var isVisible = action.data.isVisible;
@@ -62,6 +66,19 @@ export default (function (pluginState, action) {
         skipSelectionHandling: true,
         isInlineCommentViewClosed: false
       });
+    case ACTIONS.FLUSH_PENDING_SELECTIONS:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        selectedAnnotations: action.data.canSetAsSelectedAnnotations ? _toConsumableArray(pluginState.pendingSelectedAnnotations) : pluginState.selectedAnnotations,
+        pendingSelectedAnnotations: [],
+        isInlineCommentViewClosed: false
+      });
+    case ACTIONS.SET_PENDING_SELECTIONS:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        pendingSelectedAnnotations: _toConsumableArray(action.data.selectedAnnotations),
+        pendingSelectedAnnotationsUpdateCount: pluginState.pendingSelectedAnnotationsUpdateCount + 1,
+        skipSelectionHandling: true,
+        isInlineCommentViewClosed: false
+      });
     default:
       return pluginState;
   }

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

@@ -130,7 +130,7 @@ export var buildToolbar = function buildToolbar(editorAnalyticsAPI) {
         }
         if (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;
@@ -144,16 +144,19 @@ export var buildToolbar = function buildToolbar(editorAnalyticsAPI) {
                 }
               });
               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/esm/pm-plugins/types.js

@@ -8,5 +8,7 @@ export var 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/types/editor-commands/index.d.ts

@@ -9,10 +9,15 @@ import type { InlineCommentInputMethod, TargetType } from '../types';
 export declare const updateInlineCommentResolvedState: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (partialNewState: InlineCommentMap, resolveMethod?: RESOLVE_METHOD) => Command;
 export declare const closeComponent: () => Command;
 export declare const clearDirtyMark: () => Command;
+export declare const flushPendingSelections: (canSetAsSelectedAnnotations: boolean) => Command;
+export declare const setPendingSelectedAnnotation: (id: string) => Command;
 export declare const removeInlineCommentNearSelection: (id: string, supportedNodes?: string[]) => Command;
+export declare const removeInlineCommentFromDoc: (id: string, supportedNodes?: string[]) => Command;
 /**
  * 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 declare const showInlineCommentForBlockNode: (supportedBlockNodes?: string[]) => (node: PMNode | null, viewMethod?: VIEW_METHOD, isOpeningMediaCommentFromToolbar?: boolean) => Command;
 export declare const setInlineCommentDraftState: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined, supportedBlockNodes?: string[]) => (drafting: boolean, inputMethod?: InlineCommentInputMethod, targetType?: TargetType, targetNodeId?: string | undefined, isOpeningMediaCommentFromToolbar?: boolean) => Command;

package/dist/types/pm-plugins/annotation-manager-hooks.d.ts

@@ -1,5 +1,5 @@
 import { type AnnotationId } from '@atlaskit/adf-schema';
-import type { ApplyDraftResult, ClearDraftResult, GetDraftResult, StartDraftResult } from '@atlaskit/editor-common/annotation';
+import type { ApplyDraftResult, ClearAnnotationResult, ClearDraftResult, GetDraftResult, HoverAnnotationResult, SelectAnnotationResult, StartDraftResult } from '@atlaskit/editor-common/annotation';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { InlineCommentPluginOptions } from './types';
 export declare const allowAnnotation: (editorView: EditorView, options: InlineCommentPluginOptions) => () => boolean;
@@ -7,3 +7,6 @@ export declare const startDraft: (editorView: EditorView, options: InlineComment
 export declare const clearDraft: (editorView: EditorView, options: InlineCommentPluginOptions) => () => ClearDraftResult;
 export declare const applyDraft: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId) => ApplyDraftResult;
 export declare const getDraft: (editorView: EditorView, options: InlineCommentPluginOptions) => () => GetDraftResult;
+export declare const setIsAnnotationSelected: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId, isSelected: boolean) => SelectAnnotationResult;
+export declare const setIsAnnotationHovered: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId, isHovered: boolean) => HoverAnnotationResult;
+export declare const clearAnnotation: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId) => ClearAnnotationResult;

package/dist/types/pm-plugins/plugin-factory.d.ts

@@ -4,6 +4,10 @@ import type { InlineCommentPluginState } from './types';
  * 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
  */
 export declare const shouldClearBookMarkCheck: (tr: ReadonlyTransaction | Transaction, editorState: EditorState, bookmark?: SelectionBookmark) => boolean;
 export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch, initialState: InlineCommentPluginState | ((state: EditorState) => InlineCommentPluginState)) => import("prosemirror-state").SafeStateField<InlineCommentPluginState>, createCommand: <A = import("./types").InlineCommentAction>(action: A | ((state: Readonly<EditorState>) => false | A), transform?: ((tr: Transaction, state: EditorState) => Transaction) | undefined) => import("@atlaskit/editor-common/types").Command;

package/dist/types/pm-plugins/types.d.ts

@@ -15,7 +15,9 @@ export declare enum ACTIONS {
     INLINE_COMMENT_SET_VISIBLE = 5,
     CLOSE_COMPONENT = 6,
     SET_SELECTED_ANNOTATION = 7,
-    SET_HOVERED_ANNOTATION = 8
+    SET_HOVERED_ANNOTATION = 8,
+    FLUSH_PENDING_SELECTIONS = 9,
+    SET_PENDING_SELECTIONS = 10
 }
 export interface InlineCommentPluginOptions {
     dispatch: Dispatch;
@@ -80,6 +82,16 @@ export type InlineCommentAction = {
         hoveredAnnotations: AnnotationInfo[];
         selectAnnotationMethod?: VIEW_METHOD;
     };
+} | {
+    type: ACTIONS.FLUSH_PENDING_SELECTIONS;
+    data: {
+        canSetAsSelectedAnnotations: boolean;
+    };
+} | {
+    type: ACTIONS.SET_PENDING_SELECTIONS;
+    data: {
+        selectedAnnotations: AnnotationInfo[];
+    };
 };
 export type InlineCommentPluginState = {
     /**
@@ -137,4 +149,17 @@ export type InlineCommentPluginState = {
     selectAnnotationMethod?: VIEW_METHOD;
     isOpeningMediaCommentFromToolbar?: boolean;
     selectCommentExperience?: AnnotationProviders['selectCommentExperience'];
+    /**
+     * This is a list of annotations which are to be selected. This is updated all the time when the selection changes, and
+     * are periodically flushed to selectedAnnotations. This flush event results in the annotations being selected in the editor.
+     * This functionality has come about due to the fact that the editor can select annotations in 3 different ways. And the fact
+     * that we need to introduce a preemptive gate check which is async and can block annotations from being selected before they're
+     * selected.
+     */
+    pendingSelectedAnnotations: AnnotationInfo[];
+    /**
+     * This is a count of the number of times the pendingSelectedAnnotations has been updated. This can be used to determine
+     * if the pendingSelectedAnnotations has been updated since the last time it was flushed to selectedAnnotations.
+     */
+    pendingSelectedAnnotationsUpdateCount: number;
 };

package/dist/types-ts4.5/editor-commands/index.d.ts

@@ -9,10 +9,15 @@ import type { InlineCommentInputMethod, TargetType } from '../types';
 export declare const updateInlineCommentResolvedState: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (partialNewState: InlineCommentMap, resolveMethod?: RESOLVE_METHOD) => Command;
 export declare const closeComponent: () => Command;
 export declare const clearDirtyMark: () => Command;
+export declare const flushPendingSelections: (canSetAsSelectedAnnotations: boolean) => Command;
+export declare const setPendingSelectedAnnotation: (id: string) => Command;
 export declare const removeInlineCommentNearSelection: (id: string, supportedNodes?: string[]) => Command;
+export declare const removeInlineCommentFromDoc: (id: string, supportedNodes?: string[]) => Command;
 /**
  * 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 declare const showInlineCommentForBlockNode: (supportedBlockNodes?: string[]) => (node: PMNode | null, viewMethod?: VIEW_METHOD, isOpeningMediaCommentFromToolbar?: boolean) => Command;
 export declare const setInlineCommentDraftState: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined, supportedBlockNodes?: string[]) => (drafting: boolean, inputMethod?: InlineCommentInputMethod, targetType?: TargetType, targetNodeId?: string | undefined, isOpeningMediaCommentFromToolbar?: boolean) => Command;

package/dist/types-ts4.5/pm-plugins/annotation-manager-hooks.d.ts

@@ -1,5 +1,5 @@
 import { type AnnotationId } from '@atlaskit/adf-schema';
-import type { ApplyDraftResult, ClearDraftResult, GetDraftResult, StartDraftResult } from '@atlaskit/editor-common/annotation';
+import type { ApplyDraftResult, ClearAnnotationResult, ClearDraftResult, GetDraftResult, HoverAnnotationResult, SelectAnnotationResult, StartDraftResult } from '@atlaskit/editor-common/annotation';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { InlineCommentPluginOptions } from './types';
 export declare const allowAnnotation: (editorView: EditorView, options: InlineCommentPluginOptions) => () => boolean;
@@ -7,3 +7,6 @@ export declare const startDraft: (editorView: EditorView, options: InlineComment
 export declare const clearDraft: (editorView: EditorView, options: InlineCommentPluginOptions) => () => ClearDraftResult;
 export declare const applyDraft: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId) => ApplyDraftResult;
 export declare const getDraft: (editorView: EditorView, options: InlineCommentPluginOptions) => () => GetDraftResult;
+export declare const setIsAnnotationSelected: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId, isSelected: boolean) => SelectAnnotationResult;
+export declare const setIsAnnotationHovered: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId, isHovered: boolean) => HoverAnnotationResult;
+export declare const clearAnnotation: (editorView: EditorView, options: InlineCommentPluginOptions) => (id: AnnotationId) => ClearAnnotationResult;

package/dist/types-ts4.5/pm-plugins/plugin-factory.d.ts

@@ -4,6 +4,10 @@ import type { InlineCommentPluginState } from './types';
  * 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
  */
 export declare const shouldClearBookMarkCheck: (tr: ReadonlyTransaction | Transaction, editorState: EditorState, bookmark?: SelectionBookmark) => boolean;
 export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch, initialState: InlineCommentPluginState | ((state: EditorState) => InlineCommentPluginState)) => import("prosemirror-state").SafeStateField<InlineCommentPluginState>, createCommand: <A = import("./types").InlineCommentAction>(action: A | ((state: Readonly<EditorState>) => false | A), transform?: ((tr: Transaction, state: EditorState) => Transaction) | undefined) => import("@atlaskit/editor-common/types").Command;

package/dist/types-ts4.5/pm-plugins/types.d.ts

@@ -15,7 +15,9 @@ export declare enum ACTIONS {
     INLINE_COMMENT_SET_VISIBLE = 5,
     CLOSE_COMPONENT = 6,
     SET_SELECTED_ANNOTATION = 7,
-    SET_HOVERED_ANNOTATION = 8
+    SET_HOVERED_ANNOTATION = 8,
+    FLUSH_PENDING_SELECTIONS = 9,
+    SET_PENDING_SELECTIONS = 10
 }
 export interface InlineCommentPluginOptions {
     dispatch: Dispatch;
@@ -80,6 +82,16 @@ export type InlineCommentAction = {
         hoveredAnnotations: AnnotationInfo[];
         selectAnnotationMethod?: VIEW_METHOD;
     };
+} | {
+    type: ACTIONS.FLUSH_PENDING_SELECTIONS;
+    data: {
+        canSetAsSelectedAnnotations: boolean;
+    };
+} | {
+    type: ACTIONS.SET_PENDING_SELECTIONS;
+    data: {
+        selectedAnnotations: AnnotationInfo[];
+    };
 };
 export type InlineCommentPluginState = {
     /**
@@ -137,4 +149,17 @@ export type InlineCommentPluginState = {
     selectAnnotationMethod?: VIEW_METHOD;
     isOpeningMediaCommentFromToolbar?: boolean;
     selectCommentExperience?: AnnotationProviders['selectCommentExperience'];
+    /**
+     * This is a list of annotations which are to be selected. This is updated all the time when the selection changes, and
+     * are periodically flushed to selectedAnnotations. This flush event results in the annotations being selected in the editor.
+     * This functionality has come about due to the fact that the editor can select annotations in 3 different ways. And the fact
+     * that we need to introduce a preemptive gate check which is async and can block annotations from being selected before they're
+     * selected.
+     */
+    pendingSelectedAnnotations: AnnotationInfo[];
+    /**
+     * This is a count of the number of times the pendingSelectedAnnotations has been updated. This can be used to determine
+     * if the pendingSelectedAnnotations has been updated since the last time it was flushed to selectedAnnotations.
+     */
+    pendingSelectedAnnotationsUpdateCount: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-annotation",
-	"version": "2.8.3",
+	"version": "2.9.0",
 	"description": "Annotation plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -33,7 +33,7 @@
 	"dependencies": {
 		"@atlaskit/adf-schema": "^47.6.0",
 		"@atlaskit/analytics-next": "^11.0.0",
-		"@atlaskit/editor-common": "^105.10.0",
+		"@atlaskit/editor-common": "^105.11.0",
 		"@atlaskit/editor-plugin-analytics": "^2.3.0",
 		"@atlaskit/editor-plugin-connectivity": "^2.0.0",
 		"@atlaskit/editor-plugin-editor-viewmode-effects": "^2.0.0",
@@ -42,7 +42,7 @@
 		"@atlaskit/icon": "^26.3.0",
 		"@atlaskit/onboarding": "^14.1.0",
 		"@atlaskit/platform-feature-flags": "^1.1.0",
-		"@atlaskit/tmp-editor-statsig": "^5.0.0",
+		"@atlaskit/tmp-editor-statsig": "^5.1.0",
 		"@babel/runtime": "^7.0.0"
 	},
 	"peerDependencies": {
@@ -97,6 +97,9 @@
 		"platform_editor_comments_api_manager": {
 			"type": "boolean"
 		},
+		"platform_editor_comments_api_manager_select": {
+			"type": "boolean"
+		},
 		"editor_inline_comments_on_inline_nodes": {
 			"type": "boolean"
 		},