@atlaskit/editor-plugin-show-diff 15.1.4 → 15.1.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 15.1.5
+
+### Patch Changes
+
+- [`2772d8de10083`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/2772d8de10083) -
+  Anchor the diff contributor tag on the first non-whitespace character of a change, instead of on
+  its first character, so a change whose range opens on whitespace is captioned on the text it
+  changed. Also move a replacement's tag onto its deleted half whenever that half renders in front
+  of the inserted text, so the tag consistently marks where the change begins. A change whose
+  content is nothing but whitespace — a space typed between two words, a run of trailing spaces, an
+  added blank line — now carries no tag at all, since it has no visible content to caption; the
+  change itself is still highlighted. Behind the `confluence_ncs_step_diffing_version_history` gate.
+- Updated dependencies
+
 ## 15.1.4
 
 ### Patch Changes

package/dist/cjs/pm-plugins/calculateDiff/diffBySteps.js

@@ -12,6 +12,7 @@ var _prosemirrorChangeset = require("prosemirror-changeset");
 var _model = require("@atlaskit/editor-prosemirror/model");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _attributions = require("../decorations/colorSchemes/attributions");
+var _charsByOffset = require("../utils/charsByOffset");
 var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _optimizeChanges = require("./optimizeChanges");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -26,36 +27,6 @@ var mapPosition = function mapPosition(mapping, pos) {
   return mapping.map(pos);
 };
 
-/**
- * Build a per-content-offset view of the textblock's characters.
- *
- * Returns an array `chars` whose length is `parent.content.size`. For every
- * offset that lies inside a text node, `chars[offset]` is the character at
- * that offset; for every offset that lies inside (or on the edge of) a
- * non-text inline node — hardBreak, mention, emoji, date, etc. — the entry
- * is `null`.
- *
- * Using doc positions to index `parent.textContent` is wrong because
- * `textContent` strips non-text inline nodes, so every such node shifts the
- * lookup off by its size. This per-offset view restores a 1:1 mapping between
- * doc positions inside the textblock and the character (or "no character",
- * i.e. a hard word boundary) at that position.
- */
-var buildCharsByOffset = function buildCharsByOffset(parent) {
-  var chars = new Array(parent.content.size).fill(null);
-  parent.content.forEach(function (child, offset) {
-    var _child$text;
-    if (!child.isText) {
-      return;
-    }
-    var text = (_child$text = child.text) !== null && _child$text !== void 0 ? _child$text : '';
-    for (var i = 0; i < text.length; i++) {
-      chars[offset + i] = text[i];
-    }
-  });
-  return chars;
-};
-
 /**
  * Given a ProseMirror doc and a position range [from, to], expand
  * both endpoints outward to the nearest word boundaries.
@@ -99,7 +70,7 @@ var expandToWordBoundaries = function expandToWordBoundaries(doc, from, to) {
   // Per-offset view of the textblock so we don't conflate the inline
   // positions of non-text nodes (hardBreak, mention, emoji, date, etc.)
   // with the characters returned by `parent.textContent`.
-  var chars = buildCharsByOffset(parent);
+  var chars = (0, _charsByOffset.buildCharsByOffset)(parent);
 
   // Convert absolute doc positions to zero-based content offsets.
   var fromIdx = from - parentStart;

package/dist/cjs/pm-plugins/calculateDiff/smart/classifySmartChanges.js

@@ -8,6 +8,7 @@ exports.classifySmartChanges = void 0;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _charsByOffset = require("../../utils/charsByOffset");
 var _helpers = require("./helpers");
 var _segmentText = require("./segmentText");
 var _thresholds = require("./thresholds");
@@ -285,9 +286,9 @@ var classifyBlockGroup = function classifyBlockGroup(group, originalDoc, newDoc,
  * Sentence- and paragraph-level classification for a single text-bearing block.
  */
 var classifyTextblock = function classifyTextblock(blockA, blockB, changes, locale, thresholds) {
-  var charsB = (0, _segmentText.buildCharsByOffset)(blockB.node);
+  var charsB = (0, _charsByOffset.buildCharsByOffset)(blockB.node);
   var sentencesB = (0, _segmentText.segmentSentences)(charsB, locale);
-  var charsA = (0, _segmentText.buildCharsByOffset)(blockA.node);
+  var charsA = (0, _charsByOffset.buildCharsByOffset)(blockA.node);
   var sentencesA = (0, _segmentText.segmentSentences)(charsA, locale);
 
   // Block content starts one position after the block's outer start (open token).

package/dist/cjs/pm-plugins/calculateDiff/smart/segmentText.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.segmentWordSpans = exports.segmentSentences = exports.countWords = exports.buildCharsByOffset = void 0;
+exports.segmentWordSpans = exports.segmentSentences = exports.countWords = void 0;
+var _charsByOffset = require("../../utils/charsByOffset");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
@@ -30,41 +31,9 @@ var NON_WORD_CHAR_SET = new Set(NON_WORD_CHARS.split(''));
 var isWordChar = function isWordChar(ch) {
   return !NON_WORD_CHAR_SET.has(ch);
 };
-// Whitespace is checked via a Set rather than a regex to avoid both the `require-unicode-regexp`
-// lint rule and the TS1501 error the `u` flag triggers under this package's build lib target.
-var WHITESPACE_CHAR_SET = new Set([' ', '\t', '\n', '\r', '\f', '\v', "\xA0"]);
-var isWhitespaceChar = function isWhitespaceChar(ch) {
-  return WHITESPACE_CHAR_SET.has(ch);
-};
 // Sentence terminators used by the regex fallback. We intentionally keep this small and
 // conservative — the Intl.Segmenter path is the source of truth when available.
 var SENTENCE_TERMINATORS = new Set(['.', '!', '?', '…', '。', '！', '？']);
-
-/**
- * Build a per-content-offset view of a textblock's characters.
- *
- * `chars[i]` is the character at content offset `i`, or `null` when that offset lies
- * inside a non-text inline node (mention, date, emoji, hardBreak, …). A `null` acts as an
- * *opaque single token*: it counts as one word and never terminates a sentence.
- */
-var buildCharsByOffset = exports.buildCharsByOffset = function buildCharsByOffset(parent) {
-  var chars = Array.from({
-    length: parent.content.size
-  }, function () {
-    return null;
-  });
-  parent.content.forEach(function (child, offset) {
-    var _child$text;
-    if (!child.isText) {
-      return;
-    }
-    var text = (_child$text = child.text) !== null && _child$text !== void 0 ? _child$text : '';
-    for (var i = 0; i < text.length; i++) {
-      chars[offset + i] = text[i];
-    }
-  });
-  return chars;
-};
 var getSegmenterCtor = function getSegmenterCtor() {
   if (typeof Intl === 'undefined') {
     return undefined;
@@ -177,7 +146,7 @@ var segmentSentences = exports.segmentSentences = function segmentSentences(char
     if (ch !== null && SENTENCE_TERMINATORS.has(ch)) {
       // Consume trailing spaces as part of this sentence.
       var end = i + 1;
-      while (end < chars.length && chars[end] !== null && isWhitespaceChar(chars[end])) {
+      while (end < chars.length && chars[end] !== null && (0, _charsByOffset.isWhitespaceChar)(chars[end])) {
         end++;
       }
       spans.push({

package/dist/cjs/pm-plugins/decorations/createContributorTagWidget.js

@@ -4,11 +4,12 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.unmountContributorTag = exports.mountContributorTag = exports.createContributorTagWidget = exports.createContributorTagHost = exports.CONTRIBUTOR_TAG_HOST_ATTRIBUTE = void 0;
+exports.unmountContributorTag = exports.mountContributorTag = exports.isContributorTagWidgetEnabled = exports.createContributorTagWidget = exports.createContributorTagHost = exports.CONTRIBUTOR_TAG_HOST_ATTRIBUTE = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _contributorTagController = require("../../ui/ContributorTag/contributorTagController");
+var _charsByOffset = require("../utils/charsByOffset");
 var _createAnchorDecorationWidgets = require("./createAnchorDecorationWidgets");
 var _decorationKeys = require("./decorationKeys");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -17,7 +18,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 var CONTRIBUTOR_TAG_HOST_ATTRIBUTE = exports.CONTRIBUTOR_TAG_HOST_ATTRIBUTE = 'data-contributor-tag-host';
 
 // Contributor tags only render behind this gate — see `areAttributionColorGatesEnabled`.
-var isContributorTagWidgetEnabled = function isContributorTagWidgetEnabled() {
+var isContributorTagWidgetEnabled = exports.isContributorTagWidgetEnabled = function isContributorTagWidgetEnabled() {
   return (0, _fg.fg)('confluence_ncs_step_diffing_version_history');
 };
 
@@ -84,30 +85,55 @@ var createContributorTagHost = exports.createContributorTagHost = function creat
 };
 
 /**
- * The start of the inline content that `[from, to)` actually highlights.
+ * The first *visible* character of the content that `[from, to)` highlights.
  *
- * `from` is not sufficient: a range can begin at the tail of one paragraph and only cover text in a
- * later block, and ProseMirror clips `Decoration.inline` to the content it can paint — so a host
- * left at `from` would sit lines away from the highlight.
+ * `from` is not sufficient, for two reasons. A range can begin at the tail of one paragraph and only
+ * cover text in a later block, and ProseMirror clips `Decoration.inline` to the content it can paint
+ * — so a host left at `from` would sit lines away from the highlight. And a range routinely starts on
+ * whitespace, because the changeset joins neighbouring edits across the space between them: a tag
+ * hosted there captions the gap in front of the change rather than the change (EDITOR-8855).
+ *
+ * Whitespace is skipped across blocks, so a range whose first block contributes nothing but spaces
+ * anchors on the next block that has something to show. The fallback to the first paintable position
+ * covers a range holding no text at all — an atomic block such as media or a rule; a range of
+ * nothing but whitespace never reaches here, because a change with no visible content carries no tag
+ * (see `hasVisibleContent`).
  */
-var resolveInlineContentStart = function resolveInlineContentStart(doc, from, to) {
+var resolveTagAnchorPos = function resolveTagAnchorPos(doc, from, to) {
+  var _ref2;
   var edge;
+  var visibleEdge;
   doc.nodesBetween(from, to, function (node, nodePos) {
+    if (visibleEdge !== undefined) {
+      return false;
+    }
     if (!node.isTextblock) {
-      return edge === undefined;
+      return true;
     }
 
     // The slice of this block the range actually covers; empty means nothing paintable.
-    var contentFrom = Math.max(nodePos + 1, from);
-    var contentTo = Math.min(nodePos + 1 + node.content.size, to);
+    var blockStart = nodePos + 1;
+    var contentFrom = Math.max(blockStart, from);
+    var contentTo = Math.min(blockStart + node.content.size, to);
     if (contentTo > contentFrom && edge === undefined) {
       edge = contentFrom;
     }
 
+    // A `null` is a non-text inline node (mention, emoji, date, …). Those are visible, so they
+    // anchor the tag exactly as a letter does.
+    var chars = (0, _charsByOffset.buildCharsByOffset)(node);
+    for (var offset = contentFrom - blockStart; offset < contentTo - blockStart; offset++) {
+      var char = chars[offset];
+      if (char === null || !(0, _charsByOffset.isWhitespaceChar)(char)) {
+        visibleEdge = blockStart + offset;
+        break;
+      }
+    }
+
     // Textblocks have no block children to descend into.
     return false;
   });
-  return edge !== null && edge !== void 0 ? edge : from;
+  return (_ref2 = visibleEdge !== null && visibleEdge !== void 0 ? visibleEdge : edge) !== null && _ref2 !== void 0 ? _ref2 : from;
 };
 
 /**
@@ -128,21 +154,21 @@ var resolveCodeBlockStart = function resolveCodeBlockStart(doc, pos) {
 };
 
 /**
- * A widget hosting the contributor tag of one diff range, placed on the first character the range
- * highlights — or, with `anchorAtRangeStart`, at `from` itself. Either way a host that would land
- * inside a code block is hoisted out in front of it; see `resolveCodeBlockStart`.
+ * A widget hosting the contributor tag of one diff range, placed on the first visible character the
+ * range highlights — or, with `anchorAtRangeStart`, at `from` itself. Either way a host that would
+ * land inside a code block is hoisted out in front of it; see `resolveCodeBlockStart`.
  *
  * The tag is mounted in `toDOM` and taken down in `destroy`, so it lives exactly as long as the host
  * element ProseMirror drew it into — see `mountContributorTag`.
  */
-var createContributorTagWidget = exports.createContributorTagWidget = function createContributorTagWidget(_ref2) {
-  var _ref2$anchorAtRangeSt = _ref2.anchorAtRangeStart,
-    anchorAtRangeStart = _ref2$anchorAtRangeSt === void 0 ? false : _ref2$anchorAtRangeSt,
-    doc = _ref2.doc,
-    from = _ref2.from,
-    to = _ref2.to,
-    diffId = _ref2.diffId,
-    mountContext = _ref2.mountContext;
+var createContributorTagWidget = exports.createContributorTagWidget = function createContributorTagWidget(_ref3) {
+  var _ref3$anchorAtRangeSt = _ref3.anchorAtRangeStart,
+    anchorAtRangeStart = _ref3$anchorAtRangeSt === void 0 ? false : _ref3$anchorAtRangeSt,
+    doc = _ref3.doc,
+    from = _ref3.from,
+    to = _ref3.to,
+    diffId = _ref3.diffId,
+    mountContext = _ref3.mountContext;
   if (!isContributorTagWidgetEnabled()) {
     return undefined;
   }
@@ -150,7 +176,7 @@ var createContributorTagWidget = exports.createContributorTagWidget = function c
   // Reassigned when ProseMirror redraws this decoration, which it may do more than once for the
   // same `Decoration` instance.
   var mount;
-  var anchorPos = anchorAtRangeStart ? from : resolveInlineContentStart(doc, from, to);
+  var anchorPos = anchorAtRangeStart ? from : resolveTagAnchorPos(doc, from, to);
   // A change inside a code block is hoisted out of it; anything else keeps its own anchor.
   var codeBlockPos = resolveCodeBlockStart(doc, anchorPos);
   return _view.Decoration.widget(

package/dist/cjs/pm-plugins/decorations/createInlineChangedDecoration.js

@@ -11,6 +11,7 @@ var _lazyNodeView = require("@atlaskit/editor-common/lazy-node-view");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _isExtendedEnabled = require("../isExtendedEnabled");
+var _hasVisibleContent = require("../utils/hasVisibleContent");
 var _factory = require("./colorSchemes/factory");
 var _schemes = require("./colorSchemes/schemes");
 var _createAnchorDecorationWidgets = require("./createAnchorDecorationWidgets");
@@ -141,6 +142,12 @@ var createInlineChangedDecoration = exports.createInlineChangedDecoration = func
   // rebuilds decorations without touching the doc, and a fresh id would change the React key and the
   // tag host's key, remounting every tag mid-step. Random ids are kept when tags are off.
   var diffId = showContributorTags ? "inline-".concat(change.fromB, "-").concat(change.toB) : crypto.randomUUID();
+
+  // Whether this highlight hosts a tag. A range of nothing but whitespace has nothing to caption,
+  // so it stays unattributed: the spec is the only route attribution takes to
+  // `extractContributorTags`, so dropping the key there is what keeps a tag from being resolved for
+  // a host that is never emitted (EDITOR-8855).
+  var canTagChange = showContributorTags && !!doc && (0, _isExtendedEnabled.isExtendedEnabled)(diffType) && (0, _createContributorTagWidget.isContributorTagWidgetEnabled)() && (0, _hasVisibleContent.hasVisibleContent)(doc.slice(change.fromB, change.toB).content);
   if (shouldHideDeleted) {
     return [_view.Decoration.inline(change.fromB, change.toB, {
       style: displayNoneStyle
@@ -185,7 +192,7 @@ var createInlineChangedDecoration = exports.createInlineChangedDecoration = func
   }, showContributorTags && {
     'data-diff-id': diffId
   }), (0, _decorationKeys.buildDiffDecorationSpec)({
-    attributionKey: attributionKey,
+    attributionKey: canTagChange ? attributionKey : undefined,
     colorScheme: colorScheme,
     decorationType: 'inline',
     diffId: diffId,
@@ -230,7 +237,7 @@ var createInlineChangedDecoration = exports.createInlineChangedDecoration = func
 
   // Built from the raw change range, not the anchors above: a tag lines up with the changed text,
   // while the bar's anchors are held on a block boundary when a deleted widget renders beside them.
-  if (showContributorTags && doc && (0, _isExtendedEnabled.isExtendedEnabled)(diffType)) {
+  if (canTagChange && doc) {
     var tagWidget = (0, _createContributorTagWidget.createContributorTagWidget)({
       doc: doc,
       from: change.fromB,

package/dist/cjs/pm-plugins/decorations/createNodeChangedDecorationWidget.js

@@ -9,6 +9,7 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _isExtendedEnabled = require("../isExtendedEnabled");
+var _hasVisibleContent = require("../utils/hasVisibleContent");
 var _createAnchorDecorationWidgets = require("./createAnchorDecorationWidgets");
 var _createChangedRowDecorationWidgets = require("./createChangedRowDecorationWidgets");
 var _createContributorTagWidget = require("./createContributorTagWidget");
@@ -220,6 +221,10 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
   // Derived from the deleted range so it survives a recalculation — see the same reasoning in
   // `createInlineChangedDecoration`.
   var diffId = showContributorTags ? "widget-".concat(change.fromA, "-").concat(change.toA) : crypto.randomUUID();
+  // Whether this widget hosts a tag. Removing nothing but whitespace leaves no visible deleted
+  // content to caption, so the change stays unattributed — matching the inline half's rule in
+  // `createInlineChangedDecoration` (EDITOR-8855).
+  var canTagWidget = showContributorTags && (0, _hasVisibleContent.hasVisibleContent)(slice.content);
   var decorations = [];
   var replacementNode = newDoc.nodeAt(change.fromB);
   var firstReplacedNode = slice.content.firstChild;
@@ -355,7 +360,7 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
   // Taken down in the widget's `destroy` below: `dom` is rebuilt on every recalculation, so the tag
   // mounted into it must not outlive the copy ProseMirror is drawing.
   var tagMount;
-  if (showContributorTags) {
+  if (canTagWidget) {
     // Lets the contributor tag find the deleted content on hover.
     dom.setAttribute('data-diff-id', diffId);
 
@@ -378,7 +383,7 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
     }
   }
   decorations.push(_view.Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread(_objectSpread({}, (0, _decorationKeys.buildDiffDecorationSpec)(_objectSpread({
-    attributionKey: attributionKey,
+    attributionKey: canTagWidget ? attributionKey : undefined,
     colorScheme: colorScheme,
     decorationType: 'widget',
     diffId: diffId,

package/dist/cjs/pm-plugins/decorations/extractContributorTags.js

@@ -8,6 +8,7 @@ exports.extractContributorTags = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _decorationKeys = require("./decorationKeys");
 var _excluded = ["connectedToKey"];
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -36,6 +37,16 @@ var isSameChange = function isSameChange(widget, inline) {
   return widget.spec.attributionKey === inline.spec.attributionKey && widget.from >= inline.from && widget.from <= inline.to;
 };
 
+/**
+ * Whether a deleted-content widget is the left-most half of the replacement it belongs to, in which
+ * case it keeps the tag so the tag marks where the change begins (EDITOR-8855). `side: -1` paints
+ * the deleted content in front of the inserted text; `1` is `deletedDiffPlacement: 'bottom'` /
+ * `inlineDeletedDiffPlacement: 'after'`, where the inline half leads instead.
+ */
+var leadsReplacement = function leadsReplacement(widget) {
+  return (0, _fg.fg)('confluence_ncs_step_diffing_version_history') && widget.spec.side === -1;
+};
+
 /**
  * Whether `inner` captions the same change as the block decoration `block`, in which case only the
  * block keeps the tag — one tag per block. Containment counts in either direction: a leaf block's
@@ -48,7 +59,7 @@ var isSameBlockChange = function isSameBlockChange(inner, block) {
 /**
  * One model per diff decoration whose attribution resolves to a supplied contributor; anything
  * unattributed, untaggable or unresolved is skipped. A replacement's two decorations are collapsed
- * into the single inline tag — see `isSameChange`.
+ * into a single tag, on whichever half renders first — see `isSameChange` and `leadsReplacement`.
  */
 var extractContributorTags = exports.extractContributorTags = function extractContributorTags(decorations, contributors) {
   if (!contributors) {
@@ -77,7 +88,7 @@ var extractContributorTags = exports.extractContributorTags = function extractCo
       });
     }
 
-    // The inline decoration keeps the tag: it captions content still in the document.
+    // Candidate hosts, in the order they outrank each other: block, then leading widget, then inline.
   } catch (err) {
     _iterator.e(err);
   } finally {
@@ -91,6 +102,10 @@ var extractContributorTags = exports.extractContributorTags = function extractCo
     var decoration = _ref3.decoration;
     return decoration.spec.decorationType === 'block';
   });
+  var widgetTargets = targets.filter(function (_ref4) {
+    var decoration = _ref4.decoration;
+    return decoration.spec.decorationType === 'widget';
+  });
   var linkedDiffIds = new Map();
   var folded = new Set();
   var fold = function fold(host, target) {
@@ -107,19 +122,32 @@ var extractContributorTags = exports.extractContributorTags = function extractCo
       }
 
       // A block outranks both other kinds, so it is tried first.
-      var block = blockTargets.find(function (_ref4) {
-        var decoration = _ref4.decoration;
+      var block = blockTargets.find(function (_ref5) {
+        var decoration = _ref5.decoration;
         return isSameBlockChange(target.decoration, decoration);
       });
       if (block) {
         fold(block, target);
         return 0; // continue
       }
-      if (decorationType !== 'widget') {
+      if (decorationType === 'inline') {
+        // The deleted half renders in front of this one, so that half captions the change.
+        var leadingWidget = widgetTargets.find(function (_ref6) {
+          var decoration = _ref6.decoration;
+          return leadsReplacement(decoration) && isSameChange(decoration, target.decoration);
+        });
+        if (leadingWidget) {
+          fold(leadingWidget, target);
+        }
         return 0; // continue
       }
-      var host = inlineTargets.find(function (_ref5) {
-        var decoration = _ref5.decoration;
+
+      // A leading widget keeps its own tag; it was folded into above.
+      if (leadsReplacement(target.decoration)) {
+        return 0; // continue
+      }
+      var host = inlineTargets.find(function (_ref7) {
+        var decoration = _ref7.decoration;
         return isSameChange(target.decoration, decoration);
       });
       if (host) {
@@ -133,9 +161,9 @@ var extractContributorTags = exports.extractContributorTags = function extractCo
   }
   return targets.filter(function (target) {
     return !folded.has(target);
-  }).map(function (_ref6) {
-    var contributor = _ref6.contributor,
-      spec = _ref6.decoration.spec;
+  }).map(function (_ref8) {
+    var contributor = _ref8.contributor,
+      spec = _ref8.decoration.spec;
     var connected = contributor.connectedToKey ? contributors[contributor.connectedToKey] : undefined;
     var connectedContributor = connected ? toTagContributor(connected) : undefined;
     var linked = linkedDiffIds.get(spec.diffId);

package/dist/cjs/pm-plugins/utils/charsByOffset.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWhitespaceChar = exports.buildCharsByOffset = void 0;
+/**
+ * Whitespace as the diff treats it, U+00A0 included: a non-breaking space separates words for every
+ * consumer here, so it is not a character a change can be said to start on.
+ *
+ * A Set rather than a regex, to avoid both the `require-unicode-regexp` lint rule and the TS1501
+ * error the `u` flag triggers under this package's declaration build target.
+ */
+var WHITESPACE_CHAR_SET = new Set([' ', '\t', '\n', '\r', '\f', '\v', "\xA0"]);
+var isWhitespaceChar = exports.isWhitespaceChar = function isWhitespaceChar(char) {
+  return WHITESPACE_CHAR_SET.has(char);
+};
+
+/**
+ * Build a per-content-offset view of a textblock's characters.
+ *
+ * Returns an array whose length is `parent.content.size`. For every offset that lies inside a text
+ * node, `chars[offset]` is the character at that offset; for every offset that lies inside (or on
+ * the edge of) a non-text inline node — hardBreak, mention, emoji, date, … — the entry is `null`,
+ * which acts as an *opaque single token*: it counts as one word and is never whitespace.
+ *
+ * Using doc positions to index `parent.textContent` is wrong because `textContent` strips non-text
+ * inline nodes, so every such node shifts the lookup off by its size. This per-offset view restores
+ * a 1:1 mapping between doc positions inside the textblock and the character (or "no character",
+ * i.e. a hard word boundary) at that position.
+ */
+var buildCharsByOffset = exports.buildCharsByOffset = function buildCharsByOffset(parent) {
+  var chars = new Array(parent.content.size).fill(null);
+  parent.content.forEach(function (child, offset) {
+    var _child$text;
+    if (!child.isText) {
+      return;
+    }
+    var text = (_child$text = child.text) !== null && _child$text !== void 0 ? _child$text : '';
+    for (var i = 0; i < text.length; i++) {
+      chars[offset + i] = text[i];
+    }
+  });
+  return chars;
+};

package/dist/cjs/pm-plugins/utils/hasVisibleContent.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasVisibleContent = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _charsByOffset = require("./charsByOffset");
+/**
+ * Whether `fragment` holds anything a reader can see.
+ *
+ * Text counts once it carries a single non-whitespace character; a leaf node (mention, emoji, date,
+ * media, rule, hardBreak, …) counts in its own right, exactly as `resolveTagAnchorPos` treats one.
+ * Everything else is descended into, so a paragraph is visible when its content is.
+ *
+ * A change whose content is nothing but whitespace — a space typed between two words, a run of
+ * trailing spaces, an added blank paragraph — has no visible content for a contributor tag to
+ * caption, so it carries no tag (EDITOR-8855).
+ */
+var _hasVisibleContent = exports.hasVisibleContent = function hasVisibleContent(fragment) {
+  var visible = false;
+  fragment.forEach(function (node) {
+    if (visible) {
+      return;
+    }
+    if (node.isText) {
+      var _node$text;
+      visible = (0, _toConsumableArray2.default)((_node$text = node.text) !== null && _node$text !== void 0 ? _node$text : '').some(function (char) {
+        return !(0, _charsByOffset.isWhitespaceChar)(char);
+      });
+      return;
+    }
+    visible = node.isLeaf || _hasVisibleContent(node.content);
+  });
+  return visible;
+};

package/dist/cjs/ui/ContributorTag/contributorTagController.js

@@ -94,7 +94,7 @@ var identityOf = function identityOf(model) {
  * `toDOM` for a widget it reuses: stepping to the next change republishes the tags without redrawing
  * their hosts, so anything the tag reacts to — `isActive` above all — has to arrive through a
  * subscription of its own (EDITOR-8702). Draws nothing when this diff has no tag, which is the case
- * for the deleted half of a replacement: that half is folded into the inline tag.
+ * for the folded half of a replacement: its two decorations share the one tag.
  */
 var ContributorTagController = exports.ContributorTagController = /*#__PURE__*/function () {
   function ContributorTagController(options) {

package/dist/cjs/ui/IndicatorBar/IndicatorBar.js

@@ -1,4 +1,4 @@
-/* IndicatorBar.tsx generated by @compiled/babel-plugin v2.0.0 */
+/* IndicatorBar.tsx generated by @compiled/babel-plugin v3.0.1 */
 "use strict";
 
 var _typeof = require("@babel/runtime/helpers/typeof");

package/dist/cjs/ui/IndicatorBar/IndicatorBarContentComponent.js

@@ -1,4 +1,4 @@
-/* IndicatorBarContentComponent.tsx generated by @compiled/babel-plugin v2.0.0 */
+/* IndicatorBarContentComponent.tsx generated by @compiled/babel-plugin v3.0.1 */
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

package/dist/es2019/pm-plugins/calculateDiff/diffBySteps.js

@@ -2,6 +2,7 @@ import { simplifyChanges, ChangeSet } from 'prosemirror-changeset';
 import { Mark } from '@atlaskit/editor-prosemirror/model';
 import { Mapping, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
 import { getAttributionKey } from '../decorations/colorSchemes/attributions';
+import { buildCharsByOffset } from '../utils/charsByOffset';
 import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { optimizeChanges } from './optimizeChanges';
 const WORD_CHAR_REGEX = /[\p{L}\p{N}_]/u;
@@ -9,36 +10,6 @@ const PUNCTUATION_REGEX = /\p{P}/u;
 const WHITESPACE_REGEX = /\s/u;
 const mapPosition = (mapping, pos) => mapping.map(pos);
 
-/**
- * Build a per-content-offset view of the textblock's characters.
- *
- * Returns an array `chars` whose length is `parent.content.size`. For every
- * offset that lies inside a text node, `chars[offset]` is the character at
- * that offset; for every offset that lies inside (or on the edge of) a
- * non-text inline node — hardBreak, mention, emoji, date, etc. — the entry
- * is `null`.
- *
- * Using doc positions to index `parent.textContent` is wrong because
- * `textContent` strips non-text inline nodes, so every such node shifts the
- * lookup off by its size. This per-offset view restores a 1:1 mapping between
- * doc positions inside the textblock and the character (or "no character",
- * i.e. a hard word boundary) at that position.
- */
-const buildCharsByOffset = parent => {
-  const chars = new Array(parent.content.size).fill(null);
-  parent.content.forEach((child, offset) => {
-    var _child$text;
-    if (!child.isText) {
-      return;
-    }
-    const text = (_child$text = child.text) !== null && _child$text !== void 0 ? _child$text : '';
-    for (let i = 0; i < text.length; i++) {
-      chars[offset + i] = text[i];
-    }
-  });
-  return chars;
-};
-
 /**
  * Given a ProseMirror doc and a position range [from, to], expand
  * both endpoints outward to the nearest word boundaries.

package/dist/es2019/pm-plugins/calculateDiff/smart/classifySmartChanges.js

@@ -1,5 +1,6 @@
+import { buildCharsByOffset } from '../../utils/charsByOffset';
 import { makePromotedChange, mergeOverlappingByNewDocRange, rangesOverlap } from './helpers';
-import { buildCharsByOffset, countWords, segmentSentences, segmentWordSpans } from './segmentText';
+import { countWords, segmentSentences, segmentWordSpans } from './segmentText';
 import { resolveThresholds } from './thresholds';
 /**
  * Block-first `smart` classifier.