@atlaskit/editor-core 178.1.0 → 178.1.2

package/dist/es2019/plugins/list/actions/outdent-list-items-selected.js

@@ -14,17 +14,13 @@ export const outdentListItemsSelected = (tr, state) => {
     doc: tr.doc
   });
   const rootList = findRootParentListNode(normalizedSelection.$from);
-
   if (!rootList) {
     return;
   }
-
   const commonList = normalizedSelection.$from.blockRange(rootList, isListNode);
-
   if (!commonList) {
     return;
   }
-
   let hasNormalizedToPositionLiftedOut = false;
   let hasNormalizedFromPositionLiftedOut = false;
   const {
@@ -36,11 +32,9 @@ export const outdentListItemsSelected = (tr, state) => {
     const $from = tr.doc.resolve(tr.mapping.map(range.from));
     const $to = tr.doc.resolve(tr.mapping.map(range.to));
     const mappedRange = $from.blockRange($to, isListNode);
-
     if (!mappedRange) {
       return;
     }
-
     if (isListItemNode($from.node(mappedRange.depth - 1))) {
       outdentRangeToParentList({
         tr,
@@ -71,7 +65,6 @@ export const outdentListItemsSelected = (tr, state) => {
     direction: JoinDirection.RIGHT
   });
 };
-
 const calculateNewSelection = ({
   tr,
   originalSelection,
@@ -89,51 +82,41 @@ const calculateNewSelection = ({
   let to = tr.mapping.map($to.pos);
   const LIST_STRUCTURE_CHANGED_OFFSET = 2;
   const isToFromSameListItem = $from.sameParent($to);
-
   if (hasNormalizedFromPositionLiftedOut) {
     const fromMapped = isToFromSameListItem ? $from.pos : from;
     from = hasNormalizedFromPositionLiftedOut ? $from.pos : fromMapped;
     from = hasCommonListMoved ? from - LIST_STRUCTURE_CHANGED_OFFSET : from;
     from = Math.max(from, 0);
   }
-
   if (hasNormalizedToPositionLiftedOut) {
     const toMapped = isToFromSameListItem ? $to.pos : to;
     to = hasNormalizedToPositionLiftedOut ? $to.pos : toMapped;
     to = hasCommonListMoved ? to - LIST_STRUCTURE_CHANGED_OFFSET : to;
     to = Math.min(to, tr.doc.nodeSize - 2);
   }
-
   if (normalizedSelection instanceof GapCursorSelection) {
     const nextSelectionFrom = tr.doc.resolve(from);
     return new GapCursorSelection(nextSelectionFrom, normalizedSelection.side);
   }
-
   if (originalSelection instanceof NodeSelection) {
     return NodeSelection.create(tr.doc, from);
   }
-
   if (isCursorSelection) {
     return TextSelection.between(tr.doc.resolve(to), tr.doc.resolve(to), -1);
   }
-
   return TextSelection.between(tr.doc.resolve(from), tr.doc.resolve(to), -1);
 };
-
 const splitRangeSelection = selection => {
   const commonListRange = createListNodeRange({
     selection
   });
-
   if (!commonListRange) {
     return [];
   }
-
   const {
     $from,
     $to
   } = selection;
-
   if ($from.pos === $to.pos && $from.sameParent($to)) {
     return [{
       from: commonListRange.start,
@@ -141,32 +124,24 @@ const splitRangeSelection = selection => {
       depth: commonListRange.depth
     }];
   }
-
   const lastListItem = findPreviousListItemSibling($from);
-
   if (!lastListItem) {
     return [];
   }
-
   const nodeRanges = [];
   const {
     doc
   } = $from;
   let previousListItem = findPreviousListItemSibling($to);
-
   while (previousListItem && previousListItem.pos >= lastListItem.pos && previousListItem.pos >= commonListRange.start) {
     const node = doc.nodeAt(previousListItem.pos);
-
     if (!node || !isListItemNode(node)) {
       return [];
     }
-
     let offset = 0;
-
     if (node && node.lastChild && isListNode(node.lastChild)) {
       offset = node.lastChild.nodeSize;
     }
-
     const start = previousListItem.pos + 1;
     nodeRanges.push({
       from: start,
@@ -175,10 +150,8 @@ const splitRangeSelection = selection => {
     });
     previousListItem = findPreviousListItemSibling(previousListItem);
   }
-
   return nodeRanges;
 };
-
 const outdentRangeToParentList = ({
   tr,
   range
@@ -188,21 +161,17 @@ const outdentRangeToParentList = ({
   const {
     listItem
   } = tr.doc.type.schema.nodes;
-
   if (end < endOfList) {
     const slice = new Slice(Fragment.from(listItem.create(null, range.parent.copy())), 1, 0);
     const step = new ReplaceAroundStep(end - 1, endOfList, end, endOfList, slice, 1, true);
     tr.step(step);
     range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
   }
-
   const target = liftTarget(range);
-
   if (target) {
     tr.lift(range, target);
   }
 };
-
 const extractListItemsRangeFromList = ({
   tr,
   range,
@@ -216,40 +185,33 @@ const extractListItemsRangeFromList = ({
   const isAtBottom = listEnd === range.end;
   const isTheEntireList = isAtTop && isAtBottom;
   let listItemContent = isAtTop ? Fragment.empty : Fragment.from(list.copy(Fragment.empty));
-
   for (let i = range.startIndex; i < range.endIndex; i++) {
     listItemContent = listItemContent.append(list.child(i).content);
   }
-
   if (isAtTop) {
     for (let i = 0; i < listItemContent.childCount; i++) {
       const child = listItemContent.child(i);
-
       if (child && isListNode(child) && child.type !== list.type) {
         const newNestedList = list.type.create(null, child.content);
         listItemContent = listItemContent.replaceChild(i, newNestedList);
       }
     }
   }
-
   let nextList = list.copy(Fragment.empty);
   const featureFlags = getFeatureFlags(state);
-
   if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
     // if splitting a numbered list, keep the splitted item
     // counter as the start of the next (second half) list (instead
     // of reverting back to 1 as a starting number)
     const order = getOrderFromOrderedListNode(list);
-
     if (list.type.name === 'orderedList') {
-      nextList.attrs = { ...nextList.attrs,
+      nextList.attrs = {
+        ...nextList.attrs,
         order: range.endIndex - 1 + order
       };
     }
   }
-
   const nextListFragment = listItemContent.append(Fragment.from(nextList));
-
   if (isTheEntireList) {
     const slice = new Slice(listItemContent, 0, 0);
     const step = new ReplaceStep($start.pos - 1, range.end + 1, slice, false);
@@ -268,34 +230,25 @@ const extractListItemsRangeFromList = ({
     tr.step(step);
   }
 };
-
 const findPreviousListItemSibling = $pos => {
   const doc = $pos.doc;
   const isPositionListItem = isListNode($pos.node());
   let listItemPosition = $pos;
-
   if (!isPositionListItem) {
     const listItem = findFirstParentListItemNode($pos);
-
     if (!listItem) {
       return null;
     }
-
     return doc.resolve(listItem.pos);
   }
-
   const resolved = doc.resolve(listItemPosition.pos);
   const foundPosition = Selection.findFrom(resolved, -1);
-
   if (!foundPosition) {
     return null;
   }
-
   const parentListItemNode = findFirstParentListItemNode(foundPosition.$from);
-
   if (!parentListItemNode) {
     return null;
   }
-
   return doc.resolve(parentListItemNode.pos);
 };

package/dist/es2019/plugins/list/actions/wrap-and-join-lists.js

@@ -3,21 +3,21 @@ import { ReplaceAroundStep, findWrapping, canSplit } from 'prosemirror-transform
 import { autoJoinTr } from '../../../utils/prosemirror/autojoin';
 import { GapCursorSelection } from '../../selection/gap-cursor-selection';
 import { isWrappingPossible } from '../utils/selection';
+
 /**
  * Wraps the selection in a list with the given type. If this results in
  * two adjacent lists of the same type, those will be joined together.
  */
-
 export function wrapInListAndJoin(nodeType, tr) {
   wrapInList(nodeType)(tr);
   autoJoinTr(tr, (before, after) => before.type === after.type && before.type === nodeType);
 }
+
 /**
  * Wraps the selection in a list with the given type and attributes.
  *
  * Adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L64-L89
  */
-
 export function wrapInList(listType, attrs) {
   return function (tr) {
     const {
@@ -25,83 +25,67 @@ export function wrapInList(listType, attrs) {
       $to
     } = tr.selection;
     let range;
-
     if (tr.selection instanceof GapCursorSelection && $from.nodeAfter && isWrappingPossible(listType, tr.selection)) {
       const nodeSize = $from.nodeAfter.nodeSize || 1;
       range = $from.blockRange($from.doc.resolve($from.pos + nodeSize));
     } else {
       range = $from.blockRange($to);
     }
-
     let doJoin = false;
     let outerRange = range;
-
     if (!range) {
       return false;
-    } // This is at the top of an existing list item
-
-
-    if (range.depth >= 2 && // @ts-ignore - missing type for compatibleContent
+    }
+    // This is at the top of an existing list item
+    if (range.depth >= 2 &&
+    // @ts-ignore - missing type for compatibleContent
     $from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex === 0) {
       // Don't do anything if this is the top of the list
       if ($from.index(range.depth - 1) === 0) {
         return false;
       }
-
       let $insert = tr.doc.resolve(range.start - 2);
       outerRange = new NodeRange($insert, $insert, range.depth);
-
       if (range.endIndex < range.parent.childCount) {
         range = new NodeRange($from, tr.doc.resolve($to.end(range.depth)), range.depth);
       }
-
       doJoin = true;
     }
-
     let wrap = findWrapping(outerRange, listType, attrs, range);
-
     if (!wrap) {
       return false;
     }
-
     tr = doWrapInList(tr, range, wrap, doJoin, listType);
     return true;
   };
 }
+
 /**
  * Internal function used by wrapInList
  *
  * Adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L91-L112
  */
-
 function doWrapInList(tr, range, wrappers, joinBefore, listType) {
   let content = Fragment.empty;
-
   for (let i = wrappers.length - 1; i >= 0; i--) {
     content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
   }
-
   tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
   let found = 0;
-
   for (let i = 0; i < wrappers.length; i++) {
     if (wrappers[i].type === listType) {
       found = i + 1;
     }
   }
-
   const splitDepth = wrappers.length - found;
   let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0);
   const parent = range.parent;
-
   for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
     if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
       tr.split(splitPos, splitDepth);
       splitPos += 2 * splitDepth;
     }
-
     splitPos += parent.child(i).nodeSize;
   }
-
   return tr;
 }

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

@@ -14,17 +14,17 @@ export function indentList(inputMethod = INPUT_METHOD.KEYBOARD) {
       selection: {
         $from
       }
-    } = state; // don't indent if selection is not inside a list
+    } = state;
 
+    // don't indent if selection is not inside a list
     if (!isInsideListItem(state)) {
       return false;
-    } // Save the history, so it could undo/revert to the same state before the indent, see https://product-fabric.atlassian.net/browse/ED-14753
-
+    }
 
+    // Save the history, so it could undo/revert to the same state before the indent, see https://product-fabric.atlassian.net/browse/ED-14753
     closeHistory(tr);
     const firstListItemSelectedAttributes = getListItemAttributes($from);
     const parentListNode = findFirstParentListNode($from);
-
     if (!parentListNode || firstListItemSelectedAttributes && firstListItemSelectedAttributes.indentLevel === 0 && firstListItemSelectedAttributes.itemIndex === 0) {
       if (isInsideTableCell(state)) {
         // dont consume tab, as table-keymap should move cursor to next cell
@@ -34,7 +34,6 @@ export function indentList(inputMethod = INPUT_METHOD.KEYBOARD) {
         return true;
       }
     }
-
     const currentListNode = parentListNode.node;
     const actionSubjectId = isBulletList(currentListNode) ? ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
     indentListAction(tr);
@@ -42,26 +41,23 @@ export function indentList(inputMethod = INPUT_METHOD.KEYBOARD) {
       tr,
       maxIndentation: MAX_NESTED_LIST_INDENTATION
     });
-
     if (maximimunNestedLevelReached || !tr.docChanged) {
       // Even though this is a non-operation, we don't want to send this event to the browser. Because if we return false, the browser will move the focus to another place
       return true;
     }
-
     addAnalytics(state, tr, {
       action: ACTION.INDENTED,
       actionSubject: ACTION_SUBJECT.LIST,
       actionSubjectId,
       eventType: EVENT_TYPE.TRACK,
-      attributes: { ...getCommonListAnalyticsAttributes(state),
+      attributes: {
+        ...getCommonListAnalyticsAttributes(state),
         inputMethod
       }
     });
-
     if (dispatch) {
       dispatch(tr);
     }
-
     return true;
   };
 }