@atlaskit/editor-common 74.30.0 → 74.31.0

package/dist/cjs/utils/prosemirror/autojoin.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.autoJoinTr = autoJoinTr;
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+/**
+ * Checks whether two adjacent nodes can be joined. If so, the document
+ * will be updated to join those nodes. If not, the original transaction
+ * remains untouched.
+ *
+ * Nodes are considered joinable if the `isJoinable` predicate returns true or,
+ * if an array of strings was passed, if their node type name is in that array.
+ *
+ * Adapted from https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L597-L610
+ */
+function autoJoinTr(tr, isJoinable) {
+  if (Array.isArray(isJoinable)) {
+    var types = isJoinable;
+    isJoinable = function isJoinable(node) {
+      return types.indexOf(node.type.name) > -1;
+    };
+  }
+  var ranges = [];
+  for (var i = 0; i < tr.mapping.maps.length; i++) {
+    var map = tr.mapping.maps[i];
+    for (var j = 0; j < ranges.length; j++) {
+      ranges[j] = map.map(ranges[j]);
+    }
+    map.forEach(function (_s, _e, from, to) {
+      return ranges.push(from, to);
+    });
+  }
+
+  // Figure out which joinable points exist inside those ranges,
+  // by checking all node boundaries in their parent nodes.
+  var joinable = [];
+  for (var _i = 0; _i < ranges.length; _i += 2) {
+    var from = ranges[_i];
+    var to = ranges[_i + 1];
+    var $from = tr.doc.resolve(from);
+    var depth = $from.sharedDepth(to);
+    var parent = $from.node(depth);
+    for (var index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {
+      var _after = parent.maybeChild(index);
+      if (!_after) {
+        break;
+      }
+      if (index && joinable.indexOf(pos) === -1) {
+        var _before = parent.child(index - 1);
+        if (_before.type === _after.type && isJoinable(_before, _after)) {
+          joinable.push(pos);
+        }
+      }
+      pos += _after.nodeSize;
+    }
+  }
+  // Join the joinable points
+  joinable.sort(function (a, b) {
+    return a - b;
+  });
+  for (var _i2 = joinable.length - 1; _i2 >= 0; _i2--) {
+    if ((0, _transform.canJoin)(tr.doc, joinable[_i2])) {
+      tr.join(joinable[_i2]);
+    }
+  }
+}

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "74.30.0",
+	"version": "74.31.0",
 	"sideEffects": false
 }

package/dist/es2019/lists/analytics.js

@@ -0,0 +1,36 @@
+import { isListItemNode, isListNode } from '../utils';
+import { getListItemAttributes } from './selection';
+export const getCommonListAnalyticsAttributes = state => {
+  const {
+    selection: {
+      $from,
+      $to
+    }
+  } = state;
+  const fromAttrs = getListItemAttributes($from);
+  const toAttrs = getListItemAttributes($to);
+  return {
+    itemIndexAtSelectionStart: fromAttrs.itemIndex,
+    itemIndexAtSelectionEnd: toAttrs.itemIndex,
+    indentLevelAtSelectionStart: fromAttrs.indentLevel,
+    indentLevelAtSelectionEnd: toAttrs.indentLevel,
+    itemsInSelection: countListItemsInSelection(state)
+  };
+};
+export const countListItemsInSelection = state => {
+  const {
+    from,
+    to
+  } = state.selection;
+  if (from === to) {
+    return 1;
+  }
+  let count = 0;
+  const listSlice = state.doc.cut(from, to);
+  listSlice.content.nodesBetween(0, listSlice.content.size, (node, pos, parent, index) => {
+    if (parent && isListItemNode(parent) && !isListNode(node) && index === 0) {
+      count++;
+    }
+  });
+  return count;
+};

package/dist/es2019/lists/indentation.js

@@ -0,0 +1,18 @@
+import { numberNestedLists } from './selection';
+export const hasValidListIndentationLevel = ({
+  tr,
+  maxIndentation
+}) => {
+  const initialIndentationLevel = numberNestedLists(tr.selection.$from);
+  let currentIndentationLevel;
+  let currentPos = tr.selection.$to.pos;
+  do {
+    const resolvedPos = tr.doc.resolve(currentPos);
+    currentIndentationLevel = numberNestedLists(resolvedPos);
+    if (currentIndentationLevel > maxIndentation) {
+      return false;
+    }
+    currentPos++;
+  } while (currentIndentationLevel >= initialIndentationLevel);
+  return true;
+};

package/dist/es2019/lists/index.js

@@ -0,0 +1,6 @@
+export { getListItemAttributes, normalizeListItemsSelection } from './selection';
+export { moveTargetIntoList } from './replace-content';
+export { JoinDirection, isListNodeValidContent, joinSiblingLists } from './node';
+export { getCommonListAnalyticsAttributes, countListItemsInSelection } from './analytics';
+export { hasValidListIndentationLevel } from './indentation';
+export { isListNode, isListItemNode, isBulletList, isParagraphNode } from '../utils';

package/dist/es2019/lists/node.js

@@ -0,0 +1,97 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { isListItemNode, isListNode } from '../utils';
+export function isListNodeValidContent(node) {
+  const {
+    bulletList
+  } = node.type.schema.nodes;
+  if (!bulletList) {
+    return false;
+  }
+  const listFragment = Fragment.from(bulletList.createAndFill());
+  return !isListItemNode(node) && node.type.validContent(listFragment);
+}
+export let JoinDirection = /*#__PURE__*/function (JoinDirection) {
+  JoinDirection[JoinDirection["LEFT"] = 1] = "LEFT";
+  JoinDirection[JoinDirection["RIGHT"] = -1] = "RIGHT";
+  return JoinDirection;
+}({});
+export const joinSiblingLists = ({
+  tr,
+  direction,
+  forceListType
+}) => {
+  const result = {
+    orderedList: 0,
+    bulletList: 0
+  };
+  const {
+    doc,
+    selection: {
+      $from,
+      $to
+    },
+    selection
+  } = tr;
+  const range = $from.blockRange($to, isListNodeValidContent);
+  if (!range) {
+    return result;
+  }
+  const rootListNode = doc.nodeAt(range.start);
+  const from = isListNode(rootListNode) ? range.start : 0;
+  const to = isListNode(rootListNode) ? range.end : tr.doc.content.size;
+  const joins = [];
+  doc.nodesBetween(from, to, (node, pos, parent) => {
+    const resolvedPos = doc.resolve(pos);
+    const {
+      nodeBefore,
+      nodeAfter
+    } = resolvedPos;
+    if (!nodeBefore || !nodeAfter || !isListNode(nodeBefore) || !isListNode(nodeAfter)) {
+      return;
+    }
+    const isNestedList = isListItemNode(parent);
+    if (!isNestedList && nodeBefore.type !== nodeAfter.type && !forceListType) {
+      return;
+    }
+    const index = resolvedPos.index();
+    const positionPreviousNode = resolvedPos.posAtIndex(index - 1);
+    const positionCurrentNode = resolvedPos.posAtIndex(index);
+
+    // If the previous node is part of the selection, OR
+    // If the previous node is not part of the selection and the previous node has the same list type that we’re converting to
+    const joinBefore = positionPreviousNode >= from || nodeBefore.type === forceListType;
+    if (forceListType) {
+      if (joinBefore) {
+        tr.setNodeMarkup(positionPreviousNode, forceListType);
+      }
+      tr.setNodeMarkup(positionCurrentNode, forceListType);
+    }
+    if (isNestedList && nodeBefore.type !== nodeAfter.type) {
+      const nodeType = direction === JoinDirection.RIGHT ? nodeAfter.type : nodeBefore.type;
+      tr.setNodeMarkup(positionPreviousNode, nodeType);
+    }
+    if (joinBefore) {
+      joins.push(pos);
+    }
+  });
+  if (selection.empty && rootListNode && isListNode(rootListNode)) {
+    const resolvedPos = doc.resolve(range.start + rootListNode.nodeSize);
+    const {
+      nodeBefore,
+      nodeAfter
+    } = resolvedPos;
+    if (nodeBefore && nodeAfter && isListNode(nodeBefore) && isListNode(nodeAfter) && nodeAfter.type === nodeBefore.type) {
+      joins.push(resolvedPos.pos);
+    }
+  }
+  for (let i = joins.length - 1; i >= 0; i--) {
+    const listNode = tr.doc.nodeAt(joins[i]);
+    const listName = listNode === null || listNode === void 0 ? void 0 : listNode.type.name;
+    if (listName && (listName === 'orderedList' || listName === 'bulletList')) {
+      const amount = result[listName] || 0;
+      result[listName] = amount + 1;
+    }
+    tr.join(joins[i]);
+  }
+  return result;
+};

package/dist/es2019/lists/replace-content.js

@@ -0,0 +1,18 @@
+import { ReplaceAroundStep, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+export const moveTargetIntoList = ({
+  insertPosition,
+  $target
+}) => {
+  var _$target$nodeAfter;
+  // take the text content of the paragraph and insert after the paragraph up until before the the cut
+  const from = insertPosition;
+  const to = $target.pos + (((_$target$nodeAfter = $target.nodeAfter) === null || _$target$nodeAfter === void 0 ? void 0 : _$target$nodeAfter.nodeSize) || 0); //$cut.pos + $cut.nodeAfter.nodeSize;
+  const gapFrom = $target.posAtIndex(0, $target.depth + 1); // start pos of the child
+  const gapTo = $target.doc.resolve(gapFrom).end(); // end pos of the paragraph
+
+  if (gapTo - gapFrom === 0) {
+    return new ReplaceStep(from, to, $target.doc.slice(insertPosition, $target.pos));
+  }
+  const step = new ReplaceAroundStep(from, to, gapFrom, gapTo, $target.doc.slice(insertPosition, $target.pos), 0, true);
+  return step;
+};

package/dist/es2019/lists/selection.js

@@ -0,0 +1,53 @@
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+import { isListItemNode, isListNode } from '../utils';
+export const numberNestedLists = resolvedPos => {
+  let count = 0;
+  for (let i = resolvedPos.depth - 1; i > 0; i--) {
+    const node = resolvedPos.node(i);
+    if (isListNode(node)) {
+      count += 1;
+    }
+  }
+  return count;
+};
+export const getListItemAttributes = $pos => {
+  const indentLevel = numberNestedLists($pos) - 1;
+  const itemAtPos = findParentNodeClosestToPos($pos, isListItemNode);
+
+  // Get the index of the current item relative to parent (parent is at item depth - 1)
+  const itemIndex = $pos.index(itemAtPos ? itemAtPos.depth - 1 : undefined);
+  return {
+    indentLevel,
+    itemIndex
+  };
+};
+export const normalizeListItemsSelection = ({
+  selection,
+  doc
+}) => {
+  if (selection.empty) {
+    return selection;
+  }
+  const {
+    $from,
+    $to
+  } = selection;
+  if (selection instanceof NodeSelection) {
+    const head = resolvePositionToStartOfListItem($from);
+    return new TextSelection(head, head);
+  }
+  const head = resolvePositionToStartOfListItem($from);
+  const anchor = resolvePositionToEndOfListItem($to);
+  return new TextSelection(anchor, head);
+};
+const resolvePositionToStartOfListItem = $pos => {
+  const fromRange = $pos.blockRange($pos, isListItemNode);
+  const fromPosition = fromRange && $pos.textOffset === 0 && fromRange.end - 1 === $pos.pos ? Selection.near($pos.doc.resolve(fromRange.end + 1), 1).$from : $pos;
+  return fromPosition;
+};
+const resolvePositionToEndOfListItem = $pos => {
+  const toRange = $pos.blockRange($pos, isListItemNode);
+  const toPosition = toRange && $pos.textOffset === 0 && toRange.start + 1 === $pos.pos ? Selection.near($pos.doc.resolve(toRange.start - 1), -1).$to : $pos;
+  return toPosition;
+};

package/dist/es2019/monitoring/error.js

@@ -1,6 +1,6 @@
 const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-const packageVersion = "74.30.0";
+const packageVersion = "74.31.0";
 const sanitiseSentryEvents = (data, _hint) => {
   // Remove URL as it has UGC
   // TODO: Sanitise the URL instead of just removing it

package/dist/es2019/node-width/index.js

@@ -102,4 +102,11 @@ export const getTableContainerWidth = node => {
     return node.attrs.width;
   }
   return layoutToWidth[node.attrs.layout];
+};
+export const getTableWidthWithNumberColumn = (node, offset) => {
+  const isNumberColumnEnabled = node.attrs.isNumberColumnEnabled;
+  if (isNumberColumnEnabled && offset > 0) {
+    return getTableContainerWidth(node) - offset;
+  }
+  return getTableContainerWidth(node);
 };

package/dist/es2019/ui/DropList/index.js

@@ -8,7 +8,7 @@ import { themed } from '@atlaskit/theme/components';
 import { borderRadius } from '@atlaskit/theme/constants';
 import Layer from '../Layer';
 const packageName = "@atlaskit/editor-common";
-const packageVersion = "74.30.0";
+const packageVersion = "74.31.0";
 const halfFocusRing = 1;
 const dropOffset = '0, 8';
 class DropList extends Component {

package/dist/es2019/utils/commands.js

@@ -1,4 +1,7 @@
-export const filter = (predicates, cmd) => {
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { GapCursorSelection } from '../selection';
+import { isEmptyParagraph } from './editor-core-utils';
+const filter = (predicates, cmd) => {
   return function (state, dispatch, view) {
     if (!Array.isArray(predicates)) {
       predicates = [predicates];
@@ -8,4 +11,105 @@ export const filter = (predicates, cmd) => {
     }
     return cmd(state, dispatch, view) || false;
   };
-};
+};
+
+/**
+ * Walk forwards from a position until we encounter the (inside) start of
+ * the next node, or reach the end of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+export const walkNextNode = $startPos => {
+  let $pos = $startPos;
+
+  // invariant 1: don't walk past the end of the document
+  // invariant 2: we are at the beginning or
+  //              we haven't walked to the start of *any* node
+  //              parentOffset includes textOffset.
+  while ($pos.pos < $pos.doc.nodeSize - 2 && ($pos.pos === $startPos.pos || $pos.parentOffset > 0)) {
+    $pos = $pos.doc.resolve($pos.pos + 1);
+  }
+  return {
+    $pos: $pos,
+    foundNode: $pos.pos < $pos.doc.nodeSize - 2
+  };
+};
+
+/**
+ * Walk backwards from a position until we encounter the (inside) end of
+ * the previous node, or reach the start of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+export const walkPrevNode = $startPos => {
+  let $pos = $startPos;
+  while ($pos.pos > 0 && ($pos.pos === $startPos.pos || $pos.parentOffset < $pos.parent.nodeSize - 2)) {
+    $pos = $pos.doc.resolve($pos.pos - 1);
+  }
+  return {
+    $pos: $pos,
+    foundNode: $pos.pos > 0
+  };
+};
+
+/**
+ * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
+ * and move the node below it up. The selection will be retained, to be placed in the moved node.
+ *
+ * @param canNextNodeMoveUp check if node directly after the selection is able to be brought up to selection
+ * @returns PM Command
+ */
+export const deleteEmptyParagraphAndMoveBlockUp = canNextNodeMoveUp => {
+  return (state, dispatch, view) => {
+    const {
+      selection: {
+        $from: {
+          pos,
+          parent
+        },
+        $head,
+        empty
+      },
+      tr,
+      doc
+    } = state;
+    const {
+      $pos
+    } = walkNextNode($head);
+    const nextPMNode = doc.nodeAt($pos.pos - 1);
+    if (empty && nextPMNode && canNextNodeMoveUp(nextPMNode) && isEmptyParagraph(parent) && view !== null && view !== void 0 && view.endOfTextblock('right')) {
+      tr.deleteRange(pos - 1, pos + 1);
+      if (dispatch) {
+        dispatch(tr);
+      }
+      return true;
+    }
+    return false;
+  };
+};
+export const insertContentDeleteRange = (tr, getSelectionResolvedPos, insertions, deletions) => {
+  insertions.forEach(contentInsert => {
+    let [content, pos] = contentInsert;
+    tr.insert(tr.mapping.map(pos), content);
+  });
+  deletions.forEach(deleteRange => {
+    let [firstPos, lastPos] = deleteRange;
+    tr.delete(tr.mapping.map(firstPos), tr.mapping.map(lastPos));
+  });
+  tr.setSelection(new TextSelection(getSelectionResolvedPos(tr)));
+};
+export const isEmptySelectionAtStart = state => {
+  const {
+    empty,
+    $from
+  } = state.selection;
+  return empty && ($from.parentOffset === 0 || state.selection instanceof GapCursorSelection);
+};
+export const isEmptySelectionAtEnd = state => {
+  const {
+    empty,
+    $from
+  } = state.selection;
+  return empty && ($from.end() === $from.pos || state.selection instanceof GapCursorSelection);
+};
+export { filter as filterCommand };

package/dist/es2019/utils/document.js

@@ -250,4 +250,28 @@ const maySanitizePrivateContent = (entity, providerFactory, sanitizePrivateConte
     return sanitizeNodeForPrivacy(entity, providerFactory);
   }
   return entity;
-};
+};
+
+/**
+ * Returns false if node contains only empty inline nodes and hardBreaks.
+ */
+export function hasVisibleContent(node) {
+  const isInlineNodeHasVisibleContent = inlineNode => {
+    return inlineNode.isText ? !!inlineNode.textContent.trim() : inlineNode.type.name !== 'hardBreak';
+  };
+  if (node.isInline) {
+    return isInlineNodeHasVisibleContent(node);
+  } else if (node.isBlock && (node.isLeaf || node.isAtom)) {
+    return true;
+  } else if (!node.childCount) {
+    return false;
+  }
+  for (let index = 0; index < node.childCount; index++) {
+    const child = node.child(index);
+    const invisibleNodeTypes = ['paragraph', 'text', 'hardBreak'];
+    if (!invisibleNodeTypes.includes(child.type.name) || hasVisibleContent(child)) {
+      return true;
+    }
+  }
+  return false;
+}

package/dist/es2019/utils/index.js

@@ -33,6 +33,7 @@ export { validateADFEntity, validationErrorHandler } from './validate-using-spec
 export { getShallowPropsDifference, getPropsDifference } from './compare-props';
 export { useComponentRenderTracking } from './performance/hooks/use-component-render-tracking';
 export { isOutdatedBrowser } from './outdated-browsers';
+export { autoJoinTr } from './prosemirror/autojoin';
 export { isReferencedSource, removeConnectedNodes, getChildrenInfo, getNodeName } from './referentiality';
 export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder, isListNode, isParagraphNode, isListItemNode, isBulletList } from './list';
 export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLinkDomain, findFilepaths, isLinkInMatches, FILEPATH_REGEXP, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent, canLinkBeCreatedInRange } from './hyperlink';
@@ -40,11 +41,11 @@ export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLink
 // prosemirror-history does not export its plugin key
 export const pmHistoryPluginKey = 'history$';
 export { gridTypeForLayout } from './grid';
-export { nodesBetweenChanged, getStepRange, isEmptyDocument, processRawValue, hasDocAsParent, bracketTyped } from './document';
+export { nodesBetweenChanged, getStepRange, isEmptyDocument, processRawValue, hasDocAsParent, bracketTyped, hasVisibleContent } from './document';
 export { floatingLayouts, isRichMediaInsideOfBlockNode, calculateSnapPoints, alignAttributes } from './rich-media-utils';
 export { sanitizeNodeForPrivacy } from './filter/privacy-filter';
 export { canRenderDatasource } from './datasource';
-export { filter as filterCommands } from './commands';
+export { filterCommand, walkPrevNode, walkNextNode, isEmptySelectionAtStart, isEmptySelectionAtEnd, insertContentDeleteRange, deleteEmptyParagraphAndMoveBlockUp } from './commands';
 export function shallowEqual(obj1 = {}, obj2 = {}) {
   const keys1 = Object.keys(obj1);
   const keys2 = Object.keys(obj2);

package/dist/es2019/utils/prosemirror/autojoin.js

@@ -0,0 +1,57 @@
+import { canJoin } from '@atlaskit/editor-prosemirror/transform';
+
+/**
+ * Checks whether two adjacent nodes can be joined. If so, the document
+ * will be updated to join those nodes. If not, the original transaction
+ * remains untouched.
+ *
+ * Nodes are considered joinable if the `isJoinable` predicate returns true or,
+ * if an array of strings was passed, if their node type name is in that array.
+ *
+ * Adapted from https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L597-L610
+ */
+export function autoJoinTr(tr, isJoinable) {
+  if (Array.isArray(isJoinable)) {
+    let types = isJoinable;
+    isJoinable = node => types.indexOf(node.type.name) > -1;
+  }
+  const ranges = [];
+  for (let i = 0; i < tr.mapping.maps.length; i++) {
+    const map = tr.mapping.maps[i];
+    for (let j = 0; j < ranges.length; j++) {
+      ranges[j] = map.map(ranges[j]);
+    }
+    map.forEach((_s, _e, from, to) => ranges.push(from, to));
+  }
+
+  // Figure out which joinable points exist inside those ranges,
+  // by checking all node boundaries in their parent nodes.
+  const joinable = [];
+  for (let i = 0; i < ranges.length; i += 2) {
+    const from = ranges[i];
+    const to = ranges[i + 1];
+    const $from = tr.doc.resolve(from);
+    const depth = $from.sharedDepth(to);
+    const parent = $from.node(depth);
+    for (let index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {
+      const after = parent.maybeChild(index);
+      if (!after) {
+        break;
+      }
+      if (index && joinable.indexOf(pos) === -1) {
+        const before = parent.child(index - 1);
+        if (before.type === after.type && isJoinable(before, after)) {
+          joinable.push(pos);
+        }
+      }
+      pos += after.nodeSize;
+    }
+  }
+  // Join the joinable points
+  joinable.sort((a, b) => a - b);
+  for (let i = joinable.length - 1; i >= 0; i--) {
+    if (canJoin(tr.doc, joinable[i])) {
+      tr.join(joinable[i]);
+    }
+  }
+}

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "74.30.0",
+	"version": "74.31.0",
 	"sideEffects": false
 }

package/dist/esm/lists/analytics.js

@@ -0,0 +1,32 @@
+import { isListItemNode, isListNode } from '../utils';
+import { getListItemAttributes } from './selection';
+export var getCommonListAnalyticsAttributes = function getCommonListAnalyticsAttributes(state) {
+  var _state$selection = state.selection,
+    $from = _state$selection.$from,
+    $to = _state$selection.$to;
+  var fromAttrs = getListItemAttributes($from);
+  var toAttrs = getListItemAttributes($to);
+  return {
+    itemIndexAtSelectionStart: fromAttrs.itemIndex,
+    itemIndexAtSelectionEnd: toAttrs.itemIndex,
+    indentLevelAtSelectionStart: fromAttrs.indentLevel,
+    indentLevelAtSelectionEnd: toAttrs.indentLevel,
+    itemsInSelection: countListItemsInSelection(state)
+  };
+};
+export var countListItemsInSelection = function countListItemsInSelection(state) {
+  var _state$selection2 = state.selection,
+    from = _state$selection2.from,
+    to = _state$selection2.to;
+  if (from === to) {
+    return 1;
+  }
+  var count = 0;
+  var listSlice = state.doc.cut(from, to);
+  listSlice.content.nodesBetween(0, listSlice.content.size, function (node, pos, parent, index) {
+    if (parent && isListItemNode(parent) && !isListNode(node) && index === 0) {
+      count++;
+    }
+  });
+  return count;
+};

package/dist/esm/lists/indentation.js

@@ -0,0 +1,17 @@
+import { numberNestedLists } from './selection';
+export var hasValidListIndentationLevel = function hasValidListIndentationLevel(_ref) {
+  var tr = _ref.tr,
+    maxIndentation = _ref.maxIndentation;
+  var initialIndentationLevel = numberNestedLists(tr.selection.$from);
+  var currentIndentationLevel;
+  var currentPos = tr.selection.$to.pos;
+  do {
+    var resolvedPos = tr.doc.resolve(currentPos);
+    currentIndentationLevel = numberNestedLists(resolvedPos);
+    if (currentIndentationLevel > maxIndentation) {
+      return false;
+    }
+    currentPos++;
+  } while (currentIndentationLevel >= initialIndentationLevel);
+  return true;
+};

package/dist/esm/lists/index.js

@@ -0,0 +1,6 @@
+export { getListItemAttributes, normalizeListItemsSelection } from './selection';
+export { moveTargetIntoList } from './replace-content';
+export { JoinDirection, isListNodeValidContent, joinSiblingLists } from './node';
+export { getCommonListAnalyticsAttributes, countListItemsInSelection } from './analytics';
+export { hasValidListIndentationLevel } from './indentation';
+export { isListNode, isListItemNode, isBulletList, isParagraphNode } from '../utils';