@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinNestedListWithParentListItem = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+//Case for two adjacent list items with the first being of lower indentation
+var joinNestedListWithParentListItem = function joinNestedListWithParentListItem(_ref) {
+  var tr = _ref.tr,
+    $next = _ref.$next,
+    $head = _ref.$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
+   *     }
+   *   }
+   * }
+   *
+   */
+
+  var listE = $next.parent;
+  var listItemF = $next.nodeAfter; //We know next is before a ListItem. ListItem must have at least one child
+  if (!listItemF || !listItemF.lastChild) {
+    return false;
+  }
+  var paragraphG = listItemF.firstChild; //ListItem must have at least one child
+  if (!paragraphG) {
+    return false;
+  }
+  var beforeListE = $next.before();
+  var beforeListItemF = $next.pos;
+  var afterParagraphD = $head.after();
+  var afterListE = $next.after();
+  var afterListItemF = tr.doc.resolve($next.pos + 1).after(); //List must always have at least one listItem
+
+  var containsChildrenJ = (0, _utils.isListNode)(listItemF.lastChild);
+  var shouldRemoveListE = listE.childCount === 1 && !containsChildrenJ; //Assures no Children J and K
+
+  var textInsertPos = $head.pos;
+  var childrenHInsertPos = afterParagraphD;
+  var childrenJInsertPos = $next.pos;
+  var textContent = paragraphG.content;
+  var 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
+  var childrenJContent = listItemF.lastChild.content; //Will be invalid if there are no Children J but it will be unused
+
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, containsChildrenJ ? [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos], [childrenJContent, childrenJInsertPos]] : [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos]], [shouldRemoveListE ? [beforeListE, afterListE] : [beforeListItemF, afterListItemF]]);
+  return true;
+};
+exports.joinNestedListWithParentListItem = joinNestedListWithParentListItem;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinParagrapWithList = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+//Case for two adjacent nodes with the first being a list item and the last being a paragraph
+var joinParagrapWithList = function joinParagrapWithList(_ref) {
+  var tr = _ref.tr,
+    $next = _ref.$next,
+    $head = _ref.$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 }
+   *   }
+   * }
+   *
+   */
+
+  var paragraphE = $next.parent;
+  var beforeParagraphE = $next.before();
+  var afterParagraphE = $next.after();
+  var textInsertPos = $head.pos;
+  var textContent = paragraphE.content;
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, [[textContent, textInsertPos]], [[beforeParagraphE, afterParagraphE]]);
+  return true;
+};
+exports.joinParagrapWithList = joinParagrapWithList;

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinSiblingListItems = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+//Case for two adjacent list items of the same indentation
+var joinSiblingListItems = function joinSiblingListItems(_ref) {
+  var tr = _ref.tr,
+    $next = _ref.$next,
+    $head = _ref.$head;
+  /* CASE 2
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |$head||textInsertPos| }       //Cant have children since that would be Case 4
+   *   |childrenGInsertPos| }
+   *   ListItem E { |$next|
+   *     Paragraph F { text2 }
+   *     ...Children G
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph C { text1text2 }
+   *     ...Children G
+   *   }
+   * }
+   *
+   */
+
+  var listItemE = $next.parent;
+  var paragraphF = $next.nodeAfter; //ListItem must have at least one child
+  if (!paragraphF) {
+    return false;
+  }
+  var beforeListItemE = $next.before();
+  var afterListItemE = $next.after();
+  var endListItemB = $head.end(-1);
+  var textInsertPos = $head.pos;
+  var childrenGInsertPos = endListItemB;
+  var textContent = paragraphF.content;
+  var childrenGContent = listItemE.content.cut(paragraphF.nodeSize);
+  (0, _utils.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, [[textContent, textInsertPos], [childrenGContent, childrenGInsertPos]], [[beforeListItemE, afterListItemE]]);
+  return true;
+};
+exports.joinSiblingListItems = joinSiblingListItems;

package/dist/cjs/actions/merge-lists.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeNextListAtPosition = mergeNextListAtPosition;
+var _utils = require("@atlaskit/editor-common/utils");
+function mergeNextListAtPosition(_ref) {
+  var tr = _ref.tr,
+    listPosition = _ref.listPosition;
+  var listNodeAtPosition = tr.doc.nodeAt(listPosition);
+  if (!(0, _utils.isListNode)(listNodeAtPosition)) {
+    return;
+  }
+  var listPositionResolved = tr.doc.resolve(listPosition + listNodeAtPosition.nodeSize);
+  var pos = listPositionResolved.pos,
+    nodeAfter = listPositionResolved.nodeAfter,
+    nodeBefore = listPositionResolved.nodeBefore;
+  if (!(0, _utils.isListNode)(nodeBefore) || !(0, _utils.isListNode)(nodeAfter)) {
+    return;
+  }
+  if ((nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type.name) !== (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type.name)) {
+    var previousListPosition = pos - nodeBefore.nodeSize;
+    tr.setNodeMarkup(previousListPosition, nodeAfter.type);
+  }
+  tr.join(pos);
+}

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

@@ -0,0 +1,291 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.outdentListItemsSelected = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+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 _analytics2 = require("../utils/analytics");
+var _find = require("../utils/find");
+var _selection2 = require("../utils/selection");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var outdentListItemsSelected = function outdentListItemsSelected(tr, state, featureFlags) {
+  var originalSelection = tr.selection;
+  var normalizedSelection = (0, _lists.normalizeListItemsSelection)({
+    selection: tr.selection,
+    doc: tr.doc
+  });
+  var rootList = (0, _find.findRootParentListNode)(normalizedSelection.$from);
+  if (!rootList) {
+    return;
+  }
+  var commonList = normalizedSelection.$from.blockRange(rootList, _utils.isListNode);
+  if (!commonList) {
+    return;
+  }
+  var hasNormalizedToPositionLiftedOut = false;
+  var hasNormalizedFromPositionLiftedOut = false;
+  var oldFrom = normalizedSelection.from,
+    oldTo = normalizedSelection.to;
+  var nodeRanges = splitRangeSelection(normalizedSelection);
+  nodeRanges.forEach(function (range) {
+    var $from = tr.doc.resolve(tr.mapping.map(range.from));
+    var $to = tr.doc.resolve(tr.mapping.map(range.to));
+    var mappedRange = $from.blockRange($to, _utils.isListNode);
+    if (!mappedRange) {
+      return;
+    }
+    if ((0, _utils.isListItemNode)($from.node(mappedRange.depth - 1))) {
+      outdentRangeToParentList({
+        tr: tr,
+        range: mappedRange
+      });
+    } else {
+      extractListItemsRangeFromList({
+        tr: tr,
+        range: mappedRange,
+        state: state,
+        featureFlags: featureFlags
+      });
+      hasNormalizedToPositionLiftedOut = hasNormalizedToPositionLiftedOut || oldTo >= range.from && oldTo < range.to;
+      hasNormalizedFromPositionLiftedOut = hasNormalizedFromPositionLiftedOut || oldFrom >= range.from && oldFrom < range.to;
+    }
+  });
+  var hasCommonListMoved = commonList.start !== tr.mapping.map(commonList.start);
+  var nextSelection = calculateNewSelection({
+    originalSelection: originalSelection,
+    normalizedSelection: normalizedSelection,
+    tr: tr,
+    hasCommonListMoved: hasCommonListMoved,
+    hasNormalizedToPositionLiftedOut: hasNormalizedToPositionLiftedOut,
+    hasNormalizedFromPositionLiftedOut: hasNormalizedFromPositionLiftedOut
+  });
+  tr.setSelection(nextSelection);
+  (0, _lists.joinSiblingLists)({
+    tr: tr,
+    direction: _lists.JoinDirection.RIGHT
+  });
+};
+exports.outdentListItemsSelected = outdentListItemsSelected;
+var calculateNewSelection = function calculateNewSelection(_ref) {
+  var tr = _ref.tr,
+    originalSelection = _ref.originalSelection,
+    normalizedSelection = _ref.normalizedSelection,
+    hasCommonListMoved = _ref.hasCommonListMoved,
+    hasNormalizedToPositionLiftedOut = _ref.hasNormalizedToPositionLiftedOut,
+    hasNormalizedFromPositionLiftedOut = _ref.hasNormalizedFromPositionLiftedOut;
+  var $from = normalizedSelection.$from,
+    $to = normalizedSelection.$to;
+  var isCursorSelection = normalizedSelection.empty;
+  var from = tr.mapping.map($from.pos);
+  var to = tr.mapping.map($to.pos);
+  var LIST_STRUCTURE_CHANGED_OFFSET = 2;
+  var isToFromSameListItem = $from.sameParent($to);
+  if (hasNormalizedFromPositionLiftedOut) {
+    var 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) {
+    var 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 _selection.GapCursorSelection) {
+    var nextSelectionFrom = tr.doc.resolve(from);
+    return new _selection.GapCursorSelection(nextSelectionFrom, normalizedSelection.side);
+  }
+  if (originalSelection instanceof _state.NodeSelection) {
+    return _state.NodeSelection.create(tr.doc, from);
+  }
+  if (isCursorSelection) {
+    return _state.TextSelection.between(tr.doc.resolve(to), tr.doc.resolve(to), -1);
+  }
+  return _state.TextSelection.between(tr.doc.resolve(from), tr.doc.resolve(to), -1);
+};
+var splitRangeSelection = function splitRangeSelection(selection) {
+  var commonListRange = (0, _selection2.createListNodeRange)({
+    selection: selection
+  });
+  if (!commonListRange) {
+    return [];
+  }
+  var $from = selection.$from,
+    $to = selection.$to;
+  if ($from.pos === $to.pos && $from.sameParent($to)) {
+    return [{
+      from: commonListRange.start,
+      to: commonListRange.end,
+      depth: commonListRange.depth
+    }];
+  }
+  var lastListItem = findPreviousListItemSibling($from);
+  if (!lastListItem) {
+    return [];
+  }
+  var nodeRanges = [];
+  var doc = $from.doc;
+  var previousListItem = findPreviousListItemSibling($to);
+  while (previousListItem && previousListItem.pos >= lastListItem.pos && previousListItem.pos >= commonListRange.start) {
+    var node = doc.nodeAt(previousListItem.pos);
+    if (!node || !(0, _utils.isListItemNode)(node)) {
+      return [];
+    }
+    var offset = 0;
+    if (node && node.lastChild && (0, _utils.isListNode)(node.lastChild)) {
+      offset = node.lastChild.nodeSize;
+    }
+    var start = previousListItem.pos + 1;
+    nodeRanges.push({
+      from: start,
+      to: doc.resolve(start).end() - offset,
+      depth: previousListItem.depth
+    });
+    previousListItem = findPreviousListItemSibling(previousListItem);
+  }
+  return nodeRanges;
+};
+var outdentRangeToParentList = function outdentRangeToParentList(_ref2) {
+  var tr = _ref2.tr,
+    range = _ref2.range;
+  var end = range.end;
+  var endOfList = range.$to.end(range.depth);
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  if (end < endOfList) {
+    var slice = new _model.Slice(_model.Fragment.from(listItem.create(null, range.parent.copy())), 1, 0);
+    var step = new _transform.ReplaceAroundStep(end - 1, endOfList, end, endOfList, slice, 1, true);
+    tr.step(step);
+    range = new _model.NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+  var target = (0, _transform.liftTarget)(range);
+  if (target) {
+    tr.lift(range, target);
+  }
+};
+var extractListItemsRangeFromList = function extractListItemsRangeFromList(_ref3) {
+  var tr = _ref3.tr,
+    range = _ref3.range,
+    state = _ref3.state,
+    featureFlags = _ref3.featureFlags;
+  var list = range.parent;
+  var $start = tr.doc.resolve(range.start);
+  var listStart = $start.start(range.depth);
+  var listEnd = $start.end(range.depth);
+  var isAtTop = listStart === range.start;
+  var isAtBottom = listEnd === range.end;
+  var isTheEntireList = isAtTop && isAtBottom;
+  var listItemContent = isAtTop ? _model.Fragment.empty : _model.Fragment.from(list.copy(_model.Fragment.empty));
+  for (var i = range.startIndex; i < range.endIndex; i++) {
+    listItemContent = listItemContent.append(list.child(i).content);
+  }
+  if (isAtTop) {
+    for (var _i = 0; _i < listItemContent.childCount; _i++) {
+      var child = listItemContent.child(_i);
+      if (child && (0, _utils.isListNode)(child) && child.type !== list.type) {
+        var newNestedList = list.type.create(null, child.content);
+        listItemContent = listItemContent.replaceChild(_i, newNestedList);
+      }
+    }
+  }
+  var nextList = list.copy(_model.Fragment.empty);
+  var nextListStartNumber;
+  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)
+    var order = (0, _utils.getOrderFromOrderedListNode)(list);
+    if (list.type.name === 'orderedList') {
+      nextListStartNumber = range.endIndex - 1 + order;
+      // @ts-ignore - [unblock prosemirror bump] assigning to readonly attrs
+      nextList.attrs = _objectSpread(_objectSpread({}, nextList.attrs), {}, {
+        order: nextListStartNumber
+      });
+      var _getRestartListsAttri = (0, _analytics2.getRestartListsAttributes)(tr),
+        splitListStartNumber = _getRestartListsAttri.splitListStartNumber;
+      if (typeof splitListStartNumber !== 'number') {
+        (0, _analytics2.storeRestartListsAttributes)(tr, {
+          splitListStartNumber: nextListStartNumber
+        });
+      }
+    }
+  }
+  var nextListFragment = listItemContent.append(_model.Fragment.from(nextList));
+  if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+    // if the split list with nextListStartNumber is below another list
+    // with order (e.g due to multi-level indent items being lifted), track the
+    // list above's order instead, as it will be the split list's order after sibling joins
+    nextListFragment.forEach(function (node, _offset, index) {
+      var _node$attrs;
+      if (node.type.name === 'orderedList' && ((_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.order) === nextListStartNumber) {
+        var _prev$attrs;
+        var prev = nextListFragment.child(index - 1);
+        if ((prev === null || prev === void 0 ? void 0 : (_prev$attrs = prev.attrs) === null || _prev$attrs === void 0 ? void 0 : _prev$attrs.order) >= 0) {
+          var _prev$attrs2;
+          (0, _analytics2.storeRestartListsAttributes)(tr, {
+            splitListStartNumber: prev === null || prev === void 0 ? void 0 : (_prev$attrs2 = prev.attrs) === null || _prev$attrs2 === void 0 ? void 0 : _prev$attrs2.order
+          });
+        }
+      }
+    });
+  }
+  if (isTheEntireList) {
+    var slice = new _model.Slice(listItemContent, 0, 0);
+    var step = new _transform.ReplaceStep($start.pos - 1, range.end + 1, slice, false);
+    if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+      (0, _analytics2.storeRestartListsAttributes)(tr, {
+        outdentScenario: undefined
+      });
+    }
+    tr.step(step);
+  } else if (isAtTop) {
+    var _slice = new _model.Slice(nextListFragment, 0, 1);
+    var _step = new _transform.ReplaceStep($start.pos - 1, range.end, _slice, false);
+    tr.step(_step);
+  } else if (isAtBottom) {
+    var _slice2 = new _model.Slice(listItemContent, 1, 0);
+    var _step2 = new _transform.ReplaceStep($start.pos, listEnd + 1, _slice2, false);
+    tr.step(_step2);
+  } else {
+    if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+      (0, _analytics2.storeRestartListsAttributes)(tr, {
+        outdentScenario: _analytics.OUTDENT_SCENARIOS.SPLIT_LIST
+      });
+    }
+    var _slice3 = new _model.Slice(nextListFragment, 1, 1);
+    var _step3 = new _transform.ReplaceAroundStep($start.pos, listEnd, range.end, listEnd, _slice3, _slice3.size, false);
+    tr.step(_step3);
+  }
+};
+var findPreviousListItemSibling = function findPreviousListItemSibling($pos) {
+  var doc = $pos.doc;
+  var isPositionListItem = (0, _utils.isListNode)($pos.node());
+  var listItemPosition = $pos;
+  if (!isPositionListItem) {
+    var listItem = (0, _find.findFirstParentListItemNode)($pos);
+    if (!listItem) {
+      return null;
+    }
+    return doc.resolve(listItem.pos);
+  }
+  var resolved = doc.resolve(listItemPosition.pos);
+  var foundPosition = _state.Selection.findFrom(resolved, -1);
+  if (!foundPosition) {
+    return null;
+  }
+  var parentListItemNode = (0, _find.findFirstParentListItemNode)(foundPosition.$from);
+  if (!parentListItemNode) {
+    return null;
+  }
+  return doc.resolve(parentListItemNode.pos);
+};

package/dist/cjs/actions/wrap-and-join-lists.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapInList = wrapInList;
+exports.wrapInListAndJoin = wrapInListAndJoin;
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _selection2 = require("../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.
+ */
+function wrapInListAndJoin(nodeType, tr) {
+  wrapInList(nodeType)(tr);
+  (0, _utils.autoJoinTr)(tr, function (before, after) {
+    return before.type === after.type && before.type === nodeType;
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * 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
+ */
+function wrapInList(listType, attrs) {
+  return function (tr) {
+    var _tr$selection = tr.selection,
+      $from = _tr$selection.$from,
+      $to = _tr$selection.$to;
+    var range;
+    if (tr.selection instanceof _selection.GapCursorSelection && $from.nodeAfter && (0, _selection2.isWrappingPossible)(listType, tr.selection)) {
+      var nodeSize = $from.nodeAfter.nodeSize || 1;
+      range = $from.blockRange($from.doc.resolve($from.pos + nodeSize));
+    } else {
+      range = $from.blockRange($to);
+    }
+    var doJoin = false;
+    var 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
+    $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;
+      }
+      var $insert = tr.doc.resolve(range.start - 2);
+      outerRange = new _model.NodeRange($insert, $insert, range.depth);
+      if (range.endIndex < range.parent.childCount) {
+        range = new _model.NodeRange($from, tr.doc.resolve($to.end(range.depth)), range.depth);
+      }
+      doJoin = true;
+    }
+    var wrap = (0, _transform.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) {
+  var content = _model.Fragment.empty;
+  for (var i = wrappers.length - 1; i >= 0; i--) {
+    content = _model.Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
+  }
+  tr.step(new _transform.ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new _model.Slice(content, 0, 0), wrappers.length, true));
+  var found = 0;
+  for (var _i = 0; _i < wrappers.length; _i++) {
+    if (wrappers[_i].type === listType) {
+      found = _i + 1;
+    }
+  }
+  var splitDepth = wrappers.length - found;
+  var splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0);
+  var parent = range.parent;
+  for (var _i2 = range.startIndex, e = range.endIndex, first = true; _i2 < e; _i2++, first = false) {
+    if (!first && (0, _transform.canSplit)(tr.doc, splitPos, splitDepth)) {
+      tr.split(splitPos, splitDepth);
+      splitPos += 2 * splitDepth;
+    }
+    splitPos += parent.child(_i2).nodeSize;
+  }
+  return tr;
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indentList = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _lists = require("@atlaskit/editor-common/lists");
+var _utils = require("@atlaskit/editor-common/utils");
+var _history = require("@atlaskit/editor-prosemirror/history");
+var _indentListItemsSelected = require("../actions/indent-list-items-selected");
+var _types = require("../types");
+var _find = require("../utils/find");
+var _selection = require("../utils/selection");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var indentList = function indentList(editorAnalyticsAPI) {
+  return function () {
+    var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _analytics.INPUT_METHOD.KEYBOARD;
+    return function (state, dispatch) {
+      var tr = state.tr,
+        $from = state.selection.$from;
+
+      // don't indent if selection is not inside a list
+      if (!(0, _selection.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
+      (0, _history.closeHistory)(tr);
+      var firstListItemSelectedAttributes = (0, _lists.getListItemAttributes)($from);
+      var parentListNode = (0, _find.findFirstParentListNode)($from);
+      if (!parentListNode || firstListItemSelectedAttributes && firstListItemSelectedAttributes.indentLevel === 0 && firstListItemSelectedAttributes.itemIndex === 0) {
+        if ((0, _selection.isInsideTableCell)(state)) {
+          // dont consume tab, as table-keymap should move cursor to next cell
+          return false;
+        } else {
+          // 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;
+        }
+      }
+      var currentListNode = parentListNode.node;
+      var actionSubjectId = (0, _utils.isBulletList)(currentListNode) ? _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_BULLET : _analytics.ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER;
+      (0, _indentListItemsSelected.indentListItemsSelected)(tr);
+      var maximimunNestedLevelReached = !(0, _lists.hasValidListIndentationLevel)({
+        tr: tr,
+        maxIndentation: _types.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;
+      }
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+        action: _analytics.ACTION.INDENTED,
+        actionSubject: _analytics.ACTION_SUBJECT.LIST,
+        actionSubjectId: actionSubjectId,
+        eventType: _analytics.EVENT_TYPE.TRACK,
+        attributes: _objectSpread(_objectSpread({}, (0, _lists.getCommonListAnalyticsAttributes)(state)), {}, {
+          inputMethod: inputMethod
+        })
+      })(tr);
+      if (dispatch) {
+        dispatch(tr);
+      }
+      return true;
+    };
+  };
+};
+exports.indentList = indentList;