@atlaskit/editor-plugin-selection 0.1.0

package/dist/cjs/pm-plugins/gap-cursor-main.js

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _selection = require("@atlaskit/editor-common/selection");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _view2 = require("@atlaskit/editor-prosemirror/view");
+var _cellSelection = require("@atlaskit/editor-tables/cell-selection");
+var _actions = require("../gap-cursor/actions");
+var _direction = require("../gap-cursor/direction");
+var _utils2 = require("../gap-cursor/utils");
+var _placeGapCursor = require("../gap-cursor/utils/place-gap-cursor");
+var _gapCursorPluginKey = require("./gap-cursor-plugin-key");
+var plugin = new _safePlugin.SafePlugin({
+  key: _gapCursorPluginKey.gapCursorPluginKey,
+  state: {
+    init: function init() {
+      return {
+        selectionIsGapCursor: false,
+        displayGapCursor: true
+      };
+    },
+    apply: function apply(tr, pluginState, _oldState, newState) {
+      var _meta$displayGapCurso;
+      var meta = tr.getMeta(_gapCursorPluginKey.gapCursorPluginKey);
+      var selectionIsGapCursor = newState.selection instanceof _selection.GapCursorSelection;
+      return {
+        selectionIsGapCursor: selectionIsGapCursor,
+        // only attempt to hide gap cursor if selection is gap cursor
+        displayGapCursor: selectionIsGapCursor ? (_meta$displayGapCurso = meta === null || meta === void 0 ? void 0 : meta.displayGapCursor) !== null && _meta$displayGapCurso !== void 0 ? _meta$displayGapCurso : pluginState.displayGapCursor : true
+      };
+    }
+  },
+  view: function view(_view) {
+    /**
+     * If the selection is at the beginning of a document and is a NodeSelection,
+     * convert to a GapCursor selection. This is to stop users accidentally replacing
+     * the first node of a document by accident.
+     */
+    if (_view.state.selection.anchor === 0 && _view.state.selection instanceof _state.NodeSelection) {
+      // This is required otherwise the dispatch doesn't trigger in the correct place
+      window.requestAnimationFrame(function () {
+        _view.dispatch(_view.state.tr.setSelection(new _selection.GapCursorSelection(_view.state.doc.resolve(0), _selection.Side.LEFT)));
+      });
+    }
+    return {
+      update: function update(view) {
+        var _gapCursorPluginKey$g = _gapCursorPluginKey.gapCursorPluginKey.getState(view.state),
+          selectionIsGapCursor = _gapCursorPluginKey$g.selectionIsGapCursor;
+        /**
+         * Starting with prosemirror-view 1.19.4, cursor wrapper that previously was hiding cursor doesn't exist:
+         * https://github.com/ProseMirror/prosemirror-view/commit/4a56bc7b7e61e96ef879d1dae1014ede0fc09e43
+         *
+         * Because it was causing issues with RTL: https://github.com/ProseMirror/prosemirror/issues/948
+         *
+         * This is the work around which uses `caret-color: transparent` in order to hide regular caret,
+         * when gap cursor is visible.
+         *
+         * Browser support is pretty good: https://caniuse.com/#feat=css-caret-color
+         */
+        view.dom.classList.toggle(_selection.hideCaretModifier, selectionIsGapCursor);
+      }
+    };
+  },
+  props: {
+    decorations: function decorations(editorState) {
+      var doc = editorState.doc,
+        selection = editorState.selection;
+      var _gapCursorPluginKey$g2 = _gapCursorPluginKey.gapCursorPluginKey.getState(editorState),
+        displayGapCursor = _gapCursorPluginKey$g2.displayGapCursor;
+      if (selection instanceof _selection.GapCursorSelection && displayGapCursor) {
+        var $from = selection.$from,
+          side = selection.side;
+
+        // render decoration DOM node always to the left of the target node even if selection points to the right
+        // otherwise positioning of the right gap cursor is a nightmare when the target node has a nodeView with vertical margins
+        var position = selection.head;
+        var isRightCursor = side === _selection.Side.RIGHT;
+        if (isRightCursor && $from.nodeBefore) {
+          var nodeBeforeStart = (0, _utils.findPositionOfNodeBefore)(selection);
+          if (typeof nodeBeforeStart === 'number') {
+            position = nodeBeforeStart;
+          }
+        }
+        var node = isRightCursor ? $from.nodeBefore : $from.nodeAfter;
+        var layoutMode = node && (0, _utils2.getLayoutModeFromTargetNode)(node);
+        return _view2.DecorationSet.create(doc, [_view2.Decoration.widget(position, _placeGapCursor.toDOM, {
+          key: "".concat(_selection.JSON_ID, "-").concat(side, "-").concat(layoutMode),
+          side: layoutMode ? -1 : 0
+        })]);
+      }
+      return null;
+    },
+    // render gap cursor only when its valid
+    createSelectionBetween: function createSelectionBetween(view, $anchor, $head) {
+      if (view && view.state && view.state.selection instanceof _cellSelection.CellSelection) {
+        // Do not show GapCursor when there is a CellSection happening
+        return null;
+      }
+      if ($anchor.pos === $head.pos && _selection.GapCursorSelection.valid($head)) {
+        return new _selection.GapCursorSelection($head);
+      }
+      return null;
+    },
+    handleClick: function handleClick(view, nodePos, event) {
+      var _$pos$parent;
+      var posAtCoords = view.posAtCoords({
+        left: event.clientX,
+        top: event.clientY
+      });
+      if (!posAtCoords || (0, _utils2.isIgnoredClick)(event.target)) {
+        return false;
+      }
+      var isInsideTheTarget = posAtCoords.pos === posAtCoords.inside;
+      if (isInsideTheTarget) {
+        return false;
+      }
+      var leftSideOffsetX = 20;
+      var side = event.offsetX > leftSideOffsetX ? _selection.Side.RIGHT : _selection.Side.LEFT;
+      var $pos = view.state.doc.resolve(nodePos);
+      // In the new prosemirror-view posAtCoords  is not returning a precise value for our media nodes
+      if (((_$pos$parent = $pos.parent) === null || _$pos$parent === void 0 ? void 0 : _$pos$parent.type.name) === 'mediaSingle') {
+        var $insidePos = view.state.doc.resolve(Math.max(posAtCoords.inside, 0));
+        // We don't have GapCursors problems when the node target is inside the root level
+        if ($insidePos.depth <= 1) {
+          return false;
+        }
+        var mediaGapCursor = !$pos.nodeBefore ? $pos.before() : $pos.after();
+        return (0, _selection.setGapCursorAtPos)(mediaGapCursor, side)(view.state, view.dispatch);
+      }
+      var docSize = view.state.doc.content.size;
+      var nodeInside = posAtCoords.inside < 0 || posAtCoords.inside > docSize ? null : view.state.doc.nodeAt(posAtCoords.inside);
+      if (nodeInside !== null && nodeInside !== void 0 && nodeInside.isAtom) {
+        return false;
+      }
+      return (0, _selection.setGapCursorAtPos)(nodePos, side)(view.state, view.dispatch);
+    },
+    handleDOMEvents: {
+      /**
+       * Android composition events aren't handled well by Prosemirror
+       * We've added a couple of beforeinput hooks to help PM out when trying to delete
+       * certain nodes. We can remove these when PM has better composition support.
+       * @see https://github.com/ProseMirror/prosemirror/issues/543
+       */
+      beforeinput: function beforeinput(view, event) {
+        if (event.inputType === 'deleteContentBackward' && view.state.selection instanceof _selection.GapCursorSelection) {
+          event.preventDefault();
+          return (0, _actions.deleteNode)(_direction.Direction.BACKWARD)(view.state, view.dispatch);
+        }
+        return false;
+      }
+    }
+  }
+});
+var _default = exports.default = plugin;

package/dist/cjs/pm-plugins/gap-cursor-plugin-key.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gapCursorPluginKey = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var gapCursorPluginKey = exports.gapCursorPluginKey = new _state.PluginKey('gapCursorPlugin');

package/dist/cjs/pm-plugins/keymap.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _commands = require("../commands");
+function keymapPlugin() {
+  var list = {};
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.moveRight.common, _commands.arrowRight, list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.moveLeft.common, _commands.arrowLeft, list);
+  return (0, _keymap.keymap)(list);
+}
+var _default = exports.default = keymapPlugin;

package/dist/cjs/pm-plugins/selection-main.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInitialState = exports.createPlugin = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _actions = require("../actions");
+var _pluginFactory = require("../plugin-factory");
+var _types = require("../types");
+var _utils = require("../utils");
+var _createSelectionBetween = require("./events/create-selection-between");
+var _keydown = require("./events/keydown");
+var getInitialState = exports.getInitialState = function getInitialState(state) {
+  return {
+    decorationSet: (0, _utils.getDecorations)(state.tr),
+    selection: state.selection
+  };
+};
+var createPlugin = exports.createPlugin = function createPlugin(dispatch, dispatchAnalyticsEvent) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return new _safePlugin.SafePlugin({
+    key: _types.selectionPluginKey,
+    state: (0, _pluginFactory.createPluginState)(dispatch, getInitialState),
+    view: function view() {
+      return {
+        update: function update(editorView, oldEditorState) {
+          var state = editorView.state;
+          if (!(0, _utils.shouldRecalcDecorations)({
+            oldEditorState: oldEditorState,
+            newEditorState: state
+          })) {
+            return;
+          }
+          var analyticsPayload = (0, _utils.getNodeSelectionAnalyticsPayload)(state.selection) || (0, _utils.getAllSelectionAnalyticsPayload)(state.selection) ||
+          // We handle all range/cell selections except click and drag here, which is
+          // handled in mouseup handler below
+          !editorView.mouseDown && ((0, _utils.getRangeSelectionAnalyticsPayload)(state.selection, state.doc) || (0, _utils.getCellSelectionAnalyticsPayload)(state));
+
+          // We have to use dispatchAnalyticsEvent over any of the analytics plugin helpers
+          // as there were several issues caused by the fact that adding analytics through
+          // the plugin adds a new step to the transaction
+          // This causes prosemirror to run through some different code paths, eg. attempting
+          // to map selection
+          if (analyticsPayload) {
+            dispatchAnalyticsEvent(analyticsPayload);
+          }
+        }
+      };
+    },
+    appendTransaction: function appendTransaction(_transactions, oldEditorState, newEditorState) {
+      if (!(0, _utils.shouldRecalcDecorations)({
+        oldEditorState: oldEditorState,
+        newEditorState: newEditorState
+      })) {
+        return;
+      }
+      var tr = newEditorState.tr;
+      tr.setMeta(_types.selectionPluginKey, {
+        type: _actions.SelectionActionTypes.SET_DECORATIONS,
+        selection: tr.selection,
+        decorationSet: (0, _utils.getDecorations)(tr)
+      });
+      return tr;
+    },
+    filterTransaction: function filterTransaction(tr, state) {
+      // Prevent single click selecting atom nodes on mobile (we want to select with long press gesture instead)
+      if (options.useLongPressSelection && tr.selectionSet && tr.selection instanceof _state.NodeSelection && !tr.getMeta(_types.selectionPluginKey)) {
+        return false;
+      }
+
+      // Prevent prosemirror's mutation observer overriding a node selection with a text selection
+      // for exact same range - this was cause of being unable to change dates in collab:
+      // https://product-fabric.atlassian.net/browse/ED-10645
+      if (state.selection instanceof _state.NodeSelection && tr.selection instanceof _state.TextSelection && state.selection.from === tr.selection.from && state.selection.to === tr.selection.to) {
+        return false;
+      }
+      return true;
+    },
+    props: {
+      createSelectionBetween: _createSelectionBetween.onCreateSelectionBetween,
+      decorations: function decorations(state) {
+        return (0, _pluginFactory.getPluginState)(state).decorationSet;
+      },
+      handleDOMEvents: {
+        keydown: _keydown.onKeydown,
+        // We only want to fire analytics for a click and drag range/cell selection when
+        // the user has finished, otherwise we will get an event almost every time they move
+        // their mouse which is too much
+        mouseup: function mouseup(editorView, event) {
+          var mouseEvent = event;
+          if (!mouseEvent.shiftKey) {
+            var analyticsPayload = (0, _utils.getRangeSelectionAnalyticsPayload)(editorView.state.selection, editorView.state.doc) || (0, _utils.getCellSelectionAnalyticsPayload)(editorView.state);
+            if (analyticsPayload) {
+              dispatchAnalyticsEvent(analyticsPayload);
+            }
+          }
+          return false;
+        }
+      }
+    }
+  });
+};

package/dist/cjs/reducer.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reducer = reducer;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _actions = require("./actions");
+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) { (0, _defineProperty2.default)(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; }
+function reducer(pluginState, action) {
+  switch (action.type) {
+    case _actions.SelectionActionTypes.SET_DECORATIONS:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        decorationSet: action.decorationSet,
+        selection: action.selection
+      });
+    case _actions.SelectionActionTypes.SET_RELATIVE_SELECTION:
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        selectionRelativeToNode: action.selectionRelativeToNode
+      });
+    default:
+      return pluginState;
+  }
+}

package/dist/cjs/types.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "RelativeSelectionPos", {
+  enumerable: true,
+  get: function get() {
+    return _selection.RelativeSelectionPos;
+  }
+});
+exports.selectionPluginKey = exports.SelectionDirection = void 0;
+var _selection = require("@atlaskit/editor-common/selection");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var selectionPluginKey = exports.selectionPluginKey = new _state.PluginKey('selection');
+var SelectionDirection = exports.SelectionDirection = /*#__PURE__*/function (SelectionDirection) {
+  SelectionDirection[SelectionDirection["Before"] = -1] = "Before";
+  SelectionDirection[SelectionDirection["After"] = 1] = "After";
+  return SelectionDirection;
+}({});

package/dist/cjs/utils.js

@@ -0,0 +1,280 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createSelectionClickHandler", {
+  enumerable: true,
+  get: function get() {
+    return _selection.createSelectionClickHandler;
+  }
+});
+exports.findSelectableContainerParent = exports.findSelectableContainerBefore = exports.findSelectableContainerAfter = exports.findLastChildNodeToSelect = exports.findFirstChildNodeToSelect = void 0;
+Object.defineProperty(exports, "getAllSelectionAnalyticsPayload", {
+  enumerable: true,
+  get: function get() {
+    return _selection.getAllSelectionAnalyticsPayload;
+  }
+});
+Object.defineProperty(exports, "getCellSelectionAnalyticsPayload", {
+  enumerable: true,
+  get: function get() {
+    return _selection.getCellSelectionAnalyticsPayload;
+  }
+});
+exports.getDecorations = void 0;
+Object.defineProperty(exports, "getNodeSelectionAnalyticsPayload", {
+  enumerable: true,
+  get: function get() {
+    return _selection.getNodeSelectionAnalyticsPayload;
+  }
+});
+exports.getNodesToDecorateFromSelection = void 0;
+Object.defineProperty(exports, "getRangeSelectionAnalyticsPayload", {
+  enumerable: true,
+  get: function get() {
+    return _selection.getRangeSelectionAnalyticsPayload;
+  }
+});
+exports.isSelectionAtStartOfParentNode = exports.isSelectionAtEndOfParentNode = exports.isSelectableContainerNode = exports.isSelectableChildNode = void 0;
+exports.shouldRecalcDecorations = shouldRecalcDecorations;
+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 _view = require("@atlaskit/editor-prosemirror/view");
+var _editorSharedStyles = require("@atlaskit/editor-shared-styles");
+var _types = require("./types");
+var getDecorations = exports.getDecorations = function getDecorations(tr) {
+  if (tr.selection instanceof _state.NodeSelection) {
+    return _view.DecorationSet.create(tr.doc, [_view.Decoration.node(tr.selection.from, tr.selection.to, {
+      class: _editorSharedStyles.akEditorSelectedNodeClassName
+    })]);
+  }
+  if (tr.selection instanceof _state.TextSelection || tr.selection instanceof _state.AllSelection) {
+    var decorations = getNodesToDecorateFromSelection(tr.selection, tr.doc).map(function (_ref) {
+      var node = _ref.node,
+        pos = _ref.pos;
+      return _view.Decoration.node(pos, pos + node.nodeSize, {
+        class: _editorSharedStyles.akEditorSelectedNodeClassName
+      });
+    });
+    return _view.DecorationSet.create(tr.doc, decorations);
+  }
+  return _view.DecorationSet.empty;
+};
+var topLevelBlockNodesThatHaveSelectionStyles = ['table', 'panel', 'expand', 'layoutSection', 'decisionList', 'decisionItem', 'codeBlock'];
+
+/**
+ * Use `getNodesToDecorateFromSelection` to collect and return
+ * a list of nodes within the Selection that should have Selection
+ * decorations applied. This allows selection styles to be added to
+ * nested nodes. It will ignore text nodes as decorations are
+ * applied natively and also ignore nodes that don't completely
+ * sit within the given `Selection`.
+ */
+var getNodesToDecorateFromSelection = exports.getNodesToDecorateFromSelection = function getNodesToDecorateFromSelection(selection, doc) {
+  var nodes = [];
+  if (selection.from !== selection.to) {
+    var from = selection.from,
+      to = selection.to;
+    doc.nodesBetween(from, to, function (node, pos) {
+      var withinSelection = from <= pos && pos + node.nodeSize <= to;
+      // The reason we need to check for these nodes is to stop
+      // traversing their children if they are within a selection -
+      // this is to prevent selection styles from being added to
+      // the children as well as the parent node.
+      // Example scenario is if an entire table has been selected
+      // we should not traverse its children so we can apply the
+      // selection styles to the table. But if an entire tableRow
+      // has been selected (but the parent table has not) we should
+      // traverse it as it could contain other nodes that need
+      // selection styles. I couldn’t see a clear way to differentiate
+      // without explicitly stating which nodes should be traversed
+      // and which shouldn’t.
+      var isTopLevelNodeThatHasSelectionStyles = topLevelBlockNodesThatHaveSelectionStyles.includes(node.type.name);
+      // If the node is a top-level block node and completely sits within
+      // the selection, we do not recurse it's children to prevent selection
+      // styles being added to its child nodes. The expected behaviour
+      // is that selection styles are only added to the parent.
+      if (node && withinSelection && isTopLevelNodeThatHasSelectionStyles) {
+        nodes.push({
+          node: node,
+          pos: pos
+        });
+        return false;
+        // Otherwise we recurse the children and return them so we can apply
+        // selection styles. Text is handled by the browser.
+      } else if (node && withinSelection && !node.isText) {
+        nodes.push({
+          node: node,
+          pos: pos
+        });
+      }
+      return true;
+    });
+  }
+  return nodes;
+};
+function shouldRecalcDecorations(_ref2) {
+  var oldEditorState = _ref2.oldEditorState,
+    newEditorState = _ref2.newEditorState;
+  var oldSelection = oldEditorState.selection;
+  var newSelection = newEditorState.selection;
+  var oldPluginState = _types.selectionPluginKey.getState(oldEditorState);
+  var newPluginState = _types.selectionPluginKey.getState(newEditorState);
+  if (!oldPluginState || !newPluginState) {
+    return false;
+  }
+
+  // If selection is unchanged, no need to recalculate
+  if (oldSelection.eq(newSelection)) {
+    // We need this special case for NodeSelection, as Prosemirror still thinks the
+    // selections are equal when the node has changed
+    if (oldSelection instanceof _state.NodeSelection && newSelection instanceof _state.NodeSelection) {
+      var oldDecorations = oldPluginState.decorationSet.find();
+      var newDecorations = newPluginState.decorationSet.find();
+      // There might not be old or new decorations if the node selection is for a text node
+      // This wouldn't have happened intentionally, but we need to handle this case regardless
+      if (oldDecorations.length > 0 && newDecorations.length > 0) {
+        return !oldDecorations[0].eq(newDecorations[0]);
+      }
+      return !(oldDecorations.length === 0 && newDecorations.length === 0);
+    }
+    return false;
+  }
+
+  // There's no point updating decorations if going from one standard TextSelection to another
+  if (oldSelection instanceof _state.TextSelection && newSelection instanceof _state.TextSelection && oldSelection.from === oldSelection.to && newSelection.from === newSelection.to) {
+    return false;
+  }
+  return true;
+}
+var isSelectableContainerNode = exports.isSelectableContainerNode = function isSelectableContainerNode(node) {
+  return !!(node && !node.isAtom && _state.NodeSelection.isSelectable(node));
+};
+var isSelectableChildNode = exports.isSelectableChildNode = function isSelectableChildNode(node) {
+  return !!(node && (node.isText || (0, _utils.isEmptyParagraph)(node) || _state.NodeSelection.isSelectable(node)));
+};
+
+/**
+ * Finds closest parent node that is a selectable block container node
+ * If it finds a parent that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+var findSelectableContainerParent = exports.findSelectableContainerParent = function findSelectableContainerParent(selection) {
+  var foundNodeThatSupportsGapCursor = false;
+  var selectableNode = (0, _utils2.findParentNode)(function (node) {
+    var isSelectable = isSelectableContainerNode(node);
+    if (!isSelectable && !(0, _selection.isIgnored)(node)) {
+      foundNodeThatSupportsGapCursor = true;
+    }
+    return isSelectable;
+  })(selection);
+  if (!foundNodeThatSupportsGapCursor) {
+    return selectableNode;
+  }
+};
+
+/**
+ * Finds node before that is a selectable block container node, starting
+ * from $pos.depth + 1 and working in
+ * If it finds a node that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+var findSelectableContainerBefore = exports.findSelectableContainerBefore = function findSelectableContainerBefore($pos, doc) {
+  // prosemirror just returns the same pos from Selection.findFrom when
+  // parent.inlineContent is true, so we move position back one here
+  // to counteract that
+  if ($pos.parent.inlineContent && isSelectableContainerNode($pos.parent)) {
+    $pos = doc.resolve($pos.start() - 1);
+  }
+  var selectionBefore = _state.Selection.findFrom($pos, -1);
+  if (selectionBefore) {
+    var $selectionBefore = doc.resolve(selectionBefore.from);
+    for (var i = $pos.depth + 1; i <= $selectionBefore.depth; i++) {
+      var node = $selectionBefore.node(i);
+      if (isSelectableContainerNode(node)) {
+        return {
+          node: node,
+          pos: $selectionBefore.start(i) - 1
+        };
+      }
+      if (i > $pos.depth + 1 && !(0, _selection.isIgnored)(node)) {
+        return;
+      }
+    }
+
+    /**
+     * Stick to the default left selection behaviour,
+     * useful for mediaSingleWithCaption
+     */
+    if (selectionBefore instanceof _state.NodeSelection && _state.NodeSelection.isSelectable(selectionBefore.node)) {
+      return {
+        node: selectionBefore.node,
+        pos: selectionBefore.from
+      };
+    }
+  }
+};
+
+/**
+ * Finds node after that is a selectable block container node, starting
+ * from $pos.depth + 1 and working in
+ * If it finds a node that is not selectable but supports gap cursor, will
+ * return undefined
+ */
+var findSelectableContainerAfter = exports.findSelectableContainerAfter = function findSelectableContainerAfter($pos, doc) {
+  var selectionAfter = _state.Selection.findFrom($pos, 1);
+  if (selectionAfter) {
+    var $selectionAfter = doc.resolve(selectionAfter.from);
+    for (var i = $pos.depth + 1; i <= $selectionAfter.depth; i++) {
+      var node = $selectionAfter.node(i);
+      if (isSelectableContainerNode(node)) {
+        return {
+          node: node,
+          pos: $selectionAfter.start(i) - 1
+        };
+      }
+      if (i > $pos.depth + 1 && !(0, _selection.isIgnored)(node)) {
+        return;
+      }
+    }
+  }
+};
+
+/**
+ * Finds first child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+var findFirstChildNodeToSelect = exports.findFirstChildNodeToSelect = function findFirstChildNodeToSelect(parent) {
+  return (0, _utils2.flatten)(parent).find(function (child) {
+    return isSelectableChildNode(child.node) || !(0, _selection.isIgnored)(child.node);
+  });
+};
+
+/**
+ * Finds last child node that is a selectable block container node OR that
+ * supports gap cursor
+ */
+var findLastChildNodeToSelect = exports.findLastChildNodeToSelect = function findLastChildNodeToSelect(parent) {
+  var child;
+  parent.descendants(function (node, pos) {
+    if (isSelectableChildNode(node) || !(0, _selection.isIgnored)(node)) {
+      child = {
+        node: node,
+        pos: pos
+      };
+      return false;
+    }
+  });
+  if (child) {
+    return child;
+  }
+};
+var isSelectionAtStartOfParentNode = exports.isSelectionAtStartOfParentNode = function isSelectionAtStartOfParentNode($pos, selection) {
+  return (0, _selection.isSelectionAtStartOfNode)($pos, findSelectableContainerParent(selection));
+};
+var isSelectionAtEndOfParentNode = exports.isSelectionAtEndOfParentNode = function isSelectionAtEndOfParentNode($pos, selection) {
+  return (0, _selection.isSelectionAtEndOfNode)($pos, findSelectableContainerParent(selection));
+};

package/dist/es2019/actions.js

@@ -0,0 +1,5 @@
+export let SelectionActionTypes = /*#__PURE__*/function (SelectionActionTypes) {
+  SelectionActionTypes["SET_DECORATIONS"] = "SET_DECORATIONS";
+  SelectionActionTypes["SET_RELATIVE_SELECTION"] = "SET_RELATIVE_SELECTION";
+  return SelectionActionTypes;
+}({});