@atlaskit/editor-plugin-list 0.2.0 → 1.0.0

package/dist/cjs/pm-plugins/input-rules/wrapping-join-rule.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWrappingJoinRule = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _prosemirrorInputRules = require("@atlaskit/prosemirror-input-rules");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+var createWrappingJoinRule = function createWrappingJoinRule(_ref) {
+  var match = _ref.match,
+    nodeType = _ref.nodeType,
+    getAttrs = _ref.getAttrs,
+    joinPredicate = _ref.joinPredicate,
+    featureFlags = _ref.featureFlags;
+  var handler = function handler(state, match, start, end) {
+    var attrs = (getAttrs instanceof Function ? getAttrs(match) : getAttrs) || {};
+    var tr = state.tr;
+    var fixedStart = Math.max(start, 1);
+    tr.delete(fixedStart, end);
+    var $start = tr.doc.resolve(fixedStart);
+    var range = $start.blockRange();
+    var wrapping = range && (0, _transform.findWrapping)(range, nodeType, attrs);
+    if (!wrapping || !range) {
+      return null;
+    }
+    var parentNodePosMapped = tr.mapping.map(range.start);
+    var parentNode = tr.doc.nodeAt(parentNodePosMapped);
+    var lastWrap = wrapping[wrapping.length - 1];
+    if (parentNode && lastWrap) {
+      var allowedMarks = lastWrap.type.allowedMarks(parentNode.marks) || [];
+      tr.setNodeMarkup(parentNodePosMapped, parentNode.type, parentNode.attrs, allowedMarks);
+    }
+    tr.wrap(range, wrapping);
+    if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists && nodeType === state.schema.nodes.orderedList) {
+      // if an orderedList node would be inserted by the input rule match, and
+      // that orderedList node is being added directly before another orderedList
+      // node, then join those nodes
+      var $end = tr.doc.resolve(tr.mapping.map(end));
+      var _node = (0, _utils.findParentNodeOfTypeClosestToPos)($end, nodeType);
+      if (_node) {
+        var nodeEnd = _node.pos + _node.node.nodeSize;
+        var after = tr.doc.resolve(nodeEnd).nodeAfter;
+        if (after && after.type === nodeType && (0, _transform.canJoin)(tr.doc, nodeEnd) && (!joinPredicate || joinPredicate(match, after, _analytics.JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.JOINED_TO_LIST_BELOW))) {
+          tr.join(nodeEnd);
+        }
+      }
+    }
+    var before = tr.doc.resolve(fixedStart - 1).nodeBefore;
+    if (before && before.type === nodeType && (0, _transform.canJoin)(tr.doc, fixedStart - 1) && (!joinPredicate || joinPredicate(match, before, _analytics.JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST.JOINED_TO_LIST_ABOVE))) {
+      tr.join(fixedStart - 1);
+    }
+    return tr;
+  };
+  return (0, _prosemirrorInputRules.createRule)(match, handler);
+};
+exports.createWrappingJoinRule = createWrappingJoinRule;

package/dist/cjs/pm-plugins/keymap.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.keymapPlugin = keymapPlugin;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _commands = require("../commands");
+function keymapPlugin(featureFlags, editorAnalyticsAPI) {
+  var list = {};
+  (0, _keymaps.bindKeymapWithCommand)((0, _keymaps.findShortcutByKeymap)(_keymaps.toggleOrderedList), (0, _commands.toggleList)(editorAnalyticsAPI)(_analytics.INPUT_METHOD.KEYBOARD, 'orderedList'), list);
+  (0, _keymaps.bindKeymapWithCommand)((0, _keymaps.findShortcutByKeymap)(_keymaps.toggleBulletList), (0, _commands.toggleList)(editorAnalyticsAPI)(_analytics.INPUT_METHOD.KEYBOARD, 'bulletList'), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.indentList.common, (0, _commands.indentList)(editorAnalyticsAPI)(_analytics.INPUT_METHOD.KEYBOARD), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.outdentList.common, (0, _commands.outdentList)(editorAnalyticsAPI)(_analytics.INPUT_METHOD.KEYBOARD, featureFlags), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.enter.common, (0, _commands.enterKeyCommand)(editorAnalyticsAPI)(featureFlags), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.backspace.common, (0, _commands.backspaceKeyCommand)(editorAnalyticsAPI)(featureFlags), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.deleteKey.common, (0, _commands.deleteKeyCommand)(editorAnalyticsAPI), list);
+
+  // This shortcut is Mac only
+  (0, _keymaps.bindKeymapWithCommand)((0, _keymaps.findKeyMapForBrowser)(_keymaps.forwardDelete), (0, _commands.deleteKeyCommand)(editorAnalyticsAPI), list);
+  return (0, _keymap.keymap)(list);
+}
+var _default = keymapPlugin;
+exports.default = _default;

package/dist/cjs/pm-plugins/main.js

@@ -0,0 +1,166 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginKey = exports.getDecorations = exports.createPlugin = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _selection = require("@atlaskit/editor-common/selection");
+var _styles = require("@atlaskit/editor-common/styles");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _view = require("@atlaskit/editor-prosemirror/view");
+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 listPluginKey = new _state.PluginKey('listPlugin');
+var pluginKey = listPluginKey;
+exports.pluginKey = pluginKey;
+var initialState = {
+  bulletListActive: false,
+  bulletListDisabled: false,
+  orderedListActive: false,
+  orderedListDisabled: false,
+  decorationSet: _view.DecorationSet.empty
+};
+var getDecorations = function getDecorations(doc, state, featureFlags) {
+  var decorations = [];
+
+  // this stack keeps track of each (nested) list to calculate the indentation level
+  var processedListsStack = [];
+  doc.nodesBetween(0, doc.content.size, function (node, currentNodeStartPos) {
+    if (processedListsStack.length > 0) {
+      var isOutsideLastList = true;
+      while (isOutsideLastList && processedListsStack.length > 0) {
+        var lastList = processedListsStack[processedListsStack.length - 1];
+        var lastListEndPos = lastList.startPos + lastList.node.nodeSize;
+        isOutsideLastList = currentNodeStartPos >= lastListEndPos;
+        // once we finish iterating over each innermost list, pop the stack to
+        // decrease the indent level attribute accordingly
+        if (isOutsideLastList) {
+          processedListsStack.pop();
+        }
+      }
+    }
+    if ((0, _utils.isListNode)(node)) {
+      processedListsStack.push({
+        node: node,
+        startPos: currentNodeStartPos
+      });
+      var from = currentNodeStartPos;
+      var to = currentNodeStartPos + node.nodeSize;
+      var depth = processedListsStack.length;
+      decorations.push(_view.Decoration.node(from, to, {
+        'data-indent-level': "".concat(depth)
+      }));
+      if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists) {
+        var _node$attrs;
+        // If a numbered list has item counters numbering >= 100, we'll need to add special
+        // spacing to account for the extra digit chars
+        var digitsSize = (0, _utils.getItemCounterDigitsSize)({
+          itemsCount: node === null || node === void 0 ? void 0 : node.childCount,
+          order: node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.order
+        });
+        if (digitsSize) {
+          decorations.push(_view.Decoration.node(from, to, {
+            style: (0, _styles.getOrderedListInlineStyles)(digitsSize, 'string')
+          }));
+        }
+      } else {
+        if (node.childCount >= 100) {
+          decorations.push(_view.Decoration.node(from, to, {
+            'data-child-count': '100+'
+          }));
+        }
+      }
+    }
+  });
+  return _view.DecorationSet.empty.add(doc, decorations);
+};
+exports.getDecorations = getDecorations;
+var handleDocChanged = function handleDocChanged(featureFlags) {
+  return function (tr, pluginState, editorState) {
+    var nextPluginState = handleSelectionChanged(tr, pluginState);
+    var decorationSet = getDecorations(tr.doc, editorState, featureFlags);
+    return _objectSpread(_objectSpread({}, nextPluginState), {}, {
+      decorationSet: decorationSet
+    });
+  };
+};
+var handleSelectionChanged = function handleSelectionChanged(tr, pluginState) {
+  var _tr$doc$type$schema$n = tr.doc.type.schema.nodes,
+    bulletList = _tr$doc$type$schema$n.bulletList,
+    orderedList = _tr$doc$type$schema$n.orderedList;
+  var listParent = (0, _utils2.findParentNodeOfType)([bulletList, orderedList])(tr.selection);
+  var bulletListActive = !!listParent && listParent.node.type === bulletList;
+  var orderedListActive = !!listParent && listParent.node.type === orderedList;
+  var bulletListDisabled = !(bulletListActive || orderedListActive || (0, _selection2.isWrappingPossible)(bulletList, tr.selection));
+  var orderedListDisabled = !(bulletListActive || orderedListActive || (0, _selection2.isWrappingPossible)(orderedList, tr.selection));
+  if (bulletListActive !== pluginState.bulletListActive || orderedListActive !== pluginState.orderedListActive || bulletListDisabled !== pluginState.bulletListDisabled || orderedListDisabled !== pluginState.orderedListDisabled) {
+    var nextPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
+      bulletListActive: bulletListActive,
+      orderedListActive: orderedListActive,
+      bulletListDisabled: bulletListDisabled,
+      orderedListDisabled: orderedListDisabled
+    });
+    return nextPluginState;
+  }
+  return pluginState;
+};
+var reducer = function reducer() {
+  return function (state) {
+    return state;
+  };
+};
+var createInitialState = function createInitialState(featureFlags) {
+  return function (state) {
+    return _objectSpread(_objectSpread({}, initialState), {}, {
+      decorationSet: getDecorations(state.doc, state, featureFlags)
+    });
+  };
+};
+var createPlugin = function createPlugin(eventDispatch, featureFlags) {
+  var _pluginFactory = (0, _utils.pluginFactory)(listPluginKey, reducer(), {
+      onDocChanged: handleDocChanged(featureFlags),
+      onSelectionChanged: handleSelectionChanged
+    }),
+    getPluginState = _pluginFactory.getPluginState,
+    createPluginState = _pluginFactory.createPluginState;
+  return new _safePlugin.SafePlugin({
+    state: createPluginState(eventDispatch, createInitialState(featureFlags)),
+    key: listPluginKey,
+    props: {
+      decorations: function decorations(state) {
+        var _getPluginState = getPluginState(state),
+          decorationSet = _getPluginState.decorationSet;
+        return decorationSet;
+      },
+      handleClick: function handleClick(view, pos, event) {
+        var state = view.state;
+        if (['LI', 'UL'].includes((event === null || event === void 0 ? void 0 : event.target).tagName)) {
+          var _nodeAtPos$firstChild;
+          var nodeAtPos = state.tr.doc.nodeAt(pos);
+          var _view$state$schema$no = view.state.schema.nodes,
+            listItem = _view$state$schema$no.listItem,
+            codeBlock = _view$state$schema$no.codeBlock;
+          if ((nodeAtPos === null || nodeAtPos === void 0 ? void 0 : nodeAtPos.type) === listItem && (nodeAtPos === null || nodeAtPos === void 0 ? void 0 : (_nodeAtPos$firstChild = nodeAtPos.firstChild) === null || _nodeAtPos$firstChild === void 0 ? void 0 : _nodeAtPos$firstChild.type) === codeBlock) {
+            var _document, _document$elementFrom;
+            var bufferPx = 50;
+            var isCodeBlockNextToListMarker = Boolean((_document = document) === null || _document === void 0 ? void 0 : (_document$elementFrom = _document.elementFromPoint(event.clientX + (_styles.listItemCounterPadding + bufferPx), event.clientY)) === null || _document$elementFrom === void 0 ? void 0 : _document$elementFrom.closest(".".concat(_styles.CodeBlockSharedCssClassName.CODEBLOCK_CONTAINER)));
+            if (isCodeBlockNextToListMarker) {
+              // +1 needed to put cursor inside li
+              // otherwise gap cursor markup will be injected as immediate child of ul resulting in invalid html
+              (0, _selection.setGapCursorSelection)(view, pos + 1, _selection.Side.LEFT);
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+    }
+  });
+};
+exports.createPlugin = createPlugin;

package/dist/cjs/transforms.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.liftFollowingList = liftFollowingList;
+exports.liftNodeSelectionList = liftNodeSelectionList;
+exports.liftTextSelectionList = liftTextSelectionList;
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _indentation = require("./utils/indentation");
+function liftListItem(selection, tr) {
+  var $from = selection.$from,
+    $to = selection.$to;
+  var nodeType = tr.doc.type.schema.nodes.listItem;
+  var range = $from.blockRange($to, function (node) {
+    return !!node.childCount && !!node.firstChild && node.firstChild.type === nodeType;
+  });
+  if (!range || range.depth < 2 || $from.node(range.depth - 1).type !== nodeType) {
+    return tr;
+  }
+  var end = range.end;
+  var endOfList = $to.end(range.depth);
+  if (end < endOfList) {
+    tr.step(new _transform.ReplaceAroundStep(end - 1, endOfList, end, endOfList, new _model.Slice(_model.Fragment.from(nodeType.create(undefined, range.parent.copy())), 1, 0), 1, true));
+    range = new _model.NodeRange(tr.doc.resolve($from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+  return tr.lift(range, (0, _transform.liftTarget)(range)).scrollIntoView();
+}
+
+// Function will lift list item following selection to level-1.
+function liftFollowingList(from, to, rootListDepth, tr) {
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var lifted = false;
+  tr.doc.nodesBetween(from, to, function (node, pos) {
+    if (!lifted && node.type === listItem && pos > from) {
+      lifted = true;
+      var listDepth = rootListDepth + 3;
+      while (listDepth > rootListDepth + 2) {
+        var start = tr.doc.resolve(tr.mapping.map(pos));
+        listDepth = start.depth;
+        var end = tr.doc.resolve(tr.mapping.map(pos + node.textContent.length));
+        var sel = new _state.TextSelection(start, end);
+        tr = liftListItem(sel, tr);
+      }
+    }
+  });
+  return tr;
+}
+function liftNodeSelectionList(selection, tr) {
+  var from = selection.from;
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var mappedPosition = tr.mapping.map(from);
+  var nodeAtPos = tr.doc.nodeAt(mappedPosition);
+  var start = tr.doc.resolve(mappedPosition);
+  if ((start === null || start === void 0 ? void 0 : start.parent.type) !== listItem) {
+    return tr;
+  }
+  var end = tr.doc.resolve(mappedPosition + ((nodeAtPos === null || nodeAtPos === void 0 ? void 0 : nodeAtPos.nodeSize) || 1));
+  var range = start.blockRange(end);
+  if (range) {
+    var _liftTarget = (0, _indentation.getListLiftTarget)(start);
+    tr.lift(range, _liftTarget);
+  }
+  return tr;
+}
+// The function will list paragraphs in selection out to level 1 below root list.
+function liftTextSelectionList(selection, tr) {
+  var from = selection.from,
+    to = selection.to;
+  var paragraph = tr.doc.type.schema.nodes.paragraph;
+  var listCol = [];
+  tr.doc.nodesBetween(from, to, function (node, pos) {
+    if (node.type === paragraph) {
+      listCol.push({
+        node: node,
+        pos: pos
+      });
+    }
+  });
+  for (var i = listCol.length - 1; i >= 0; i--) {
+    var _paragraph = listCol[i];
+    var start = tr.doc.resolve(tr.mapping.map(_paragraph.pos));
+    if (start.depth > 0) {
+      var end = void 0;
+      if (_paragraph.node.textContent && _paragraph.node.textContent.length > 0) {
+        end = tr.doc.resolve(tr.mapping.map(_paragraph.pos + _paragraph.node.textContent.length));
+      } else {
+        end = tr.doc.resolve(tr.mapping.map(_paragraph.pos + 1));
+      }
+      var range = start.blockRange(end);
+      if (range) {
+        tr.lift(range, (0, _indentation.getListLiftTarget)(start));
+      }
+    }
+  }
+  return tr;
+}

package/dist/cjs/types.js

@@ -2,4 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+exports.MAX_NESTED_LIST_INDENTATION = void 0;
+var MAX_NESTED_LIST_INDENTATION = 6;
+exports.MAX_NESTED_LIST_INDENTATION = MAX_NESTED_LIST_INDENTATION;

package/dist/cjs/utils/analytics.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.storeRestartListsAttributes = exports.getRestartListsAttributes = exports.RESTART_LISTS_ANALYTICS_KEY = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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 RESTART_LISTS_ANALYTICS_KEY = 'restartListsAnalytics';
+exports.RESTART_LISTS_ANALYTICS_KEY = RESTART_LISTS_ANALYTICS_KEY;
+var getRestartListsAttributes = function getRestartListsAttributes(tr) {
+  var _tr$getMeta;
+  return (_tr$getMeta = tr.getMeta(RESTART_LISTS_ANALYTICS_KEY)) !== null && _tr$getMeta !== void 0 ? _tr$getMeta : {};
+};
+exports.getRestartListsAttributes = getRestartListsAttributes;
+var storeRestartListsAttributes = function storeRestartListsAttributes(tr, attributes) {
+  var meta = getRestartListsAttributes(tr);
+  tr.setMeta(RESTART_LISTS_ANALYTICS_KEY, _objectSpread(_objectSpread({}, meta), attributes));
+};
+exports.storeRestartListsAttributes = storeRestartListsAttributes;

package/dist/cjs/utils/find.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findFirstParentListItemNode = findFirstParentListItemNode;
+exports.findFirstParentListNode = findFirstParentListNode;
+exports.findRootParentListNode = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+function findFirstParentListNode($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var listNodePosition = null;
+  if ((0, _utils.isListNode)(currentNode)) {
+    listNodePosition = $pos.pos;
+  } else {
+    var result = (0, _utils2.findParentNodeClosestToPos)($pos, _utils.isListNode);
+    listNodePosition = result && result.pos;
+  }
+  if (listNodePosition == null) {
+    return null;
+  }
+  var node = $pos.doc.nodeAt(listNodePosition);
+  if (!node) {
+    return null;
+  }
+  return {
+    node: node,
+    pos: listNodePosition
+  };
+}
+function findFirstParentListItemNode($pos) {
+  var currentNode = $pos.doc.nodeAt($pos.pos);
+  var listItemNodePosition = (0, _utils.isListItemNode)(currentNode) ? $pos : (0, _utils2.findParentNodeClosestToPos)($pos, _utils.isListItemNode);
+  if (!listItemNodePosition || listItemNodePosition.pos === null) {
+    return null;
+  }
+  var node = $pos.doc.nodeAt(listItemNodePosition.pos);
+  if (!node) {
+    return null;
+  }
+  return {
+    node: node,
+    pos: listItemNodePosition.pos
+  };
+}
+var findRootParentListNode = function findRootParentListNode($pos) {
+  var doc = $pos.doc;
+  if ($pos.pos + 1 > doc.content.size) {
+    return null;
+  }
+  if ($pos.depth === 0) {
+    return doc.resolve($pos.pos + 1);
+  }
+  var currentNode = doc.nodeAt($pos.pos);
+  var beforePosition = $pos.before();
+  var nodeBefore = doc.nodeAt(beforePosition);
+  if ((0, _utils.isListNode)(currentNode) && !(0, _utils.isListItemNode)(nodeBefore)) {
+    return doc.resolve($pos.pos + 1);
+  }
+  var parentList = (0, _utils2.findParentNodeClosestToPos)($pos, _utils.isListNode);
+  if (!parentList) {
+    return null;
+  }
+  var listNodePosition = doc.resolve(parentList.pos);
+  return findRootParentListNode(listNodePosition);
+};
+exports.findRootParentListNode = findRootParentListNode;

package/dist/cjs/utils/indentation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getListLiftTarget = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+// This will return (depth - 1) for root list parent of a list.
+var getListLiftTarget = function getListLiftTarget(resPos) {
+  var target = resPos.depth;
+  for (var i = resPos.depth; i > 0; i--) {
+    var node = resPos.node(i);
+    if ((0, _utils.isListNode)(node)) {
+      target = i;
+    }
+    if (!(0, _utils.isListItemNode)(node) && !(0, _utils.isListNode)(node)) {
+      break;
+    }
+  }
+  return target - 1;
+};
+exports.getListLiftTarget = getListLiftTarget;

package/dist/cjs/utils/mark.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitiseMarksInSelection = void 0;
+var sanitiseMarksInSelection = function sanitiseMarksInSelection(tr, newParentType) {
+  var _tr$selection = tr.selection,
+    from = _tr$selection.from,
+    to = _tr$selection.to;
+  var nodesSanitized = [];
+  tr.doc.nodesBetween(from, to, function (node, pos, parent) {
+    if (node.isText) {
+      return false;
+    }
+    // Skip expands and layouts if they are outside selection
+    // but continue to iterate over their children.
+    if (['expand', 'layoutSection'].includes(node.type.name) && (pos < from || pos > to)) {
+      return true;
+    }
+    node.marks.forEach(function (mark) {
+      if (!(parent !== null && parent !== void 0 && parent.type.allowsMarkType(mark.type)) || newParentType && !newParentType.allowsMarkType(mark.type)) {
+        var filteredMarks = node.marks.filter(function (m) {
+          return m.type !== mark.type;
+        });
+        var position = pos > 0 ? pos : 0;
+        var marksRemoved = node.marks.filter(function (m) {
+          return m.type === mark.type;
+        });
+        nodesSanitized.push({
+          node: node,
+          marksRemoved: marksRemoved
+        });
+        tr.setNodeMarkup(position, undefined, node.attrs, filteredMarks);
+      }
+    });
+  });
+  return nodesSanitized;
+};
+exports.sanitiseMarksInSelection = sanitiseMarksInSelection;

package/dist/cjs/utils/node.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isListNodeValidContent = isListNodeValidContent;
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+function isListNodeValidContent(node) {
+  var bulletList = node.type.schema.nodes.bulletList;
+  if (!bulletList) {
+    return false;
+  }
+  var listFragment = _model.Fragment.from(bulletList.createAndFill());
+  return !(0, _utils.isListItemNode)(node) && node.type.validContent(listFragment);
+}

package/dist/cjs/utils/selection.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectionContainsList = exports.isWrappingPossible = exports.isPosInsideParagraph = exports.isPosInsideList = exports.isInsideTableCell = exports.isInsideListItem = exports.createListNodeRange = exports.canJoinToPreviousListItem = void 0;
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("@atlaskit/editor-common/utils");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var isPosInsideParagraph = function isPosInsideParagraph($pos) {
+  return $pos.parent.type.name === 'paragraph';
+};
+exports.isPosInsideParagraph = isPosInsideParagraph;
+var isPosInsideList = function isPosInsideList($pos) {
+  var posGrandParent = $pos.node(-1);
+  return (0, _utils.isListItemNode)($pos.parent) || (0, _utils.isListNode)($pos.parent) || (0, _utils.isListItemNode)(posGrandParent);
+};
+exports.isPosInsideList = isPosInsideList;
+var isWrappingPossible = function isWrappingPossible(nodeType, selection) {
+  var $from = selection.$from,
+    $to = selection.$to;
+  var range;
+  if (selection instanceof _selection.GapCursorSelection && $from.nodeAfter) {
+    var nodeSize = $from.nodeAfter.nodeSize || 1;
+    range = $from.blockRange($from.doc.resolve($from.pos + nodeSize));
+  } else {
+    range = $from.blockRange($to);
+  }
+  if (!range) {
+    return false;
+  }
+  var wrap = (0, _transform.findWrapping)(range, nodeType);
+  if (!wrap) {
+    return false;
+  }
+  return true;
+};
+
+// canOutdent
+exports.isWrappingPossible = isWrappingPossible;
+var isInsideListItem = function isInsideListItem(state) {
+  var parent = state.selection.$from.parent;
+  var listItem = state.schema.nodes.listItem;
+  if (state.selection instanceof _selection.GapCursorSelection) {
+    return (0, _utils.isListItemNode)(parent);
+  }
+  return (0, _utils2.hasParentNodeOfType)(listItem)(state.selection) && (0, _utils.isParagraphNode)(parent);
+};
+exports.isInsideListItem = isInsideListItem;
+var isInsideTableCell = function isInsideTableCell(state) {
+  var _state$schema$nodes = state.schema.nodes,
+    tableCell = _state$schema$nodes.tableCell,
+    tableHeader = _state$schema$nodes.tableHeader;
+  return !!(0, _utils2.findParentNodeOfType)([tableCell, tableHeader])(state.selection);
+};
+exports.isInsideTableCell = isInsideTableCell;
+var canJoinToPreviousListItem = function canJoinToPreviousListItem(state) {
+  var $from = state.selection.$from;
+  var $before = state.doc.resolve($from.pos - 1);
+  var nodeBefore = $before ? $before.nodeBefore : null;
+  if (state.selection instanceof _selection.GapCursorSelection) {
+    nodeBefore = $from.nodeBefore;
+  }
+  return (0, _utils.isListNode)(nodeBefore);
+};
+exports.canJoinToPreviousListItem = canJoinToPreviousListItem;
+var selectionContainsList = function selectionContainsList(tr) {
+  var _tr$selection = tr.selection,
+    from = _tr$selection.from,
+    to = _tr$selection.to;
+  var foundListNode = null;
+  tr.doc.nodesBetween(from, to, function (node) {
+    if ((0, _utils.isListNode)(node)) {
+      foundListNode = node;
+    }
+    if (foundListNode) {
+      return false;
+    }
+    return true;
+  });
+  return foundListNode;
+};
+exports.selectionContainsList = selectionContainsList;
+var createListNodeRange = function createListNodeRange(_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;
+};
+exports.createListNodeRange = createListNodeRange;