@atlaskit/editor-common 74.5.2 → 74.7.0

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

@@ -0,0 +1,203 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+import React from 'react';
+import classnames from 'classnames';
+import { Resizable } from 're-resizable';
+import { akRichMediaResizeZIndex } from '@atlaskit/editor-shared-styles';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../../analytics';
+import { richMediaClassName } from '../../styles';
+import { gridTypeForLayout } from '../../utils';
+import { handleSides, snapTo } from './utils';
+var getResizeAnalyticsEvent = function getResizeAnalyticsEvent(type, size, layout) {
+  var actionSubject = type === 'embed' ? ACTION_SUBJECT.EMBEDS : ACTION_SUBJECT.MEDIA_SINGLE;
+  return {
+    action: ACTION.EDITED,
+    actionSubject: actionSubject,
+    actionSubjectId: ACTION_SUBJECT_ID.RESIZED,
+    attributes: {
+      size: size,
+      layout: layout
+    },
+    eventType: EVENT_TYPE.UI
+  };
+};
+var getWidthFromSnapPoints = function getWidthFromSnapPoints(width, snapPoints) {
+  if (snapPoints.length) {
+    return Math.min(Math.max(width, snapPoints[0]), snapPoints[snapPoints.length - 1]);
+  }
+  return width;
+};
+var Resizer = /*#__PURE__*/function (_React$Component) {
+  _inherits(Resizer, _React$Component);
+  var _super = _createSuper(Resizer);
+  function Resizer() {
+    var _this;
+    _classCallCheck(this, Resizer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "resizable", /*#__PURE__*/React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      isResizing: false
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleResizeStart", function (event) {
+      var _this$props = _this.props,
+        _this$props$innerPadd = _this$props.innerPadding,
+        innerPadding = _this$props$innerPadd === void 0 ? 0 : _this$props$innerPadd,
+        highlights = _this$props.highlights,
+        displayGrid = _this$props.displayGrid,
+        layout = _this$props.layout,
+        width = _this$props.width,
+        snapPoints = _this$props.snapPoints;
+
+      // prevent creating a drag event on Firefox
+      event.preventDefault();
+      _this.setState({
+        isResizing: true
+      }, function () {
+        var newHighlights = highlights(width + innerPadding, snapPoints);
+        displayGrid === null || displayGrid === void 0 ? void 0 : displayGrid(newHighlights.length > 0, gridTypeForLayout(layout), newHighlights);
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleResize", function (_event, _direction, _elementRef, delta) {
+      var _this$props2 = _this.props,
+        highlights = _this$props2.highlights,
+        calcNewSize = _this$props2.calcNewSize,
+        scaleFactor = _this$props2.scaleFactor,
+        snapPoints = _this$props2.snapPoints,
+        displayGrid = _this$props2.displayGrid,
+        layout = _this$props2.layout,
+        updateSize = _this$props2.updateSize,
+        _this$props2$innerPad = _this$props2.innerPadding,
+        innerPadding = _this$props2$innerPad === void 0 ? 0 : _this$props2$innerPad;
+      var resizable = _this.resizable.current;
+      var isResizing = _this.state.isResizing;
+      if (!resizable || !resizable.state.original || !isResizing) {
+        return;
+      }
+      var newWidth = getWidthFromSnapPoints(resizable.state.original.width + delta.width * (scaleFactor || 1), snapPoints);
+      var newSize = calcNewSize(newWidth + innerPadding, false);
+      if (newSize.layout !== layout) {
+        updateSize(newSize.width, newSize.layout);
+      }
+      var newHighlights = highlights(newWidth, snapPoints);
+      displayGrid === null || displayGrid === void 0 ? void 0 : displayGrid(newHighlights.length > 0, gridTypeForLayout(newSize.layout), newHighlights);
+      resizable.updateSize({
+        width: newWidth,
+        height: 'auto'
+      });
+      resizable.setState({
+        isResizing: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleResizeStop", function (_event, _direction, _elementRef, delta) {
+      var _this$props3 = _this.props,
+        highlights = _this$props3.highlights,
+        calcNewSize = _this$props3.calcNewSize,
+        snapPoints = _this$props3.snapPoints,
+        displayGrid = _this$props3.displayGrid,
+        layout = _this$props3.layout,
+        updateSize = _this$props3.updateSize,
+        dispatchAnalyticsEvent = _this$props3.dispatchAnalyticsEvent,
+        nodeType = _this$props3.nodeType;
+      var resizable = _this.resizable.current;
+      var isResizing = _this.state.isResizing;
+      if (!resizable || !resizable.state.original || !isResizing) {
+        return;
+      }
+      var newWidth = getWidthFromSnapPoints(resizable.state.original.width + delta.width, snapPoints);
+      var snapWidth = snapTo(newWidth, snapPoints);
+      var newSize = calcNewSize(snapWidth, true);
+      var newHighlights = highlights(newWidth, snapPoints);
+      if (dispatchAnalyticsEvent) {
+        dispatchAnalyticsEvent(getResizeAnalyticsEvent(nodeType, newSize.width, newSize.layout));
+      }
+      // show committed grid size
+      displayGrid === null || displayGrid === void 0 ? void 0 : displayGrid(newHighlights.length > 0, gridTypeForLayout(newSize.layout), newHighlights);
+      _this.setState({
+        isResizing: false
+      }, function () {
+        updateSize(newSize.width, newSize.layout);
+        displayGrid === null || displayGrid === void 0 ? void 0 : displayGrid(false, gridTypeForLayout(layout), []);
+      });
+    });
+    return _this;
+  }
+  _createClass(Resizer, [{
+    key: "render",
+    value: function render() {
+      var handleStyles = {};
+      var handles = {};
+      var handleComponent = {};
+      var _this$props4 = this.props,
+        _this$props4$innerPad = _this$props4.innerPadding,
+        innerPadding = _this$props4$innerPad === void 0 ? 0 : _this$props4$innerPad,
+        width = _this$props4.width,
+        pctWidth = _this$props4.pctWidth,
+        selected = _this$props4.selected,
+        layout = _this$props4.layout,
+        enable = _this$props4.enable,
+        children = _this$props4.children,
+        ratio = _this$props4.ratio,
+        handleComponentFunc = _this$props4.handleComponentFunc;
+      var isResizing = this.state.isResizing;
+      handleSides.forEach(function (side) {
+        var _handleStyles$side;
+        handles[side] = "richMedia-resize-handle-".concat(side);
+        handleStyles[side] = (_handleStyles$side = {
+          width: '24px'
+        }, _defineProperty(_handleStyles$side, side, "".concat(-13 - innerPadding, "px")), _defineProperty(_handleStyles$side, "zIndex", akRichMediaResizeZIndex), _defineProperty(_handleStyles$side, "pointerEvents", 'auto'), _handleStyles$side);
+        var sideHandleComponent = handleComponentFunc && handleComponentFunc(side);
+        if (sideHandleComponent) {
+          handleComponent[side] = sideHandleComponent;
+        }
+      });
+      var className = classnames(richMediaClassName, "image-".concat(layout), this.props.className, {
+        'is-resizing': isResizing,
+        'not-resized': !pctWidth,
+        'richMedia-selected': selected,
+        'rich-media-wrapped': layout === 'wrap-left' || layout === 'wrap-right'
+      });
+      var handleWrapperStyle;
+      if (ratio) {
+        handleWrapperStyle = {
+          position: 'absolute',
+          width: '100%',
+          paddingBottom: "".concat(ratio, "%"),
+          top: 0,
+          pointerEvents: 'none'
+        };
+      }
+
+      // Ideally, Resizable would let you pass in the component rather than
+      // the div. For now, we just apply the same styles using CSS
+      return /*#__PURE__*/React.createElement(Resizable, {
+        ref: this.resizable,
+        size: {
+          width: width,
+          // just content itself (no paddings)
+          height: 'auto'
+        },
+        className: className,
+        handleClasses: handles,
+        handleStyles: handleStyles,
+        handleWrapperStyle: handleWrapperStyle,
+        handleComponent: handleComponent,
+        enable: enable,
+        onResize: this.handleResize,
+        onResizeStop: this.handleResizeStop,
+        onResizeStart: this.handleResizeStart
+      }, children);
+    }
+  }]);
+  return Resizer;
+}(React.Component);
+export { Resizer as default };

package/dist/esm/ui/ResizerLegacy/styled.js

@@ -0,0 +1,7 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _templateObject;
+import { css } from '@emotion/react';
+import { MediaSingleDimensionHelper } from '../MediaSingle/styled';
+export var wrapperStyle = function wrapperStyle(props) {
+  return css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  & > div {\n    ", ";\n    position: relative;\n    clear: both;\n\n    > div {\n      position: absolute;\n      height: 100%;\n      width: 100%;\n    }\n  }\n"])), MediaSingleDimensionHelper(props));
+};

package/dist/esm/ui/ResizerLegacy/types.js

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

package/dist/esm/ui/ResizerLegacy/utils.js

@@ -0,0 +1,12 @@
+export var snapTo = function snapTo(target, points) {
+  return points.length === 0 ?
+  // extreme last case if there are no points somehow
+  target : points.reduce(function (point, closest) {
+    return Math.abs(closest - target) < Math.abs(point - target) ? closest : point;
+  });
+};
+export var handleSides = ['left', 'right'];
+export var imageAlignmentMap = {
+  left: 'start',
+  right: 'end'
+};

package/dist/esm/ui/index.js

@@ -18,4 +18,8 @@ export { clearNextSiblingMarginTopStyle, clearNextSiblingBlockMarkMarginTopStyle
 export { IntlErrorBoundary, REACT_INTL_ERROR_MESSAGE } from './IntlErrorBoundary';
 export { default as IntlProviderIfMissingWrapper } from './IntlProviderIfMissingWrapper';
 export { default as FloatingToolbarButton } from './FloatingToolbar/Button';
-export { ContextPanelProvider, ContextPanelWidthProvider, ContextPanelConsumer, ContextPanel } from './ContextPanel/context';
+export { RECENT_SEARCH_WIDTH_IN_PX, RECENT_SEARCH_WIDTH_WITHOUT_ITEMS_IN_PX, RECENT_SEARCH_HEIGHT_IN_PX, LINKPICKER_HEIGHT_IN_PX } from './LinkSearch/const';
+export { ContextPanelProvider, ContextPanelWidthProvider, ContextPanelConsumer, ContextPanel } from './ContextPanel/context';
+export { default as Resizer } from './ResizerLegacy';
+export { snapTo, handleSides, imageAlignmentMap } from './ResizerLegacy/utils';
+export { wrapperStyle } from './ResizerLegacy/styled';

package/dist/esm/utils/document.js

@@ -0,0 +1,246 @@
+import { Node } from 'prosemirror-model';
+import { transformDedupeMarks, transformIndentationMarks, transformInvalidMediaContent, transformMediaLinkMarks, transformNodesMissingContent, transformTextLinkCodeMarks } from '@atlaskit/adf-utils/transforms';
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '../analytics';
+import { isEmptyParagraph } from './editor-core-utils';
+import { sanitizeNodeForPrivacy } from './filter/privacy-filter';
+import { findAndTrackUnsupportedContentNodes } from './track-unsupported-content';
+import { validateADFEntity } from './validate-using-spec';
+export var getStepRange = function getStepRange(transaction) {
+  var from = -1;
+  var to = -1;
+  transaction.mapping.maps.forEach(function (stepMap, index) {
+    stepMap.forEach(function (oldStart, oldEnd) {
+      var newStart = transaction.mapping.slice(index).map(oldStart, -1);
+      var newEnd = transaction.mapping.slice(index).map(oldEnd);
+      from = newStart < from || from === -1 ? newStart : from;
+      to = newEnd > to || to === -1 ? newEnd : to;
+    });
+  });
+  if (from !== -1) {
+    return {
+      from: from,
+      to: to
+    };
+  }
+  return null;
+};
+
+// Checks to see if the parent node is the document, ie not contained within another entity
+export function hasDocAsParent($anchor) {
+  return $anchor.depth === 1;
+}
+
+/**
+ * Checks if a node looks like an empty document
+ */
+export function isEmptyDocument(node) {
+  var nodeChild = node.content.firstChild;
+  if (node.childCount !== 1 || !nodeChild) {
+    return false;
+  }
+  return isEmptyParagraph(nodeChild);
+}
+export function bracketTyped(state) {
+  var selection = state.selection;
+  var _ref = selection,
+    $cursor = _ref.$cursor,
+    $anchor = _ref.$anchor;
+  if (!$cursor) {
+    return false;
+  }
+  var node = $cursor.nodeBefore;
+  if (!node) {
+    return false;
+  }
+  if (node.type.name === 'text' && node.text === '{') {
+    var paragraphNode = $anchor.node();
+    return paragraphNode.marks.length === 0 && hasDocAsParent($anchor);
+  }
+  return false;
+}
+export function nodesBetweenChanged(tr, f, startPos) {
+  var stepRange = getStepRange(tr);
+  if (!stepRange) {
+    return;
+  }
+  tr.doc.nodesBetween(stepRange.from, stepRange.to, f, startPos);
+}
+export function processRawValue(schema, value, providerFactory, sanitizePrivateContent, contentTransformer, dispatchAnalyticsEvent) {
+  if (!value) {
+    return;
+  }
+  var node;
+  if (typeof value === 'string') {
+    try {
+      if (contentTransformer) {
+        var doc = contentTransformer.parse(value);
+        node = doc.toJSON();
+      } else {
+        node = JSON.parse(value);
+      }
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error("Error processing value: ".concat(value, " isn't a valid JSON"));
+      return;
+    }
+  } else {
+    node = value;
+  }
+  if (Array.isArray(node)) {
+    // eslint-disable-next-line no-console
+    console.error("Error processing value: ".concat(node, " is an array, but it must be an object."));
+    return;
+  }
+  try {
+    // ProseMirror always require a child under doc
+    if (node.type === 'doc') {
+      if (Array.isArray(node.content) && node.content.length === 0) {
+        node.content.push({
+          type: 'paragraph',
+          content: []
+        });
+      }
+      // Just making sure doc is always valid
+      if (!node.version) {
+        node.version = 1;
+      }
+    }
+    if (contentTransformer) {
+      return Node.fromJSON(schema, node);
+    }
+
+    // link mark on mediaSingle is deprecated, need to move link mark to child media node
+    // https://product-fabric.atlassian.net/browse/ED-14043
+    var _transformMediaLinkMa = transformMediaLinkMarks(node),
+      transformedAdf = _transformMediaLinkMa.transformedAdf,
+      isTransformed = _transformMediaLinkMa.isTransformed;
+    if (isTransformed && dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.MEDIA_LINK_TRANSFORMED,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL
+      });
+    }
+
+    // See: HOT-97965 https://product-fabric.atlassian.net/browse/ED-14400
+    // We declared in code mark spec that links and marks should not co-exist on
+    // text nodes. This util strips code marks from bad text nodes and preserves links.
+    // Otherwise, prosemirror will try to repair the invalid document by stripping links
+    // and preserving code marks during content changes.
+    var _transformTextLinkCod = transformTextLinkCodeMarks(transformedAdf);
+    transformedAdf = _transformTextLinkCod.transformedAdf;
+    isTransformed = _transformTextLinkCod.isTransformed;
+    if (isTransformed && dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.TEXT_LINK_MARK_TRANSFORMED,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL
+      });
+    }
+    var discardedMarks = [];
+    var _transformDedupeMarks = transformDedupeMarks(transformedAdf);
+    transformedAdf = _transformDedupeMarks.transformedAdf;
+    isTransformed = _transformDedupeMarks.isTransformed;
+    discardedMarks = _transformDedupeMarks.discardedMarks;
+    if (isTransformed && dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.DEDUPE_MARKS_TRANSFORMED_V2,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL,
+        attributes: {
+          /** UGC WARNING
+           *
+           * DO NOT include the `mark` attributes inside, we map here to only
+           * extract the mark type as that is the only non-UGC safe information
+           * that we can add to event-attributes
+           *
+           */
+          discardedMarkTypes: discardedMarks.map(function (mark) {
+            return mark.type;
+          })
+        }
+      });
+    }
+    var _transformNodesMissin = transformNodesMissingContent(transformedAdf);
+    transformedAdf = _transformNodesMissin.transformedAdf;
+    isTransformed = _transformNodesMissin.isTransformed;
+    if (isTransformed && dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.NODES_MISSING_CONTENT_TRANSFORMED,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL
+      });
+    }
+    var _transformIndentation = transformIndentationMarks(transformedAdf);
+    transformedAdf = _transformIndentation.transformedAdf;
+    isTransformed = _transformIndentation.isTransformed;
+    if (isTransformed && dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.INDENTATION_MARKS_TRANSFORMED,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL
+      });
+    }
+    var _transformInvalidMedi = transformInvalidMediaContent(transformedAdf);
+    transformedAdf = _transformInvalidMedi.transformedAdf;
+    isTransformed = _transformInvalidMedi.isTransformed;
+    if (isTransformed && dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.INVALID_MEDIA_CONTENT_TRANSFORMED,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL
+      });
+    }
+    var entity = validateADFEntity(schema, transformedAdf || node, dispatchAnalyticsEvent);
+    var newEntity = maySanitizePrivateContent(entity, providerFactory, sanitizePrivateContent);
+    var parsedDoc = Node.fromJSON(schema, newEntity);
+
+    // throws an error if the document is invalid
+    try {
+      parsedDoc.check();
+    } catch (err) {
+      if (dispatchAnalyticsEvent) {
+        dispatchAnalyticsEvent({
+          action: ACTION.INVALID_PROSEMIRROR_DOCUMENT,
+          actionSubject: ACTION_SUBJECT.EDITOR,
+          eventType: EVENT_TYPE.OPERATIONAL,
+          attributes: {
+            errorStack: err instanceof Error ? err.stack : String(err)
+          }
+        });
+      }
+      throw err;
+    }
+    if (dispatchAnalyticsEvent) {
+      findAndTrackUnsupportedContentNodes(parsedDoc, schema, dispatchAnalyticsEvent);
+    }
+    return parsedDoc;
+  } catch (e) {
+    if (dispatchAnalyticsEvent) {
+      dispatchAnalyticsEvent({
+        action: ACTION.DOCUMENT_PROCESSING_ERROR,
+        actionSubject: ACTION_SUBJECT.EDITOR,
+        eventType: EVENT_TYPE.OPERATIONAL,
+        nonPrivacySafeAttributes: {
+          errorStack: e instanceof Error ? e.stack : String(e)
+        }
+      });
+    }
+
+    // eslint-disable-next-line no-console
+    console.error("Error processing document:\n".concat(e instanceof Error ? e.message : String(e), "\n\n"), JSON.stringify(node));
+    if (isProseMirrorSchemaCheckError(e)) {
+      throw e;
+    }
+    return;
+  }
+}
+function isProseMirrorSchemaCheckError(error) {
+  return error instanceof RangeError && (!!error.message.match(/^Invalid collection of marks for node/) || !!error.message.match(/^Invalid content for node/));
+}
+var maySanitizePrivateContent = function maySanitizePrivateContent(entity, providerFactory, sanitizePrivateContent) {
+  if (sanitizePrivateContent && providerFactory) {
+    return sanitizeNodeForPrivacy(entity, providerFactory);
+  }
+  return entity;
+};

package/dist/esm/utils/editor-core-utils.js

@@ -1,5 +1,6 @@
 import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+import { hasParentNodeOfType } from 'prosemirror-utils';
 import { closest } from './dom';
 
 /**
@@ -76,4 +77,7 @@ export var isValidPosition = function isValidPosition(pos, state) {
     return true;
   }
   return false;
+};
+export var isInLayoutColumn = function isInLayoutColumn(state) {
+  return hasParentNodeOfType(state.schema.nodes.layoutSection)(state.selection);
 };

package/dist/esm/utils/filter/privacy-filter.js

@@ -0,0 +1,48 @@
+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; }
+import { traverse } from '@atlaskit/adf-utils/traverse';
+import { isResolvingMentionProvider } from '@atlaskit/mention/resource';
+/**
+ * Sanitises a document where some content should not be in the document (e.g. mention names).
+ *
+ * It is expected that these names we be resolved separately (e.g. when rendering
+ * a node view).
+ */
+export function sanitizeNodeForPrivacy(json, providerFactory) {
+  var mentionNames = new Map();
+  var hasCacheableMentions = false;
+  var sanitizedJSON = traverse(json, {
+    mention: function mention(node) {
+      if (node.attrs && node.attrs.text) {
+        hasCacheableMentions = true;
+        // Remove @ prefix
+        var text = node.attrs.text;
+        var name = text.startsWith('@') ? text.slice(1) : text;
+        mentionNames.set(node.attrs.id, name);
+      }
+      return _objectSpread(_objectSpread({}, node), {}, {
+        attrs: _objectSpread(_objectSpread({}, node.attrs), {}, {
+          text: ''
+        })
+      });
+    }
+  });
+  if (hasCacheableMentions && providerFactory) {
+    var handler = function handler(_name, providerPromise) {
+      if (providerPromise) {
+        providerPromise.then(function (provider) {
+          if (isResolvingMentionProvider(provider)) {
+            mentionNames.forEach(function (name, id) {
+              provider.cacheMentionName(id, name);
+            });
+            mentionNames.clear();
+            providerFactory.unsubscribe('mentionProvider', handler);
+          }
+        });
+      }
+    };
+    providerFactory.subscribe('mentionProvider', handler);
+  }
+  return sanitizedJSON;
+}

package/dist/esm/utils/index.js

@@ -3,7 +3,7 @@ export { getExtensionLozengeData } from './macro';
 export { default as browser } from './browser';
 export { default as ErrorReporter } from './error-reporter';
 export { isPastDate, timestampToIsoFormat, timestampToString, timestampToTaskContext, timestampToUTCDate, todayTimestampInUTC } from './date';
-export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition, isEmptyParagraph } from './editor-core-utils';
+export { isElementInTableCell, isTextSelection, isLastItemMediaGroup, setNodeSelection, setTextSelection, nonNullable, stepAddsOneOf, stepHasSlice, extractSliceFromStep, isValidPosition, isEmptyParagraph, isInLayoutColumn } from './editor-core-utils';
 export { withImageLoader } from './imageLoader';
 export { absoluteBreakoutWidth, calcBreakoutWidth, calcWideWidth, breakoutConsts, calculateBreakoutStyles, calcBreakoutWidthPx } from './breakout';
 export { findChangedNodesFromTransaction, validNode, validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent, isMediaNode, isNodeBeforeMediaNode } from './nodes';
@@ -39,4 +39,7 @@ export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLink
 
 // prosemirror-history does not export its plugin key
 export var pmHistoryPluginKey = 'history$';
-export { gridTypeForLayout } from './grid';
+export { gridTypeForLayout } from './grid';
+export { nodesBetweenChanged, getStepRange, isEmptyDocument, processRawValue, hasDocAsParent, bracketTyped } from './document';
+export { floatingLayouts, isRichMediaInsideOfBlockNode, calculateSnapPoints, alignAttributes } from './rich-media-utils';
+export { sanitizeNodeForPrivacy } from './filter/privacy-filter';