@atlaskit/editor-core 178.1.0 → 178.1.2

package/dist/es2019/plugins/list/actions/conversions.js

@@ -18,64 +18,57 @@ export function convertListType({
     }
   } = 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
+  } = 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
-
+  }
 
+  // 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
-
+    }
 
+    // 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({
@@ -90,7 +83,6 @@ export function convertListType({
     tr,
     nextListNodeType
   });
-
   if (tr.docChanged) {
     joinSiblingLists({
       tr,
@@ -98,7 +90,6 @@ export function convertListType({
     });
   }
 }
-
 const convertSelectedList = ({
   tr,
   nextListNodeType
@@ -112,10 +103,9 @@ const convertSelectedList = ({
   } = tr;
   const {
     codeBlock
-  } = tr.doc.type.schema.nodes; // get the positions of all the leaf nodes within the selection
-
+  } = 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 {
@@ -125,34 +115,29 @@ const convertSelectedList = ({
       if (!node.isLeaf && !(node.type === codeBlock && node.childCount === 0)) {
         return true;
       }
-
       nodePositions.push(pos);
     });
-  } // use those positions to get the closest parent list nodes
-
+  }
 
+  // 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
-
+    }
 
+    // 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,
@@ -163,17 +148,13 @@ const convertAroundList = ({
     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/plugins/list/actions/indent-list-items-selected.js

@@ -17,34 +17,27 @@ export const indentListItemsSelected = tr => {
   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 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;
@@ -63,13 +56,11 @@ export const indentListItemsSelected = tr => {
   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,
@@ -78,7 +69,6 @@ export const indentListItemsSelected = tr => {
   });
   tr.setSelection(nextSelection);
 };
-
 const calculateRange = ({
   selection
 }) => {
@@ -87,14 +77,11 @@ const calculateRange = ({
     $to
   } = selection;
   const range = $from.blockRange($to, isListNode);
-
   if (!range) {
     return null;
   }
-
   return range;
 };
-
 const calculateNewSelection = ({
   tr,
   normalizedSelection,
@@ -106,16 +93,13 @@ const calculateNewSelection = ({
     $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));
@@ -124,7 +108,6 @@ const calculateNewSelection = ({
   } = Selection.near(tr.doc.resolve($to.pos - offset), -1);
   return new TextSelection(nextSelectionFrom, nextSelectionTo);
 };
-
 const createIndentedListItemsSlice = ({
   tr,
   from,

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

@@ -1,6 +1,7 @@
 import { ReplaceAroundStep } from 'prosemirror-transform';
-import { Fragment, Slice } from 'prosemirror-model'; // adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L206:L231
+import { Fragment, Slice } from 'prosemirror-model';
 
+// adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L206:L231
 export const indentList = tr => {
   const {
     $from,
@@ -10,30 +11,28 @@ export const indentList = tr => {
     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
-
+  }
 
+  // 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
+  // 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
+  }
+
+  // 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;

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

@@ -11,53 +11,44 @@ export const calcJoinListScenario = (walkNode, $head) => {
   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
+  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
+  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/plugins/list/actions/join-list-items-scenarios/join-list-item-with-paragraph.js

@@ -13,56 +13,52 @@ export const joinListItemWithParagraph = ({
     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
+  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
-
+  }
 
+  // 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
-
+  }
 
+  // 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)
-
+  }
 
+  // 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)
-
+  }
 
+  // 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)]);
@@ -71,11 +67,9 @@ export const joinListItemWithParagraph = ({
     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/plugins/list/actions/join-list-items-scenarios/join-list-item-with-parent-nested-list.js

@@ -57,12 +57,11 @@ export const joinListItemWithParentNestedList = ({
    * }
    *
    */
-  const listItemK = $next.parent; //List must have at least one child
 
+  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();

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

@@ -41,19 +41,16 @@ export const joinNestedListWithParentListItem = ({
    * }
    *
    */
+
   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();
@@ -68,7 +65,6 @@ export const joinNestedListWithParentListItem = ({
   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]]);

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

@@ -26,6 +26,7 @@ export const joinParagrapWithList = ({
    * }
    *
    */
+
   const paragraphE = $next.parent;
   const beforeParagraphE = $next.before();
   const afterParagraphE = $next.after();

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

@@ -30,13 +30,12 @@ export const joinSiblingListItems = ({
    * }
    *
    */
+
   const listItemE = $next.parent;
   const paragraphF = $next.nodeAfter; //ListItem must have at least one child
-
   if (!paragraphF) {
     return false;
   }
-
   const beforeListItemE = $next.before();
   const afterListItemE = $next.after();
   const endListItemB = $head.end(-1);

package/dist/es2019/plugins/list/actions/merge-lists.js

@@ -4,26 +4,21 @@ export function mergeNextListAtPosition({
   listPosition
 }) {
   const listNodeAtPosition = tr.doc.nodeAt(listPosition);
-
   if (!isListNode(listNodeAtPosition)) {
     return;
   }
-
   const listPositionResolved = tr.doc.resolve(listPosition + listNodeAtPosition.nodeSize);
   const {
     pos,
     nodeAfter,
     nodeBefore
   } = listPositionResolved;
-
   if (!isListNode(nodeBefore) || !isListNode(nodeAfter)) {
     return;
   }
-
   if ((nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type.name) !== (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type.name)) {
     const previousListPosition = pos - nodeBefore.nodeSize;
     tr.setNodeMarkup(previousListPosition, nodeAfter.type);
   }
-
   tr.join(pos);
 }