@atlaskit/editor-plugin-show-diff 20.0.1 → 20.0.3

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 20.0.3
+
+### Patch Changes
+
+- Updated dependencies
+
+## 20.0.2
+
+### Patch Changes
+
+- [`4d3e3d0afb998`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/4d3e3d0afb998) -
+  Fix "Removed" labels on table diffs:
+  - Keep the label on deleted table rows attached to its row when the page scrolls.
+  - Identify deleted table columns by cell `localId` when a diff replaces the whole table, so
+    columns with matching content, such as empty columns, are labelled correctly. Tables without
+    usable cell ids fall back to comparing whole columns, and only label columns when that
+    comparison has one answer.
+
+- [`b8c8e84ed75bd`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b8c8e84ed75bd) -
+  Keep unattributed diff decorations separate from attributed changes in navigation and active
+  highlighting under `confluence_ncs_step_diffing_version_history`.
+- Updated dependencies
+
 ## 20.0.1
 
 ### Patch Changes

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

@@ -127,19 +127,18 @@ var leafTextblockRanges = function leafTextblockRanges(doc, from, to) {
 // once it has more leaf textblocks (~cells) than this threshold. Small tables
 // keep the precise per-cell path.
 var LARGE_TABLE_LEAF_THRESHOLD = 40;
-
 /**
- * An active scrollable change may contain several underlying diff changes. Treat ranges that
- * overlap or touch the active range as part of the same active customer-facing edit.
+ * An active scrollable change may contain several underlying diff changes. With attribution, only
+ * ranges belonging to the selected contributor (including the anonymous contributor) are active.
  */
-var isRangeActive = function isRangeActive(activeIndexPos, from, to) {
+var isRangeActive = function isRangeActive(activeIndexPos, from, to, attributionKey) {
   if (activeIndexPos === undefined) {
     return undefined;
   }
   if (!(0, _fg.fg)('confluence_ncs_step_diffing_version_history')) {
     return from === activeIndexPos.from && to === activeIndexPos.to;
   }
-  return from <= activeIndexPos.to && activeIndexPos.from <= to;
+  return from <= activeIndexPos.to && activeIndexPos.from <= to && (!('attributionKey' in activeIndexPos) || activeIndexPos.attributionKey === attributionKey);
 };
 var isLargeInsertedTableRange = function isLargeInsertedTableRange(doc, from, to) {
   var containsTable = false;
@@ -214,7 +213,7 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
         if (!(node !== null && node !== void 0 && node.isBlock)) {
           continue;
         }
-        var isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+        var isActive = isRangeActive(activeIndexPos, pos, nodeEnd, attributionKey);
         decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createBlockChangedDecoration.createBlockChangedDecoration)({
           attributionKey: attributionKey,
           change: {
@@ -258,7 +257,7 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
     }
     if (node.isBlock && (!requireContainedBlocks || pos >= from) && pos + node.nodeSize <= to) {
       var _nodeEnd = pos + node.nodeSize;
-      var _isActive = isRangeActive(activeIndexPos, pos, _nodeEnd);
+      var _isActive = isRangeActive(activeIndexPos, pos, _nodeEnd, attributionKey);
       decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createBlockChangedDecoration.createBlockChangedDecoration)({
         attributionKey: attributionKey,
         change: {
@@ -542,7 +541,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     var leftAnchorId = (0, _fg.fg)('platform_editor_ai_show_diff_patch_2') ? "replacement-".concat(change.fromA, "-").concat(change.toA, "-").concat(change.fromB, "-").concat(change.toB) : undefined;
     var changeColorScheme = attributionColors ? (0, _attributions.getColorSchemeForChange)(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var attributionKey = showContributorTags ? (0, _attributions.getAttributionKeyForChange)(change, attributedChanges) : undefined;
-    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
     var deletedColumns = change.deletedColumns;
     // On an inverted diff the table that lost columns is the one in `tr.doc`, so the column
     // indices address it directly and each label anchors inside its own cell.
@@ -779,7 +778,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     var _attributionColors$ge, _attributionColors;
     var changeColorScheme = change.attributionKey ? (_attributionColors$ge = (_attributionColors = attributionColors) === null || _attributionColors === void 0 ? void 0 : _attributionColors.get(change.attributionKey)) !== null && _attributionColors$ge !== void 0 ? _attributionColors$ge : colorScheme : colorScheme;
     var attributionKey = showContributorTags ? change.attributionKey : undefined;
-    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
     decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createInlineChangedDecoration.createInlineChangedDecoration)({
       attributionKey: attributionKey,
       change: change,
@@ -808,7 +807,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     var attributionKey = showContributorTags ? change.attributionKey : undefined;
     if (change.isInline) {
       // Inline nodes (e.g. date, emoji, mention, status) need an inline decoration rather than a block decoration
-      var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+      var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
       decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createInlineChangedDecoration.createInlineChangedDecoration)({
         attributionKey: attributionKey,
         change: change,

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

@@ -13,7 +13,6 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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; }
 var CELL_CONTENT_OFFSET = exports.CELL_CONTENT_OFFSET = 2;
-var IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
 var tablesIn = function tablesIn(doc) {
   var tables = [];
   doc.descendants(function (node, pos) {
@@ -63,41 +62,107 @@ var positionMatchedColumns = function positionMatchedColumns(_ref) {
   }
   return surviving;
 };
-var addContentMatchedColumns = function addContentMatchedColumns(surviving, before, after) {
-  var _before$node$firstChi, _before$node$firstChi2, _after$node$firstChil, _after$node$firstChil2;
-  var beforeCells = (_before$node$firstChi = (_before$node$firstChi2 = before.node.firstChild) === null || _before$node$firstChi2 === void 0 ? void 0 : _before$node$firstChi2.children) !== null && _before$node$firstChi !== void 0 ? _before$node$firstChi : [];
-  var afterCells = (_after$node$firstChil = (_after$node$firstChil2 = after.node.firstChild) === null || _after$node$firstChil2 === void 0 ? void 0 : _after$node$firstChil2.children) !== null && _after$node$firstChil !== void 0 ? _after$node$firstChil : [];
-  var _iterator = _createForOfIteratorHelper(afterCells),
+var headerLocalIds = function headerLocalIds(table) {
+  var _table$node$firstChil, _table$node$firstChil2;
+  return ((_table$node$firstChil = (_table$node$firstChil2 = table.node.firstChild) === null || _table$node$firstChil2 === void 0 ? void 0 : _table$node$firstChil2.children) !== null && _table$node$firstChil !== void 0 ? _table$node$firstChil : []).map(function (cell) {
+    var _cell$attrs$localId;
+    return (_cell$attrs$localId = cell.attrs.localId) !== null && _cell$attrs$localId !== void 0 ? _cell$attrs$localId : undefined;
+  });
+};
+
+/**
+ * Cells keep their `localId` when a column is deleted, so the first row's ids name each remaining
+ * column even when the steps replaced the whole table. Missing or repeated ids, such as in content
+ * pasted from elsewhere, cannot name a column.
+ */
+var localIdMatchedColumns = function localIdMatchedColumns(before, after) {
+  var beforeIds = headerLocalIds(before);
+  if (beforeIds.some(function (id) {
+    return !id;
+  }) || new Set(beforeIds).size !== beforeIds.length) {
+    return undefined;
+  }
+  var surviving = new Set();
+  var previousColumn = -1;
+  var _iterator = _createForOfIteratorHelper(headerLocalIds(after)),
     _step;
   try {
-    var _loop = function _loop() {
-        var afterCell = _step.value;
-        var matches = beforeCells.flatMap(function (beforeCell, column) {
-          return (0, _document.areNodesEqualIgnoreAttrs)(beforeCell, afterCell, IGNORED_CELL_ATTRS) ? [column] : [];
-        });
-        if (matches.length !== 1) {
-          return {
-            v: false
-          };
-        }
-        surviving.add(matches[0]);
-      },
-      _ret;
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      _ret = _loop();
-      if (_ret) return _ret.v;
+      var id = _step.value;
+      var column = id ? beforeIds.indexOf(id) : -1;
+      if (column <= previousColumn) {
+        return undefined;
+      }
+      surviving.add(column);
+      previousColumn = column;
     }
   } catch (err) {
     _iterator.e(err);
   } finally {
     _iterator.f();
   }
-  var ordered = (0, _toConsumableArray2.default)(surviving);
-  return !ordered.some(function (column, index) {
-    return index > 0 && column <= ordered[index - 1];
+  return surviving;
+};
+var IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
+
+/** Rows may also have been deleted, so the remaining cells only need to appear in order. */
+var isColumnKept = function isColumnKept(before, beforeColumn, after, afterColumn) {
+  var beforeRow = 0;
+  return after.node.children.every(function (afterRow) {
+    var afterCell = afterRow.maybeChild(afterColumn);
+    while (beforeRow < before.node.childCount) {
+      var beforeCell = before.node.child(beforeRow++).maybeChild(beforeColumn);
+      if (afterCell && beforeCell && (0, _document.areNodesEqualIgnoreAttrs)(beforeCell, afterCell, IGNORED_CELL_ATTRS)) {
+        return true;
+      }
+    }
+    return false;
   });
 };
+
+/**
+ * Pairs each remaining column with an equal original column, keeping their order, and takes each
+ * pair from the `direction` end first. Returns the original column of each remaining column.
+ */
+var pairColumnsInOrder = function pairColumnsInOrder(beforeWidth, afterWidth, isMatch, direction) {
+  var step = direction === 'left' ? 1 : -1;
+  var pairing = [];
+  var beforeColumn = direction === 'left' ? 0 : beforeWidth - 1;
+  var afterColumn = direction === 'left' ? 0 : afterWidth - 1;
+  for (; afterColumn >= 0 && afterColumn < afterWidth; afterColumn += step) {
+    while (beforeColumn >= 0 && beforeColumn < beforeWidth && !isMatch(beforeColumn, afterColumn)) {
+      beforeColumn += step;
+    }
+    if (beforeColumn < 0 || beforeColumn >= beforeWidth) {
+      return undefined;
+    }
+    pairing.push(beforeColumn);
+    beforeColumn += step;
+  }
+  return direction === 'left' ? pairing : pairing.reverse();
+};
+
+/**
+ * For tables whose cells have no usable ids, such as content created before cells had ids. Every
+ * valid pairing of remaining columns to original ones lies between the leftmost and the rightmost
+ * pairing, so the columns are only reported when those two agree. Otherwise, such as when several
+ * original columns are identical, which of them were removed cannot be known.
+ */
+var uniquelyContentMatchedColumns = function uniquelyContentMatchedColumns(before, after, beforeWidth, afterWidth) {
+  var isMatch = function isMatch(beforeColumn, afterColumn) {
+    return isColumnKept(before, beforeColumn, after, afterColumn);
+  };
+  var leftmost = pairColumnsInOrder(beforeWidth, afterWidth, isMatch, 'left');
+  var rightmost = pairColumnsInOrder(beforeWidth, afterWidth, isMatch, 'right');
+  if (!leftmost || !rightmost || leftmost.some(function (column, index) {
+    return column !== rightmost[index];
+  })) {
+    return undefined;
+  }
+  return new Set(leftmost);
+};
 var findDeletedColumns = function findDeletedColumns(before, after, afterToBefore) {
+  var _localIdMatchedColumn;
   var beforeMap = _tableMap.TableMap.get(before.node);
   var afterMap = _tableMap.TableMap.get(after.node);
   // Merged or malformed tables do not have reliable column indices.
@@ -105,13 +170,14 @@ var findDeletedColumns = function findDeletedColumns(before, after, afterToBefor
     return [];
   }
   var beforeOffsets = columnOffsets(beforeMap, before.node);
-  var surviving = positionMatchedColumns({
+  var positionMatched = positionMatchedColumns({
     before: before,
     after: after,
     afterToBefore: afterToBefore,
     beforeOffsets: beforeOffsets
   });
-  if (surviving.size !== afterMap.width && !addContentMatchedColumns(surviving, before, after)) {
+  var surviving = positionMatched.size === afterMap.width ? positionMatched : (_localIdMatchedColumn = localIdMatchedColumns(before, after)) !== null && _localIdMatchedColumn !== void 0 ? _localIdMatchedColumn : uniquelyContentMatchedColumns(before, after, beforeMap.width, afterMap.width);
+  if (!surviving) {
     return [];
   }
   return beforeOffsets.flatMap(function (_, column) {

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

@@ -38,6 +38,11 @@ var getAttributionIdentity = function getAttributionIdentity(change) {
     mergeable: true
   };
 };
+var hasContributor = function hasContributor(change) {
+  return [].concat((0, _toConsumableArray2.default)(change.deleted), (0, _toConsumableArray2.default)(change.inserted)).some(function (span) {
+    return (0, _attributions.getAttributionKey)(span.data) !== undefined;
+  });
+};
 var byNewDocRange = function byNewDocRange(left, right) {
   return left.fromB - right.fromB || left.toB - right.toB;
 };
@@ -95,12 +100,28 @@ var blockNodeRanges = function blockNodeRanges(doc, change, ownsPosition) {
  */
 var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc) {
   return changes.flatMap(function (change) {
-    if (getAttributionIdentity(change).mergeable) {
-      return [change];
+    var _change$inserted$;
+    // A replacement can carry an anonymous deletion and an authored insertion. The deleted side
+    // needs its own zero-width change or the insertion's actor claims the deletion too.
+    var deletedKeys = new Set(change.deleted.map(function (span) {
+      return (0, _attributions.getAttributionKey)(span.data);
+    }));
+    var firstInsertedKey = (0, _attributions.getAttributionKey)((_change$inserted$ = change.inserted[0]) === null || _change$inserted$ === void 0 ? void 0 : _change$inserted$.data);
+    var detachDeleted = change.deleted.length > 0 && change.inserted.length > 0 && deletedKeys.size === 1 && !deletedKeys.has(firstInsertedKey) && (deletedKeys.has(undefined) || firstInsertedKey === undefined);
+    var deletedChange = detachDeleted ? [_objectSpread(_objectSpread({}, change), {}, {
+      toB: change.fromB,
+      inserted: []
+    })] : [];
+    var contentChange = detachDeleted ? _objectSpread(_objectSpread({}, change), {}, {
+      fromA: change.toA,
+      deleted: []
+    }) : change;
+    if (getAttributionIdentity(contentChange).mergeable) {
+      return [].concat(deletedChange, [contentChange]);
     }
     var runs = [];
-    var offset = change.fromB;
-    var _iterator = _createForOfIteratorHelper(change.inserted),
+    var offset = contentChange.fromB;
+    var _iterator = _createForOfIteratorHelper(contentChange.inserted),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -127,32 +148,32 @@ var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc)
     } finally {
       _iterator.f();
     }
-    if (runs.length < 2 || offset !== change.toB) {
-      return [change];
+    if (runs.length < 2 || offset !== contentChange.toB) {
+      return [].concat(deletedChange, [contentChange]);
     }
-    return runs.map(function (run, index) {
+    return [].concat(deletedChange, (0, _toConsumableArray2.default)(runs.map(function (run, index) {
       var owned = blockNodeRanges(doc, {
-        from: change.fromB,
-        to: change.toB
+        from: contentChange.fromB,
+        to: contentChange.toB
       }, function (pos) {
         return pos >= run.from && pos < run.to;
       });
-      return _objectSpread(_objectSpread({}, change), {}, {
-        fromA: index === 0 ? change.fromA : change.toA,
+      return _objectSpread(_objectSpread({}, contentChange), {}, {
+        fromA: index === 0 ? contentChange.fromA : contentChange.toA,
         fromB: run.from,
         toB: run.to,
-        deleted: index === 0 ? change.deleted : [],
+        deleted: index === 0 ? contentChange.deleted : [],
         inserted: run.spans
       }, owned ? {
         blockNodeRangesB: owned
       } : {});
-    });
+    })));
   });
 };
 
 /**
- * Subtracts every other author's contained change from a change's range, so both contributions
- * survive. Applies when the contributors arrive as separate changes rather than as spans of one —
+ * Subtracts every differently attributed contained change from a change's range, including when
+ * one has no contributor. Applies when the changes arrive separately rather than as spans of one —
  * the `step` diff type. A contained change by the same author, and one that only partially
  * overlaps, are left for the collapse below.
  *
@@ -161,10 +182,11 @@ var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc)
 var splitContainedChanges = function splitContainedChanges(changes, doc) {
   return changes.flatMap(function (change) {
     var _getAttributionIdenti = getAttributionIdentity(change),
-      key = _getAttributionIdenti.key;
+      key = _getAttributionIdenti.key,
+      mergeable = _getAttributionIdenti.mergeable;
     var inner = mergeRanges(changes.filter(function (other) {
-      var otherKey = getAttributionIdentity(other).key;
-      return other !== change && key !== undefined && otherKey !== undefined && otherKey !== key && isContained(change, other);
+      var otherIdentity = getAttributionIdentity(other);
+      return other !== change && mergeable && otherIdentity.mergeable && otherIdentity.key !== key && isContained(change, other);
     }).map(function (_ref) {
       var fromB = _ref.fromB,
         toB = _ref.toB;
@@ -242,7 +264,7 @@ var mergeBlockNodeRanges = function mergeBlockNodeRanges(left, right) {
   return left.blockNodeRangesB && right.blockNodeRangesB ? [].concat((0, _toConsumableArray2.default)(left.blockNodeRangesB), (0, _toConsumableArray2.default)(right.blockNodeRangesB)) : undefined;
 };
 
-/** Unions the changes whose new-document ranges strictly overlap, leaving touching ones alone. */
+/** Unions overlapping changes, except when only one side names a contributor. */
 var collapse = function collapse(changes) {
   // A zero-length new-document range paints no inline decoration, so it is kept aside rather than
   // folded into a neighbouring insertion.
@@ -258,7 +280,9 @@ var collapse = function collapse(changes) {
     for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
       var change = _step3.value;
       var current = collapsed[collapsed.length - 1];
-      if (current && change.fromB < current.toB) {
+      var currentHasContributor = current && hasContributor(current);
+      var changeHasContributor = hasContributor(change);
+      if (current && change.fromB < current.toB && currentHasContributor === changeHasContributor) {
         var blockNodeRangesB = mergeBlockNodeRanges(current, change);
         collapsed[collapsed.length - 1] = _objectSpread({
           fromA: Math.min(current.fromA, change.fromA),
@@ -288,8 +312,8 @@ var collapse = function collapse(changes) {
  * characters — which stacks two inline decorations and renders one contributor tag per copy.
  *
  * Merging keeps every span from both sides, so the latest-writer rule still decides whose tag is
- * shown. Ranges that merely touch are left alone, so an unattributed edit next to an attributed one
- * is not credited to it.
+ * shown among attributed edits. An unattributed change never merges with an attributed one.
+ * Ranges that merely touch are left alone.
  *
  * Contributors are separated first, by `splitMixedIdentityChanges` and `splitContainedChanges`.
  * Both leave ranges that only touch, so they survive the collapse.

package/dist/cjs/pm-plugins/decorations/colorSchemes/attributions.js

@@ -244,13 +244,12 @@ var getAttributionKeyForChanges = function getAttributionKeyForChanges(changes)
 };
 
 /**
- * The attribution key owning a change. Inline and step changes retain direct attribution spans, so
- * resolve those first. Grouped and smart-classified changes can lose that data; for those, fall
- * back to the latest overlapping attributed step.
+ * Preserve overlap attribution outside Confluence version history. Within version history, a
+ * recovery step's keyless spans must not inherit an overlapping NCS step's actor.
  */
 var getAttributionKeyForChange = exports.getAttributionKeyForChange = function getAttributionKeyForChange(change, attributedChanges) {
-  var _getAttributionKeyFor;
-  return (_getAttributionKeyFor = getAttributionKeyForChanges([change])) !== null && _getAttributionKeyFor !== void 0 ? _getAttributionKeyFor : getAttributionKeyForChanges(attributedChanges.filter(function (attributedChange) {
+  var directKey = getAttributionKeyForChanges([change]);
+  return directKey !== null && directKey !== void 0 ? directKey : (0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? undefined : getAttributionKeyForChanges(attributedChanges.filter(function (attributedChange) {
     return changesOverlap(change, attributedChange);
   }));
 };

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

@@ -222,7 +222,7 @@ var createChangedRowDOM = function createChangedRowDOM(_ref3) {
   return tr;
 };
 var supportsAnchorPositioning = function supportsAnchorPositioning() {
-  return typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)');
+  return typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)') && CSS.supports('position-anchor', '--a');
 };
 var createAnchoredRemovedLozengeWidget = function createAnchoredRemovedLozengeWidget(_ref4) {
   var anchorName = _ref4.anchorName,
@@ -233,6 +233,9 @@ var createAnchoredRemovedLozengeWidget = function createAnchoredRemovedLozengeWi
   var lozenge = (0, _wrapBlockNodeView.createRemovedLozenge)(intl, isActive, colorScheme, true);
   var inset = lozenge.style.top;
   lozenge.style.setProperty('position', 'fixed');
+  // Fixed labels only follow their default anchor on scroll, and escape scroll-container clipping.
+  lozenge.style.setProperty('position-anchor', "--".concat(anchorName));
+  lozenge.style.setProperty('position-visibility', 'anchors-visible');
   lozenge.style.setProperty('top', "calc(anchor(--".concat(anchorName, " top) + ").concat(inset, ")"));
   lozenge.style.setProperty('left', "calc(anchor(--".concat(anchorName, " right) - ").concat(inset, ")"));
   lozenge.style.setProperty('right', 'auto');

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

@@ -148,7 +148,7 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
   // node renders beneath its replacement; otherwise anchor at the start (change.fromB).
   var anchorPos = placeBelow ? change.toB : change.fromB;
   var safeInsertPos = (0, _findSafeInsertPos.findSafeInsertPos)(newDoc, anchorPos, slice);
-  var isActive = activeIndexPos && ((0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? safeInsertPos >= activeIndexPos.from && safeInsertPos <= activeIndexPos.to : safeInsertPos === activeIndexPos.from && safeInsertPos === activeIndexPos.to);
+  var isActive = activeIndexPos && ((0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? safeInsertPos >= activeIndexPos.from && safeInsertPos <= activeIndexPos.to && (!('attributionKey' in activeIndexPos) || activeIndexPos.attributionKey === attributionKey) : safeInsertPos === activeIndexPos.from && safeInsertPos === activeIndexPos.to);
   if (deletedBlankLineCount > 0) {
     // The blocks have no content to serialize, so the deletion is shown as one struck-through
     // return glyph per line the author removed. A single widget, not one per line: the lines are

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

@@ -104,7 +104,9 @@ var owningStop = function owningStop(target, stops) {
  * containment, and the leading change of what it covers.
  */
 var resolveActiveTarget = function resolveActiveTarget(surviving, activeIndexPos) {
-  return containedBy(surviving, activeIndexPos)[0];
+  return containedBy(surviving, activeIndexPos).find(function (target) {
+    return !(0, _fg.fg)('confluence_ncs_step_diffing_version_history') || !('attributionKey' in activeIndexPos) || target.decoration.spec.attributionKey === activeIndexPos.attributionKey;
+  });
 };
 
 /**

package/dist/cjs/pm-plugins/getScrollableDecorations.js

@@ -90,18 +90,13 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
     return a.from === b.from ? a.to - b.to : a.from - b.from;
   });
   sortedDecorations.forEach(function (decoration) {
-    var _openGroups$find;
     // A gap ends the run: nothing before it can be joined.
     if (decoration.from > clusterTo) {
       openGroups = [];
     }
     var contributor = contributorOf(decoration);
-    // An unattributed decoration names nobody to keep apart, so it joins whatever is open — a
-    // decision item's own highlight must not split the stop from the tag on its list.
-    var openGroup = (_openGroups$find = openGroups.find(function (group) {
+    var openGroup = openGroups.find(function (group) {
       return group.contributor === contributor;
-    })) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(function (group) {
-      return group.contributor === '';
     });
     if (openGroup === undefined) {
       var group = {
@@ -113,8 +108,6 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
       groups.push(group);
       openGroups = [].concat((0, _toConsumableArray2.default)(openGroups), [group]);
     } else {
-      // The first contributor to join claims the group, so the next one still starts its own.
-      openGroup.contributor = openGroup.contributor || contributor;
       openGroup.decorations.push(decoration);
       openGroup.to = Math.max(openGroup.to, decoration.to);
     }

package/dist/cjs/pm-plugins/main.js

@@ -12,6 +12,7 @@ var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
 var _state2 = require("@atlaskit/editor-prosemirror/state");
 var _transformOverride = require("@atlaskit/editor-prosemirror/transform-override");
 var _view = require("@atlaskit/editor-prosemirror/view");
+var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _announceActiveDiff = require("../ui/DiffNavigation/announceActiveDiff");
 var _calculateDiffDecorations = require("./calculateDiff/calculateDiffDecorations");
 var _decorationKeys = require("./decorations/decorationKeys");
@@ -177,10 +178,12 @@ var createPlugin = exports.createPlugin = function createPlugin(config, getIntl,
               var activeDecoration = _decorations[nextIndex];
               newPluginState = _objectSpread(_objectSpread({}, currentPluginState), {}, {
                 activeIndex: nextIndex,
-                activeIndexPos: activeDecoration ? {
+                activeIndexPos: activeDecoration ? _objectSpread({
                   from: activeDecoration.from,
                   to: activeDecoration.to
-                } : undefined
+                }, (0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? {
+                  attributionKey: (0, _decorationKeys.isDiffDecoration)(activeDecoration) ? activeDecoration.spec.attributionKey : undefined
+                } : {}) : undefined
               });
               // Recalculate decorations with the new active index
               var _calculateDiffDecorat2 = (0, _calculateDiffDecorations.calculateDiffDecorations)({

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

@@ -114,19 +114,18 @@ const leafTextblockRanges = (doc, from, to) => {
 // once it has more leaf textblocks (~cells) than this threshold. Small tables
 // keep the precise per-cell path.
 const LARGE_TABLE_LEAF_THRESHOLD = 40;
-
 /**
- * An active scrollable change may contain several underlying diff changes. Treat ranges that
- * overlap or touch the active range as part of the same active customer-facing edit.
+ * An active scrollable change may contain several underlying diff changes. With attribution, only
+ * ranges belonging to the selected contributor (including the anonymous contributor) are active.
  */
-const isRangeActive = (activeIndexPos, from, to) => {
+const isRangeActive = (activeIndexPos, from, to, attributionKey) => {
   if (activeIndexPos === undefined) {
     return undefined;
   }
   if (!fg('confluence_ncs_step_diffing_version_history')) {
     return from === activeIndexPos.from && to === activeIndexPos.to;
   }
-  return from <= activeIndexPos.to && activeIndexPos.from <= to;
+  return from <= activeIndexPos.to && activeIndexPos.from <= to && (!('attributionKey' in activeIndexPos) || activeIndexPos.attributionKey === attributionKey);
 };
 const isLargeInsertedTableRange = (doc, from, to) => {
   let containsTable = false;
@@ -187,7 +186,7 @@ const calculateNodesForBlockDecoration = ({
       if (!(node !== null && node !== void 0 && node.isBlock)) {
         continue;
       }
-      const isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+      const isActive = isRangeActive(activeIndexPos, pos, nodeEnd, attributionKey);
       decorations.push(...createBlockChangedDecoration({
         attributionKey,
         change: {
@@ -226,7 +225,7 @@ const calculateNodesForBlockDecoration = ({
     }
     if (node.isBlock && (!requireContainedBlocks || pos >= from) && pos + node.nodeSize <= to) {
       const nodeEnd = pos + node.nodeSize;
-      const isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+      const isActive = isRangeActive(activeIndexPos, pos, nodeEnd, attributionKey);
       decorations.push(...createBlockChangedDecoration({
         attributionKey,
         change: {
@@ -488,7 +487,7 @@ const calculateDiffDecorationsInner = ({
     const leftAnchorId = fg('platform_editor_ai_show_diff_patch_2') ? `replacement-${change.fromA}-${change.toA}-${change.fromB}-${change.toB}` : undefined;
     const changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     const attributionKey = showContributorTags ? getAttributionKeyForChange(change, attributedChanges) : undefined;
-    const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
     const {
       deletedColumns
     } = change;
@@ -701,7 +700,7 @@ const calculateDiffDecorationsInner = ({
     var _attributionColors$ge, _attributionColors;
     const changeColorScheme = change.attributionKey ? (_attributionColors$ge = (_attributionColors = attributionColors) === null || _attributionColors === void 0 ? void 0 : _attributionColors.get(change.attributionKey)) !== null && _attributionColors$ge !== void 0 ? _attributionColors$ge : colorScheme : colorScheme;
     const attributionKey = showContributorTags ? change.attributionKey : undefined;
-    const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
     decorations.push(...createInlineChangedDecoration({
       attributionKey,
       change,
@@ -726,7 +725,7 @@ const calculateDiffDecorationsInner = ({
     const attributionKey = showContributorTags ? change.attributionKey : undefined;
     if (change.isInline) {
       // Inline nodes (e.g. date, emoji, mention, status) need an inline decoration rather than a block decoration
-      const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+      const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
       decorations.push(...createInlineChangedDecoration({
         attributionKey,
         change,