@atlaskit/editor-plugin-selection 0.2.2 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-plugin-selection
 
+## 1.0.1
+
+### Patch Changes
+
+- [#70261](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/70261) [`a92879d672c6`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/a92879d672c6) - [ux] ED-21620: Corrected the selection functions for atom nodes that are triggered on pressing the right and left arrow keys.
+
+## 1.0.0
+
+### Major Changes
+
+- [#72386](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/72386) [`0c52b0be40c1`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/0c52b0be40c1) - This changeset exists to bump all editor plugins that currently don't have a major version. This is to address an issue with Jira plugin consumption.
+
 ## 0.2.2
 
 ### Patch Changes

package/dist/cjs/commands.js

@@ -7,11 +7,14 @@ exports.setSelectionRelativeToNode = exports.setSelectionInsideAtNodeEnd = expor
 var _selection = require("@atlaskit/editor-common/selection");
 var _utils = require("@atlaskit/editor-common/utils");
 var _state = require("@atlaskit/editor-prosemirror/state");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _actions = require("./actions");
 var _gapCursorSelection = require("./gap-cursor-selection");
 var _pluginFactory = require("./plugin-factory");
 var _types = require("./types");
 var _utils2 = require("./utils");
+/* eslint-disable import/no-extraneous-dependencies */
+
 var selectNearNode = exports.selectNearNode = function selectNearNode(selectionRelativeToNode, selection) {
   return function (_ref) {
     var tr = _ref.tr;
@@ -117,6 +120,25 @@ var arrowRightFromNode = function arrowRightFromNode(selection) {
       $to = selection.$to;
     var _getPluginState2 = (0, _pluginFactory.getPluginState)(state),
       selectionRelativeToNode = _getPluginState2.selectionRelativeToNode;
+    if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.change-navigation-for-atom-nodes')) {
+      if (node.isAtom) {
+        if ((0, _utils2.isSelectionAtEndOfParentNode)($to, selection) && (node.isInline || (0, _selection.isIgnored)(node))) {
+          // selection is for inline node or atom node which is ignored by gap-cursor and 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;
+    }
     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
@@ -127,10 +149,10 @@ var arrowRightFromNode = function arrowRightFromNode(selection) {
       // 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)) {
+      var _selectableNode4 = (0, _utils2.findSelectableContainerAfter)($to, state.doc);
+      if (_selectableNode4 && (0, _selection.isIgnored)(_selectableNode4.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 setSelectionRelativeToNode(_types.RelativeSelectionPos.Start, _state.NodeSelection.create(state.doc, _selectableNode4.pos))(state, dispatch);
       }
     }
     return false;
@@ -144,6 +166,29 @@ var arrowLeftFromNode = function arrowLeftFromNode(selection) {
       $from = selection.$from;
     var _getPluginState3 = (0, _pluginFactory.getPluginState)(state),
       selectionRelativeToNode = _getPluginState3.selectionRelativeToNode;
+    if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.change-navigation-for-atom-nodes')) {
+      if (node.isAtom) {
+        if ((0, _utils2.isSelectionAtStartOfParentNode)($from, selection) && (node.isInline || (0, _selection.isIgnored)(node))) {
+          // selection is for inline node or atom node which is ignored by gap-cursor and 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;
+    }
     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
@@ -159,9 +204,9 @@ var arrowLeftFromNode = function arrowLeftFromNode(selection) {
       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);
+      var _selectableNode5 = (0, _utils2.findSelectableContainerBefore)($from, state.doc);
+      if (_selectableNode5 && (0, _selection.isIgnored)(_selectableNode5.node)) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.End, _state.NodeSelection.create(state.doc, _selectableNode5.pos))(state, dispatch);
       }
     }
     return false;
@@ -192,9 +237,9 @@ var arrowLeftFromText = function arrowLeftFromText(selection) {
       // 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);
+      var _selectableNode6 = (0, _utils2.findSelectableContainerParent)(selection);
+      if (_selectableNode6) {
+        return setSelectionRelativeToNode(_types.RelativeSelectionPos.Start, _state.NodeSelection.create(state.doc, _selectableNode6.pos))(state, dispatch);
       }
     }
     return false;
@@ -215,18 +260,36 @@ var setSelectionInsideAtNodeStart = function setSelectionInsideAtNodeStart(selec
       return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), _types.SelectionDirection.After)(state, dispatch);
     }
     var selectableNode = (0, _utils2.findFirstChildNodeToSelect)(node);
+    if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.change-navigation-for-atom-nodes')) {
+      if (selectableNode) {
+        var childNode = selectableNode.node,
+          childPos = selectableNode.pos;
+        var selectionPos = pos + childPos + 1;
+        if (childNode.isText || childNode.isAtom && (0, _selection.isIgnored)(childNode) || childNode.isInline) {
+          //selection is for text node, inline node or atom node which is ignored by gap-cursor. set selection before it.
+          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;
+    }
     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);
+      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);
+        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 setSelectionRelativeToNode(selectionRelativeToNode, _state.NodeSelection.create(state.doc, _selectionPos))(state, dispatch);
       }
     }
     return false;
@@ -238,18 +301,36 @@ var setSelectionInsideAtNodeEnd = exports.setSelectionInsideAtNodeEnd = function
       return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), _types.SelectionDirection.Before)(state, dispatch);
     }
     var selectableNode = (0, _utils2.findLastChildNodeToSelect)(node);
+    if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.change-navigation-for-atom-nodes')) {
+      if (selectableNode) {
+        var childNode = selectableNode.node,
+          childPos = selectableNode.pos;
+        var selectionPos = from + childPos + childNode.nodeSize;
+        if (childNode.isText || childNode.isAtom && (0, _selection.isIgnored)(childNode) || childNode.isInline) {
+          //selection is for text node, inline node or atom node which is ignored by gap-cursor. set selection after it.
+          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;
+    }
     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);
+      var _childNode2 = selectableNode.node,
+        _childPos2 = selectableNode.pos;
+      var _selectionPos2 = from + _childPos2 + _childNode2.nodeSize;
+      if (_childNode2.isText || _childNode2.isAtom) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(_selectionPos2 + 1), _types.SelectionDirection.After)(state, dispatch);
+      } else if ((0, _utils.isEmptyParagraph)(_childNode2)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(_selectionPos2), _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);
+        return setSelectionRelativeToNode(selectionRelativeToNode, new _gapCursorSelection.GapCursorSelection(state.doc.resolve(_selectionPos2 + 1), _gapCursorSelection.Side.RIGHT))(state, dispatch);
       } else if ((0, _utils2.isSelectableContainerNode)(node)) {
-        return setSelectionRelativeToNode(selectionRelativeToNode, _state.NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+        return setSelectionRelativeToNode(selectionRelativeToNode, _state.NodeSelection.create(state.doc, _selectionPos2))(state, dispatch);
       }
     }
     return false;

package/dist/es2019/commands.js

@@ -1,6 +1,8 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { isIgnored as isIgnoredByGapCursor } from '@atlaskit/editor-common/selection';
 import { isEmptyParagraph, isNodeEmpty } from '@atlaskit/editor-common/utils';
 import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
 import { SelectionActionTypes } from './actions';
 import { GapCursorSelection, Side } from './gap-cursor-selection';
 import { createCommand, getPluginState } from './plugin-factory';
@@ -115,6 +117,25 @@ const arrowRightFromNode = selection => (state, dispatch) => {
   const {
     selectionRelativeToNode
   } = getPluginState(state);
+  if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+    if (node.isAtom) {
+      if (isSelectionAtEndOfParentNode($to, selection) && (node.isInline || isIgnoredByGapCursor(node))) {
+        // selection is for inline node or atom node which is ignored by gap-cursor and that is the last child of its parent node - set text selection after it
+        return findAndSetTextSelection(RelativeSelectionPos.End, state.doc.resolve(from + 1), SelectionDirection.After)(state, dispatch);
+      }
+      return false;
+    } else if (selectionRelativeToNode === RelativeSelectionPos.Start) {
+      // selection is for container node - set selection inside it at the start
+      return setSelectionInsideAtNodeStart(RelativeSelectionPos.Inside, node, from)(state, dispatch);
+    } else if (isIgnoredByGapCursor(node) && (!selectionRelativeToNode || selectionRelativeToNode === RelativeSelectionPos.End)) {
+      const selectableNode = findSelectableContainerAfter($to, state.doc);
+      if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
+        // selection is for node without gap cursor followed by another node without gap cursor - set node selection for next node
+        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  }
   if (node.isAtom) {
     if (isSelectionAtEndOfParentNode($to, selection)) {
       // selection is for inline node that is the last child of its parent node - set text selection after it
@@ -143,6 +164,29 @@ const arrowLeftFromNode = selection => (state, dispatch) => {
   const {
     selectionRelativeToNode
   } = getPluginState(state);
+  if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+    if (node.isAtom) {
+      if (isSelectionAtStartOfParentNode($from, selection) && (node.isInline || isIgnoredByGapCursor(node))) {
+        // selection is for inline node or atom node which is ignored by gap-cursor and that is the first child of its parent node - set text selection before it
+        return findAndSetTextSelection(RelativeSelectionPos.Start, state.doc.resolve(from), SelectionDirection.Before)(state, dispatch);
+      }
+      return false;
+    } else if (selectionRelativeToNode === RelativeSelectionPos.End) {
+      // selection is for container node - set selection inside it at the end
+      return setSelectionInsideAtNodeEnd(RelativeSelectionPos.Inside, node, from, to)(state, dispatch);
+    } else if (!selectionRelativeToNode || selectionRelativeToNode === 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(RelativeSelectionPos.Before, node, from)(state, dispatch);
+    } else if (isIgnoredByGapCursor(node) && selectionRelativeToNode === RelativeSelectionPos.Start) {
+      // selection is for node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
+      const selectableNode = findSelectableContainerBefore($from, state.doc);
+      if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      }
+    }
+    return false;
+  }
   if (node.isAtom) {
     if (isSelectionAtStartOfParentNode($from, selection)) {
       // selection is for inline node that is the first child of its parent node - set text selection before it
@@ -207,6 +251,26 @@ const setSelectionInsideAtNodeStart = (selectionRelativeToNode, node, pos) => (s
     return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), SelectionDirection.After)(state, dispatch);
   }
   const selectableNode = findFirstChildNodeToSelect(node);
+  if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+    if (selectableNode) {
+      const {
+        node: childNode,
+        pos: childPos
+      } = selectableNode;
+      const selectionPos = pos + childPos + 1;
+      if (childNode.isText || childNode.isAtom && isIgnoredByGapCursor(childNode) || childNode.isInline) {
+        //selection is for text node, inline node or atom node which is ignored by gap-cursor. set selection before it.
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.Before)(state, dispatch);
+      } else if (isEmptyParagraph(childNode)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.Before)(state, dispatch);
+      } else if (!isIgnoredByGapCursor(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos), Side.LEFT))(state, dispatch);
+      } else if (isSelectableContainerNode(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+      }
+    }
+    return false;
+  }
   if (selectableNode) {
     const {
       node: childNode,
@@ -230,6 +294,26 @@ export const setSelectionInsideAtNodeEnd = (selectionRelativeToNode, node, from,
     return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), SelectionDirection.Before)(state, dispatch);
   }
   const selectableNode = findLastChildNodeToSelect(node);
+  if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+    if (selectableNode) {
+      const {
+        node: childNode,
+        pos: childPos
+      } = selectableNode;
+      const selectionPos = from + childPos + childNode.nodeSize;
+      if (childNode.isText || childNode.isAtom && isIgnoredByGapCursor(childNode) || childNode.isInline) {
+        //selection is for text node, inline node or atom node which is ignored by gap-cursor. set selection after it.
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.After)(state, dispatch);
+      } else if (isEmptyParagraph(childNode)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.After)(state, dispatch);
+      } else if (!isIgnoredByGapCursor(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos + 1), Side.RIGHT))(state, dispatch);
+      } else if (isSelectableContainerNode(node)) {
+        return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+      }
+    }
+    return false;
+  }
   if (selectableNode) {
     const {
       node: childNode,

package/dist/esm/commands.js

@@ -1,6 +1,8 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { isIgnored as isIgnoredByGapCursor } from '@atlaskit/editor-common/selection';
 import { isEmptyParagraph, isNodeEmpty } from '@atlaskit/editor-common/utils';
 import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
 import { SelectionActionTypes } from './actions';
 import { GapCursorSelection, Side } from './gap-cursor-selection';
 import { createCommand, getPluginState } from './plugin-factory';
@@ -111,6 +113,25 @@ var arrowRightFromNode = function arrowRightFromNode(selection) {
       $to = selection.$to;
     var _getPluginState2 = getPluginState(state),
       selectionRelativeToNode = _getPluginState2.selectionRelativeToNode;
+    if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+      if (node.isAtom) {
+        if (isSelectionAtEndOfParentNode($to, selection) && (node.isInline || isIgnoredByGapCursor(node))) {
+          // selection is for inline node or atom node which is ignored by gap-cursor and that is the last child of its parent node - set text selection after it
+          return findAndSetTextSelection(RelativeSelectionPos.End, state.doc.resolve(from + 1), SelectionDirection.After)(state, dispatch);
+        }
+        return false;
+      } else if (selectionRelativeToNode === RelativeSelectionPos.Start) {
+        // selection is for container node - set selection inside it at the start
+        return setSelectionInsideAtNodeStart(RelativeSelectionPos.Inside, node, from)(state, dispatch);
+      } else if (isIgnoredByGapCursor(node) && (!selectionRelativeToNode || selectionRelativeToNode === RelativeSelectionPos.End)) {
+        var selectableNode = findSelectableContainerAfter($to, state.doc);
+        if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
+          // selection is for node without gap cursor followed by another node without gap cursor - set node selection for next node
+          return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+        }
+      }
+      return false;
+    }
     if (node.isAtom) {
       if (isSelectionAtEndOfParentNode($to, selection)) {
         // selection is for inline node that is the last child of its parent node - set text selection after it
@@ -121,10 +142,10 @@ var arrowRightFromNode = function arrowRightFromNode(selection) {
       // selection is for container node - set selection inside it at the start
       return setSelectionInsideAtNodeStart(RelativeSelectionPos.Inside, node, from)(state, dispatch);
     } else if (isIgnoredByGapCursor(node) && (!selectionRelativeToNode || selectionRelativeToNode === RelativeSelectionPos.End)) {
-      var selectableNode = findSelectableContainerAfter($to, state.doc);
-      if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
+      var _selectableNode4 = findSelectableContainerAfter($to, state.doc);
+      if (_selectableNode4 && isIgnoredByGapCursor(_selectableNode4.node)) {
         // selection is for node without gap cursor followed by another node without gap cursor - set node selection for next node
-        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, _selectableNode4.pos))(state, dispatch);
       }
     }
     return false;
@@ -138,6 +159,29 @@ var arrowLeftFromNode = function arrowLeftFromNode(selection) {
       $from = selection.$from;
     var _getPluginState3 = getPluginState(state),
       selectionRelativeToNode = _getPluginState3.selectionRelativeToNode;
+    if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+      if (node.isAtom) {
+        if (isSelectionAtStartOfParentNode($from, selection) && (node.isInline || isIgnoredByGapCursor(node))) {
+          // selection is for inline node or atom node which is ignored by gap-cursor and that is the first child of its parent node - set text selection before it
+          return findAndSetTextSelection(RelativeSelectionPos.Start, state.doc.resolve(from), SelectionDirection.Before)(state, dispatch);
+        }
+        return false;
+      } else if (selectionRelativeToNode === RelativeSelectionPos.End) {
+        // selection is for container node - set selection inside it at the end
+        return setSelectionInsideAtNodeEnd(RelativeSelectionPos.Inside, node, from, to)(state, dispatch);
+      } else if (!selectionRelativeToNode || selectionRelativeToNode === 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(RelativeSelectionPos.Before, node, from)(state, dispatch);
+      } else if (isIgnoredByGapCursor(node) && selectionRelativeToNode === RelativeSelectionPos.Start) {
+        // selection is for node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
+        var selectableNode = findSelectableContainerBefore($from, state.doc);
+        if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
+          return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+        }
+      }
+      return false;
+    }
     if (node.isAtom) {
       if (isSelectionAtStartOfParentNode($from, selection)) {
         // selection is for inline node that is the first child of its parent node - set text selection before it
@@ -153,9 +197,9 @@ var arrowLeftFromNode = function arrowLeftFromNode(selection) {
       return setSelectionInsideAtNodeStart(RelativeSelectionPos.Before, node, from)(state, dispatch);
     } else if (isIgnoredByGapCursor(node) && selectionRelativeToNode === RelativeSelectionPos.Start) {
       // selection is for node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
-      var selectableNode = findSelectableContainerBefore($from, state.doc);
-      if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
+      var _selectableNode5 = findSelectableContainerBefore($from, state.doc);
+      if (_selectableNode5 && isIgnoredByGapCursor(_selectableNode5.node)) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, _selectableNode5.pos))(state, dispatch);
       }
     }
     return false;
@@ -186,9 +230,9 @@ var arrowLeftFromText = function arrowLeftFromText(selection) {
       // from responding to arrow left key
       setSelectionRelativeToNode(undefined)(state, dispatch);
     } else if (isSelectionAtStartOfParentNode(selection.$from, selection)) {
-      var _selectableNode4 = findSelectableContainerParent(selection);
-      if (_selectableNode4) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, _selectableNode4.pos))(state, dispatch);
+      var _selectableNode6 = findSelectableContainerParent(selection);
+      if (_selectableNode6) {
+        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, _selectableNode6.pos))(state, dispatch);
       }
     }
     return false;
@@ -209,18 +253,36 @@ var setSelectionInsideAtNodeStart = function setSelectionInsideAtNodeStart(selec
       return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), SelectionDirection.After)(state, dispatch);
     }
     var selectableNode = findFirstChildNodeToSelect(node);
+    if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+      if (selectableNode) {
+        var childNode = selectableNode.node,
+          childPos = selectableNode.pos;
+        var selectionPos = pos + childPos + 1;
+        if (childNode.isText || childNode.isAtom && isIgnoredByGapCursor(childNode) || childNode.isInline) {
+          //selection is for text node, inline node or atom node which is ignored by gap-cursor. set selection before it.
+          return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.Before)(state, dispatch);
+        } else if (isEmptyParagraph(childNode)) {
+          return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.Before)(state, dispatch);
+        } else if (!isIgnoredByGapCursor(node)) {
+          return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos), Side.LEFT))(state, dispatch);
+        } else if (isSelectableContainerNode(node)) {
+          return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+        }
+      }
+      return false;
+    }
     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), SelectionDirection.Before)(state, dispatch);
-      } else if (isEmptyParagraph(childNode)) {
-        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.Before)(state, dispatch);
+      var _childNode = selectableNode.node,
+        _childPos = selectableNode.pos;
+      var _selectionPos = pos + _childPos + 1;
+      if (_childNode.isText || _childNode.isAtom) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(_selectionPos), SelectionDirection.Before)(state, dispatch);
+      } else if (isEmptyParagraph(_childNode)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(_selectionPos + 1), SelectionDirection.Before)(state, dispatch);
       } else if (!isIgnoredByGapCursor(node)) {
-        return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos), Side.LEFT))(state, dispatch);
+        return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(_selectionPos), Side.LEFT))(state, dispatch);
       } else if (isSelectableContainerNode(node)) {
-        return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+        return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, _selectionPos))(state, dispatch);
       }
     }
     return false;
@@ -232,18 +294,36 @@ export var setSelectionInsideAtNodeEnd = function setSelectionInsideAtNodeEnd(se
       return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), SelectionDirection.Before)(state, dispatch);
     }
     var selectableNode = findLastChildNodeToSelect(node);
+    if (getBooleanFF('platform.editor.change-navigation-for-atom-nodes')) {
+      if (selectableNode) {
+        var childNode = selectableNode.node,
+          childPos = selectableNode.pos;
+        var selectionPos = from + childPos + childNode.nodeSize;
+        if (childNode.isText || childNode.isAtom && isIgnoredByGapCursor(childNode) || childNode.isInline) {
+          //selection is for text node, inline node or atom node which is ignored by gap-cursor. set selection after it.
+          return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos + 1), SelectionDirection.After)(state, dispatch);
+        } else if (isEmptyParagraph(childNode)) {
+          return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.After)(state, dispatch);
+        } else if (!isIgnoredByGapCursor(node)) {
+          return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos + 1), Side.RIGHT))(state, dispatch);
+        } else if (isSelectableContainerNode(node)) {
+          return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+        }
+      }
+      return false;
+    }
     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), SelectionDirection.After)(state, dispatch);
-      } else if (isEmptyParagraph(childNode)) {
-        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(selectionPos), SelectionDirection.After)(state, dispatch);
+      var _childNode2 = selectableNode.node,
+        _childPos2 = selectableNode.pos;
+      var _selectionPos2 = from + _childPos2 + _childNode2.nodeSize;
+      if (_childNode2.isText || _childNode2.isAtom) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(_selectionPos2 + 1), SelectionDirection.After)(state, dispatch);
+      } else if (isEmptyParagraph(_childNode2)) {
+        return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(_selectionPos2), SelectionDirection.After)(state, dispatch);
       } else if (!isIgnoredByGapCursor(node)) {
-        return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(selectionPos + 1), Side.RIGHT))(state, dispatch);
+        return setSelectionRelativeToNode(selectionRelativeToNode, new GapCursorSelection(state.doc.resolve(_selectionPos2 + 1), Side.RIGHT))(state, dispatch);
       } else if (isSelectableContainerNode(node)) {
-        return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, selectionPos))(state, dispatch);
+        return setSelectionRelativeToNode(selectionRelativeToNode, NodeSelection.create(state.doc, _selectionPos2))(state, dispatch);
       }
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-plugin-selection",
-  "version": "0.2.2",
+  "version": "1.0.1",
   "description": "Selection plugin for @atlaskit/editor-core",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -21,7 +21,7 @@
     "runReact18": false
   },
   "dependencies": {
-    "@atlaskit/editor-common": "^77.3.0",
+    "@atlaskit/editor-common": "^77.4.0",
     "@atlaskit/editor-prosemirror": "3.0.0",
     "@atlaskit/editor-shared-styles": "^2.9.0",
     "@atlaskit/editor-tables": "^2.5.0",
@@ -78,5 +78,10 @@
     "no-unused-dependencies": {
       "checkDevDependencies": true
     }
+  },
+  "platform-feature-flags": {
+    "platform.editor.change-navigation-for-atom-nodes": {
+      "type": "boolean"
+    }
   }
 }