@atlaskit/editor-plugin-paste 0.1.22 → 0.2.0

package/dist/esm/edge-cases/index.js

@@ -0,0 +1,81 @@
+import { isListNode } from '@atlaskit/editor-common/utils';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { findParentNodeOfType, safeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { isCursorSelectionAtTextStartOrEnd, isEmptyNode, isSelectionInsidePanel } from '../util';
+import { insertSliceAtNodeEdge, insertSliceInsideOfPanelNodeSelected, insertSliceIntoEmptyNode, insertSliceIntoRangeSelectionInsideList } from './lists';
+export function insertSliceForLists(_ref) {
+  var _slice$content$firstC;
+  var tr = _ref.tr,
+    slice = _ref.slice,
+    schema = _ref.schema;
+  var selection = tr.selection,
+    _tr$selection = tr.selection,
+    $to = _tr$selection.$to,
+    $from = _tr$selection.$from;
+  var _ref2 = selection,
+    $cursor = _ref2.$cursor;
+  var panelNode = isSelectionInsidePanel(selection);
+  var selectionIsInsideList = $from.blockRange($to, isListNode);
+  if (!$cursor && selectionIsInsideList) {
+    return insertSliceIntoRangeSelectionInsideList({
+      tr: tr,
+      slice: slice
+    });
+  }
+
+  // if inside an empty panel, try and insert content inside it rather than replace it
+  if (panelNode && isEmptyNode(panelNode) && $from.node() === $to.node()) {
+    return insertSliceInsideOfPanelNodeSelected(panelNode)({
+      tr: tr,
+      slice: slice
+    });
+  }
+  if (!$cursor || selectionIsInsideList) {
+    return tr.replaceSelection(slice);
+  }
+  if (isEmptyNode(tr.doc.resolve($cursor.pos).node())) {
+    return insertSliceIntoEmptyNode({
+      tr: tr,
+      slice: slice
+    });
+  }
+
+  // When pasting a single list item into an action or decision, we skip the special "insert at node edge"
+  // logic so that prosemirror pastes the list's content into the action/decision, rather than
+  // pasting a whole list node directly after the action/decision item. (But we still preserve the
+  // existing "insert at" node edge" behaviour if dealing with a list with more than one item, so that
+  // it still inserts whole list node after the action/decision item).
+  var pastingIntoActionOrDecision = Boolean(findParentNodeOfType([schema.nodes.taskList, schema.nodes.decisionList])(selection));
+  var oneListItem = slice.content.childCount === 1 && isListNode(slice.content.firstChild) && ((_slice$content$firstC = slice.content.firstChild) === null || _slice$content$firstC === void 0 ? void 0 : _slice$content$firstC.childCount) === 1;
+  if (!(pastingIntoActionOrDecision && oneListItem) && isCursorSelectionAtTextStartOrEnd(selection)) {
+    return insertSliceAtNodeEdge({
+      tr: tr,
+      slice: slice
+    });
+  }
+  tr.replaceSelection(slice);
+}
+export function insertSliceForListsInsideBlockquote(_ref3) {
+  var tr = _ref3.tr,
+    slice = _ref3.slice;
+  safeInsert(slice.content, tr.selection.$to.pos)(tr).scrollIntoView();
+  // ProseMirror doesn't give a proper way to tell us where something was inserted.
+  // However, we can know "how" it inserted something.
+  //
+  // So, instead of weird depth calculations, we can use the step produced by the transform.
+  // For instance:
+  //    The `replaceStep.to and replaceStep.from`, tell us the real position
+  //    where the content will be insert.
+  //    Then, we can use the `tr.mapping.map` to the updated position after the replace operation
+  var replaceStep = tr.steps[0];
+  if (!(replaceStep instanceof ReplaceStep)) {
+    return tr;
+  }
+  var nextPosition = tr.mapping.map(replaceStep.to);
+  // The findFrom will make search for both: TextSelection and NodeSelections.
+  var nextSelection = Selection.findFrom(tr.doc.resolve(Math.min(nextPosition, tr.doc.content.size)), -1);
+  if (nextSelection) {
+    tr.setSelection(nextSelection);
+  }
+}

package/dist/esm/edge-cases/lists.js

@@ -0,0 +1,98 @@
+import { isEmptyParagraph } from '@atlaskit/editor-common/utils';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { Transform } from '@atlaskit/editor-prosemirror/transform';
+export function insertSliceIntoEmptyNode(_ref) {
+  var tr = _ref.tr,
+    slice = _ref.slice;
+  tr.replaceSelection(slice);
+}
+export function insertSliceAtNodeEdge(_ref2) {
+  var tr = _ref2.tr,
+    slice = _ref2.slice;
+  var selection = tr.selection;
+  var _ref3 = selection,
+    $cursor = _ref3.$cursor;
+  if (!$cursor) {
+    return;
+  }
+  var position = !$cursor.nodeBefore ? $cursor.before() : $cursor.after();
+  tr.replaceRange(position, position, slice);
+  var startSlicePosition = tr.doc.resolve(Math.min(position + slice.content.size - slice.openEnd, tr.doc.content.size));
+  var direction = -1;
+  tr.setSelection(TextSelection.near(startSlicePosition, direction));
+}
+export function insertSliceIntoRangeSelectionInsideList(_ref4) {
+  var tr = _ref4.tr,
+    slice = _ref4.slice;
+  var _tr$selection = tr.selection,
+    $to = _tr$selection.$to,
+    $from = _tr$selection.$from,
+    to = _tr$selection.to,
+    from = _tr$selection.from;
+
+  // when the selection is inside of the same list item
+  // we can use a normal replace
+  if ($from.sameParent($to) || $from.depth === $to.depth) {
+    return tr.replaceSelection(slice);
+  }
+
+  // if pasting a list inside another list, ensure no empty list items get added
+  var newRange = $from.blockRange($to);
+  if (!newRange) {
+    return;
+  }
+  var startPos = from;
+  var endPos = $to.nodeAfter ? to : to + 2;
+  var newSlice = tr.doc.slice(endPos, newRange.end);
+  tr.deleteRange(startPos, newRange.end);
+  var mapped = tr.mapping.map(startPos);
+  tr.replaceRange(mapped, mapped, slice);
+  if (newSlice.size <= 0) {
+    return;
+  }
+  var newSelection = TextSelection.near(tr.doc.resolve(tr.mapping.map(mapped)), -1);
+  // @ts-ignore - [unblock prosemirror bump] assigning to readonly prop
+  newSlice.openEnd = newSlice.openStart;
+  tr.replaceRange(newSelection.from, newSelection.from, newSlice);
+  tr.setSelection(TextSelection.near(tr.doc.resolve(newSelection.from), -1));
+}
+export function insertSliceInsideOfPanelNodeSelected(panelNode) {
+  return function (_ref5) {
+    var tr = _ref5.tr,
+      slice = _ref5.slice;
+    var selection = tr.selection,
+      _tr$selection2 = tr.selection,
+      $to = _tr$selection2.$to,
+      $from = _tr$selection2.$from;
+    var panelPosition = selection.from;
+
+    // if content of slice isn't valid for a panel node, insert the invalid node and following content after
+    if (panelNode && !panelNode.type.validContent(Fragment.from(slice.content))) {
+      var _parentNode$firstChil;
+      var insertPosition = $to.pos + 1;
+      tr.replaceRange(insertPosition, insertPosition, slice);
+      // need to delete the empty paragraph at the top of the panel
+      var parentNode = tr.doc.resolve($from.before()).node();
+      if (parentNode && parentNode.childCount > 1 && ((_parentNode$firstChil = parentNode.firstChild) === null || _parentNode$firstChil === void 0 ? void 0 : _parentNode$firstChil.type.name) === 'paragraph' && isEmptyParagraph(parentNode.firstChild)) {
+        var startPosDelete = tr.doc.resolve($from.before()).posAtIndex(0);
+        var endPosDelete = tr.doc.resolve($from.before()).posAtIndex(1);
+        var SIZE_OF_EMPTY_PARAGRAPH = 2; // {startPos}<p>{startPos + 1}</p>{endPos}
+        if (endPosDelete - startPosDelete === SIZE_OF_EMPTY_PARAGRAPH) {
+          tr.delete(startPosDelete, endPosDelete);
+        }
+      }
+      tr.setSelection(TextSelection.near(tr.doc.resolve(insertPosition + slice.content.size - slice.openStart - slice.openEnd + 1)));
+      return;
+    }
+    var temporaryDoc = new Transform(tr.doc.type.createAndFill());
+    temporaryDoc.replaceRange(0, temporaryDoc.doc.content.size, slice);
+    var sliceWithoutInvalidListSurrounding = temporaryDoc.doc.slice(0);
+    var newPanel = panelNode.copy(sliceWithoutInvalidListSurrounding.content);
+    var panelNodeSelected = selection instanceof NodeSelection ? selection.node : null;
+    var replaceFrom = panelNodeSelected ? panelPosition : tr.doc.resolve(panelPosition).start();
+    var replaceTo = panelNodeSelected ? panelPosition + panelNodeSelected.nodeSize : replaceFrom;
+    tr.replaceRangeWith(replaceFrom, replaceTo, newPanel);
+    tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + newPanel.content.size), -1));
+  };
+}