@atlaskit/editor-core 190.1.20 → 190.1.24

package/dist/esm/plugins/annotation/nodeviews/index.js

@@ -1,52 +0,0 @@
-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';
-import { AnnotationSharedClassNames } from '@atlaskit/editor-common/styles';
-import ReactNodeView from '@atlaskit/editor-common/react-node-view';
-export var AnnotationNodeView = /*#__PURE__*/function (_ReactNodeView) {
-  _inherits(AnnotationNodeView, _ReactNodeView);
-  var _super = _createSuper(AnnotationNodeView);
-  function AnnotationNodeView() {
-    _classCallCheck(this, AnnotationNodeView);
-    return _super.apply(this, arguments);
-  }
-  _createClass(AnnotationNodeView, [{
-    key: "createDomRef",
-    value: function createDomRef() {
-      return document.createElement('span');
-    }
-  }, {
-    key: "getContentDOM",
-    value: function getContentDOM() {
-      var dom = document.createElement('span');
-      dom.className = 'ak-editor-annotation';
-      return {
-        dom: dom
-      };
-    }
-  }, {
-    key: "render",
-    value: function render(_props, forwardRef) {
-      return (
-        /*#__PURE__*/
-        // all inline comment states are now set in decorations at ../pm-plugins/inline-comment.ts
-        React.createElement("span", {
-          "data-mark-type": "annotation",
-          ref: forwardRef
-        })
-      );
-    }
-  }]);
-  return AnnotationNodeView;
-}(ReactNodeView);
-export var getAnnotationViewClassname = function getAnnotationViewClassname(isUnresolved, hasFocus) {
-  if (!isUnresolved) {
-    return;
-  }
-  return hasFocus ? AnnotationSharedClassNames.focus : AnnotationSharedClassNames.blur;
-};

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

@@ -1,236 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { RESOLVE_METHOD } from '@atlaskit/editor-common/analytics';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import { AnnotationTypes } from '@atlaskit/adf-schema';
-import { AnnotationNodeView, getAnnotationViewClassname } from '../nodeviews';
-import { getBooleanFF } from '@atlaskit/platform-feature-flags';
-import { updateInlineCommentResolvedState, updateMouseState, clearDirtyMark, setInlineCommentsVisibility, setSelectedAnnotation, closeComponent } from '../commands';
-import { getAllAnnotations, inlineCommentPluginKey, getPluginState } from '../utils';
-import { createPluginState } from './plugin-factory';
-var fetchProviderStates = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(provider, annotationIds) {
-    var data, result;
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.next = 2;
-          return provider.getState(annotationIds);
-        case 2:
-          data = _context.sent;
-          result = {};
-          data.forEach(function (annotation) {
-            if (annotation.annotationType === AnnotationTypes.INLINE_COMMENT) {
-              result[annotation.id] = annotation.state.resolved;
-            }
-          });
-          return _context.abrupt("return", result);
-        case 6:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return function fetchProviderStates(_x, _x2) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-// fetchState is unable to return a command as it's runs async and may dispatch at a later time
-// Requires `editorView` instead of the decomposition as the async means state may end up stale
-var fetchState = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(provider, annotationIds, editorView, editorAnalyticsAPI) {
-    var inlineCommentStates;
-    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          if (!(!annotationIds || !annotationIds.length)) {
-            _context2.next = 2;
-            break;
-          }
-          return _context2.abrupt("return");
-        case 2:
-          _context2.next = 4;
-          return fetchProviderStates(provider, annotationIds);
-        case 4:
-          inlineCommentStates = _context2.sent;
-          if (editorView.dispatch) {
-            updateInlineCommentResolvedState(editorAnalyticsAPI)(inlineCommentStates)(editorView.state, editorView.dispatch);
-          }
-        case 6:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return function fetchState(_x3, _x4, _x5, _x6) {
-    return _ref2.apply(this, arguments);
-  };
-}();
-var initialState = function initialState() {
-  var disallowOnWhitespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-  return {
-    annotations: {},
-    selectedAnnotations: [],
-    mouseData: {
-      isSelecting: false
-    },
-    disallowOnWhitespace: disallowOnWhitespace,
-    isInlineCommentViewClosed: false,
-    isVisible: true,
-    skipSelectionHandling: false
-  };
-};
-var hideToolbar = function hideToolbar(state, dispatch) {
-  return function () {
-    updateMouseState({
-      isSelecting: true
-    })(state, dispatch);
-  };
-};
-
-// Subscribe to updates from consumer
-var onResolve = function onResolve(editorAnalyticsAPI) {
-  return function (state, dispatch) {
-    return function (annotationId) {
-      updateInlineCommentResolvedState(editorAnalyticsAPI)(_defineProperty({}, annotationId, true), RESOLVE_METHOD.CONSUMER)(state, dispatch);
-    };
-  };
-};
-var onUnResolve = function onUnResolve(editorAnalyticsAPI) {
-  return function (state, dispatch) {
-    return function (annotationId) {
-      updateInlineCommentResolvedState(editorAnalyticsAPI)(_defineProperty({}, annotationId, false))(state, dispatch);
-    };
-  };
-};
-var onMouseUp = function onMouseUp(state, dispatch) {
-  return function (e) {
-    var _ref3 = getPluginState(state) || {},
-      mouseData = _ref3.mouseData;
-    if (mouseData !== null && mouseData !== void 0 && mouseData.isSelecting) {
-      updateMouseState({
-        isSelecting: false
-      })(state, dispatch);
-    }
-  };
-};
-var onSetVisibility = function onSetVisibility(view) {
-  return function (isVisible) {
-    var state = view.state,
-      dispatch = view.dispatch;
-    setInlineCommentsVisibility(isVisible)(state, dispatch);
-    if (isVisible) {
-      // PM retains focus when we click away from the editor.
-      // This will restore the visual aspect of the selection,
-      // otherwise it will seem a floating toolbar will appear
-      // for no reason.
-      view.focus();
-    }
-  };
-};
-export var inlineCommentPlugin = function inlineCommentPlugin(options) {
-  var provider = options.provider,
-    portalProviderAPI = options.portalProviderAPI,
-    eventDispatcher = options.eventDispatcher;
-  return new SafePlugin({
-    key: inlineCommentPluginKey,
-    state: createPluginState(options.dispatch, initialState(provider.disallowOnWhitespace)),
-    view: function view(editorView) {
-      // Get initial state
-      // Need to pass `editorView` to mitigate editor state going stale
-      fetchState(provider, getAllAnnotations(editorView.state.doc), editorView, options.editorAnalyticsAPI);
-      var resolve = function resolve(annotationId) {
-        return onResolve(options.editorAnalyticsAPI)(editorView.state, editorView.dispatch)(annotationId);
-      };
-      var unResolve = function unResolve(annotationId) {
-        return onUnResolve(options.editorAnalyticsAPI)(editorView.state, editorView.dispatch)(annotationId);
-      };
-      var mouseUp = function mouseUp(event) {
-        return onMouseUp(editorView.state, editorView.dispatch)(event);
-      };
-      var setVisibility = function setVisibility(isVisible) {
-        return onSetVisibility(editorView)(isVisible);
-      };
-      var setSelectedAnnotationFn = function setSelectedAnnotationFn(annotationId) {
-        if (!annotationId) {
-          closeComponent()(editorView.state, editorView.dispatch);
-        } else {
-          setSelectedAnnotation(annotationId)(editorView.state, editorView.dispatch);
-        }
-      };
-      var updateSubscriber = provider.updateSubscriber;
-      if (updateSubscriber) {
-        updateSubscriber.on('resolve', resolve).on('delete', resolve).on('unresolve', unResolve).on('create', unResolve).on('setvisibility', setVisibility).on('setselectedannotation', setSelectedAnnotationFn);
-      }
-      editorView.root.addEventListener('mouseup', mouseUp);
-      return {
-        update: function update(view, _prevState) {
-          var _ref4 = getPluginState(view.state) || {},
-            dirtyAnnotations = _ref4.dirtyAnnotations;
-          if (!dirtyAnnotations) {
-            return;
-          }
-          clearDirtyMark()(view.state, view.dispatch);
-          fetchState(provider, getAllAnnotations(view.state.doc), view, options.editorAnalyticsAPI);
-        },
-        destroy: function destroy() {
-          editorView.root.removeEventListener('mouseup', mouseUp);
-          if (updateSubscriber) {
-            updateSubscriber.off('resolve', resolve).off('delete', resolve).off('unresolve', unResolve).off('create', unResolve).off('setvisibility', setVisibility).off('setselectedannotation', setSelectedAnnotationFn);
-          }
-        }
-      };
-    },
-    props: {
-      nodeViews: {
-        annotation: function annotation(node, view, getPos) {
-          return new AnnotationNodeView(node, view, getPos, portalProviderAPI, eventDispatcher) // resolved
-          .init();
-        }
-      },
-      handleDOMEvents: {
-        mousedown: function mousedown(view) {
-          var pluginState = getPluginState(view.state);
-          if (!(pluginState !== null && pluginState !== void 0 && pluginState.mouseData.isSelecting)) {
-            hideToolbar(view.state, view.dispatch)();
-          }
-          return false;
-        }
-      },
-      decorations: function decorations(state) {
-        // highlight comments, depending on state
-        var _ref5 = getPluginState(state) || {},
-          draftDecorationSet = _ref5.draftDecorationSet,
-          annotations = _ref5.annotations,
-          selectedAnnotations = _ref5.selectedAnnotations,
-          isVisible = _ref5.isVisible,
-          isInlineCommentViewClosed = _ref5.isInlineCommentViewClosed;
-        var decorations = draftDecorationSet !== null && draftDecorationSet !== void 0 ? draftDecorationSet : DecorationSet.empty;
-        var focusDecorations = [];
-        state.doc.descendants(function (node, pos) {
-          node.marks.filter(function (mark) {
-            return mark.type === state.schema.marks.annotation;
-          }).forEach(function (mark) {
-            var isSelected = getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') ? !isInlineCommentViewClosed && !!(selectedAnnotations !== null && selectedAnnotations !== void 0 && selectedAnnotations.some(function (selectedAnnotation) {
-              return selectedAnnotation.id === mark.attrs.id;
-            })) : !!(selectedAnnotations !== null && selectedAnnotations !== void 0 && selectedAnnotations.some(function (selectedAnnotation) {
-              return selectedAnnotation.id === mark.attrs.id;
-            }));
-            var isUnresolved = !!annotations && annotations[mark.attrs.id] === false;
-            if (isVisible) {
-              focusDecorations.push(Decoration.inline(pos, pos + node.nodeSize, {
-                class: "".concat(getAnnotationViewClassname(isUnresolved, isSelected), " ").concat(isUnresolved),
-                nodeName: 'span'
-              }));
-            }
-          });
-        });
-        decorations = decorations.add(state.doc, focusDecorations);
-        return decorations;
-      }
-    }
-  });
-};

package/dist/esm/plugins/annotation/pm-plugins/keymap.js

@@ -1,9 +0,0 @@
-import { keymap } from '@atlaskit/editor-prosemirror/keymap';
-import { bindKeymapWithCommand, addInlineComment } from '../../../keymaps';
-import { setInlineCommentDraftState } from '../commands';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-export function keymapPlugin(editorAnalyticsAPI) {
-  var list = {};
-  bindKeymapWithCommand(addInlineComment.common, setInlineCommentDraftState(editorAnalyticsAPI)(true, INPUT_METHOD.SHORTCUT), list);
-  return keymap(list);
-}

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

@@ -1,101 +0,0 @@
-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 { pluginFactory } from '../../../utils/plugin-state-factory';
-import { findAnnotationsInSelection, inlineCommentPluginKey, isSelectedAnnotationsChanged } from '../utils';
-import { getBooleanFF } from '@atlaskit/platform-feature-flags';
-import reducer from './reducer';
-var handleDocChanged = function handleDocChanged(tr, prevPluginState) {
-  if (!tr.getMeta('replaceDocument')) {
-    return getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox') ? getSelectionChangedHandler(false)(tr, prevPluginState) : handleSelectionChanged(tr, prevPluginState);
-  }
-  return _objectSpread(_objectSpread({}, prevPluginState), {}, {
-    dirtyAnnotations: true
-  });
-};
-var handleSelectionChanged = function handleSelectionChanged(tr, pluginState) {
-  if (pluginState.skipSelectionHandling) {
-    return _objectSpread(_objectSpread({}, pluginState), {}, {
-      skipSelectionHandling: false
-    });
-  }
-  var selectedAnnotations = findAnnotationsInSelection(tr.selection, tr.doc);
-  var changed = selectedAnnotations.length !== pluginState.selectedAnnotations.length || selectedAnnotations.some(function (annotationInfo) {
-    return !pluginState.selectedAnnotations.some(function (aInfo) {
-      return aInfo.type === annotationInfo.id;
-    });
-  });
-  if (changed) {
-    return _objectSpread(_objectSpread({}, pluginState), {}, {
-      selectedAnnotations: selectedAnnotations
-    });
-  }
-  return pluginState;
-};
-var getSelectionChangedHandler = function getSelectionChangedHandler(reopenCommentView) {
-  return function (tr, pluginState) {
-    /**
-     * If feature flag is **OFF** we want to keep the old behavior. Note that
-     * reopenCommentView is not relevant here when using old behaviour.
-     *
-     * Feature flag is evaluated here rather than directly in onSelectionChanged where it is assigned
-     * to prevent the plugin from setting up the handler before the feature flag is evaluated.
-     *
-     * This comment / logic can be cleaned up once the feature flag is removed.
-     */
-    if (!getBooleanFF('platform.editor.annotation.decouple-inline-comment-closed_flmox')) {
-      return handleSelectionChanged(tr, pluginState);
-    }
-    if (pluginState.skipSelectionHandling) {
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
-        skipSelectionHandling: false
-      }, reopenCommentView && {
-        isInlineCommentViewClosed: false
-      });
-    }
-    var selectedAnnotations = findAnnotationsInSelection(tr.selection, tr.doc);
-    if (selectedAnnotations.length === 0) {
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
-        selectedAnnotations: selectedAnnotations,
-        isInlineCommentViewClosed: true
-      });
-    }
-    if (isSelectedAnnotationsChanged(selectedAnnotations, pluginState.selectedAnnotations)) {
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
-        selectedAnnotations: selectedAnnotations
-      }, reopenCommentView && {
-        isInlineCommentViewClosed: false
-      });
-    }
-    return _objectSpread(_objectSpread({}, pluginState), reopenCommentView && {
-      isInlineCommentViewClosed: false
-    });
-  };
-};
-var _pluginFactory = pluginFactory(inlineCommentPluginKey, reducer, {
-    onSelectionChanged: getSelectionChangedHandler(true),
-    onDocChanged: handleDocChanged,
-    mapping: function mapping(tr, pluginState) {
-      var draftDecorationSet = pluginState.draftDecorationSet,
-        bookmark = pluginState.bookmark;
-      var mappedDecorationSet, mappedBookmark;
-      if (draftDecorationSet) {
-        mappedDecorationSet = draftDecorationSet.map(tr.mapping, tr.doc);
-      }
-      if (bookmark) {
-        mappedBookmark = bookmark.map(tr.mapping);
-      }
-
-      // return same pluginState if mappings did not change
-      if (mappedBookmark === bookmark && mappedDecorationSet === draftDecorationSet) {
-        return pluginState;
-      }
-      return _objectSpread(_objectSpread({}, pluginState), {}, {
-        draftDecorationSet: mappedDecorationSet,
-        bookmark: mappedBookmark
-      });
-    }
-  }),
-  createPluginState = _pluginFactory.createPluginState,
-  createCommand = _pluginFactory.createCommand;
-export { createPluginState, createCommand };

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

@@ -1,77 +0,0 @@
-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/plugins/annotation/pm-plugins/types.js

@@ -1,11 +0,0 @@
-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/plugins/annotation/toolbar.js

@@ -1,52 +0,0 @@
-import React from 'react';
-import CommentIcon from '@atlaskit/icon/glyph/comment';
-import { addInlineComment, ToolTipContent } from '../../keymaps';
-import { setInlineCommentDraftState } from './commands';
-import { AnnotationTestIds, AnnotationSelectionType } from './types';
-import { isSelectionValid } from './utils';
-import { annotationMessages } from '@atlaskit/editor-common/messages';
-import { calculateToolbarPositionAboveSelection, calculateToolbarPositionTrackHead } from '@atlaskit/editor-common/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/plugins/annotation/types.js

@@ -1,14 +0,0 @@
-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/plugins/annotation/ui/AnnotationViewWrapper.js

@@ -1,31 +0,0 @@
-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';
-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);