@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

package/.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+  rules: {
+    '@typescript-eslint/no-duplicate-imports': 'error',
+    '@typescript-eslint/no-explicit-any': 'error',
+  },
+  overrides: [
+    {
+      files: ['**/__tests__/**/*.{js,ts,tsx}', '**/examples/**/*.{js,ts,tsx}'],
+      rules: {
+        '@typescript-eslint/no-explicit-any': 'off',
+      },
+    },
+  ],
+};

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @atlaskit/editor-plugin-list
 
+## 1.0.0
+
+### Major Changes
+
+- [`8e9c21af71d`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8e9c21af71d) - Extracting list plugin code from editor-core to @atlaskit/editor-plugin-list.
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -4,6 +4,6 @@ List plugin for @atlaskit/editor-core
 
 ## Usage
 
-`import EditorPluginList from '@atlaskit/editor-plugin-list';`
+`import { listPlugin } from '@atlaskit/editor-plugin-list';`
 
 Detailed docs and example usage can be found [here](https://atlaskit.atlassian.com/packages/editor/editor-plugin-list).

package/dist/cjs/actions/conversions.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertListType = convertListType;
+var _lists = require("@atlaskit/editor-common/lists");
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _find = require("../utils/find");
+function convertListType(_ref) {
+  var tr = _ref.tr,
+    nextListNodeType = _ref.nextListNodeType;
+  var doc = tr.doc,
+    _tr$selection = tr.selection,
+    $from = _tr$selection.$from,
+    $to = _tr$selection.$to;
+  var listRange;
+  if (tr.selection instanceof _selection.GapCursorSelection) {
+    var _$from$nodeAfter;
+    var nodeSize = ((_$from$nodeAfter = $from.nodeAfter) === null || _$from$nodeAfter === void 0 ? void 0 : _$from$nodeAfter.nodeSize) || 1;
+    listRange = $from.blockRange($from.doc.resolve($from.pos + nodeSize));
+  } else {
+    listRange = $from.blockRange($to, _utils.isListNode);
+  }
+  if (listRange) {
+    return convertSelectedList({
+      tr: tr,
+      nextListNodeType: nextListNodeType
+    });
+  }
+  var nodeRangeAroundList = $from.blockRange($to);
+  if (!nodeRangeAroundList) {
+    return;
+  }
+  var parentNode = nodeRangeAroundList.parent;
+  var startIndex = nodeRangeAroundList.startIndex,
+    endIndex = nodeRangeAroundList.endIndex,
+    depth = nodeRangeAroundList.depth;
+
+  // Checking for invalid nodes to prevent conversion
+  // eg. a panel cannot be wrapped in a list so return
+  // It will skip this check if the selection begins within a list
+  // This is to match the behaviour of the toolbar buttons being disabled
+  if (!(0, _find.findFirstParentListNode)($from)) {
+    for (var i = startIndex; i < endIndex; i++) {
+      var position = nodeRangeAroundList.$from.posAtIndex(i, depth);
+      var resolvedPosition = doc.resolve(position);
+      var currentChild = parentNode.child(i);
+      var currentNodeRange = resolvedPosition.blockRange(tr.doc.resolve(position + currentChild.nodeSize));
+      if (currentNodeRange && !(0, _utils.isListNode)(currentChild) && !(0, _transform.findWrapping)(currentNodeRange, nextListNodeType)) {
+        return;
+      }
+    }
+  }
+
+  // Checking for any non list nodes and wrapping them in a list
+  // so they can be converted
+  tr.doc.nodesBetween(nodeRangeAroundList.start, nodeRangeAroundList.end, function (node, pos) {
+    // Skip over any nodes that are part of a list
+    if ((0, _find.findFirstParentListNode)(tr.doc.resolve(tr.mapping.map(pos)))) {
+      return false;
+    }
+
+    // The following applies to suitable nodes that are not within a list
+    var currentNodeNotWrappedInList = node;
+    var isNotAnEmptyParagraphAndIsParagraphOrLeafNode = !(0, _utils.isEmptyParagraph)(currentNodeNotWrappedInList) && (!node.type.isBlock || node.type.name === 'paragraph');
+    if (isNotAnEmptyParagraphAndIsParagraphOrLeafNode && nodeRangeAroundList) {
+      var remainingNodeRange = new _model.NodeRange(tr.doc.resolve(tr.mapping.map(pos)), tr.doc.resolve(tr.mapping.map(pos) + currentNodeNotWrappedInList.nodeSize), nodeRangeAroundList.depth);
+      convertAroundList({
+        tr: tr,
+        nextListNodeType: nextListNodeType,
+        nodeRange: remainingNodeRange
+      });
+      return false;
+    }
+  });
+  convertSelectedList({
+    tr: tr,
+    nextListNodeType: nextListNodeType
+  });
+  if (tr.docChanged) {
+    (0, _lists.joinSiblingLists)({
+      tr: tr,
+      forceListType: nextListNodeType
+    });
+  }
+}
+var convertSelectedList = function convertSelectedList(_ref2) {
+  var tr = _ref2.tr,
+    nextListNodeType = _ref2.nextListNodeType;
+  var selection = tr.selection,
+    _tr$selection2 = tr.selection,
+    from = _tr$selection2.from,
+    to = _tr$selection2.to;
+  var codeBlock = tr.doc.type.schema.nodes.codeBlock;
+  // get the positions of all the leaf nodes within the selection
+  var nodePositions = [];
+  if (selection instanceof _state.TextSelection && selection.$cursor || selection instanceof _selection.GapCursorSelection) {
+    nodePositions.push(from);
+  } else {
+    // nodesBetween doesn't return leaf nodes that are outside of from and to
+    tr.doc.nodesBetween(from, to, function (node, pos) {
+      // isLeaf is false for empty codeBlock so adding additional check for childCount
+      if (!node.isLeaf && !(node.type === codeBlock && node.childCount === 0)) {
+        return true;
+      }
+      nodePositions.push(pos);
+    });
+  }
+
+  // use those positions to get the closest parent list nodes
+  nodePositions.reduce(function (acc, pos) {
+    var closestParentListNode = (0, _utils2.findParentNodeClosestToPos)(tr.doc.resolve(pos), _utils.isListNode);
+    if (!closestParentListNode) {
+      return acc;
+    }
+
+    // don't add duplicates if the parent has already been added into the array
+    var existingParent = acc.find(function (node) {
+      return node.pos === closestParentListNode.pos && node.start === closestParentListNode.start && node.depth === closestParentListNode.depth;
+    });
+    if (!existingParent) {
+      acc.push(closestParentListNode);
+    }
+    return acc;
+  }, []).forEach(function (item) {
+    tr.setNodeMarkup(item.pos, nextListNodeType);
+  });
+};
+var convertAroundList = function convertAroundList(_ref3) {
+  var tr = _ref3.tr,
+    nextListNodeType = _ref3.nextListNodeType,
+    nodeRange = _ref3.nodeRange;
+  for (var i = nodeRange.endIndex - 1; i >= nodeRange.startIndex; i--) {
+    // @ts-ignore posAtIndex is a public API but has no type yet
+    var position = nodeRange.$from.posAtIndex(i, nodeRange.depth);
+    var resolvedPos = tr.doc.resolve(position + 1);
+    var range = resolvedPos.blockRange(resolvedPos);
+    if (!range) {
+      return;
+    }
+    var wrappings = (0, _transform.findWrapping)(range, nextListNodeType);
+    if (!range || !wrappings) {
+      return;
+    }
+    tr.wrap(range, wrappings);
+  }
+};

package/dist/cjs/actions/indent-list-items-selected.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indentListItemsSelected = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _lists = require("@atlaskit/editor-common/lists");
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _find = require("../utils/find");
+var indentListItemsSelected = function indentListItemsSelected(tr) {
+  var originalSelection = tr.selection;
+  var normalizedSelection = (0, _lists.normalizeListItemsSelection)({
+    selection: originalSelection,
+    doc: tr.doc
+  });
+  var $from = normalizedSelection.$from,
+    $to = normalizedSelection.$to;
+  var range = calculateRange({
+    selection: normalizedSelection
+  });
+  if (!range) {
+    return false;
+  }
+  var listItemsSelected = {
+    from: (0, _find.findFirstParentListItemNode)($from),
+    to: (0, _find.findFirstParentListItemNode)($to)
+  };
+  if (listItemsSelected.from === null || listItemsSelected.to === null) {
+    return null;
+  }
+  var resolvedPos = tr.doc.resolve(listItemsSelected.from.pos);
+  var listItemIndex = resolvedPos.index();
+  // @ts-ignore
+  var positionListItemPosition = resolvedPos.posAtIndex(listItemIndex - 1);
+  var previousListItem = tr.doc.nodeAt(positionListItemPosition);
+  if (!previousListItem || !(0, _utils.isListItemNode)(previousListItem)) {
+    return null;
+  }
+  if ((0, _utils.isListItemNode)(previousListItem) && listItemIndex === 0) {
+    return null;
+  }
+  var listItemSelectedCommonParent = range.parent;
+  var previousNestedList = (0, _utils.isListNode)(previousListItem.lastChild) ? previousListItem.lastChild : null;
+  var listNodeType = previousNestedList ? previousNestedList.type : listItemSelectedCommonParent.type;
+  var nestedList = listItemsSelected.to.node.lastChild;
+  var nestedItemsOffset = nestedList && (0, _utils.isListNode)(nestedList) ? nestedList.nodeSize : 0;
+  var from = listItemsSelected.from.pos;
+  var to = listItemsSelected.to.pos + listItemsSelected.to.node.nodeSize - nestedItemsOffset;
+  var _createIndentedListIt = createIndentedListItemsSlice({
+      tr: tr,
+      listNodeType: listNodeType,
+      range: range,
+      from: from,
+      to: to
+    }),
+    _createIndentedListIt2 = (0, _slicedToArray2.default)(_createIndentedListIt, 2),
+    sliceSelected = _createIndentedListIt2[0],
+    nestedListItemsLeftover = _createIndentedListIt2[1];
+  var hasPreviousNestedList = Boolean(previousNestedList);
+  var start = from - 1;
+  tr.replaceRange(hasPreviousNestedList ? start - 1 : start, range.end, sliceSelected);
+  var leftoverContentPosition = tr.mapping.map(to) - 2;
+  if (nestedListItemsLeftover.openStart === 0) {
+    tr.insert(leftoverContentPosition, nestedListItemsLeftover.content);
+  } else {
+    tr.replace(leftoverContentPosition - nestedListItemsLeftover.openStart, leftoverContentPosition - nestedListItemsLeftover.openStart, nestedListItemsLeftover);
+  }
+  var nextSelection = calculateNewSelection({
+    originalSelection: originalSelection,
+    normalizedSelection: normalizedSelection,
+    tr: tr,
+    hasPreviousNestedList: hasPreviousNestedList
+  });
+  tr.setSelection(nextSelection);
+};
+exports.indentListItemsSelected = indentListItemsSelected;
+var calculateRange = function calculateRange(_ref) {
+  var selection = _ref.selection;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var range = $from.blockRange($to, _utils.isListNode);
+  if (!range) {
+    return null;
+  }
+  return range;
+};
+var calculateNewSelection = function calculateNewSelection(_ref2) {
+  var tr = _ref2.tr,
+    normalizedSelection = _ref2.normalizedSelection,
+    originalSelection = _ref2.originalSelection,
+    hasPreviousNestedList = _ref2.hasPreviousNestedList;
+  var offset = hasPreviousNestedList ? 2 : 0;
+  var $from = normalizedSelection.$from,
+    $to = normalizedSelection.$to;
+  if (normalizedSelection instanceof _selection.GapCursorSelection) {
+    var _nextSelectionFrom = tr.doc.resolve($from.pos - offset);
+    return new _selection.GapCursorSelection(_nextSelectionFrom, normalizedSelection.side);
+  }
+  if (originalSelection instanceof _state.NodeSelection) {
+    return _state.NodeSelection.create(tr.doc, $from.pos - offset);
+  }
+  var _Selection$near = _state.Selection.near(tr.doc.resolve($from.pos - offset)),
+    nextSelectionFrom = _Selection$near.$from;
+  var _Selection$near2 = _state.Selection.near(tr.doc.resolve($to.pos - offset), -1),
+    nextSelectionTo = _Selection$near2.$to;
+  return new _state.TextSelection(nextSelectionFrom, nextSelectionTo);
+};
+var createIndentedListItemsSlice = function createIndentedListItemsSlice(_ref3) {
+  var tr = _ref3.tr,
+    from = _ref3.from,
+    to = _ref3.to,
+    listNodeType = _ref3.listNodeType,
+    range = _ref3.range;
+  var listItemsSlice = tr.doc.slice(from, to - 2);
+  var listFragment = _model.Fragment.from(listNodeType.create(null, listItemsSlice.content));
+  var nonSelectedListItemsSlice = tr.doc.slice(to, range.end - 2);
+  var openStart = tr.doc.slice(from - 1, range.end).openStart;
+  var slice = new _model.Slice(listFragment, openStart, 0);
+  return [slice, nonSelectedListItemsSlice];
+};

package/dist/cjs/actions/indent-list.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indentList = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+// adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L206:L231
+var indentList = function indentList(tr) {
+  var _tr$selection = tr.selection,
+    $from = _tr$selection.$from,
+    $to = _tr$selection.$to;
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var range = $from.blockRange($to, function (node) {
+    return !!node.childCount && !!node.firstChild && node.firstChild.type === listItem;
+  });
+  if (!range) {
+    return false;
+  }
+
+  // get the index of the selected list item in the list it is part of
+  var startIndex = range.startIndex;
+  if (startIndex === 0) {
+    return false;
+  }
+
+  // get the parent list of the list item(s) in the selected range
+  var parent = range.parent;
+
+  // get the list immediately before the selection start
+  var previousListItem = parent.child(startIndex - 1);
+  if (previousListItem.type !== listItem) {
+    return false;
+  }
+
+  // if that list was nested, join the selected list items into the same
+  // nested list; if not, create a new child list of the same type and
+  // nest it under the current level
+  var isPreviousListNested = previousListItem.lastChild && ['bulletList', 'orderedList'].includes(previousListItem.lastChild.type.name);
+  var inner = _model.Fragment.from(isPreviousListNested ? listItem.create() : undefined);
+  var nextListNodeType = isPreviousListNested ? previousListItem.lastChild.type : parent.type;
+  var nextListNodeContent = _model.Fragment.from(nextListNodeType.create(null, inner));
+  var slice = new _model.Slice(_model.Fragment.from(listItem.create(null, nextListNodeContent)), isPreviousListNested ? 3 : 1, 0);
+  var before = range.start;
+  var after = range.end;
+  tr.step(new _transform.ReplaceAroundStep(before - (isPreviousListNested ? 3 : 1), after, before, after, slice, 1, true));
+};
+exports.indentList = indentList;

package/dist/cjs/actions/join-list-items-forward.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcJoinListScenario = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _utils = require("@atlaskit/editor-common/utils");
+var _selection = require("../utils/selection");
+var _joinListItemsScenarios = require("./join-list-items-scenarios");
+var calcJoinListScenario = function calcJoinListScenario(walkNode, $head) {
+  var $next = walkNode.$pos,
+    nextFoundNode = walkNode.foundNode;
+  var headParent = $head.parent;
+  var headGrandParent = $head.node(-1);
+  var headInList = (0, _selection.isPosInsideList)($head);
+  var headInParagraph = (0, _selection.isPosInsideParagraph)($head);
+  var headInLastNonListChild = headGrandParent && headGrandParent.lastChild && (headGrandParent.lastChild === headParent || headGrandParent.childCount > 1 && headGrandParent.child(headGrandParent.childCount - 2) === headParent &&
+  //find the second last child if a list item may be the last child
+  (0, _utils.isListNode)(headGrandParent.lastChild));
+  var nextInList = (0, _selection.isPosInsideList)($next);
+  var nextInParagraph = (0, _selection.isPosInsideParagraph)($next);
+  if (!headInList && headInParagraph && nextInList) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_LIST_ITEM_WITH_PARAGRAPH, _joinListItemsScenarios.joinListItemWithParagraph];
+  }
+  if (!nextFoundNode || !headInList || !headInParagraph || !headInLastNonListChild) {
+    return false;
+  }
+  if (!nextInList && nextInParagraph) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_PARAGRAPH_WITH_LIST, _joinListItemsScenarios.joinParagrapWithList];
+  }
+  if (!nextInList) {
+    return false;
+  }
+  var nextNodeAfter = $next.nodeAfter;
+  var nextGrandParent = $next.node(-1);
+  var headGreatGrandParent = $head.node(-2);
+  var nextInListItem = (0, _utils.isListItemNode)($next.parent);
+  var nextNodeAfterListItem = (0, _utils.isListItemNode)(nextNodeAfter);
+  var nextListItemHasFirstChildParagraph = nextNodeAfter &&
+  //Redundant check but the linter complains otherwise
+  nextNodeAfterListItem && (0, _utils.isParagraphNode)(nextNodeAfter.firstChild);
+  if (!nextInListItem && nextListItemHasFirstChildParagraph) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT, _joinListItemsScenarios.joinNestedListWithParentListItem];
+  }
+  if (!nextInListItem) {
+    return false;
+  }
+  var nextParentSiblingOfHeadParent = nextGrandParent && nextGrandParent === headGreatGrandParent;
+  var nextNodeAfterIsParagraph = (0, _utils.isParagraphNode)(nextNodeAfter);
+  if (!nextNodeAfterIsParagraph) {
+    return false;
+  }
+  if (nextParentSiblingOfHeadParent) {
+    return [_analytics.LIST_TEXT_SCENARIOS.JOIN_SIBLINGS, _joinListItemsScenarios.joinSiblingListItems];
+  }
+  return [_analytics.LIST_TEXT_SCENARIOS.JOIN_PARENT_SIBLING_TO_PARENT_CHILD, _joinListItemsScenarios.joinListItemWithParentNestedList];
+};
+exports.calcJoinListScenario = calcJoinListScenario;

package/dist/cjs/actions/join-list-items-scenarios/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "joinListItemWithParagraph", {
+  enumerable: true,
+  get: function get() {
+    return _joinListItemWithParagraph.joinListItemWithParagraph;
+  }
+});
+Object.defineProperty(exports, "joinListItemWithParentNestedList", {
+  enumerable: true,
+  get: function get() {
+    return _joinListItemWithParentNestedList.joinListItemWithParentNestedList;
+  }
+});
+Object.defineProperty(exports, "joinNestedListWithParentListItem", {
+  enumerable: true,
+  get: function get() {
+    return _joinNestedListWithParentListItem.joinNestedListWithParentListItem;
+  }
+});
+Object.defineProperty(exports, "joinParagrapWithList", {
+  enumerable: true,
+  get: function get() {
+    return _joinParagraphWithList.joinParagrapWithList;
+  }
+});
+Object.defineProperty(exports, "joinSiblingListItems", {
+  enumerable: true,
+  get: function get() {
+    return _joinSiblingListItems.joinSiblingListItems;
+  }
+});
+var _joinParagraphWithList = require("./join-paragraph-with-list");
+var _joinSiblingListItems = require("./join-sibling-list-items");
+var _joinNestedListWithParentListItem = require("./join-nested-list-with-parent-list-item");
+var _joinListItemWithParentNestedList = require("./join-list-item-with-parent-nested-list");
+var _joinListItemWithParagraph = require("./join-list-item-with-paragraph");

package/dist/cjs/actions/join-list-items-scenarios/join-list-item-with-paragraph.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinListItemWithParagraph = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+// Case for when a users selection is at the end of a paragraph, the paragraph
+// is followed by a list, and they delete forward
+var joinListItemWithParagraph = function joinListItemWithParagraph(_ref) {
+  var tr = _ref.tr,
+    $next = _ref.$next,
+    $head = _ref.$head;
+  // For empty paragraphs before a list
+  if ($head.parent.content.size < 1) {
+    (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+      return tr.doc.resolve($head.pos);
+    }, [], [[$head.pos - 1, $head.pos]]);
+    return true;
+  }
+  var paragraphPosition = $head.pos;
+  var list = tr.doc.nodeAt($next.pos - 1);
+  var firstListItem = tr.doc.nodeAt($next.pos);
+  if (!list || !firstListItem) {
+    return false;
+  }
+  var firstChildNodeOfFirstListItem = firstListItem.firstChild;
+  if (!firstChildNodeOfFirstListItem) {
+    return false;
+  }
+  var lastChildOfFirstListItem = firstListItem.lastChild;
+  var firstGrandchildOfFirstListItem = firstChildNodeOfFirstListItem.firstChild;
+  var firstListItemHasOneChildWithNoNestedLists = hasSingleChild(firstListItem) && firstChildNodeOfFirstListItem.childCount < 2 && $next.nodeAfter;
+  var firstListItemContainsParagraphAndNestedList = !hasSingleChild(firstListItem) && lastChildOfFirstListItem && (0, _utils.isListNode)(lastChildOfFirstListItem);
+  var insertions = [];
+  var deletions = [];
+
+  // For lists that only have one list item with no children - need to remove remaining list
+  if (hasSingleChild(list) && hasSingleChild(firstListItem) && $next.nodeAfter) {
+    deletions.push([tr.mapping.map($next.pos - 1), tr.mapping.map($next.pos + $next.nodeAfter.nodeSize + 1)]);
+  }
+
+  // For first list items that have a paragraph and a list
+  if (firstListItemContainsParagraphAndNestedList) {
+    var firstListItemNestedList = _model.Fragment.from(lastChildOfFirstListItem.content);
+    insertions.push([firstListItemNestedList, tr.mapping.map($next.pos)]);
+  }
+
+  // For first list item has one child & no nested lists OR first list items that have a paragraph and a list
+  if (firstListItemHasOneChildWithNoNestedLists || firstListItemContainsParagraphAndNestedList) {
+    deletions.push([tr.mapping.map($next.pos), tr.mapping.map($next.pos + firstListItem.nodeSize - 1)]);
+    var firstListItemText = _model.Fragment.from(firstChildNodeOfFirstListItem.content);
+    insertions.push([firstListItemText, paragraphPosition]);
+    (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+      return tr.doc.resolve($head.pos);
+    }, insertions, deletions);
+    return true;
+  }
+
+  // For any first list items that have multiple children (eg. multiple paragraphs)
+  if (firstListItem.childCount > 1) {
+    insertions.push([_model.Fragment.from(firstChildNodeOfFirstListItem.content), paragraphPosition]);
+    deletions.push([tr.mapping.map($next.pos + 1), tr.mapping.map($next.pos + firstChildNodeOfFirstListItem.nodeSize + 1)]);
+    (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+      return tr.doc.resolve($head.pos);
+    }, insertions, deletions);
+    return true;
+  }
+
+  // For any remaining first list items that have a single child (eg. single paragraph, multiple lines of text)
+  if (firstGrandchildOfFirstListItem && firstGrandchildOfFirstListItem.type.name === 'hardBreak') {
+    var nodeSizeOfGrandchild = firstGrandchildOfFirstListItem ? firstGrandchildOfFirstListItem.nodeSize : 0;
+    deletions.push([tr.mapping.map($next.pos + 2), tr.mapping.map($next.pos + 2 + nodeSizeOfGrandchild)]);
+  } else {
+    insertions.push([_model.Fragment.from(firstChildNodeOfFirstListItem.content), paragraphPosition]);
+    var nodeSizeOfFirstChild = firstChildNodeOfFirstListItem.nodeSize;
+    deletions.push([tr.mapping.map($next.pos), tr.mapping.map($next.pos + 2 + nodeSizeOfFirstChild)]);
+  }
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve($head.pos);
+  }, insertions, deletions);
+  return true;
+};
+exports.joinListItemWithParagraph = joinListItemWithParagraph;
+var hasSingleChild = function hasSingleChild(node) {
+  return node.childCount === 1;
+};

package/dist/cjs/actions/join-list-items-scenarios/join-list-item-with-parent-nested-list.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinListItemWithParentNestedList = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+//Case for two adjacent list items with the first being of greater indentation
+var joinListItemWithParentNestedList = function joinListItemWithParentNestedList(_ref) {
+  var tr = _ref.tr,
+    $next = _ref.$next,
+    $head = _ref.$head;
+  /* CASE 4
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     Paragraph C { text1 }
+   *     ...Children D
+   *     List E {
+   *       ...
+   *         List F {       //May be multiple levels of lists
+   *           ...Children G
+   *           ListItem H {        //Last node of the block
+   *             ...Children I
+   *             Paragraph J { text2 |$head||textInsertPos| } |childrenMInsertPos|        //Cant have children since this ListItem is the last of the block
+   *           }
+   *         }
+   *       ...
+   *     |childrenOInsertPos| }
+   *   }
+   *   ListItem K { |$next|
+   *      Paragraph L { text3 }
+   *      ...Children M
+   *      List? N {
+   *       ...Children O
+   *      }
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     Paragraph C { text1 }
+   *     ...Children D
+   *     List E {
+   *       ...
+   *         List F {
+   *           ...Children G
+   *           ListItem H {
+   *             ...Children I
+   *             Paragraph J { text2text3 }
+   *             ...Children M
+   *           }
+   *         }
+   *       ...
+   *       ...Children O
+   *     }
+   *   }
+   * }
+   *
+   */
+
+  var listItemK = $next.parent; //List must have at least one child
+  if (!listItemK.firstChild || !listItemK.lastChild) {
+    return false;
+  }
+  var beforeListItemK = $next.before();
+  var afterListItemB = $next.before();
+  var afterListItemK = $next.after();
+  var containsChildrenO = (0, _utils.isListNode)(listItemK.lastChild);
+  var textInsertPos = $head.pos;
+  var childrenMInsertPos = $head.pos + 1;
+  var childrenOInsertPos = afterListItemB - 2;
+  var textContent = listItemK.firstChild.content;
+  var childrenMContent = containsChildrenO ? listItemK.content.cut(listItemK.firstChild.nodeSize, listItemK.nodeSize - listItemK.lastChild.nodeSize - 2 //Get the position before
+  ) : listItemK.content.cut(listItemK.firstChild.nodeSize);
+  var childrenOContent = listItemK.lastChild.content;
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, containsChildrenO ? [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos], [childrenOContent, childrenOInsertPos]] : [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos]], [[beforeListItemK, afterListItemK]]);
+  return true;
+};
+exports.joinListItemWithParentNestedList = joinListItemWithParentNestedList;