@atlaskit/editor-plugin-selection 0.1.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @atlaskit/editor-plugin-selection

package/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,30 @@
+# Editor plugin selection
+
+Selection plugin for @atlaskit/editor-core
+
+**Note:** This component is designed for internal Atlassian development.
+External contributors will be able to use this component but will not be able to submit issues.
+
+## Install
+---
+- **Install** - *yarn add @atlaskit/editor-plugin-selection*
+- **npm** - [@atlaskit/editor-plugin-selection](https://www.npmjs.com/package/@atlaskit/editor-plugin-selection)
+- **Source** - [Bitbucket](https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/editor/editor-plugin-selection)
+- **Bundle** - [unpkg.com](https://unpkg.com/@atlaskit/editor-plugin-selection/dist/)
+
+## Usage
+---
+**Internal use only**
+
+@atlaskit/editor-plugin-selection is intended for internal use by the @atlaskit/editor-core and as a plugin dependency of the Editor within your product.
+
+Direct use of this component is not supported.
+
+Please see [Atlaskit - Editor plugin selection](https://atlaskit.atlassian.com/packages/editor/editor-plugin-selection) for documentation and examples for this package.
+
+## Support
+---
+For internal Atlassian, visit the slack channel [#help-editor](https://atlassian.slack.com/archives/CFG3PSQ9E) for support or visit [go/editor-help](https://go/editor-help) to submit a bug.
+## License
+---
+ Please see [Atlassian Frontend - License](https://developer.atlassian.com/cloud/framework/atlassian-frontend/#license) for more licensing information.

package/dist/cjs/actions.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SelectionActionTypes = void 0;
+var SelectionActionTypes = exports.SelectionActionTypes = /*#__PURE__*/function (SelectionActionTypes) {
+  SelectionActionTypes["SET_DECORATIONS"] = "SET_DECORATIONS";
+  SelectionActionTypes["SET_RELATIVE_SELECTION"] = "SET_RELATIVE_SELECTION";
+  return SelectionActionTypes;
+}({});

package/dist/cjs/commands.js

@@ -0,0 +1,257 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setSelectionRelativeToNode = exports.setSelectionInsideAtNodeEnd = exports.selectNearNode = exports.arrowRight = exports.arrowLeft = void 0;
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _actions = require("./actions");
+var _gapCursorSelection = require("./gap-cursor-selection");
+var _pluginFactory = require("./plugin-factory");
+var _types = require("./types");
+var _utils2 = require("./utils");
+var selectNearNode = exports.selectNearNode = function selectNearNode(selectionRelativeToNode, selection) {
+  return function (_ref) {
+    var tr = _ref.tr;
+    tr.setMeta(_types.selectionPluginKey, {
+      type: _actions.SelectionActionTypes.SET_RELATIVE_SELECTION,
+      selectionRelativeToNode: selectionRelativeToNode
+    });
+    if (selection) {
+      return tr.setSelection(selection);
+    }
+    return tr;
+  };
+};
+var setSelectionRelativeToNode = exports.setSelectionRelativeToNode = function setSelectionRelativeToNode(selectionRelativeToNode, selection) {
+  return (0, _pluginFactory.createCommand)({
+    type: _actions.SelectionActionTypes.SET_RELATIVE_SELECTION,
+    selectionRelativeToNode: selectionRelativeToNode
+  }, function (tr) {
+    return selectNearNode(selectionRelativeToNode, selection)({
+      tr: tr
+    }) || tr;
+  });
+};
+var arrowRight = exports.arrowRight = function arrowRight(state, dispatch) {
+  var selection = state.selection;
+  if (selection instanceof _gapCursorSelection.GapCursorSelection) {
+    return arrowRightFromGapCursor(selection)(state, dispatch);
+  } else if (selection instanceof _state.NodeSelection) {
+    return arrowRightFromNode(selection)(state, dispatch);
+  } else if (selection instanceof _state.TextSelection) {
+    return arrowRightFromText(selection)(state, dispatch);
+  }
+  return false;
+};
+var arrowLeft = exports.arrowLeft = function arrowLeft(state, dispatch) {
+  var selection = state.selection;
+  if (selection instanceof _gapCursorSelection.GapCursorSelection) {
+    return arrowLeftFromGapCursor(selection)(state, dispatch);
+  } else if (selection instanceof _state.NodeSelection) {
+    return arrowLeftFromNode(selection)(state, dispatch);
+  } else if (selection instanceof _state.TextSelection) {
+    return arrowLeftFromText(selection)(state, dispatch);
+  }
+  return false;
+};
+var arrowRightFromGapCursor = function arrowRightFromGapCursor(selection) {
+  return function (state, dispatch) {
+    var $from = selection.$from,
+      $to = selection.$to,
+      side = selection.side;
+    if (side === _gapCursorSelection.Side.LEFT) {
+      var selectableNode = (0, _utils2.findSelectableContainerAfter)($to, state.doc);
+      if (selectableNode) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.Start, _state.NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    } else if (side === _gapCursorSelection.Side.RIGHT && (0, _utils2.isSelectionAtEndOfParentNode)($from, selection)) {
+      var _selectableNode = (0, _utils2.findSelectableContainerParent)(selection);
+      if (_selectableNode) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, _selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowLeftFromGapCursor = function arrowLeftFromGapCursor(selection) {
+  return function (state, dispatch) {
+    var $from = selection.$from,
+      side = selection.side;
+    var _getPluginState = (0, _pluginFactory.getPluginState)(state),
+      selectionRelativeToNode = _getPluginState.selectionRelativeToNode;
+    if (side === _gapCursorSelection.Side.RIGHT) {
+      var selectableNode = (0, _utils2.findSelectableContainerBefore)($from, state.doc);
+      if (selectableNode) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    } else if (side === _gapCursorSelection.Side.LEFT && (0, _utils2.isSelectionAtStartOfParentNode)($from, selection)) {
+      if (selectionRelativeToNode === _types.RelativeSelectionPos.Before) {
+        var $parent = state.doc.resolve(selection.$from.before(selection.$from.depth));
+        if ($parent) {
+          var _selectableNode2 = (0, _utils2.findSelectableContainerBefore)($parent, state.doc);
+          if (_selectableNode2 && (0, _selection.isIgnored)(_selectableNode2.node)) {
+            // selection is inside node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
+            return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, _selectableNode2.pos))(state, dispatch);
+          }
+        }
+        // we don't return this as we want to reset the relative pos, but not block other plugins
+        // from responding to arrow left key
+        setSelectionRelativeToNode()(state, dispatch);
+      } else {
+        var _selectableNode3 = (0, _utils2.findSelectableContainerParent)(selection);
+        if (_selectableNode3) {
+          return setSelectionRelativeToNode(_types.RelativeSelectionPos.Start, _state.NodeSelection.create(state.doc, _selectableNode3.pos))(state, dispatch);
+        }
+      }
+    }
+    return false;
+  };
+};
+var arrowRightFromNode = function arrowRightFromNode(selection) {
+  return function (state, dispatch) {
+    var node = selection.node,
+      from = selection.from,
+      $to = selection.$to;
+    var _getPluginState2 = (0, _pluginFactory.getPluginState)(state),
+      selectionRelativeToNode = _getPluginState2.selectionRelativeToNode;
+    if (node.isAtom) {
+      if ((0, _utils2.isSelectionAtEndOfParentNode)($to, selection)) {
+        // selection is for inline node that is the last child of its parent node - set text selection after it
+        return findAndSetTextSelection(_types.RelativeSelectionPos.End, state.doc.resolve(from + 1), _types.SelectionDirection.After)(state, dispatch);
+      }
+      return false;
+    } else if (selectionRelativeToNode === _types.RelativeSelectionPos.Start) {
+      // selection is for container node - set selection inside it at the start
+      return setSelectionInsideAtNodeStart(_types.RelativeSelectionPos.Inside, node, from)(state, dispatch);
+    } else if ((0, _selection.isIgnored)(node) && (!selectionRelativeToNode || selectionRelativeToNode === _types.RelativeSelectionPos.End)) {
+      var selectableNode = (0, _utils2.findSelectableContainerAfter)($to, state.doc);
+      if (selectableNode && (0, _selection.isIgnored)(selectableNode.node)) {
+        // selection is for node without gap cursor followed by another node without gap cursor - set node selection for next node
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.Start, _state.NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowLeftFromNode = function arrowLeftFromNode(selection) {
+  return function (state, dispatch) {
+    var node = selection.node,
+      from = selection.from,
+      to = selection.to,
+      $from = selection.$from;
+    var _getPluginState3 = (0, _pluginFactory.getPluginState)(state),
+      selectionRelativeToNode = _getPluginState3.selectionRelativeToNode;
+    if (node.isAtom) {
+      if ((0, _utils2.isSelectionAtStartOfParentNode)($from, selection)) {
+        // selection is for inline node that is the first child of its parent node - set text selection before it
+        return findAndSetTextSelection(_types.RelativeSelectionPos.Start, state.doc.resolve(from), _types.SelectionDirection.Before)(state, dispatch);
+      }
+      return false;
+    } else if (selectionRelativeToNode === _types.RelativeSelectionPos.End) {
+      // selection is for container node - set selection inside it at the end
+      return setSelectionInsideAtNodeEnd(_types.RelativeSelectionPos.Inside, node, from, to)(state, dispatch);
+    } else if (!selectionRelativeToNode || selectionRelativeToNode === _types.RelativeSelectionPos.Inside) {
+      // selection is for container node - set selection inside it at the start
+      // (this is a special case when the user selects by clicking node)
+      return setSelectionInsideAtNodeStart(_types.RelativeSelectionPos.Before, node, from)(state, dispatch);
+    } else if ((0, _selection.isIgnored)(node) && selectionRelativeToNode === _types.RelativeSelectionPos.Start) {
+      // selection is for node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
+      var selectableNode = (0, _utils2.findSelectableContainerBefore)($from, state.doc);
+      if (selectableNode && (0, _selection.isIgnored)(selectableNode.node)) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowRightFromText = function arrowRightFromText(selection) {
+  return function (state, dispatch) {
+    if ((0, _utils2.isSelectionAtEndOfParentNode)(selection.$to, selection)) {
+      var selectableNode = (0, _utils2.findSelectableContainerParent)(selection);
+      if (selectableNode) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var arrowLeftFromText = function arrowLeftFromText(selection) {
+  return function (state, dispatch) {
+    var _getPluginState4 = (0, _pluginFactory.getPluginState)(state),
+      selectionRelativeToNode = _getPluginState4.selectionRelativeToNode;
+    if (selectionRelativeToNode === _types.RelativeSelectionPos.Before) {
+      var selectableNode = (0, _utils2.findSelectableContainerBefore)(selection.$from, state.doc);
+      if (selectableNode && (0, _selection.isIgnored)(selectableNode.node)) {
+        // selection is inside node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+      // we don't return this as we want to reset the relative pos, but not block other plugins
+      // from responding to arrow left key
+      setSelectionRelativeToNode(undefined)(state, dispatch);
+    } else if ((0, _utils2.isSelectionAtStartOfParentNode)(selection.$from, selection)) {
+      var _selectableNode4 = (0, _utils2.findSelectableContainerParent)(selection);
+      if (_selectableNode4) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.Start, _state.NodeSelection.create(state.doc, _selectableNode4.pos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var findAndSetTextSelection = function findAndSetTextSelection(selectionRelativeToNode, $pos, dir) {
+  return function (state, dispatch) {
+    var sel = _state.Selection.findFrom($pos, dir, true);
+    if (sel) {
+      return setSelectionRelativeToNode(selectionRelativeToNode, sel)(state, dispatch);
+    }
+    return false;
+  };
+};
+var setSelectionInsideAtNodeStart = function setSelectionInsideAtNodeStart(selectionRelativeToNode, node, pos) {
+  return function (state, dispatch) {
+    if ((0, _utils.isNodeEmpty)(node)) {
+      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), _types.SelectionDirection.After)(state, dispatch);
+    }
+    var selectableNode = (0, _utils2.findFirstChildNodeToSelect)(node);
+    if (selectableNode) {
+      var childNode = selectableNode.node,
+        childPos = selectableNode.pos;
+      var selectionPos = pos + childPos + 1;
+      if (childNode.isText || childNode.isAtom) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), _types.SelectionDirection.Before)(state, dispatch);
+      } else if ((0, _utils.isEmptyParagraph)(childNode)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), _types.SelectionDirection.Before)(state, dispatch);
+      } else if (!(0, _selection.isIgnored)(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, new _gapCursorSelection.GapCursorSelection(state.doc.resolve(selectionPos), _gapCursorSelection.Side.LEFT))(state, dispatch);
+      } else if ((0, _utils2.isSelectableContainerNode)(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, _state.NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};
+var setSelectionInsideAtNodeEnd = exports.setSelectionInsideAtNodeEnd = function setSelectionInsideAtNodeEnd(selectionRelativeToNode, node, from, to) {
+  return function (state, dispatch) {
+    if ((0, _utils.isNodeEmpty)(node)) {
+      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), _types.SelectionDirection.Before)(state, dispatch);
+    }
+    var selectableNode = (0, _utils2.findLastChildNodeToSelect)(node);
+    if (selectableNode) {
+      var childNode = selectableNode.node,
+        childPos = selectableNode.pos;
+      var selectionPos = from + childPos + childNode.nodeSize;
+      if (childNode.isText || childNode.isAtom) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), _types.SelectionDirection.After)(state, dispatch);
+      } else if ((0, _utils.isEmptyParagraph)(childNode)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), _types.SelectionDirection.After)(state, dispatch);
+      } else if (!(0, _selection.isIgnored)(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, new _gapCursorSelection.GapCursorSelection(state.doc.resolve(selectionPos + 1), _gapCursorSelection.Side.RIGHT))(state, dispatch);
+      } else if ((0, _utils2.isSelectableContainerNode)(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, _state.NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+      }
+    }
+    return false;
+  };
+};

package/dist/cjs/gap-cursor/actions.js

@@ -0,0 +1,255 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldSkipGapCursor = exports.setSelectionTopLevelBlocks = exports.setCursorForTopLevelBlocks = exports.hasGapCursorPlugin = exports.deleteNode = exports.arrow = void 0;
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _gapCursorPluginKey = require("../pm-plugins/gap-cursor-plugin-key");
+var _direction = require("./direction");
+var _selection2 = require("./selection");
+var _utils3 = require("./utils");
+var _isValidTargetNode = require("./utils/is-valid-target-node");
+var shouldSkipGapCursor = exports.shouldSkipGapCursor = function shouldSkipGapCursor(direction, state, $pos) {
+  var _$pos$nodeBefore;
+  var doc = state.doc,
+    schema = state.schema;
+  switch (direction) {
+    case _direction.Direction.UP:
+      if ((0, _selection.atTheBeginningOfDoc)(state)) {
+        return false;
+      }
+      return (0, _utils.isPositionNearTableRow)($pos, schema, 'before') || (0, _utils3.isTextBlockNearPos)(doc, schema, $pos, -1) || (0, _utils.isNodeBeforeMediaNode)($pos, state);
+    case _direction.Direction.DOWN:
+      return (0, _selection.atTheEndOfDoc)(state) || (0, _utils3.isTextBlockNearPos)(doc, schema, $pos, 1) || (0, _utils.isPositionNearTableRow)($pos, schema, 'after') || ((_$pos$nodeBefore = $pos.nodeBefore) === null || _$pos$nodeBefore === void 0 ? void 0 : _$pos$nodeBefore.type.name) === 'text' && !$pos.nodeAfter // end of a paragraph
+      ;
+
+    default:
+      return false;
+  }
+};
+
+// These cases should be handled using the handleMediaGapCursor function
+function shouldHandleMediaGapCursor(dir, state) {
+  var _selection$$from$node;
+  var selection = state.selection;
+  var upArrowFromGapCursorIntoMedia = selection instanceof _selection2.GapCursorSelection && dir === _direction.Direction.UP && selection.$from.nodeBefore && (0, _utils.isMediaNode)(selection.$from.nodeBefore);
+  var downArrowFromGapCursorIntoMediaGroup = selection instanceof _selection2.GapCursorSelection && dir === _direction.Direction.DOWN && ((_selection$$from$node = selection.$from.nodeAfter) === null || _selection$$from$node === void 0 ? void 0 : _selection$$from$node.type.name) === 'mediaGroup';
+  return upArrowFromGapCursorIntoMedia || downArrowFromGapCursorIntoMediaGroup;
+}
+
+// Handle media gap cursor for up/down arrow into media nodes
+// Should check this case by using shouldHandleMediaGapCursor first
+function handleMediaGapCursor(dir, state) {
+  var selection = state.selection,
+    tr = state.tr;
+  var $pos = (0, _direction.isBackward)(dir) ? selection.$from : selection.$to;
+  if (dir === _direction.Direction.UP && selection.$from.nodeBefore && (0, _utils.isMediaNode)(selection.$from.nodeBefore)) {
+    var _tr$doc$nodeAt;
+    var nodeBeforePos = (0, _utils2.findPositionOfNodeBefore)(tr.selection);
+    if (nodeBeforePos && selection.side === 'right' && ((_tr$doc$nodeAt = tr.doc.nodeAt(nodeBeforePos)) === null || _tr$doc$nodeAt === void 0 ? void 0 : _tr$doc$nodeAt.type.name) === 'mediaSingle') {
+      tr.setSelection(new _state.NodeSelection(tr.doc.resolve(nodeBeforePos))).scrollIntoView();
+    } else if (nodeBeforePos || nodeBeforePos === 0) {
+      tr.setSelection(new _selection2.GapCursorSelection(tr.doc.resolve(nodeBeforePos), _selection2.Side.LEFT)).scrollIntoView();
+    }
+  }
+  if (dir === _direction.Direction.DOWN && selection.$from.nodeAfter) {
+    var nodeAfterPos = selection.side === 'right' ? $pos.pos : $pos.pos + selection.$from.nodeAfter.nodeSize;
+    if (nodeAfterPos) {
+      tr.setSelection(new _selection2.GapCursorSelection(tr.doc.resolve(nodeAfterPos), _selection2.Side.LEFT)).scrollIntoView();
+    }
+  }
+  return tr;
+}
+var arrow = exports.arrow = function arrow(dir, endOfTextblock) {
+  return function (state, dispatch, view) {
+    var doc = state.doc,
+      selection = state.selection,
+      tr = state.tr;
+    var $pos = (0, _direction.isBackward)(dir) ? selection.$from : selection.$to;
+    var mustMove = selection.empty;
+
+    // start from text selection
+    if (selection instanceof _state.TextSelection) {
+      // if cursor is in the middle of a text node, do nothing
+      if (!endOfTextblock || !endOfTextblock(dir.toString())) {
+        return false;
+      }
+
+      // UP/DOWN jumps to the nearest texblock skipping gapcursor whenever possible
+      if (shouldSkipGapCursor(dir, state, $pos)) {
+        return false;
+      }
+
+      // otherwise resolve previous/next position
+      $pos = doc.resolve((0, _direction.isBackward)(dir) ? $pos.before() : $pos.after());
+      mustMove = false;
+    }
+    if (selection instanceof _state.NodeSelection) {
+      if (selection.node.isInline) {
+        return false;
+      }
+      if (dir === _direction.Direction.UP && !(0, _selection.atTheBeginningOfDoc)(state) && !(0, _utils.isNodeBeforeMediaNode)($pos, state) || dir === _direction.Direction.DOWN) {
+        // We dont add gap cursor on node selections going up and down
+        // Except we do if we're going up for a block node which is the
+        // first node in the document OR the node before is a media node
+        return false;
+      }
+    }
+
+    // Handle media gap cursor for up/down arrow into media nodes
+    if (shouldHandleMediaGapCursor(dir, state)) {
+      var updatedTr = handleMediaGapCursor(dir, state);
+      if (dispatch) {
+        dispatch(updatedTr);
+      }
+      return true;
+    }
+
+    // when jumping between block nodes at the same depth, we need to reverse cursor without changing ProseMirror position
+    if (selection instanceof _selection2.GapCursorSelection &&
+    // next node allow gap cursor position
+    (0, _isValidTargetNode.isValidTargetNode)((0, _direction.isBackward)(dir) ? $pos.nodeBefore : $pos.nodeAfter) && (
+    // gap cursor changes block node
+    (0, _direction.isBackward)(dir) && selection.side === _selection2.Side.LEFT || (0, _direction.isForward)(dir) && selection.side === _selection2.Side.RIGHT)) {
+      // reverse cursor position
+      if (dispatch) {
+        dispatch(tr.setSelection(new _selection2.GapCursorSelection($pos, selection.side === _selection2.Side.RIGHT ? _selection2.Side.LEFT : _selection2.Side.RIGHT)).scrollIntoView());
+      }
+      return true;
+    }
+    if (view) {
+      var domAtPos = view.domAtPos.bind(view);
+      var target = (0, _utils2.findDomRefAtPos)($pos.pos, domAtPos);
+      if (target && target.textContent === _utils.ZERO_WIDTH_SPACE) {
+        return false;
+      }
+    }
+    var nextSelection = _selection2.GapCursorSelection.findFrom($pos, (0, _direction.isBackward)(dir) ? -1 : 1, mustMove);
+    if (!nextSelection) {
+      return false;
+    }
+    if (!(0, _isValidTargetNode.isValidTargetNode)((0, _direction.isForward)(dir) ? nextSelection.$from.nodeBefore : nextSelection.$from.nodeAfter)) {
+      // reverse cursor position
+      if (dispatch) {
+        dispatch(tr.setSelection(new _selection2.GapCursorSelection(nextSelection.$from, (0, _direction.isForward)(dir) ? _selection2.Side.LEFT : _selection2.Side.RIGHT)).scrollIntoView());
+      }
+      return true;
+    }
+    if (dispatch) {
+      dispatch(tr.setSelection(nextSelection).scrollIntoView());
+    }
+    return true;
+  };
+};
+var deleteNode = exports.deleteNode = function deleteNode(dir) {
+  return function (state, dispatch) {
+    if (state.selection instanceof _selection2.GapCursorSelection) {
+      var _state$selection = state.selection,
+        $from = _state$selection.$from,
+        $anchor = _state$selection.$anchor;
+      var tr = state.tr;
+      if ((0, _direction.isBackward)(dir)) {
+        if (state.selection.side === 'left') {
+          tr.setSelection(new _selection2.GapCursorSelection($anchor, _selection2.Side.RIGHT));
+          if (dispatch) {
+            dispatch(tr);
+          }
+          return true;
+        }
+        tr = (0, _utils2.removeNodeBefore)(state.tr);
+      } else if ($from.nodeAfter) {
+        tr = tr.delete($from.pos, $from.pos + $from.nodeAfter.nodeSize);
+      }
+      if (dispatch) {
+        dispatch(tr.setSelection(_state.Selection.near(tr.doc.resolve(tr.mapping.map(state.selection.$from.pos)))).scrollIntoView());
+      }
+      return true;
+    }
+    return false;
+  };
+};
+
+// This function captures clicks outside of the ProseMirror contentEditable area
+// see also description of "handleClick" in gap-cursor pm-plugin
+var captureCursorCoords = function captureCursorCoords(event, editorRef, posAtCoords, tr) {
+  var rect = editorRef.getBoundingClientRect();
+
+  // capture clicks before the first block element
+  if (event.clientY < rect.top) {
+    return {
+      position: 0,
+      side: _selection2.Side.LEFT
+    };
+  }
+  if (rect.left > 0) {
+    // calculate start position of a node that is vertically at the same level
+    var _coords = posAtCoords({
+      left: rect.left,
+      top: event.clientY
+    });
+    if (_coords && _coords.inside > -1) {
+      var $from = tr.doc.resolve(_coords.inside);
+      var start = $from.before(1);
+      var side = event.clientX < rect.left ? _selection2.Side.LEFT : _selection2.Side.RIGHT;
+      var position;
+      if (side === _selection2.Side.LEFT) {
+        position = start;
+      } else {
+        var node = tr.doc.nodeAt(start);
+        if (node) {
+          position = start + node.nodeSize;
+        }
+      }
+      return {
+        position: position,
+        side: side
+      };
+    }
+  }
+  return null;
+};
+var setSelectionTopLevelBlocks = exports.setSelectionTopLevelBlocks = function setSelectionTopLevelBlocks(tr, event, editorRef, posAtCoords, editorFocused) {
+  var cursorCoords = captureCursorCoords(event, editorRef, posAtCoords, tr);
+  if (!cursorCoords) {
+    return;
+  }
+  var $pos = cursorCoords.position !== undefined ? tr.doc.resolve(cursorCoords.position) : null;
+  if ($pos === null) {
+    return;
+  }
+  var isGapCursorAllowed = cursorCoords.side === _selection2.Side.LEFT ? (0, _isValidTargetNode.isValidTargetNode)($pos.nodeAfter) : (0, _isValidTargetNode.isValidTargetNode)($pos.nodeBefore);
+  if (isGapCursorAllowed && _selection2.GapCursorSelection.valid($pos)) {
+    // this forces PM to re-render the decoration node if we change the side of the gap cursor, it doesn't do it by default
+    if (tr.selection instanceof _selection2.GapCursorSelection) {
+      tr.setSelection(_state.Selection.near($pos));
+    } else {
+      tr.setSelection(new _selection2.GapCursorSelection($pos, cursorCoords.side));
+    }
+  }
+  // try to set text selection if the editor isnt focused
+  // if the editor is focused, we are most likely dragging a selection outside.
+  else if (editorFocused === false) {
+    var selectionTemp = _state.Selection.findFrom($pos, cursorCoords.side === _selection2.Side.LEFT ? 1 : -1, true);
+    if (selectionTemp) {
+      tr.setSelection(selectionTemp);
+    }
+  }
+};
+var setCursorForTopLevelBlocks = exports.setCursorForTopLevelBlocks = function setCursorForTopLevelBlocks(event, editorRef, posAtCoords, editorFocused) {
+  return function (state, dispatch) {
+    var tr = state.tr;
+    setSelectionTopLevelBlocks(tr, event, editorRef, posAtCoords, editorFocused);
+    if (tr.selectionSet && dispatch) {
+      dispatch(tr);
+      return true;
+    }
+    return false;
+  };
+};
+var hasGapCursorPlugin = exports.hasGapCursorPlugin = function hasGapCursorPlugin(state) {
+  return Boolean(_gapCursorPluginKey.gapCursorPluginKey.get(state));
+};

package/dist/cjs/gap-cursor/direction.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Direction = void 0;
+exports.isBackward = isBackward;
+exports.isForward = isForward;
+var Direction = exports.Direction = /*#__PURE__*/function (Direction) {
+  Direction["UP"] = "up";
+  Direction["RIGHT"] = "right";
+  Direction["DOWN"] = "down";
+  Direction["LEFT"] = "left";
+  Direction["BACKWARD"] = "backward";
+  Direction["FORWARD"] = "forward";
+  return Direction;
+}({});
+function isBackward(dir) {
+  return [Direction.UP, Direction.LEFT, Direction.BACKWARD].indexOf(dir) !== -1;
+}
+function isForward(dir) {
+  return [Direction.RIGHT, Direction.DOWN, Direction.FORWARD].indexOf(dir) !== -1;
+}

package/dist/cjs/gap-cursor/selection.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GapBookmark", {
+  enumerable: true,
+  get: function get() {
+    return _selection.GapBookmark;
+  }
+});
+Object.defineProperty(exports, "GapCursorSelection", {
+  enumerable: true,
+  get: function get() {
+    return _selection.GapCursorSelection;
+  }
+});
+Object.defineProperty(exports, "JSON_ID", {
+  enumerable: true,
+  get: function get() {
+    return _selection.JSON_ID;
+  }
+});
+Object.defineProperty(exports, "Side", {
+  enumerable: true,
+  get: function get() {
+    return _selection.Side;
+  }
+});
+var _selection = require("@atlaskit/editor-common/selection");

package/dist/cjs/gap-cursor/utils/is-ignored.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isIgnored", {
+  enumerable: true,
+  get: function get() {
+    return _selection.isIgnored;
+  }
+});
+var _selection = require("@atlaskit/editor-common/selection");

package/dist/cjs/gap-cursor/utils/is-valid-target-node.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isValidTargetNode", {
+  enumerable: true,
+  get: function get() {
+    return _selection.isValidTargetNode;
+  }
+});
+var _selection = require("@atlaskit/editor-common/selection");