@atlaskit/editor-common 74.30.0 → 74.32.0

package/dist/cjs/utils/index.js

@@ -106,6 +106,12 @@ Object.defineProperty(exports, "analyticsEventKey", {
     return _analytics.analyticsEventKey;
   }
 });
+Object.defineProperty(exports, "autoJoinTr", {
+  enumerable: true,
+  get: function get() {
+    return _autojoin.autoJoinTr;
+  }
+});
 Object.defineProperty(exports, "bracketTyped", {
   enumerable: true,
   get: function get() {
@@ -220,16 +226,22 @@ Object.defineProperty(exports, "createCompareNodes", {
     return _compareNodes.createCompareNodes;
   }
 });
+Object.defineProperty(exports, "deleteEmptyParagraphAndMoveBlockUp", {
+  enumerable: true,
+  get: function get() {
+    return _commands.deleteEmptyParagraphAndMoveBlockUp;
+  }
+});
 Object.defineProperty(exports, "extractSliceFromStep", {
   enumerable: true,
   get: function get() {
     return _editorCoreUtils.extractSliceFromStep;
   }
 });
-Object.defineProperty(exports, "filterCommands", {
+Object.defineProperty(exports, "filterCommand", {
   enumerable: true,
   get: function get() {
-    return _commands.filter;
+    return _commands.filterCommand;
   }
 });
 Object.defineProperty(exports, "findAndTrackUnsupportedContentNodes", {
@@ -424,6 +436,24 @@ Object.defineProperty(exports, "hasMergedCell", {
     return _table.hasMergedCell;
   }
 });
+Object.defineProperty(exports, "hasVisibleContent", {
+  enumerable: true,
+  get: function get() {
+    return _document.hasVisibleContent;
+  }
+});
+Object.defineProperty(exports, "inputRuleWithAnalytics", {
+  enumerable: true,
+  get: function get() {
+    return _inputRules.inputRuleWithAnalytics;
+  }
+});
+Object.defineProperty(exports, "insertContentDeleteRange", {
+  enumerable: true,
+  get: function get() {
+    return _commands.insertContentDeleteRange;
+  }
+});
 Object.defineProperty(exports, "isBulletList", {
   enumerable: true,
   get: function get() {
@@ -448,6 +478,18 @@ Object.defineProperty(exports, "isEmptyParagraph", {
     return _editorCoreUtils.isEmptyParagraph;
   }
 });
+Object.defineProperty(exports, "isEmptySelectionAtEnd", {
+  enumerable: true,
+  get: function get() {
+    return _commands.isEmptySelectionAtEnd;
+  }
+});
+Object.defineProperty(exports, "isEmptySelectionAtStart", {
+  enumerable: true,
+  get: function get() {
+    return _commands.isEmptySelectionAtStart;
+  }
+});
 Object.defineProperty(exports, "isFromCurrentDomain", {
   enumerable: true,
   get: function get() {
@@ -828,6 +870,18 @@ Object.defineProperty(exports, "validationErrorHandler", {
     return _validateUsingSpec.validationErrorHandler;
   }
 });
+Object.defineProperty(exports, "walkNextNode", {
+  enumerable: true,
+  get: function get() {
+    return _commands.walkNextNode;
+  }
+});
+Object.defineProperty(exports, "walkPrevNode", {
+  enumerable: true,
+  get: function get() {
+    return _commands.walkPrevNode;
+  }
+});
 Object.defineProperty(exports, "walkUpTreeUntil", {
   enumerable: true,
   get: function get() {
@@ -875,6 +929,7 @@ var _validateUsingSpec = require("./validate-using-spec");
 var _compareProps = require("./compare-props");
 var _useComponentRenderTracking = require("./performance/hooks/use-component-render-tracking");
 var _outdatedBrowsers = require("./outdated-browsers");
+var _autojoin = require("./prosemirror/autojoin");
 var _referentiality = require("./referentiality");
 var _list = require("./list");
 var _hyperlink = require("./hyperlink");
@@ -884,6 +939,7 @@ var _richMediaUtils = require("./rich-media-utils");
 var _privacyFilter = require("./filter/privacy-filter");
 var _datasource = require("./datasource");
 var _commands = require("./commands");
+var _inputRules = require("./input-rules");
 // prosemirror-history does not export its plugin key
 var pmHistoryPluginKey = 'history$';
 exports.pmHistoryPluginKey = pmHistoryPluginKey;

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

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.inputRuleWithAnalytics = 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; }
+// 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
+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
+    });
+  };
+};
+exports.inputRuleWithAnalytics = inputRuleWithAnalytics;

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.32.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.32.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/types/input-rules.js

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

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.32.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,13 +41,14 @@ 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);
   return keys1.length === keys2.length && keys1.reduce((acc, key) => acc && obj1[key] === obj2[key], true);
-}
+}
+export { inputRuleWithAnalytics } from './input-rules';