@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

package/dist/es2019/actions/conversions.js

@@ -0,0 +1,160 @@
+import { joinSiblingLists } from '@atlaskit/editor-common/lists';
+import { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { isEmptyParagraph, isListNode } from '@atlaskit/editor-common/utils';
+import { NodeRange } from '@atlaskit/editor-prosemirror/model';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+import { findFirstParentListNode } from '../utils/find';
+export function convertListType({
+  tr,
+  nextListNodeType
+}) {
+  const {
+    doc,
+    selection: {
+      $from,
+      $to
+    }
+  } = tr;
+  let listRange;
+  if (tr.selection instanceof GapCursorSelection) {
+    var _$from$nodeAfter;
+    const 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, isListNode);
+  }
+  if (listRange) {
+    return convertSelectedList({
+      tr,
+      nextListNodeType
+    });
+  }
+  let nodeRangeAroundList = $from.blockRange($to);
+  if (!nodeRangeAroundList) {
+    return;
+  }
+  const parentNode = nodeRangeAroundList.parent;
+  const {
+    startIndex,
+    endIndex,
+    depth
+  } = nodeRangeAroundList;
+
+  // 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 (!findFirstParentListNode($from)) {
+    for (let i = startIndex; i < endIndex; i++) {
+      const position = nodeRangeAroundList.$from.posAtIndex(i, depth);
+      const resolvedPosition = doc.resolve(position);
+      const currentChild = parentNode.child(i);
+      const currentNodeRange = resolvedPosition.blockRange(tr.doc.resolve(position + currentChild.nodeSize));
+      if (currentNodeRange && !isListNode(currentChild) && !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, (node, pos) => {
+    // Skip over any nodes that are part of a list
+    if (findFirstParentListNode(tr.doc.resolve(tr.mapping.map(pos)))) {
+      return false;
+    }
+
+    // The following applies to suitable nodes that are not within a list
+    const currentNodeNotWrappedInList = node;
+    const isNotAnEmptyParagraphAndIsParagraphOrLeafNode = !isEmptyParagraph(currentNodeNotWrappedInList) && (!node.type.isBlock || node.type.name === 'paragraph');
+    if (isNotAnEmptyParagraphAndIsParagraphOrLeafNode && nodeRangeAroundList) {
+      const remainingNodeRange = new NodeRange(tr.doc.resolve(tr.mapping.map(pos)), tr.doc.resolve(tr.mapping.map(pos) + currentNodeNotWrappedInList.nodeSize), nodeRangeAroundList.depth);
+      convertAroundList({
+        tr,
+        nextListNodeType,
+        nodeRange: remainingNodeRange
+      });
+      return false;
+    }
+  });
+  convertSelectedList({
+    tr,
+    nextListNodeType
+  });
+  if (tr.docChanged) {
+    joinSiblingLists({
+      tr,
+      forceListType: nextListNodeType
+    });
+  }
+}
+const convertSelectedList = ({
+  tr,
+  nextListNodeType
+}) => {
+  const {
+    selection,
+    selection: {
+      from,
+      to
+    }
+  } = tr;
+  const {
+    codeBlock
+  } = tr.doc.type.schema.nodes;
+  // get the positions of all the leaf nodes within the selection
+  const nodePositions = [];
+  if (selection instanceof TextSelection && selection.$cursor || selection instanceof GapCursorSelection) {
+    nodePositions.push(from);
+  } else {
+    // nodesBetween doesn't return leaf nodes that are outside of from and to
+    tr.doc.nodesBetween(from, to, (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((acc, pos) => {
+    const closestParentListNode = findParentNodeClosestToPos(tr.doc.resolve(pos), isListNode);
+    if (!closestParentListNode) {
+      return acc;
+    }
+
+    // don't add duplicates if the parent has already been added into the array
+    const existingParent = acc.find(node => {
+      return node.pos === closestParentListNode.pos && node.start === closestParentListNode.start && node.depth === closestParentListNode.depth;
+    });
+    if (!existingParent) {
+      acc.push(closestParentListNode);
+    }
+    return acc;
+  }, []).forEach(item => {
+    tr.setNodeMarkup(item.pos, nextListNodeType);
+  });
+};
+const convertAroundList = ({
+  tr,
+  nextListNodeType,
+  nodeRange
+}) => {
+  for (let i = nodeRange.endIndex - 1; i >= nodeRange.startIndex; i--) {
+    // @ts-ignore posAtIndex is a public API but has no type yet
+    const position = nodeRange.$from.posAtIndex(i, nodeRange.depth);
+    const resolvedPos = tr.doc.resolve(position + 1);
+    const range = resolvedPos.blockRange(resolvedPos);
+    if (!range) {
+      return;
+    }
+    const wrappings = findWrapping(range, nextListNodeType);
+    if (!range || !wrappings) {
+      return;
+    }
+    tr.wrap(range, wrappings);
+  }
+};

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

@@ -0,0 +1,124 @@
+import { normalizeListItemsSelection } from '@atlaskit/editor-common/lists';
+import { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { isListItemNode, isListNode } from '@atlaskit/editor-common/utils';
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findFirstParentListItemNode } from '../utils/find';
+export const indentListItemsSelected = tr => {
+  const originalSelection = tr.selection;
+  const normalizedSelection = normalizeListItemsSelection({
+    selection: originalSelection,
+    doc: tr.doc
+  });
+  const {
+    $from,
+    $to
+  } = normalizedSelection;
+  const range = calculateRange({
+    selection: normalizedSelection
+  });
+  if (!range) {
+    return false;
+  }
+  const listItemsSelected = {
+    from: findFirstParentListItemNode($from),
+    to: findFirstParentListItemNode($to)
+  };
+  if (listItemsSelected.from === null || listItemsSelected.to === null) {
+    return null;
+  }
+  const resolvedPos = tr.doc.resolve(listItemsSelected.from.pos);
+  const listItemIndex = resolvedPos.index();
+  // @ts-ignore
+  const positionListItemPosition = resolvedPos.posAtIndex(listItemIndex - 1);
+  const previousListItem = tr.doc.nodeAt(positionListItemPosition);
+  if (!previousListItem || !isListItemNode(previousListItem)) {
+    return null;
+  }
+  if (isListItemNode(previousListItem) && listItemIndex === 0) {
+    return null;
+  }
+  const listItemSelectedCommonParent = range.parent;
+  const previousNestedList = isListNode(previousListItem.lastChild) ? previousListItem.lastChild : null;
+  const listNodeType = previousNestedList ? previousNestedList.type : listItemSelectedCommonParent.type;
+  const nestedList = listItemsSelected.to.node.lastChild;
+  const nestedItemsOffset = nestedList && isListNode(nestedList) ? nestedList.nodeSize : 0;
+  const from = listItemsSelected.from.pos;
+  const to = listItemsSelected.to.pos + listItemsSelected.to.node.nodeSize - nestedItemsOffset;
+  const [sliceSelected, nestedListItemsLeftover] = createIndentedListItemsSlice({
+    tr,
+    listNodeType,
+    range,
+    from,
+    to
+  });
+  const hasPreviousNestedList = Boolean(previousNestedList);
+  const start = from - 1;
+  tr.replaceRange(hasPreviousNestedList ? start - 1 : start, range.end, sliceSelected);
+  const 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);
+  }
+  const nextSelection = calculateNewSelection({
+    originalSelection,
+    normalizedSelection,
+    tr,
+    hasPreviousNestedList
+  });
+  tr.setSelection(nextSelection);
+};
+const calculateRange = ({
+  selection
+}) => {
+  const {
+    $from,
+    $to
+  } = selection;
+  const range = $from.blockRange($to, isListNode);
+  if (!range) {
+    return null;
+  }
+  return range;
+};
+const calculateNewSelection = ({
+  tr,
+  normalizedSelection,
+  originalSelection,
+  hasPreviousNestedList
+}) => {
+  const offset = hasPreviousNestedList ? 2 : 0;
+  const {
+    $from,
+    $to
+  } = normalizedSelection;
+  if (normalizedSelection instanceof GapCursorSelection) {
+    const nextSelectionFrom = tr.doc.resolve($from.pos - offset);
+    return new GapCursorSelection(nextSelectionFrom, normalizedSelection.side);
+  }
+  if (originalSelection instanceof NodeSelection) {
+    return NodeSelection.create(tr.doc, $from.pos - offset);
+  }
+  const {
+    $from: nextSelectionFrom
+  } = Selection.near(tr.doc.resolve($from.pos - offset));
+  const {
+    $to: nextSelectionTo
+  } = Selection.near(tr.doc.resolve($to.pos - offset), -1);
+  return new TextSelection(nextSelectionFrom, nextSelectionTo);
+};
+const createIndentedListItemsSlice = ({
+  tr,
+  from,
+  to,
+  listNodeType,
+  range
+}) => {
+  const listItemsSlice = tr.doc.slice(from, to - 2);
+  const listFragment = Fragment.from(listNodeType.create(null, listItemsSlice.content));
+  const nonSelectedListItemsSlice = tr.doc.slice(to, range.end - 2);
+  const openStart = tr.doc.slice(from - 1, range.end).openStart;
+  const slice = new Slice(listFragment, openStart, 0);
+  return [slice, nonSelectedListItemsSlice];
+};

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

@@ -0,0 +1,44 @@
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { ReplaceAroundStep } from '@atlaskit/editor-prosemirror/transform';
+
+// adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L206:L231
+export const indentList = tr => {
+  const {
+    $from,
+    $to
+  } = tr.selection;
+  const {
+    listItem
+  } = tr.doc.type.schema.nodes;
+  const range = $from.blockRange($to, node => !!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
+  const startIndex = range.startIndex;
+  if (startIndex === 0) {
+    return false;
+  }
+
+  // get the parent list of the list item(s) in the selected range
+  const parent = range.parent;
+
+  // get the list immediately before the selection start
+  const 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
+  const isPreviousListNested = previousListItem.lastChild && ['bulletList', 'orderedList'].includes(previousListItem.lastChild.type.name);
+  const inner = Fragment.from(isPreviousListNested ? listItem.create() : undefined);
+  const nextListNodeType = isPreviousListNested ? previousListItem.lastChild.type : parent.type;
+  const nextListNodeContent = Fragment.from(nextListNodeType.create(null, inner));
+  const slice = new Slice(Fragment.from(listItem.create(null, nextListNodeContent)), isPreviousListNested ? 3 : 1, 0);
+  const before = range.start;
+  const after = range.end;
+  tr.step(new ReplaceAroundStep(before - (isPreviousListNested ? 3 : 1), after, before, after, slice, 1, true));
+};

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

@@ -0,0 +1,54 @@
+import { LIST_TEXT_SCENARIOS } from '@atlaskit/editor-common/analytics';
+import { isListItemNode, isListNode, isParagraphNode } from '@atlaskit/editor-common/utils';
+import { isPosInsideList, isPosInsideParagraph } from '../utils/selection';
+import { joinListItemWithParagraph, joinListItemWithParentNestedList, joinNestedListWithParentListItem, joinParagrapWithList, joinSiblingListItems } from './join-list-items-scenarios';
+export const calcJoinListScenario = (walkNode, $head) => {
+  const {
+    $pos: $next,
+    foundNode: nextFoundNode
+  } = walkNode;
+  const headParent = $head.parent;
+  const headGrandParent = $head.node(-1);
+  const headInList = isPosInsideList($head);
+  const headInParagraph = isPosInsideParagraph($head);
+  const 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
+  isListNode(headGrandParent.lastChild));
+  const nextInList = isPosInsideList($next);
+  const nextInParagraph = isPosInsideParagraph($next);
+  if (!headInList && headInParagraph && nextInList) {
+    return [LIST_TEXT_SCENARIOS.JOIN_LIST_ITEM_WITH_PARAGRAPH, joinListItemWithParagraph];
+  }
+  if (!nextFoundNode || !headInList || !headInParagraph || !headInLastNonListChild) {
+    return false;
+  }
+  if (!nextInList && nextInParagraph) {
+    return [LIST_TEXT_SCENARIOS.JOIN_PARAGRAPH_WITH_LIST, joinParagrapWithList];
+  }
+  if (!nextInList) {
+    return false;
+  }
+  const nextNodeAfter = $next.nodeAfter;
+  const nextGrandParent = $next.node(-1);
+  const headGreatGrandParent = $head.node(-2);
+  const nextInListItem = isListItemNode($next.parent);
+  const nextNodeAfterListItem = isListItemNode(nextNodeAfter);
+  const nextListItemHasFirstChildParagraph = nextNodeAfter &&
+  //Redundant check but the linter complains otherwise
+  nextNodeAfterListItem && isParagraphNode(nextNodeAfter.firstChild);
+  if (!nextInListItem && nextListItemHasFirstChildParagraph) {
+    return [LIST_TEXT_SCENARIOS.JOIN_DESCENDANT_TO_PARENT, joinNestedListWithParentListItem];
+  }
+  if (!nextInListItem) {
+    return false;
+  }
+  const nextParentSiblingOfHeadParent = nextGrandParent && nextGrandParent === headGreatGrandParent;
+  const nextNodeAfterIsParagraph = isParagraphNode(nextNodeAfter);
+  if (!nextNodeAfterIsParagraph) {
+    return false;
+  }
+  if (nextParentSiblingOfHeadParent) {
+    return [LIST_TEXT_SCENARIOS.JOIN_SIBLINGS, joinSiblingListItems];
+  }
+  return [LIST_TEXT_SCENARIOS.JOIN_PARENT_SIBLING_TO_PARENT_CHILD, joinListItemWithParentNestedList];
+};

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

@@ -0,0 +1,5 @@
+export { joinParagrapWithList } from './join-paragraph-with-list';
+export { joinSiblingListItems } from './join-sibling-list-items';
+export { joinNestedListWithParentListItem } from './join-nested-list-with-parent-list-item';
+export { joinListItemWithParentNestedList } from './join-list-item-with-parent-nested-list';
+export { joinListItemWithParagraph } from './join-list-item-with-paragraph';

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

@@ -0,0 +1,74 @@
+import { insertContentDeleteRange, isListNode } from '@atlaskit/editor-common/utils';
+import { Fragment } from '@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
+export const joinListItemWithParagraph = ({
+  tr,
+  $next,
+  $head
+}) => {
+  // For empty paragraphs before a list
+  if ($head.parent.content.size < 1) {
+    insertContentDeleteRange(tr, tr => tr.doc.resolve($head.pos), [], [[$head.pos - 1, $head.pos]]);
+    return true;
+  }
+  const paragraphPosition = $head.pos;
+  const list = tr.doc.nodeAt($next.pos - 1);
+  const firstListItem = tr.doc.nodeAt($next.pos);
+  if (!list || !firstListItem) {
+    return false;
+  }
+  const firstChildNodeOfFirstListItem = firstListItem.firstChild;
+  if (!firstChildNodeOfFirstListItem) {
+    return false;
+  }
+  const lastChildOfFirstListItem = firstListItem.lastChild;
+  const firstGrandchildOfFirstListItem = firstChildNodeOfFirstListItem.firstChild;
+  const firstListItemHasOneChildWithNoNestedLists = hasSingleChild(firstListItem) && firstChildNodeOfFirstListItem.childCount < 2 && $next.nodeAfter;
+  const firstListItemContainsParagraphAndNestedList = !hasSingleChild(firstListItem) && lastChildOfFirstListItem && isListNode(lastChildOfFirstListItem);
+  const insertions = [];
+  const 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) {
+    const firstListItemNestedList = 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)]);
+    const firstListItemText = Fragment.from(firstChildNodeOfFirstListItem.content);
+    insertions.push([firstListItemText, paragraphPosition]);
+    insertContentDeleteRange(tr, tr => 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([Fragment.from(firstChildNodeOfFirstListItem.content), paragraphPosition]);
+    deletions.push([tr.mapping.map($next.pos + 1), tr.mapping.map($next.pos + firstChildNodeOfFirstListItem.nodeSize + 1)]);
+    insertContentDeleteRange(tr, tr => 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') {
+    const nodeSizeOfGrandchild = firstGrandchildOfFirstListItem ? firstGrandchildOfFirstListItem.nodeSize : 0;
+    deletions.push([tr.mapping.map($next.pos + 2), tr.mapping.map($next.pos + 2 + nodeSizeOfGrandchild)]);
+  } else {
+    insertions.push([Fragment.from(firstChildNodeOfFirstListItem.content), paragraphPosition]);
+    const nodeSizeOfFirstChild = firstChildNodeOfFirstListItem.nodeSize;
+    deletions.push([tr.mapping.map($next.pos), tr.mapping.map($next.pos + 2 + nodeSizeOfFirstChild)]);
+  }
+  insertContentDeleteRange(tr, tr => tr.doc.resolve($head.pos), insertions, deletions);
+  return true;
+};
+const hasSingleChild = node => {
+  return node.childCount === 1;
+};

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

@@ -0,0 +1,77 @@
+import { insertContentDeleteRange, isListNode } from '@atlaskit/editor-common/utils';
+//Case for two adjacent list items with the first being of greater indentation
+export const joinListItemWithParentNestedList = ({
+  tr,
+  $next,
+  $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
+   *     }
+   *   }
+   * }
+   *
+   */
+
+  const listItemK = $next.parent; //List must have at least one child
+  if (!listItemK.firstChild || !listItemK.lastChild) {
+    return false;
+  }
+  const beforeListItemK = $next.before();
+  const afterListItemB = $next.before();
+  const afterListItemK = $next.after();
+  const containsChildrenO = isListNode(listItemK.lastChild);
+  const textInsertPos = $head.pos;
+  const childrenMInsertPos = $head.pos + 1;
+  const childrenOInsertPos = afterListItemB - 2;
+  const textContent = listItemK.firstChild.content;
+  const childrenMContent = containsChildrenO ? listItemK.content.cut(listItemK.firstChild.nodeSize, listItemK.nodeSize - listItemK.lastChild.nodeSize - 2 //Get the position before
+  ) : listItemK.content.cut(listItemK.firstChild.nodeSize);
+  const childrenOContent = listItemK.lastChild.content;
+  insertContentDeleteRange(tr, tr => tr.doc.resolve(textInsertPos), containsChildrenO ? [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos], [childrenOContent, childrenOInsertPos]] : [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos]], [[beforeListItemK, afterListItemK]]);
+  return true;
+};

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

@@ -0,0 +1,71 @@
+import { insertContentDeleteRange, isListNode } from '@atlaskit/editor-common/utils';
+//Case for two adjacent list items with the first being of lower indentation
+export const joinNestedListWithParentListItem = ({
+  tr,
+  $next,
+  $head
+}) => {
+  /* CASE 3
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |$head||textInsertPos| } |childrenHInsertPos|
+   *     List E { |$next||childrenJInsertPos|
+   *       ListItem F {
+   *         Paragraph G { text2 }
+   *         ...Children H
+   *         List? I {
+   *           ...Children J
+   *         }
+   *       }
+   *       ...Children K
+   *     }
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1text2 }
+   *     ...Children H
+   *     List E {
+   *       ...Children J
+   *       ...Children K
+   *     }
+   *   }
+   * }
+   *
+   */
+
+  const listE = $next.parent;
+  const listItemF = $next.nodeAfter; //We know next is before a ListItem. ListItem must have at least one child
+  if (!listItemF || !listItemF.lastChild) {
+    return false;
+  }
+  const paragraphG = listItemF.firstChild; //ListItem must have at least one child
+  if (!paragraphG) {
+    return false;
+  }
+  const beforeListE = $next.before();
+  const beforeListItemF = $next.pos;
+  const afterParagraphD = $head.after();
+  const afterListE = $next.after();
+  const afterListItemF = tr.doc.resolve($next.pos + 1).after(); //List must always have at least one listItem
+
+  const containsChildrenJ = isListNode(listItemF.lastChild);
+  const shouldRemoveListE = listE.childCount === 1 && !containsChildrenJ; //Assures no Children J and K
+
+  const textInsertPos = $head.pos;
+  const childrenHInsertPos = afterParagraphD;
+  const childrenJInsertPos = $next.pos;
+  const textContent = paragraphG.content;
+  const childrenHContent = containsChildrenJ ? listItemF.content.cut(paragraphG.nodeSize, listItemF.nodeSize - listItemF.lastChild.nodeSize - 2) : listItemF.content.cut(paragraphG.nodeSize); //If Children J doesn't exist then Children H will include the last node
+  const childrenJContent = listItemF.lastChild.content; //Will be invalid if there are no Children J but it will be unused
+
+  insertContentDeleteRange(tr, tr => tr.doc.resolve(textInsertPos), containsChildrenJ ? [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos], [childrenJContent, childrenJInsertPos]] : [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos]], [shouldRemoveListE ? [beforeListE, afterListE] : [beforeListItemF, afterListItemF]]);
+  return true;
+};

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

@@ -0,0 +1,37 @@
+import { insertContentDeleteRange } from '@atlaskit/editor-common/utils';
+//Case for two adjacent nodes with the first being a list item and the last being a paragraph
+export const joinParagrapWithList = ({
+  tr,
+  $next,
+  $head
+}) => {
+  /* CASE 1
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |$head||textInsertPos| }
+   *   }
+   * }
+   * Paragraph E { |$next| text 2 }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1text2 }
+   *   }
+   * }
+   *
+   */
+
+  const paragraphE = $next.parent;
+  const beforeParagraphE = $next.before();
+  const afterParagraphE = $next.after();
+  const textInsertPos = $head.pos;
+  const textContent = paragraphE.content;
+  insertContentDeleteRange(tr, tr => tr.doc.resolve(textInsertPos), [[textContent, textInsertPos]], [[beforeParagraphE, afterParagraphE]]);
+  return true;
+};