@atlaskit/editor-common 74.30.0 → 74.32.0

package/dist/es2019/utils/input-rules.js

@@ -0,0 +1,16 @@
+// Roughly based on atlassian-frontend/packages/editor/editor-core/src/utils/input-rules.ts but with the Editor Analytics API that's injected in plugins
+export const inputRuleWithAnalytics = (getPayload, analyticsApi) => {
+  return originalRule => {
+    const onHandlerApply = (state, tr, matchResult) => {
+      const payload = typeof getPayload === 'function' ? getPayload(state, matchResult) : getPayload;
+      analyticsApi === null || analyticsApi === void 0 ? void 0 : analyticsApi.attachAnalyticsEvent(payload)(tr);
+      if (originalRule.onHandlerApply) {
+        originalRule.onHandlerApply(state, tr, matchResult);
+      }
+    };
+    return {
+      ...originalRule,
+      onHandlerApply
+    };
+  };
+};

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.32.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';

package/dist/esm/lists/node.js

@@ -0,0 +1,87 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { isListItemNode, isListNode } from '../utils';
+export function isListNodeValidContent(node) {
+  var bulletList = node.type.schema.nodes.bulletList;
+  if (!bulletList) {
+    return false;
+  }
+  var listFragment = Fragment.from(bulletList.createAndFill());
+  return !isListItemNode(node) && node.type.validContent(listFragment);
+}
+export var JoinDirection = /*#__PURE__*/function (JoinDirection) {
+  JoinDirection[JoinDirection["LEFT"] = 1] = "LEFT";
+  JoinDirection[JoinDirection["RIGHT"] = -1] = "RIGHT";
+  return JoinDirection;
+}({});
+export var joinSiblingLists = function joinSiblingLists(_ref) {
+  var tr = _ref.tr,
+    direction = _ref.direction,
+    forceListType = _ref.forceListType;
+  var result = {
+    orderedList: 0,
+    bulletList: 0
+  };
+  var doc = tr.doc,
+    _tr$selection = tr.selection,
+    $from = _tr$selection.$from,
+    $to = _tr$selection.$to,
+    selection = tr.selection;
+  var range = $from.blockRange($to, isListNodeValidContent);
+  if (!range) {
+    return result;
+  }
+  var rootListNode = doc.nodeAt(range.start);
+  var from = isListNode(rootListNode) ? range.start : 0;
+  var to = isListNode(rootListNode) ? range.end : tr.doc.content.size;
+  var joins = [];
+  doc.nodesBetween(from, to, function (node, pos, parent) {
+    var resolvedPos = doc.resolve(pos);
+    var nodeBefore = resolvedPos.nodeBefore,
+      nodeAfter = resolvedPos.nodeAfter;
+    if (!nodeBefore || !nodeAfter || !isListNode(nodeBefore) || !isListNode(nodeAfter)) {
+      return;
+    }
+    var isNestedList = isListItemNode(parent);
+    if (!isNestedList && nodeBefore.type !== nodeAfter.type && !forceListType) {
+      return;
+    }
+    var index = resolvedPos.index();
+    var positionPreviousNode = resolvedPos.posAtIndex(index - 1);
+    var 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
+    var joinBefore = positionPreviousNode >= from || nodeBefore.type === forceListType;
+    if (forceListType) {
+      if (joinBefore) {
+        tr.setNodeMarkup(positionPreviousNode, forceListType);
+      }
+      tr.setNodeMarkup(positionCurrentNode, forceListType);
+    }
+    if (isNestedList && nodeBefore.type !== nodeAfter.type) {
+      var nodeType = direction === JoinDirection.RIGHT ? nodeAfter.type : nodeBefore.type;
+      tr.setNodeMarkup(positionPreviousNode, nodeType);
+    }
+    if (joinBefore) {
+      joins.push(pos);
+    }
+  });
+  if (selection.empty && rootListNode && isListNode(rootListNode)) {
+    var resolvedPos = doc.resolve(range.start + rootListNode.nodeSize);
+    var nodeBefore = resolvedPos.nodeBefore,
+      nodeAfter = resolvedPos.nodeAfter;
+    if (nodeBefore && nodeAfter && isListNode(nodeBefore) && isListNode(nodeAfter) && nodeAfter.type === nodeBefore.type) {
+      joins.push(resolvedPos.pos);
+    }
+  }
+  for (var i = joins.length - 1; i >= 0; i--) {
+    var listNode = tr.doc.nodeAt(joins[i]);
+    var listName = listNode === null || listNode === void 0 ? void 0 : listNode.type.name;
+    if (listName && (listName === 'orderedList' || listName === 'bulletList')) {
+      var amount = result[listName] || 0;
+      result[listName] = amount + 1;
+    }
+    tr.join(joins[i]);
+  }
+  return result;
+};

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

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

package/dist/esm/lists/selection.js

@@ -0,0 +1,50 @@
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+import { isListItemNode, isListNode } from '../utils';
+export var numberNestedLists = function numberNestedLists(resolvedPos) {
+  var count = 0;
+  for (var i = resolvedPos.depth - 1; i > 0; i--) {
+    var node = resolvedPos.node(i);
+    if (isListNode(node)) {
+      count += 1;
+    }
+  }
+  return count;
+};
+export var getListItemAttributes = function getListItemAttributes($pos) {
+  var indentLevel = numberNestedLists($pos) - 1;
+  var itemAtPos = findParentNodeClosestToPos($pos, isListItemNode);
+
+  // Get the index of the current item relative to parent (parent is at item depth - 1)
+  var itemIndex = $pos.index(itemAtPos ? itemAtPos.depth - 1 : undefined);
+  return {
+    indentLevel: indentLevel,
+    itemIndex: itemIndex
+  };
+};
+export var normalizeListItemsSelection = function normalizeListItemsSelection(_ref) {
+  var selection = _ref.selection,
+    doc = _ref.doc;
+  if (selection.empty) {
+    return selection;
+  }
+  var $from = selection.$from,
+    $to = selection.$to;
+  if (selection instanceof NodeSelection) {
+    var _head = resolvePositionToStartOfListItem($from);
+    return new TextSelection(_head, _head);
+  }
+  var head = resolvePositionToStartOfListItem($from);
+  var anchor = resolvePositionToEndOfListItem($to);
+  return new TextSelection(anchor, head);
+};
+var resolvePositionToStartOfListItem = function resolvePositionToStartOfListItem($pos) {
+  var fromRange = $pos.blockRange($pos, isListItemNode);
+  var fromPosition = fromRange && $pos.textOffset === 0 && fromRange.end - 1 === $pos.pos ? Selection.near($pos.doc.resolve(fromRange.end + 1), 1).$from : $pos;
+  return fromPosition;
+};
+var resolvePositionToEndOfListItem = function resolvePositionToEndOfListItem($pos) {
+  var toRange = $pos.blockRange($pos, isListItemNode);
+  var 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/esm/monitoring/error.js

@@ -6,7 +6,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 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) { _defineProperty(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 SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "74.30.0";
+var packageVersion = "74.32.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // TODO: Sanitise the URL instead of just removing it

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

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

package/dist/esm/types/input-rules.js

@@ -0,0 +1 @@
+export {};

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

@@ -18,7 +18,7 @@ import { themed } from '@atlaskit/theme/components';
 import { borderRadius } from '@atlaskit/theme/constants';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "74.30.0";
+var packageVersion = "74.32.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var DropList = /*#__PURE__*/function (_Component) {

package/dist/esm/utils/commands.js

@@ -1,4 +1,8 @@
-export var filter = function filter(predicates, cmd) {
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { GapCursorSelection } from '../selection';
+import { isEmptyParagraph } from './editor-core-utils';
+var filter = function filter(predicates, cmd) {
   return function (state, dispatch, view) {
     if (!Array.isArray(predicates)) {
       predicates = [predicates];
@@ -10,4 +14,102 @@ export var filter = function 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 var walkNextNode = function walkNextNode($startPos) {
+  var $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 var walkPrevNode = function walkPrevNode($startPos) {
+  var $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 var deleteEmptyParagraphAndMoveBlockUp = function deleteEmptyParagraphAndMoveBlockUp(canNextNodeMoveUp) {
+  return function (state, dispatch, view) {
+    var _state$selection = state.selection,
+      _state$selection$$fro = _state$selection.$from,
+      pos = _state$selection$$fro.pos,
+      parent = _state$selection$$fro.parent,
+      $head = _state$selection.$head,
+      empty = _state$selection.empty,
+      tr = state.tr,
+      doc = state.doc;
+    var _walkNextNode = walkNextNode($head),
+      $pos = _walkNextNode.$pos;
+    var 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 var insertContentDeleteRange = function insertContentDeleteRange(tr, getSelectionResolvedPos, insertions, deletions) {
+  insertions.forEach(function (contentInsert) {
+    var _contentInsert = _slicedToArray(contentInsert, 2),
+      content = _contentInsert[0],
+      pos = _contentInsert[1];
+    tr.insert(tr.mapping.map(pos), content);
+  });
+  deletions.forEach(function (deleteRange) {
+    var _deleteRange = _slicedToArray(deleteRange, 2),
+      firstPos = _deleteRange[0],
+      lastPos = _deleteRange[1];
+    tr.delete(tr.mapping.map(firstPos), tr.mapping.map(lastPos));
+  });
+  tr.setSelection(new TextSelection(getSelectionResolvedPos(tr)));
+};
+export var isEmptySelectionAtStart = function isEmptySelectionAtStart(state) {
+  var _state$selection2 = state.selection,
+    empty = _state$selection2.empty,
+    $from = _state$selection2.$from;
+  return empty && ($from.parentOffset === 0 || state.selection instanceof GapCursorSelection);
+};
+export var isEmptySelectionAtEnd = function isEmptySelectionAtEnd(state) {
+  var _state$selection3 = state.selection,
+    empty = _state$selection3.empty,
+    $from = _state$selection3.$from;
+  return empty && ($from.end() === $from.pos || state.selection instanceof GapCursorSelection);
+};
+export { filter as filterCommand };

package/dist/esm/utils/document.js

@@ -243,4 +243,28 @@ var maySanitizePrivateContent = function maySanitizePrivateContent(entity, provi
     return sanitizeNodeForPrivacy(entity, providerFactory);
   }
   return entity;
-};
+};
+
+/**
+ * Returns false if node contains only empty inline nodes and hardBreaks.
+ */
+export function hasVisibleContent(node) {
+  var isInlineNodeHasVisibleContent = function 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 (var _index = 0; _index < node.childCount; _index++) {
+    var child = node.child(_index);
+    var invisibleNodeTypes = ['paragraph', 'text', 'hardBreak'];
+    if (!invisibleNodeTypes.includes(child.type.name) || hasVisibleContent(child)) {
+      return true;
+    }
+  }
+  return false;
+}

package/dist/esm/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 var 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() {
   var obj1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var obj2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -53,4 +54,5 @@ export function shallowEqual() {
   return keys1.length === keys2.length && keys1.reduce(function (acc, key) {
     return acc && obj1[key] === obj2[key];
   }, true);
-}
+}
+export { inputRuleWithAnalytics } from './input-rules';

package/dist/esm/utils/input-rules.js

@@ -0,0 +1,18 @@
+import _defineProperty from "@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) { _defineProperty(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; }
+// Roughly based on atlassian-frontend/packages/editor/editor-core/src/utils/input-rules.ts but with the Editor Analytics API that's injected in plugins
+export var inputRuleWithAnalytics = function inputRuleWithAnalytics(getPayload, analyticsApi) {
+  return function (originalRule) {
+    var onHandlerApply = function onHandlerApply(state, tr, matchResult) {
+      var payload = typeof getPayload === 'function' ? getPayload(state, matchResult) : getPayload;
+      analyticsApi === null || analyticsApi === void 0 ? void 0 : analyticsApi.attachAnalyticsEvent(payload)(tr);
+      if (originalRule.onHandlerApply) {
+        originalRule.onHandlerApply(state, tr, matchResult);
+      }
+    };
+    return _objectSpread(_objectSpread({}, originalRule), {}, {
+      onHandlerApply: onHandlerApply
+    });
+  };
+};

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

@@ -0,0 +1,63 @@
+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)) {
+    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 (canJoin(tr.doc, joinable[_i2])) {
+      tr.join(joinable[_i2]);
+    }
+  }
+}

package/dist/esm/version.json

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

package/dist/types/lists/analytics.d.ts

@@ -0,0 +1,4 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { CommonListAnalyticsAttributes } from '../analytics';
+export declare const getCommonListAnalyticsAttributes: (state: EditorState) => CommonListAnalyticsAttributes;
+export declare const countListItemsInSelection: (state: EditorState) => number;

package/dist/types/lists/indentation.d.ts

@@ -0,0 +1,5 @@
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const hasValidListIndentationLevel: ({ tr, maxIndentation, }: {
+    tr: Transaction;
+    maxIndentation: number;
+}) => boolean;

package/dist/types/lists/index.d.ts

@@ -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/types/lists/node.d.ts

@@ -0,0 +1,18 @@
+import { NodeType, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function isListNodeValidContent(node: PMNode): boolean;
+export declare enum JoinDirection {
+    LEFT = 1,
+    RIGHT = -1
+}
+type JoinSiblingListsProps = {
+    tr: Transaction;
+    direction?: JoinDirection;
+    forceListType?: NodeType;
+};
+type ListsJoined = {
+    orderedList: number;
+    bulletList: number;
+};
+export declare const joinSiblingLists: ({ tr, direction, forceListType, }: JoinSiblingListsProps) => ListsJoined;
+export {};

package/dist/types/lists/replace-content.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import { Step } from '@atlaskit/editor-prosemirror/transform';
+type Params = {
+    insertPosition: number;
+    $target: ResolvedPos;
+};
+export declare const moveTargetIntoList: ({ insertPosition, $target, }: Params) => Step;
+export {};