@atlaskit/editor-plugin-annotation 0.1.0

package/dist/cjs/ui/InlineCommentView.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InlineCommentView = InlineCommentView;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _commands = require("../commands");
+var _types = require("../types");
+var _utils2 = require("../utils");
+var _AnnotationViewWrapper = require("./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;
+};
+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 = (0, _utils2.getPluginState)(state);
+  var _ref2 = inlineCommentState || {},
+    bookmark = _ref2.bookmark,
+    selectedAnnotations = _ref2.selectedAnnotations,
+    annotations = _ref2.annotations,
+    isInlineCommentViewClosed = _ref2.isInlineCommentViewClosed;
+  var annotationsList = (0, _utils2.getAllAnnotations)(editorView.state.doc);
+  var selection = (0, _utils2.getSelectionPositions)(state, inlineCommentState);
+  var position = findPosForDOM(selection);
+  var dom;
+  try {
+    dom = (0, _utils.findDomRefAtPos)(position, editorView.domAtPos.bind(editorView));
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.warn(error);
+    if (dispatchAnalyticsEvent) {
+      var payload = {
+        action: _analytics.ACTION.ERRORED,
+        actionSubject: _analytics.ACTION_SUBJECT.CONTENT_COMPONENT,
+        eventType: _analytics.EVENT_TYPE.OPERATIONAL,
+        attributes: {
+          component: _analytics.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.default.createElement("div", {
+      "data-testid": _types.AnnotationTestIds.floatingComponent,
+      "data-editor-popup": "true"
+    }, /*#__PURE__*/_react.default.createElement(CreateComponent, {
+      dom: dom,
+      textSelection: textSelection,
+      onCreate: function onCreate(id) {
+        (0, _commands.createAnnotation)(editorAnalyticsAPI)(id)(editorView.state, editorView.dispatch);
+        !editorView.hasFocus() && editorView.focus();
+      },
+      onClose: function onClose() {
+        (0, _commands.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: _analytics.ACTION.VIEWED,
+      actionSubject: _analytics.ACTION_SUBJECT.ANNOTATION,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.INLINE_COMMENT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      attributes: {
+        overlap: activeAnnotations.length ? activeAnnotations.length - 1 : 0
+      }
+    };
+    dispatchAnalyticsEvent(payload);
+  };
+  if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.annotation.decouple-inline-comment-closed_flmox') && isInlineCommentViewClosed || !selectedAnnotations) {
+    return null;
+  }
+  return /*#__PURE__*/_react.default.createElement(_AnnotationViewWrapper.AnnotationViewWrapper, {
+    "data-editor-popup": "true",
+    "data-testid": _types.AnnotationTestIds.floatingComponent,
+    key: (0, _utils2.getAnnotationViewKey)(activeAnnotations),
+    onViewed: onAnnotationViewed
+  }, /*#__PURE__*/_react.default.createElement(ViewComponent, {
+    annotationsList: annotationsList,
+    annotations: activeAnnotations,
+    dom: dom,
+    onDelete: function onDelete(id) {
+      return (0, _commands.removeInlineCommentNearSelection)(id)(state, dispatch);
+    },
+    onResolve: function onResolve(id) {
+      return (0, _commands.updateInlineCommentResolvedState)(editorAnalyticsAPI)((0, _defineProperty2.default)({}, id, true), _analytics.RESOLVE_METHOD.COMPONENT)(editorView.state, editorView.dispatch);
+    },
+    onClose: function onClose() {
+      (0, _commands.closeComponent)()(editorView.state, editorView.dispatch);
+    }
+  }));
+}

package/dist/cjs/utils.js

@@ -0,0 +1,372 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDraftDecoration = void 0;
+exports.annotationExists = annotationExists;
+Object.defineProperty(exports, "containsAnyAnnotations", {
+  enumerable: true,
+  get: function get() {
+    return _utils.containsAnyAnnotations;
+  }
+});
+exports.getPluginState = exports.getDraftCommandAnalyticsPayload = exports.getAnnotationViewKey = exports.getAllAnnotations = exports.findAnnotationsInSelection = void 0;
+exports.getSelectionPositions = getSelectionPositions;
+Object.defineProperty(exports, "hasAnnotationMark", {
+  enumerable: true,
+  get: function get() {
+    return _utils.hasAnnotationMark;
+  }
+});
+exports.hasInvalidNodes = void 0;
+exports.hasInvalidWhitespaceNode = hasInvalidWhitespaceNode;
+exports.inlineCommentPluginKey = void 0;
+exports.isSelectedAnnotationsChanged = isSelectedAnnotationsChanged;
+exports.isSelectionValid = void 0;
+exports.stripNonExistingAnnotations = stripNonExistingAnnotations;
+exports.surroundingMarks = void 0;
+var _adfSchema = require("@atlaskit/adf-schema");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _styles = require("@atlaskit/editor-common/styles");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var _types = require("./types");
+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
+ */
+var surroundingMarks = exports.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);
+    });
+  });
+};
+var getAllAnnotations = exports.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(_adfSchema.AnnotationTypes);
+    return allowedTypes.includes(type);
+  }
+};
+
+/*
+ * add decoration for the comment selection in draft state
+ * (when creating new comment)
+ */
+var addDraftDecoration = exports.addDraftDecoration = function addDraftDecoration(start, end) {
+  return _view.Decoration.inline(start, end, {
+    class: "".concat(_styles.AnnotationSharedClassNames.draft)
+  });
+};
+var getAnnotationViewKey = exports.getAnnotationViewKey = function getAnnotationViewKey(annotations) {
+  var keys = annotations.map(function (mark) {
+    return mark.id;
+  }).join('_');
+  return "view-annotation-wrapper_".concat(keys);
+};
+var findAnnotationsInSelection = exports.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
+ */
+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;
+}
+var inlineCommentPluginKey = exports.inlineCommentPluginKey = new _state.PluginKey('inlineCommentPluginKey');
+var getPluginState = exports.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 = (0, _utils.getAnnotationIdsFromRange)({
+    from: from,
+    to: to
+  }, state.doc, state.schema);
+  return annotations.length;
+};
+
+/**
+ * get payload for the open/close analytics event
+ */
+var getDraftCommandAnalyticsPayload = exports.getDraftCommandAnalyticsPayload = function getDraftCommandAnalyticsPayload(drafting, inputMethod) {
+  var payload = function payload(state) {
+    var attributes = {};
+    if (drafting) {
+      attributes = {
+        inputMethod: inputMethod,
+        overlap: getAnnotationsInSelectionCount(state)
+      };
+    }
+    return {
+      action: drafting ? _analytics.ACTION.OPENED : _analytics.ACTION.CLOSED,
+      actionSubject: _analytics.ACTION_SUBJECT.ANNOTATION,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.INLINE_COMMENT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      attributes: attributes
+    };
+  };
+  return payload;
+};
+var isSelectionValid = exports.isSelectionValid = function isSelectionValid(state) {
+  var selection = state.selection;
+  var _ref3 = getPluginState(state) || {},
+    disallowOnWhitespace = _ref3.disallowOnWhitespace;
+  if (selection.empty || !(selection instanceof _state.TextSelection || selection instanceof _state.AllSelection)) {
+    return _types.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 _types.AnnotationSelectionType.INVALID;
+  }
+  if (containsInvalidNodes) {
+    return _types.AnnotationSelectionType.DISABLED;
+  }
+  if (disallowOnWhitespace && hasInvalidWhitespaceNode(selection, state.schema)) {
+    return _types.AnnotationSelectionType.INVALID;
+  }
+  if (isEmptyTextSelection(selection, state.schema)) {
+    return _types.AnnotationSelectionType.INVALID;
+  }
+  return _types.AnnotationSelectionType.VALID;
+};
+var hasInvalidNodes = exports.hasInvalidNodes = function hasInvalidNodes(state) {
+  var selection = state.selection,
+    doc = state.doc,
+    schema = state.schema;
+  return !(0, _utils.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
+ */
+function hasInvalidWhitespaceNode(selection, schema) {
+  var foundInvalidWhitespace = false;
+  var content = selection.content().content;
+  content.descendants(function (node) {
+    if ((0, _utils.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
+      (0, _utils.isParagraph)(node, schema);
+      if (!nodeIsTrailingNewLine) {
+        foundInvalidWhitespace = true;
+      }
+    }
+    return !foundInvalidWhitespace;
+  });
+  return foundInvalidWhitespace;
+}
+
+/*
+ * verifies that the annotation exists by the given id
+ */
+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
+ */
+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 ((0, _utils.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
+ */
+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;
+    });
+  });
+}

package/dist/es2019/commands/index.js

@@ -0,0 +1,123 @@
+import { AnnotationTypes } from '@atlaskit/adf-schema';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { createCommand } from '../pm-plugins/plugin-factory';
+import { ACTIONS } from '../pm-plugins/types';
+import { AnnotationSelectionType } from '../types';
+import { getPluginState, isSelectionValid } from '../utils';
+import transform from './transform';
+export const updateInlineCommentResolvedState = editorAnalyticsAPI => (partialNewState, resolveMethod) => {
+  const command = {
+    type: ACTIONS.UPDATE_INLINE_COMMENT_STATE,
+    data: partialNewState
+  };
+  const allResolved = Object.values(partialNewState).every(state => state);
+  if (resolveMethod && allResolved) {
+    return createCommand(command, transform.addResolveAnalytics(editorAnalyticsAPI)(resolveMethod));
+  }
+  return createCommand(command);
+};
+export const closeComponent = () => createCommand({
+  type: ACTIONS.CLOSE_COMPONENT
+});
+export const clearDirtyMark = () => createCommand({
+  type: ACTIONS.INLINE_COMMENT_CLEAR_DIRTY_MARK
+});
+export const removeInlineCommentNearSelection = id => (state, dispatch) => {
+  const {
+    tr,
+    selection: {
+      $from
+    }
+  } = state;
+  const {
+    annotation: annotationMarkType
+  } = state.schema.marks;
+  const hasAnnotation = $from.marks().some(mark => mark.type === annotationMarkType);
+  if (!hasAnnotation) {
+    return false;
+  }
+
+  // just remove entire mark from around the node
+  tr.removeMark($from.start(), $from.end(), annotationMarkType.create({
+    id,
+    type: AnnotationTypes.INLINE_COMMENT
+  }));
+  if (dispatch) {
+    dispatch(tr);
+  }
+  return true;
+};
+const getDraftCommandAction = drafting => {
+  return editorState => {
+    // validate selection only when entering draft mode
+    if (drafting && isSelectionValid(editorState) !== AnnotationSelectionType.VALID) {
+      return false;
+    }
+    return {
+      type: ACTIONS.SET_INLINE_COMMENT_DRAFT_STATE,
+      data: {
+        drafting,
+        editorState
+      }
+    };
+  };
+};
+export const setInlineCommentDraftState = editorAnalyticsAPI => (drafting, inputMethod = INPUT_METHOD.TOOLBAR) => {
+  const commandAction = getDraftCommandAction(drafting);
+  return createCommand(commandAction, transform.addOpenCloseAnalytics(editorAnalyticsAPI)(drafting, inputMethod));
+};
+export const addInlineComment = editorAnalyticsAPI => id => {
+  const commandAction = editorState => ({
+    type: ACTIONS.ADD_INLINE_COMMENT,
+    data: {
+      drafting: false,
+      inlineComments: {
+        [id]: false
+      },
+      // Auto make the newly inserted comment selected.
+      // We move the selection to the head of the comment selection.
+      selectedAnnotations: [{
+        id,
+        type: AnnotationTypes.INLINE_COMMENT
+      }],
+      editorState
+    }
+  });
+  return createCommand(commandAction, transform.addInlineComment(editorAnalyticsAPI)(id));
+};
+export const updateMouseState = mouseData => createCommand({
+  type: ACTIONS.INLINE_COMMENT_UPDATE_MOUSE_STATE,
+  data: {
+    mouseData
+  }
+});
+export const setSelectedAnnotation = id => createCommand({
+  type: ACTIONS.SET_SELECTED_ANNOTATION,
+  data: {
+    selectedAnnotations: [{
+      id,
+      type: AnnotationTypes.INLINE_COMMENT
+    }]
+  }
+});
+export const createAnnotation = editorAnalyticsAPI => (id, annotationType = AnnotationTypes.INLINE_COMMENT) => (state, dispatch) => {
+  // don't try to add if there are is no temp highlight bookmarked
+  const {
+    bookmark
+  } = getPluginState(state) || {};
+  if (!bookmark || !dispatch) {
+    return false;
+  }
+  if (annotationType === AnnotationTypes.INLINE_COMMENT) {
+    return addInlineComment(editorAnalyticsAPI)(id)(state, dispatch);
+  }
+  return false;
+};
+export const setInlineCommentsVisibility = isVisible => {
+  return createCommand({
+    type: ACTIONS.INLINE_COMMENT_SET_VISIBLE,
+    data: {
+      isVisible
+    }
+  });
+};