@atlaskit/editor-core 188.4.0 → 188.5.2

package/dist/es2019/plugins/selection/utils.js

@@ -1,233 +0,0 @@
-import { NodeSelection, TextSelection, Selection, AllSelection } from '@atlaskit/editor-prosemirror/state';
-import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import { flatten, findParentNode } from '@atlaskit/editor-prosemirror/utils';
-import { akEditorSelectedNodeClassName } from '@atlaskit/editor-shared-styles';
-import { isSelectionAtStartOfNode, isSelectionAtEndOfNode, getNodeSelectionAnalyticsPayload, getAllSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, createSelectionClickHandler, isIgnored as isIgnoredByGapCursor } from '@atlaskit/editor-common/selection';
-import { isEmptyParagraph } from '@atlaskit/editor-common/utils';
-import { selectionPluginKey } from './types';
-export const getDecorations = tr => {
-  if (tr.selection instanceof NodeSelection) {
-    return DecorationSet.create(tr.doc, [Decoration.node(tr.selection.from, tr.selection.to, {
-      class: akEditorSelectedNodeClassName
-    })]);
-  }
-  if (tr.selection instanceof TextSelection || tr.selection instanceof AllSelection) {
-    const decorations = getNodesToDecorateFromSelection(tr.selection, tr.doc).map(({
-      node,
-      pos
-    }) => {
-      return Decoration.node(pos, pos + node.nodeSize, {
-        class: akEditorSelectedNodeClassName
-      });
-    });
-    return DecorationSet.create(tr.doc, decorations);
-  }
-  return DecorationSet.empty;
-};
-const 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`.
- */
-export const getNodesToDecorateFromSelection = (selection, doc) => {
-  const nodes = [];
-  if (selection.from !== selection.to) {
-    const {
-      from,
-      to
-    } = selection;
-    doc.nodesBetween(from, to, (node, pos) => {
-      const 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.
-      const 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,
-          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,
-          pos
-        });
-      }
-      return true;
-    });
-  }
-  return nodes;
-};
-export function shouldRecalcDecorations({
-  oldEditorState,
-  newEditorState
-}) {
-  const oldSelection = oldEditorState.selection;
-  const newSelection = newEditorState.selection;
-  const oldPluginState = selectionPluginKey.getState(oldEditorState);
-  const newPluginState = 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 NodeSelection && newSelection instanceof NodeSelection) {
-      const oldDecorations = oldPluginState.decorationSet.find();
-      const 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 TextSelection && newSelection instanceof TextSelection && oldSelection.from === oldSelection.to && newSelection.from === newSelection.to) {
-    return false;
-  }
-  return true;
-}
-export const isSelectableContainerNode = node => !!(node && !node.isAtom && NodeSelection.isSelectable(node));
-export const isSelectableChildNode = node => !!(node && (node.isText || isEmptyParagraph(node) || 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
- */
-export const findSelectableContainerParent = selection => {
-  let foundNodeThatSupportsGapCursor = false;
-  const selectableNode = findParentNode(node => {
-    const isSelectable = isSelectableContainerNode(node);
-    if (!isSelectable && !isIgnoredByGapCursor(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
- */
-export const 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);
-  }
-  const selectionBefore = Selection.findFrom($pos, -1);
-  if (selectionBefore) {
-    const $selectionBefore = doc.resolve(selectionBefore.from);
-    for (let i = $pos.depth + 1; i <= $selectionBefore.depth; i++) {
-      const node = $selectionBefore.node(i);
-      if (isSelectableContainerNode(node)) {
-        return {
-          node,
-          pos: $selectionBefore.start(i) - 1
-        };
-      }
-      if (i > $pos.depth + 1 && !isIgnoredByGapCursor(node)) {
-        return;
-      }
-    }
-
-    /**
-     * Stick to the default left selection behaviour,
-     * useful for mediaSingleWithCaption
-     */
-    if (selectionBefore instanceof NodeSelection && 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
- */
-export const findSelectableContainerAfter = ($pos, doc) => {
-  const selectionAfter = Selection.findFrom($pos, 1);
-  if (selectionAfter) {
-    const $selectionAfter = doc.resolve(selectionAfter.from);
-    for (let i = $pos.depth + 1; i <= $selectionAfter.depth; i++) {
-      const node = $selectionAfter.node(i);
-      if (isSelectableContainerNode(node)) {
-        return {
-          node,
-          pos: $selectionAfter.start(i) - 1
-        };
-      }
-      if (i > $pos.depth + 1 && !isIgnoredByGapCursor(node)) {
-        return;
-      }
-    }
-  }
-};
-
-/**
- * Finds first child node that is a selectable block container node OR that
- * supports gap cursor
- */
-export const findFirstChildNodeToSelect = parent => flatten(parent).find(child => isSelectableChildNode(child.node) || !isIgnoredByGapCursor(child.node));
-
-/**
- * Finds last child node that is a selectable block container node OR that
- * supports gap cursor
- */
-export const findLastChildNodeToSelect = parent => {
-  let child;
-  parent.descendants((node, pos) => {
-    if (isSelectableChildNode(node) || !isIgnoredByGapCursor(node)) {
-      child = {
-        node,
-        pos
-      };
-      return false;
-    }
-  });
-  if (child) {
-    return child;
-  }
-};
-export const isSelectionAtStartOfParentNode = ($pos, selection) => isSelectionAtStartOfNode($pos, findSelectableContainerParent(selection));
-export const isSelectionAtEndOfParentNode = ($pos, selection) => isSelectionAtEndOfNode($pos, findSelectableContainerParent(selection));
-export { getNodeSelectionAnalyticsPayload, getAllSelectionAnalyticsPayload, getRangeSelectionAnalyticsPayload, getCellSelectionAnalyticsPayload, createSelectionClickHandler };

package/dist/es2019/selection-api/api.js

@@ -1,20 +0,0 @@
-import { setSelectionRelativeToNode as setSelectionRelativeToNodeOriginalCommand } from '../plugins/selection/commands';
-import { getPluginState as getSelectionPluginState } from '../plugins/selection/plugin-factory';
-export const createEditorSelectionAPI = () => {
-  return {
-    getSelectionPluginState: state => {
-      return getSelectionPluginState(state);
-    },
-    setSelectionRelativeToNode: ({
-      selectionRelativeToNode,
-      selection
-    }) => state => {
-      let tr = state.tr;
-      const fakeDispatch = _tr => {
-        tr = _tr;
-      };
-      setSelectionRelativeToNodeOriginalCommand(selectionRelativeToNode, selection)(state, fakeDispatch);
-      return tr;
-    }
-  };
-};

package/dist/esm/plugins/selection/actions.js

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

package/dist/esm/plugins/selection/commands.js

@@ -1,251 +0,0 @@
-import { NodeSelection, TextSelection, Selection } from '@atlaskit/editor-prosemirror/state';
-import { GapCursorSelection, Side } from './gap-cursor-selection';
-import { isIgnored as isIgnoredByGapCursor } from '@atlaskit/editor-common/selection';
-import { isNodeEmpty, isEmptyParagraph } from '@atlaskit/editor-common/utils';
-import { SelectionActionTypes } from './actions';
-import { createCommand, getPluginState } from './plugin-factory';
-import { isSelectableContainerNode, isSelectionAtEndOfParentNode, findSelectableContainerParent, isSelectionAtStartOfParentNode, findSelectableContainerBefore, findSelectableContainerAfter, findFirstChildNodeToSelect, findLastChildNodeToSelect } from './utils';
-import { RelativeSelectionPos, SelectionDirection, selectionPluginKey } from './types';
-export var selectNearNode = function selectNearNode(selectionRelativeToNode, selection) {
-  return function (_ref) {
-    var tr = _ref.tr;
-    tr.setMeta(selectionPluginKey, {
-      type: SelectionActionTypes.SET_RELATIVE_SELECTION,
-      selectionRelativeToNode: selectionRelativeToNode
-    });
-    if (selection) {
-      return tr.setSelection(selection);
-    }
-    return tr;
-  };
-};
-export var setSelectionRelativeToNode = function setSelectionRelativeToNode(selectionRelativeToNode, selection) {
-  return createCommand({
-    type: SelectionActionTypes.SET_RELATIVE_SELECTION,
-    selectionRelativeToNode: selectionRelativeToNode
-  }, function (tr) {
-    return selectNearNode(selectionRelativeToNode, selection)({
-      tr: tr
-    }) || tr;
-  });
-};
-export var arrowRight = function arrowRight(state, dispatch) {
-  var selection = state.selection;
-  if (selection instanceof GapCursorSelection) {
-    return arrowRightFromGapCursor(selection)(state, dispatch);
-  } else if (selection instanceof NodeSelection) {
-    return arrowRightFromNode(selection)(state, dispatch);
-  } else if (selection instanceof TextSelection) {
-    return arrowRightFromText(selection)(state, dispatch);
-  }
-  return false;
-};
-export var arrowLeft = function arrowLeft(state, dispatch) {
-  var selection = state.selection;
-  if (selection instanceof GapCursorSelection) {
-    return arrowLeftFromGapCursor(selection)(state, dispatch);
-  } else if (selection instanceof NodeSelection) {
-    return arrowLeftFromNode(selection)(state, dispatch);
-  } else if (selection instanceof 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 === Side.LEFT) {
-      var selectableNode = findSelectableContainerAfter($to, state.doc);
-      if (selectableNode) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-      }
-    } else if (side === Side.RIGHT && isSelectionAtEndOfParentNode($from, selection)) {
-      var _selectableNode = findSelectableContainerParent(selection);
-      if (_selectableNode) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.End, 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 = getPluginState(state),
-      selectionRelativeToNode = _getPluginState.selectionRelativeToNode;
-    if (side === Side.RIGHT) {
-      var selectableNode = findSelectableContainerBefore($from, state.doc);
-      if (selectableNode) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-      }
-    } else if (side === Side.LEFT && isSelectionAtStartOfParentNode($from, selection)) {
-      if (selectionRelativeToNode === RelativeSelectionPos.Before) {
-        var $parent = state.doc.resolve(selection.$from.before(selection.$from.depth));
-        if ($parent) {
-          var _selectableNode2 = findSelectableContainerBefore($parent, state.doc);
-          if (_selectableNode2 && isIgnoredByGapCursor(_selectableNode2.node)) {
-            // selection is inside node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
-            return setSelectionRelativeToNode(RelativeSelectionPos.End, 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 = findSelectableContainerParent(selection);
-        if (_selectableNode3) {
-          return setSelectionRelativeToNode(RelativeSelectionPos.Start, 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 = getPluginState(state),
-      selectionRelativeToNode = _getPluginState2.selectionRelativeToNode;
-    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
-        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;
-  };
-};
-var arrowLeftFromNode = function arrowLeftFromNode(selection) {
-  return function (state, dispatch) {
-    var node = selection.node,
-      from = selection.from,
-      to = selection.to,
-      $from = selection.$from;
-    var _getPluginState3 = getPluginState(state),
-      selectionRelativeToNode = _getPluginState3.selectionRelativeToNode;
-    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
-        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;
-  };
-};
-var arrowRightFromText = function arrowRightFromText(selection) {
-  return function (state, dispatch) {
-    if (isSelectionAtEndOfParentNode(selection.$to, selection)) {
-      var selectableNode = findSelectableContainerParent(selection);
-      if (selectableNode) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.End, NodeSelection.create(state.doc, selectableNode.pos))(state, dispatch);
-      }
-    }
-    return false;
-  };
-};
-var arrowLeftFromText = function arrowLeftFromText(selection) {
-  return function (state, dispatch) {
-    var _getPluginState4 = getPluginState(state),
-      selectionRelativeToNode = _getPluginState4.selectionRelativeToNode;
-    if (selectionRelativeToNode === RelativeSelectionPos.Before) {
-      var selectableNode = findSelectableContainerBefore(selection.$from, state.doc);
-      if (selectableNode && isIgnoredByGapCursor(selectableNode.node)) {
-        // selection is inside node without gap cursor preceeded by another node without gap cursor - set node selection for previous node
-        return setSelectionRelativeToNode(RelativeSelectionPos.End, 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 (isSelectionAtStartOfParentNode(selection.$from, selection)) {
-      var _selectableNode4 = findSelectableContainerParent(selection);
-      if (_selectableNode4) {
-        return setSelectionRelativeToNode(RelativeSelectionPos.Start, NodeSelection.create(state.doc, _selectableNode4.pos))(state, dispatch);
-      }
-    }
-    return false;
-  };
-};
-var findAndSetTextSelection = function findAndSetTextSelection(selectionRelativeToNode, $pos, dir) {
-  return function (state, dispatch) {
-    var sel = 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 (isNodeEmpty(node)) {
-      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(pos), SelectionDirection.After)(state, dispatch);
-    }
-    var selectableNode = 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), 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;
-  };
-};
-export var setSelectionInsideAtNodeEnd = function setSelectionInsideAtNodeEnd(selectionRelativeToNode, node, from, to) {
-  return function (state, dispatch) {
-    if (isNodeEmpty(node)) {
-      return findAndSetTextSelection(selectionRelativeToNode, state.doc.resolve(to), SelectionDirection.Before)(state, dispatch);
-    }
-    var selectableNode = 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), 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;
-  };
-};