@atlaskit/editor-core 190.1.19 → 190.1.23

package/dist/esm/plugins/annotation/commands/transform.js

@@ -1,80 +0,0 @@
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { AnnotationTypes } from '@atlaskit/adf-schema';
-import { ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, ACTION, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { getSelectionPositions, getPluginState, getDraftCommandAnalyticsPayload } from '../utils';
-import { applyMarkOnRange } from '@atlaskit/editor-common/mark';
-var addAnnotationMark = function addAnnotationMark(id) {
-  return function (transaction, state) {
-    var inlineCommentState = getPluginState(state);
-    var _getSelectionPosition = getSelectionPositions(state, inlineCommentState),
-      from = _getSelectionPosition.from,
-      to = _getSelectionPosition.to,
-      head = _getSelectionPosition.head;
-    var annotationMark = state.schema.marks.annotation.create({
-      id: id,
-      type: AnnotationTypes.INLINE_COMMENT
-    });
-    // Apply the mark only to text node in the range.
-    var tr = applyMarkOnRange(from, to, false, annotationMark, transaction);
-    // set selection back to the end of annotation once annotation mark is applied
-    tr.setSelection(TextSelection.create(tr.doc, head));
-    return tr;
-  };
-};
-var addInlineComment = function addInlineComment(editorAnalyticsAPI) {
-  return function (id) {
-    return function (transaction, state) {
-      var tr = addAnnotationMark(id)(transaction, state);
-      // add insert analytics step to transaction
-      tr = addInsertAnalytics(editorAnalyticsAPI)(tr, state);
-      // add close analytics step to transaction
-      tr = addOpenCloseAnalytics(editorAnalyticsAPI)(false, INPUT_METHOD.TOOLBAR)(tr, state);
-      return tr;
-    };
-  };
-};
-var addOpenCloseAnalytics = function addOpenCloseAnalytics(editorAnalyticsAPI) {
-  return function (drafting) {
-    var method = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : INPUT_METHOD.TOOLBAR;
-    return function (transaction, state) {
-      var draftingPayload = getDraftCommandAnalyticsPayload(drafting, method)(state);
-      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(draftingPayload)(transaction);
-      return transaction;
-    };
-  };
-};
-var addInsertAnalytics = function addInsertAnalytics(editorAnalyticsAPI) {
-  return function (transaction, state) {
-    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
-      action: ACTION.INSERTED,
-      actionSubject: ACTION_SUBJECT.ANNOTATION,
-      eventType: EVENT_TYPE.TRACK,
-      actionSubjectId: ACTION_SUBJECT_ID.INLINE_COMMENT
-    })(transaction);
-    return transaction;
-  };
-};
-var addResolveAnalytics = function addResolveAnalytics(editorAnalyticsAPI) {
-  return function (method) {
-    return function (transaction, state) {
-      var resolvedPayload = {
-        action: ACTION.RESOLVED,
-        actionSubject: ACTION_SUBJECT.ANNOTATION,
-        actionSubjectId: ACTION_SUBJECT_ID.INLINE_COMMENT,
-        eventType: EVENT_TYPE.TRACK,
-        attributes: {
-          method: method
-        }
-      };
-      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(resolvedPayload)(transaction);
-      return transaction;
-    };
-  };
-};
-export default {
-  addAnnotationMark: addAnnotationMark,
-  addInlineComment: addInlineComment,
-  addOpenCloseAnalytics: addOpenCloseAnalytics,
-  addInsertAnalytics: addInsertAnalytics,
-  addResolveAnalytics: addResolveAnalytics
-};

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

@@ -1,118 +0,0 @@
-import React from 'react';
-import { annotation } from '@atlaskit/adf-schema';
-import { keymapPlugin } from './pm-plugins/keymap';
-import { inlineCommentPlugin } from './pm-plugins/inline-comment';
-import { AnnotationUpdateEmitter } from './update-provider';
-import { getPluginState } from './utils';
-import { buildToolbar } from './toolbar';
-import { InlineCommentView } from './ui/InlineCommentView';
-import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
-import { getBooleanFF } from '@atlaskit/platform-feature-flags';
-var annotationPlugin = function annotationPlugin(_ref) {
-  var annotationProviders = _ref.config,
-    api = _ref.api;
-  return {
-    name: 'annotation',
-    marks: function marks() {
-      return [{
-        name: 'annotation',
-        mark: annotation
-      }];
-    },
-    getSharedState: function getSharedState(editorState) {
-      if (!editorState) {
-        return undefined;
-      }
-      return getPluginState(editorState) || undefined;
-    },
-    pmPlugins: function pmPlugins() {
-      return [{
-        name: 'annotation',
-        plugin: function plugin(_ref2) {
-          var dispatch = _ref2.dispatch,
-            portalProviderAPI = _ref2.portalProviderAPI,
-            eventDispatcher = _ref2.eventDispatcher;
-          if (annotationProviders) {
-            var _api$analytics;
-            return inlineCommentPlugin({
-              dispatch: dispatch,
-              portalProviderAPI: portalProviderAPI,
-              eventDispatcher: eventDispatcher,
-              provider: annotationProviders.inlineComment,
-              editorAnalyticsAPI: api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions
-            });
-          }
-          return;
-        }
-      }, {
-        name: 'annotationKeymap',
-        plugin: function plugin() {
-          if (annotationProviders) {
-            var _api$analytics2;
-            return keymapPlugin(api === null || api === void 0 || (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions);
-          }
-          return;
-        }
-      }];
-    },
-    pluginsOptions: {
-      floatingToolbar: function floatingToolbar(state, intl) {
-        if (getBooleanFF('platform.editor.enable-selection-toolbar_ucdwd') || !annotationProviders) {
-          return;
-        }
-        var pluginState = getPluginState(state);
-        if (pluginState && pluginState.isVisible && !pluginState.bookmark && !pluginState.mouseData.isSelecting) {
-          var _api$analytics3;
-          var isToolbarAbove = annotationProviders.inlineComment.isToolbarAbove;
-          return buildToolbar(api === null || api === void 0 || (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions)(state, intl, isToolbarAbove);
-        }
-      },
-      selectionToolbar: function selectionToolbar(state, intl) {
-        if (!getBooleanFF('platform.editor.enable-selection-toolbar_ucdwd') || !annotationProviders) {
-          return;
-        }
-        var pluginState = getPluginState(state);
-        if (pluginState && pluginState.isVisible && !pluginState.bookmark && !pluginState.mouseData.isSelecting) {
-          var _api$analytics4;
-          var isToolbarAbove = annotationProviders.inlineComment.isToolbarAbove;
-          return buildToolbar(api === null || api === void 0 || (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : _api$analytics4.actions)(state, intl, isToolbarAbove);
-        }
-      }
-    },
-    contentComponent: function contentComponent(_ref3) {
-      var editorView = _ref3.editorView,
-        dispatchAnalyticsEvent = _ref3.dispatchAnalyticsEvent;
-      if (!annotationProviders) {
-        return null;
-      }
-      return /*#__PURE__*/React.createElement(AnnotationContentComponent, {
-        api: api,
-        editorView: editorView,
-        annotationProviders: annotationProviders,
-        dispatchAnalyticsEvent: dispatchAnalyticsEvent
-      });
-    }
-  };
-};
-function AnnotationContentComponent(_ref4) {
-  var _api$analytics5;
-  var api = _ref4.api,
-    editorView = _ref4.editorView,
-    annotationProviders = _ref4.annotationProviders,
-    dispatchAnalyticsEvent = _ref4.dispatchAnalyticsEvent;
-  var _useSharedPluginState = useSharedPluginState(api, ['annotation']),
-    inlineCommentState = _useSharedPluginState.annotationState;
-  if (inlineCommentState && !inlineCommentState.isVisible) {
-    return null;
-  }
-  return /*#__PURE__*/React.createElement("div", {
-    "data-editor-popup": "true"
-  }, /*#__PURE__*/React.createElement(InlineCommentView, {
-    providers: annotationProviders,
-    editorView: editorView,
-    dispatchAnalyticsEvent: dispatchAnalyticsEvent,
-    editorAnalyticsAPI: api === null || api === void 0 || (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 ? void 0 : _api$analytics5.actions
-  }));
-}
-export default annotationPlugin;
-export { AnnotationUpdateEmitter };

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;
-}