@atlaskit/editor-plugin-annotation 0.1.0

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

@@ -0,0 +1,77 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
+import { addDraftDecoration } from '../utils';
+import { ACTIONS } from './types';
+export default (function (pluginState, action) {
+  switch (action.type) {
+    case ACTIONS.UPDATE_INLINE_COMMENT_STATE:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        annotations: _objectSpread(_objectSpread({}, pluginState.annotations), action.data)
+      });
+    case ACTIONS.INLINE_COMMENT_UPDATE_MOUSE_STATE:
+      var mouseData = Object.assign({}, pluginState.mouseData, action.data.mouseData);
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        mouseData: mouseData
+      });
+    case ACTIONS.SET_INLINE_COMMENT_DRAFT_STATE:
+      return getNewDraftState(pluginState, action.data.drafting, action.data.editorState);
+    case ACTIONS.INLINE_COMMENT_CLEAR_DIRTY_MARK:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        dirtyAnnotations: false,
+        annotations: {}
+      });
+    case ACTIONS.CLOSE_COMPONENT:
+      return getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') ? _objectSpread(_objectSpread({}, pluginState), {}, {
+        isInlineCommentViewClosed: true
+      }) : _objectSpread(_objectSpread({}, pluginState), {}, {
+        selectedAnnotations: []
+      });
+    case ACTIONS.ADD_INLINE_COMMENT:
+      var updatedPluginState = getNewDraftState(pluginState, action.data.drafting, action.data.editorState);
+      return _objectSpread(_objectSpread({}, updatedPluginState), {}, {
+        selectedAnnotations: [].concat(_toConsumableArray(updatedPluginState.selectedAnnotations), _toConsumableArray(action.data.selectedAnnotations)),
+        annotations: _objectSpread(_objectSpread({}, pluginState.annotations), action.data.inlineComments)
+      }, getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') && {
+        isInlineCommentViewClosed: false
+      });
+    case ACTIONS.INLINE_COMMENT_SET_VISIBLE:
+      var isVisible = action.data.isVisible;
+      if (isVisible === pluginState.isVisible) {
+        return pluginState;
+      }
+      return _objectSpread(_objectSpread({}, isVisible ? pluginState : getNewDraftState(pluginState, false)), {}, {
+        isVisible: isVisible
+      });
+    case ACTIONS.SET_SELECTED_ANNOTATION:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        selectedAnnotations: _toConsumableArray(action.data.selectedAnnotations),
+        skipSelectionHandling: true
+      }, getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') && {
+        // if selecting annotation explicitly, reopen the comment view
+        isInlineCommentViewClosed: false
+      });
+    default:
+      return pluginState;
+  }
+});
+function getNewDraftState(pluginState, drafting, editorState) {
+  var draftDecorationSet = pluginState.draftDecorationSet;
+  if (!draftDecorationSet || !drafting) {
+    draftDecorationSet = DecorationSet.empty;
+  }
+  var newState = _objectSpread(_objectSpread({}, pluginState), {}, {
+    draftDecorationSet: draftDecorationSet
+  });
+  newState.bookmark = undefined;
+  if (drafting && editorState) {
+    newState.bookmark = editorState.selection.getBookmark();
+    var resolvedBookmark = newState.bookmark.resolve(editorState.doc);
+    var draftDecoration = addDraftDecoration(resolvedBookmark.from, resolvedBookmark.to);
+    newState.draftDecorationSet = draftDecorationSet.add(editorState.doc, [draftDecoration]);
+  }
+  return newState;
+}

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

@@ -0,0 +1,11 @@
+export var ACTIONS = /*#__PURE__*/function (ACTIONS) {
+  ACTIONS[ACTIONS["UPDATE_INLINE_COMMENT_STATE"] = 0] = "UPDATE_INLINE_COMMENT_STATE";
+  ACTIONS[ACTIONS["SET_INLINE_COMMENT_DRAFT_STATE"] = 1] = "SET_INLINE_COMMENT_DRAFT_STATE";
+  ACTIONS[ACTIONS["INLINE_COMMENT_UPDATE_MOUSE_STATE"] = 2] = "INLINE_COMMENT_UPDATE_MOUSE_STATE";
+  ACTIONS[ACTIONS["INLINE_COMMENT_CLEAR_DIRTY_MARK"] = 3] = "INLINE_COMMENT_CLEAR_DIRTY_MARK";
+  ACTIONS[ACTIONS["ADD_INLINE_COMMENT"] = 4] = "ADD_INLINE_COMMENT";
+  ACTIONS[ACTIONS["INLINE_COMMENT_SET_VISIBLE"] = 5] = "INLINE_COMMENT_SET_VISIBLE";
+  ACTIONS[ACTIONS["CLOSE_COMPONENT"] = 6] = "CLOSE_COMPONENT";
+  ACTIONS[ACTIONS["SET_SELECTED_ANNOTATION"] = 7] = "SET_SELECTED_ANNOTATION";
+  return ACTIONS;
+}({});

package/dist/esm/toolbar.js

@@ -0,0 +1,52 @@
+import React from 'react';
+import { addInlineComment, ToolTipContent } from '@atlaskit/editor-common/keymaps';
+import { annotationMessages } from '@atlaskit/editor-common/messages';
+import { calculateToolbarPositionAboveSelection, calculateToolbarPositionTrackHead } from '@atlaskit/editor-common/utils';
+import CommentIcon from '@atlaskit/icon/glyph/comment';
+import { setInlineCommentDraftState } from './commands';
+import { AnnotationSelectionType, AnnotationTestIds } from './types';
+import { isSelectionValid } from './utils';
+export var buildToolbar = function buildToolbar(editorAnalyticsAPI) {
+  return function (state, intl) {
+    var isToolbarAbove = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var schema = state.schema;
+    var selectionValid = isSelectionValid(state);
+    if (selectionValid === AnnotationSelectionType.INVALID) {
+      return undefined;
+    }
+    var createCommentMessage = intl.formatMessage(annotationMessages.createComment);
+    var commentDisabledMessage = intl.formatMessage(annotationMessages.createCommentInvalid);
+    var createComment = {
+      type: 'button',
+      showTitle: true,
+      disabled: selectionValid === AnnotationSelectionType.DISABLED,
+      testId: AnnotationTestIds.floatingToolbarCreateButton,
+      icon: CommentIcon,
+      tooltipContent: selectionValid === AnnotationSelectionType.DISABLED ? commentDisabledMessage : /*#__PURE__*/React.createElement(ToolTipContent, {
+        description: createCommentMessage,
+        keymap: addInlineComment
+      }),
+      title: createCommentMessage,
+      onClick: function onClick(state, dispatch) {
+        return setInlineCommentDraftState(editorAnalyticsAPI)(true)(state, dispatch);
+      }
+    };
+    var annotation = schema.marks.annotation;
+    var validNodes = Object.keys(schema.nodes).reduce(function (acc, current) {
+      var type = schema.nodes[current];
+      if (type.allowsMarkType(annotation)) {
+        acc.push(type);
+      }
+      return acc;
+    }, []);
+    var toolbarTitle = intl.formatMessage(annotationMessages.toolbar);
+    var calcToolbarPosition = isToolbarAbove ? calculateToolbarPositionAboveSelection : calculateToolbarPositionTrackHead;
+    var onPositionCalculated = calcToolbarPosition(toolbarTitle);
+    return {
+      title: toolbarTitle,
+      nodeType: validNodes,
+      items: [createComment],
+      onPositionCalculated: onPositionCalculated
+    };
+  };
+};

package/dist/esm/types.js

@@ -0,0 +1,14 @@
+export var AnnotationSelectionType = /*#__PURE__*/function (AnnotationSelectionType) {
+  AnnotationSelectionType["INVALID"] = "invalid";
+  AnnotationSelectionType["DISABLED"] = "disabled";
+  AnnotationSelectionType["VALID"] = "valid";
+  return AnnotationSelectionType;
+}({}); // Annotation can be created
+var prefix = 'ak-editor-annotation';
+export var AnnotationTestIds = {
+  prefix: prefix,
+  floatingComponent: "".concat(prefix, "-floating-component"),
+  floatingToolbarCreateButton: "".concat(prefix, "-toolbar-create-button"),
+  componentSave: "".concat(prefix, "-dummy-save-button"),
+  componentClose: "".concat(prefix, "-dummy-close-button")
+};

package/dist/esm/ui/AnnotationViewWrapper.js

@@ -0,0 +1,32 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+import React from 'react';
+// eslint-disable-next-line @repo/internal/react/no-class-components
+export var AnnotationViewWrapper = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(AnnotationViewWrapper, _React$PureComponent);
+  var _super = _createSuper(AnnotationViewWrapper);
+  function AnnotationViewWrapper() {
+    _classCallCheck(this, AnnotationViewWrapper);
+    return _super.apply(this, arguments);
+  }
+  _createClass(AnnotationViewWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var onViewed = this.props.onViewed;
+      if (onViewed) {
+        onViewed();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return this.props.children;
+    }
+  }]);
+  return AnnotationViewWrapper;
+}(React.PureComponent);

package/dist/esm/ui/InlineCommentView.js

@@ -0,0 +1,142 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, CONTENT_COMPONENT, EVENT_TYPE, RESOLVE_METHOD } from '@atlaskit/editor-common/analytics';
+import { findDomRefAtPos } from '@atlaskit/editor-prosemirror/utils';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
+import { closeComponent, createAnnotation, removeInlineCommentNearSelection, setInlineCommentDraftState, updateInlineCommentResolvedState } from '../commands';
+import { AnnotationTestIds } from '../types';
+import { getAllAnnotations, getAnnotationViewKey, getPluginState, getSelectionPositions } from '../utils';
+import { AnnotationViewWrapper } from './AnnotationViewWrapper';
+var findPosForDOM = function findPosForDOM(sel) {
+  var $from = sel.$from,
+    from = sel.from;
+
+  // Retrieve current TextNode
+  var index = $from.index();
+  var node = index < $from.parent.childCount && $from.parent.child(index);
+
+  // Right edge of a mark.
+  if (!node && $from.nodeBefore && $from.nodeBefore.isText && $from.nodeBefore.marks.find(function (mark) {
+    return mark.type.name === 'annotation';
+  })) {
+    return from - 1;
+  }
+  return from;
+};
+export function InlineCommentView(_ref) {
+  var providers = _ref.providers,
+    editorView = _ref.editorView,
+    editorAnalyticsAPI = _ref.editorAnalyticsAPI,
+    dispatchAnalyticsEvent = _ref.dispatchAnalyticsEvent;
+  // As inlineComment is the only annotation present, this function is not generic
+  var inlineCommentProvider = providers.inlineComment;
+  var state = editorView.state,
+    dispatch = editorView.dispatch;
+  var CreateComponent = inlineCommentProvider.createComponent,
+    ViewComponent = inlineCommentProvider.viewComponent;
+  var inlineCommentState = getPluginState(state);
+  var _ref2 = inlineCommentState || {},
+    bookmark = _ref2.bookmark,
+    selectedAnnotations = _ref2.selectedAnnotations,
+    annotations = _ref2.annotations,
+    isInlineCommentViewClosed = _ref2.isInlineCommentViewClosed;
+  var annotationsList = getAllAnnotations(editorView.state.doc);
+  var selection = getSelectionPositions(state, inlineCommentState);
+  var position = findPosForDOM(selection);
+  var dom;
+  try {
+    dom = findDomRefAtPos(position, editorView.domAtPos.bind(editorView));
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.warn(error);
+    if (dispatchAnalyticsEvent) {
+      var payload = {
+        action: ACTION.ERRORED,
+        actionSubject: ACTION_SUBJECT.CONTENT_COMPONENT,
+        eventType: EVENT_TYPE.OPERATIONAL,
+        attributes: {
+          component: CONTENT_COMPONENT.INLINE_COMMENT,
+          selection: selection.toJSON(),
+          position: position,
+          docSize: editorView.state.doc.nodeSize,
+          error: error.toString()
+        }
+      };
+      dispatchAnalyticsEvent(payload);
+    }
+  }
+  if (!dom) {
+    return null;
+  }
+
+  // Create Component
+  if (bookmark) {
+    if (!CreateComponent) {
+      return null;
+    }
+
+    //getting all text between bookmarked positions
+    var textSelection = state.doc.textBetween(selection.from, selection.to);
+    return /*#__PURE__*/React.createElement("div", {
+      "data-testid": AnnotationTestIds.floatingComponent,
+      "data-editor-popup": "true"
+    }, /*#__PURE__*/React.createElement(CreateComponent, {
+      dom: dom,
+      textSelection: textSelection,
+      onCreate: function onCreate(id) {
+        createAnnotation(editorAnalyticsAPI)(id)(editorView.state, editorView.dispatch);
+        !editorView.hasFocus() && editorView.focus();
+      },
+      onClose: function onClose() {
+        setInlineCommentDraftState(editorAnalyticsAPI)(false)(editorView.state, editorView.dispatch);
+        !editorView.hasFocus() && editorView.focus();
+      }
+    }));
+  }
+
+  // View Component
+  var activeAnnotations = (selectedAnnotations === null || selectedAnnotations === void 0 ? void 0 : selectedAnnotations.filter(function (mark) {
+    return annotations && annotations[mark.id] === false;
+  })) || [];
+  if (!ViewComponent || activeAnnotations.length === 0) {
+    return null;
+  }
+  var onAnnotationViewed = function onAnnotationViewed() {
+    if (!dispatchAnalyticsEvent) {
+      return;
+    }
+    // fire analytics
+    var payload = {
+      action: ACTION.VIEWED,
+      actionSubject: ACTION_SUBJECT.ANNOTATION,
+      actionSubjectId: ACTION_SUBJECT_ID.INLINE_COMMENT,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        overlap: activeAnnotations.length ? activeAnnotations.length - 1 : 0
+      }
+    };
+    dispatchAnalyticsEvent(payload);
+  };
+  if (getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') && isInlineCommentViewClosed || !selectedAnnotations) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(AnnotationViewWrapper, {
+    "data-editor-popup": "true",
+    "data-testid": AnnotationTestIds.floatingComponent,
+    key: getAnnotationViewKey(activeAnnotations),
+    onViewed: onAnnotationViewed
+  }, /*#__PURE__*/React.createElement(ViewComponent, {
+    annotationsList: annotationsList,
+    annotations: activeAnnotations,
+    dom: dom,
+    onDelete: function onDelete(id) {
+      return removeInlineCommentNearSelection(id)(state, dispatch);
+    },
+    onResolve: function onResolve(id) {
+      return updateInlineCommentResolvedState(editorAnalyticsAPI)(_defineProperty({}, id, true), RESOLVE_METHOD.COMPONENT)(editorView.state, editorView.dispatch);
+    },
+    onClose: function onClose() {
+      closeComponent()(editorView.state, editorView.dispatch);
+    }
+  }));
+}

package/dist/esm/utils.js

@@ -0,0 +1,345 @@
+import { AnnotationTypes } from '@atlaskit/adf-schema';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { AnnotationSharedClassNames } from '@atlaskit/editor-common/styles';
+import { canApplyAnnotationOnRange, containsAnyAnnotations, getAnnotationIdsFromRange, hasAnnotationMark, isParagraph, isText } from '@atlaskit/editor-common/utils';
+import { AllSelection, PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import { AnnotationSelectionType } from './types';
+export { hasAnnotationMark, containsAnyAnnotations };
+function sum(arr, f) {
+  return arr.reduce(function (val, x) {
+    return val + f(x);
+  }, 0);
+}
+/**
+ * Finds the marks in the nodes to the left and right.
+ * @param $pos Position to center search around
+ */
+export var surroundingMarks = function surroundingMarks($pos) {
+  var nodeBefore = $pos.nodeBefore,
+    nodeAfter = $pos.nodeAfter;
+  var markNodeBefore = nodeBefore && $pos.doc.nodeAt(Math.max(0, $pos.pos - nodeBefore.nodeSize - 1));
+  var markNodeAfter = nodeAfter && $pos.doc.nodeAt($pos.pos + nodeAfter.nodeSize);
+  return [markNodeBefore && markNodeBefore.marks || [], markNodeAfter && markNodeAfter.marks || []];
+};
+
+/**
+ * Finds annotation marks, and returns their IDs.
+ * @param marks Array of marks to search in
+ */
+var filterAnnotationIds = function filterAnnotationIds(marks) {
+  if (!marks.length) {
+    return [];
+  }
+  var annotation = marks[0].type.schema.marks.annotation;
+  return marks.filter(function (mark) {
+    return mark.type === annotation;
+  }).map(function (mark) {
+    return mark.attrs.id;
+  });
+};
+
+/**
+ * Re-orders the annotation array based on the order in the document.
+ *
+ * This places the marks that do not appear in the surrounding nodes
+ * higher in the list. That is, the inner-most one appears first.
+ *
+ * Undo, for example, can re-order annotation marks in the document.
+ * @param annotations annotation metadata
+ * @param $from location to look around (usually the selection)
+ */
+var reorderAnnotations = function reorderAnnotations(annotations, $from) {
+  var idSet = surroundingMarks($from).map(filterAnnotationIds);
+  annotations.sort(function (a, b) {
+    return sum(idSet, function (ids) {
+      return ids.indexOf(a.id);
+    }) - sum(idSet, function (ids) {
+      return ids.indexOf(b.id);
+    });
+  });
+};
+export var getAllAnnotations = function getAllAnnotations(doc) {
+  var allAnnotationIds = new Set();
+  doc.descendants(function (node) {
+    node.marks.filter(function (mark) {
+      return mark.type.name === 'annotation';
+    })
+    // filter out annotations with invalid attributes as they cause errors when interacting with them
+    .filter(validateAnnotationMark).forEach(function (m) {
+      return allAnnotationIds.add(m.attrs.id);
+    });
+    return true;
+  });
+  return Array.from(allAnnotationIds);
+};
+
+/*
+ * verifies if annotation mark contains valid attributes
+ */
+var validateAnnotationMark = function validateAnnotationMark(annotationMark) {
+  var _ref = annotationMark.attrs,
+    id = _ref.id,
+    annotationType = _ref.annotationType;
+  return validateAnnotationId(id) && validateAnnotationType(annotationType);
+  function validateAnnotationId(id) {
+    if (!id || typeof id !== 'string') {
+      return false;
+    }
+    var invalidIds = ['null', 'undefined'];
+    return !invalidIds.includes(id.toLowerCase());
+  }
+  function validateAnnotationType(type) {
+    if (!type || typeof type !== 'string') {
+      return false;
+    }
+    var allowedTypes = Object.values(AnnotationTypes);
+    return allowedTypes.includes(type);
+  }
+};
+
+/*
+ * add decoration for the comment selection in draft state
+ * (when creating new comment)
+ */
+export var addDraftDecoration = function addDraftDecoration(start, end) {
+  return Decoration.inline(start, end, {
+    class: "".concat(AnnotationSharedClassNames.draft)
+  });
+};
+export var getAnnotationViewKey = function getAnnotationViewKey(annotations) {
+  var keys = annotations.map(function (mark) {
+    return mark.id;
+  }).join('_');
+  return "view-annotation-wrapper_".concat(keys);
+};
+export var findAnnotationsInSelection = function findAnnotationsInSelection(selection, doc) {
+  var empty = selection.empty,
+    $anchor = selection.$anchor,
+    anchor = selection.anchor;
+  // Only detect annotations on caret selection
+  if (!empty || !doc) {
+    return [];
+  }
+  var node = doc.nodeAt(anchor);
+  if (!node && !$anchor.nodeBefore) {
+    return [];
+  }
+  var annotationMark = doc.type.schema.marks.annotation;
+  var nodeBefore = $anchor.nodeBefore;
+  var anchorAnnotationMarks = node && node.marks || [];
+  var marks = [];
+  if (annotationMark.isInSet(anchorAnnotationMarks)) {
+    marks = anchorAnnotationMarks;
+  } else if (nodeBefore && annotationMark.isInSet(nodeBefore.marks)) {
+    marks = nodeBefore.marks;
+  }
+  var annotations = marks.filter(function (mark) {
+    return mark.type.name === 'annotation';
+  }).map(function (mark) {
+    return {
+      id: mark.attrs.id,
+      type: mark.attrs.annotationType
+    };
+  });
+  reorderAnnotations(annotations, $anchor);
+  return annotations;
+};
+
+/**
+ * get selection from position to apply new comment for
+ * @return bookmarked positions if they exists, otherwise current selection positions
+ */
+export function getSelectionPositions(editorState, inlineCommentState) {
+  var _ref2 = inlineCommentState || {},
+    bookmark = _ref2.bookmark;
+  // get positions via saved bookmark if it is available
+  // this is to make comments box positioned relative to temporary highlight rather then current selection
+  if (bookmark) {
+    return bookmark.resolve(editorState.doc);
+  }
+  return editorState.selection;
+}
+export var inlineCommentPluginKey = new PluginKey('inlineCommentPluginKey');
+export var getPluginState = function getPluginState(state) {
+  return inlineCommentPluginKey.getState(state);
+};
+
+/**
+ * get number of unique annotations within current selection
+ */
+var getAnnotationsInSelectionCount = function getAnnotationsInSelectionCount(state) {
+  var _state$selection = state.selection,
+    from = _state$selection.from,
+    to = _state$selection.to;
+  var annotations = getAnnotationIdsFromRange({
+    from: from,
+    to: to
+  }, state.doc, state.schema);
+  return annotations.length;
+};
+
+/**
+ * get payload for the open/close analytics event
+ */
+export var getDraftCommandAnalyticsPayload = function getDraftCommandAnalyticsPayload(drafting, inputMethod) {
+  var payload = function payload(state) {
+    var attributes = {};
+    if (drafting) {
+      attributes = {
+        inputMethod: inputMethod,
+        overlap: getAnnotationsInSelectionCount(state)
+      };
+    }
+    return {
+      action: drafting ? ACTION.OPENED : ACTION.CLOSED,
+      actionSubject: ACTION_SUBJECT.ANNOTATION,
+      actionSubjectId: ACTION_SUBJECT_ID.INLINE_COMMENT,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: attributes
+    };
+  };
+  return payload;
+};
+export var isSelectionValid = function isSelectionValid(state) {
+  var selection = state.selection;
+  var _ref3 = getPluginState(state) || {},
+    disallowOnWhitespace = _ref3.disallowOnWhitespace;
+  if (selection.empty || !(selection instanceof TextSelection || selection instanceof AllSelection)) {
+    return AnnotationSelectionType.INVALID;
+  }
+  var containsInvalidNodes = hasInvalidNodes(state);
+
+  // A selection that only covers 1 pos, and is an invalid node
+  // e.g. a text selection over a mention
+  if (containsInvalidNodes && selection.to - selection.from === 1) {
+    return AnnotationSelectionType.INVALID;
+  }
+  if (containsInvalidNodes) {
+    return AnnotationSelectionType.DISABLED;
+  }
+  if (disallowOnWhitespace && hasInvalidWhitespaceNode(selection, state.schema)) {
+    return AnnotationSelectionType.INVALID;
+  }
+  if (isEmptyTextSelection(selection, state.schema)) {
+    return AnnotationSelectionType.INVALID;
+  }
+  return AnnotationSelectionType.VALID;
+};
+export var hasInvalidNodes = function hasInvalidNodes(state) {
+  var selection = state.selection,
+    doc = state.doc,
+    schema = state.schema;
+  return !canApplyAnnotationOnRange({
+    from: selection.from,
+    to: selection.to
+  }, doc, schema);
+};
+
+/**
+ * Checks if selection contains only empty text
+ * e.g. when you select across multiple empty paragraphs
+ */
+function isEmptyTextSelection(selection, schema) {
+  var _schema$nodes = schema.nodes,
+    text = _schema$nodes.text,
+    paragraph = _schema$nodes.paragraph;
+  var hasContent = false;
+  selection.content().content.descendants(function (node) {
+    // for empty paragraph - consider empty (nothing to comment on)
+    if (node.type === paragraph && !node.content.size) {
+      return false;
+    }
+    // for not a text or nonempty text - consider nonempty (can comment if the node is supported for annotations)
+    if (node.type !== text || !node.textContent) {
+      hasContent = true;
+    }
+    return !hasContent;
+  });
+  return !hasContent;
+}
+
+/**
+ * Checks if any of the nodes in a given selection are completely whitespace
+ * This is to conform to Confluence annotation specifications
+ */
+export function hasInvalidWhitespaceNode(selection, schema) {
+  var foundInvalidWhitespace = false;
+  var content = selection.content().content;
+  content.descendants(function (node) {
+    if (isText(node, schema)) {
+      return false;
+    }
+    if (node.textContent.trim() === '') {
+      // Trailing new lines do not result in the annotation spanning into
+      // the trailing new line so can be ignored when looking for invalid
+      // whitespace nodes.
+      var nodeIsTrailingNewLine =
+      // it is the final node
+      node.eq(content.lastChild) &&
+      // and there are multiple nodes
+      !node.eq(content.firstChild) &&
+      // and it is a paragraph node
+      isParagraph(node, schema);
+      if (!nodeIsTrailingNewLine) {
+        foundInvalidWhitespace = true;
+      }
+    }
+    return !foundInvalidWhitespace;
+  });
+  return foundInvalidWhitespace;
+}
+
+/*
+ * verifies that the annotation exists by the given id
+ */
+export function annotationExists(annotationId, state) {
+  var commentsPluginState = getPluginState(state);
+  return !!(commentsPluginState !== null && commentsPluginState !== void 0 && commentsPluginState.annotations) && Object.keys(commentsPluginState.annotations).includes(annotationId);
+}
+
+/*
+ * remove annotations that dont exsist in plugin state from slice
+ */
+export function stripNonExistingAnnotations(slice, state) {
+  if (!slice.content.size) {
+    return false;
+  }
+  slice.content.forEach(function (node) {
+    stripNonExistingAnnotationsFromNode(node, state);
+    node.content.descendants(function (node) {
+      stripNonExistingAnnotationsFromNode(node, state);
+      return true;
+    });
+  });
+}
+
+/*
+ * remove annotations that dont exsist in plugin state
+ * from node
+ */
+function stripNonExistingAnnotationsFromNode(node, state) {
+  if (hasAnnotationMark(node, state)) {
+    node.marks = node.marks.filter(function (mark) {
+      if (mark.type.name === 'annotation') {
+        return annotationExists(mark.attrs.id, state);
+      }
+      return true;
+    });
+  }
+  return node;
+}
+
+/**
+ * Compares two sets of annotationInfos to see if the annotations have changed
+ * This function assumes annotations will have unique id's for simplicity
+ */
+export function isSelectedAnnotationsChanged(oldSelectedAnnotations, newSelectedAnnotations) {
+  return newSelectedAnnotations.length !== oldSelectedAnnotations.length ||
+  // assuming annotations have unique id's for simplicity
+  newSelectedAnnotations.some(function (annotation) {
+    return !oldSelectedAnnotations.find(function (pluginStateAnnotation) {
+      return annotation.id === pluginStateAnnotation.id && annotation.type === pluginStateAnnotation.type;
+    });
+  });
+}