@atlaskit/editor-plugin-show-diff 16.1.0 → 16.2.0

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

@@ -1,5 +1,5 @@
-import _toArray from "@babel/runtime/helpers/toArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toArray from "@babel/runtime/helpers/toArray";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 var _excluded = ["connectedToKey"];
@@ -51,6 +51,14 @@ var isSameBlockChange = function isSameBlockChange(inner, block) {
   return inner.spec.attributionKey === block.spec.attributionKey && (block.from <= inner.from && inner.to <= block.to || inner.from <= block.from && block.to <= inner.to);
 };
 
+/**
+ * Whether `outer` is the box `inner` sits in, for one contributor. Nested blocks they inserted read
+ * as one change, so only the outermost keeps a tag (EDITOR-8932).
+ */
+var containsBlock = function containsBlock(outer, inner) {
+  return outer.spec.attributionKey === inner.spec.attributionKey && outer.from <= inner.from && inner.to <= outer.to && outer.to - outer.from > inner.to - inner.from;
+};
+
 /**
  * Which of two changes in the same range leads, and so is the one a tag captions. Position first,
  * then `side`, since deleted content shares its `from` with the content that replaced it and paints
@@ -71,6 +79,19 @@ var containedBy = function containedBy(targets, _ref2) {
   }).sort(byLeadingPosition);
 };
 
+/**
+ * The stop a target is stepped to by: the narrowest one that wholly covers it. A stop's range is
+ * the union of the decorations grouped into it, so one inserted run's inline highlight stretches
+ * its stop over every block the run spans — including blocks that are a stop of their own. Picking
+ * the narrowest keeps each of those blocks in the stop that actually reaches it, rather than
+ * letting the widest stop claim them all and fold away every tag but the first (EDITOR-8932).
+ */
+var owningStop = function owningStop(target, stops) {
+  return stops.reduce(function (narrowest, stop) {
+    return stop.from <= target.decoration.from && target.decoration.to <= stop.to && (narrowest === undefined || stop.to - stop.from < narrowest.to - narrowest.from) ? stop : narrowest;
+  }, undefined);
+};
+
 /**
  * The one tag a navigation step reveals. `spec.isActive` is no use here: it covers everything the
  * group's union range touches, so several tags revealed over each other (EDITOR-8971). Hence
@@ -139,6 +160,10 @@ export var extractContributorTags = function extractContributorTags(decorations,
   });
   var linkedDiffIds = new Map();
   var folded = new Set();
+
+  /**
+   * A folded target keeps no tag of its own — it becomes a hover target of the host instead.
+   */
   var fold = function fold(host, target) {
     var _linkedDiffIds$get, _linkedDiffIds$get2;
     folded.add(target);
@@ -196,58 +221,113 @@ export var extractContributorTags = function extractContributorTags(decorations,
     if (_ret === 0) continue;
   }
 
+  // A nested block folds into the outermost one of the same contributor, so nesting adds no tags.
+  if (fg('confluence_ncs_step_diffing_version_history')) {
+    var blocksByContributor = new Map();
+    var _iterator2 = _createForOfIteratorHelper(blockTargets),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _target$decoration$sp, _blocksByContributor$;
+        var target = _step2.value;
+        var key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
+        blocksByContributor.set(key, [].concat(_toConsumableArray((_blocksByContributor$ = blocksByContributor.get(key)) !== null && _blocksByContributor$ !== void 0 ? _blocksByContributor$ : []), [target]));
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    var _iterator3 = _createForOfIteratorHelper(blocksByContributor.values()),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var contributorBlocks = _step3.value;
+        // Block ranges nest rather than partially overlap, so ascending `from` then descending `to`
+        // reaches every block after the ones containing it. A stack of the blocks still open at
+        // this position then yields each block's container in one pass, rather than rescanning
+        // every block for the widest that contains it.
+        var nested = _toConsumableArray(contributorBlocks).sort(function (left, right) {
+          return left.decoration.from - right.decoration.from || right.decoration.to - left.decoration.to;
+        });
+        var open = [];
+        var _iterator4 = _createForOfIteratorHelper(nested),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _target = _step4.value;
+            while (open.length > 0 && !containsBlock(open[open.length - 1].decoration, _target.decoration)) {
+              open.pop();
+            }
+            // Outermost first, so the bottom of the stack is the block the tag survives on.
+            if (open.length > 0) {
+              fold(open[0], _target);
+            }
+            open.push(_target);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  }
+
   // One tag per contributor per navigation stop. The folds above only catch a replacement's two
   // halves and a block's own highlights; two of one contributor's changes that merely touch are a
   // single stop (`groupTouchingDecorations`) yet kept a tag each, so the stop's trailing tag was
   // drawn but could never be stepped to (EDITOR-8971). It folds into the leading tag of its
   // contributor, staying a hover target. Contributors are kept apart: a stop spanning two of them
   // still captions each, rather than crediting one for the other's change.
-  var _iterator2 = _createForOfIteratorHelper(stops !== null && stops !== void 0 ? stops : []),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var stop = _step2.value;
-      var byContributor = new Map();
-      var _iterator3 = _createForOfIteratorHelper(containedBy(targets.filter(function (target) {
-          return !folded.has(target);
-        }), stop)),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _target$decoration$sp, _byContributor$get;
-          var target = _step3.value;
-          var key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
-          byContributor.set(key, [].concat(_toConsumableArray((_byContributor$get = byContributor.get(key)) !== null && _byContributor$get !== void 0 ? _byContributor$get : []), [target]));
+  // Each target is counted against one stop only — see `owningStop`.
+  if (stops !== null && stops !== void 0 && stops.length) {
+    var byStopAndContributor = new Map();
+    var _iterator5 = _createForOfIteratorHelper(targets.filter(function (target) {
+        return !folded.has(target);
+      })),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _target2$decoration$s, _byStopAndContributor;
+        var _target2 = _step5.value;
+        var stop = owningStop(_target2, stops);
+        if (stop === undefined) {
+          continue;
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
+        var _key = "".concat(stop.from, "-").concat(stop.to, "|").concat((_target2$decoration$s = _target2.decoration.spec.attributionKey) !== null && _target2$decoration$s !== void 0 ? _target2$decoration$s : '');
+        byStopAndContributor.set(_key, [].concat(_toConsumableArray((_byStopAndContributor = byStopAndContributor.get(_key)) !== null && _byStopAndContributor !== void 0 ? _byStopAndContributor : []), [_target2]));
       }
-      var _iterator4 = _createForOfIteratorHelper(byContributor.values()),
-        _step4;
-      try {
-        var _loop2 = function _loop2() {
-          var _step4$value = _toArray(_step4.value),
-            leader = _step4$value[0],
-            trailing = _arrayLikeToArray(_step4$value).slice(1);
-          trailing.forEach(function (target) {
-            return fold(leader, target);
-          });
-        };
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          _loop2();
-        }
-      } catch (err) {
-        _iterator4.e(err);
-      } finally {
-        _iterator4.f();
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    var _iterator6 = _createForOfIteratorHelper(byStopAndContributor.values()),
+      _step6;
+    try {
+      var _loop2 = function _loop2() {
+        var members = _step6.value;
+        var _sort = _toConsumableArray(members).sort(byLeadingPosition),
+          _sort2 = _toArray(_sort),
+          leader = _sort2[0],
+          trailing = _arrayLikeToArray(_sort2).slice(1);
+        trailing.forEach(function (target) {
+          return fold(leader, target);
+        });
+      };
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        _loop2();
       }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
     }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
   }
   var surviving = targets.filter(function (target) {
     return !folded.has(target);

package/dist/esm/pm-plugins/decorations/revealStyles.js

@@ -1,4 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { buildDeletedInlineStyleStandard, getDeletedInlineRevealColors, getInsertedInlineRevealColors } from './colorSchemes/factory';
@@ -108,6 +109,7 @@ export var resolveRevealStyle = function resolveRevealStyle(_ref4) {
     return undefined;
   }
   var colors = getColorScheme(colorScheme);
+  var brand = isInserted && Object.prototype.hasOwnProperty.call(agentBrandColorSchemes, colors.insertColor) ? agentBrandColorSchemes[colors.insertColor] : undefined;
   var _resolveRevealColors = resolveRevealColors(colors, {
       hideAddedDiffsUnderline: hideAddedDiffsUnderline,
       isActive: isActive,
@@ -117,7 +119,9 @@ export var resolveRevealStyle = function resolveRevealStyle(_ref4) {
     border = _resolveRevealColors.border;
   return {
     role: isInserted ? 'added' : 'deleted',
-    style: (isInserted || !includeDeletedTextStyle ? '' : deletedTextOnlyStyle(colors, isActive)) + revealBaseStyle + buildWipeableBackground(background) + buildRevealVariables({
+    style: (brand ? convertToInlineCss({
+      color: brand.text
+    }) : '') + (isInserted || !includeDeletedTextStyle ? '' : deletedTextOnlyStyle(colors, isActive)) + revealBaseStyle + buildWipeableBackground(background) + buildRevealVariables({
       background: background,
       border: border
     })

package/dist/esm/pm-plugins/decorations/utils/absorbFirstChildMarginReset.js

@@ -0,0 +1,28 @@
+import { createBoxlessMarginAbsorber } from './createMarginAbsorber';
+
+/**
+ * Keeps a block node rendered inside a diff widget from losing its own top margin.
+ *
+ * The editor's leading-block margin reset is written against the parent element, not the document
+ * position, so it fires wherever a text block is a first child — including inside the widget's own
+ * `span`, which is what a whole-block deletion renders into. The widget then has no margin of its
+ * own, and the block sits flush against whatever is above it, regardless of where in the document
+ * the widget landed.
+ *
+ * The margin is not re-supplied; it is never taken away. Prepending an element the reset does not
+ * select moves the real block off the leading position, so the ordinary `.ProseMirror p`,
+ * `.ProseMirror h2` and similar rules go on applying to it untouched. That is why this needs no
+ * knowledge of which margin the block should have — unlike `createNodeShapedMarginSpacer`, which
+ * replicates a margin that has already been zeroed and cannot be read back.
+ *
+ * Unconditional, because the absorber generates no box: it costs nothing in a widget holding
+ * inline content, which the reset was never going to match anyway. Deciding here instead would mean
+ * restating the reset's selector list, and a copy of another package's CSS drifts silently.
+ */
+export var absorbFirstChildMarginReset = function absorbFirstChildMarginReset(_ref) {
+  var dom = _ref.dom,
+    testId = _ref.testId;
+  dom.prepend(createBoxlessMarginAbsorber({
+    testId: testId
+  }));
+};

package/dist/esm/pm-plugins/decorations/utils/createMarginAbsorber.js

@@ -0,0 +1,37 @@
+/**
+ * An empty, invisible element whose only job is to occupy a position in the DOM.
+ *
+ * At the top of the document `firstBlockNodeStyles` zeroes the top margin of whatever element
+ * follows a leading `.ProseMirror-widget`, and it does so with `!important` — which no inline style
+ * can outrank. This takes that hit so the shaped spacer after it, one position further along, keeps
+ * the margin it is there to supply.
+ *
+ * It contributes no height (no content, border or padding) and margins collapse through it, so it
+ * cannot affect layout beyond the selector it absorbs.
+ */
+export var createMarginAbsorber = function createMarginAbsorber(_ref) {
+  var testId = _ref.testId;
+  // Block-level: an empty inline element takes the match just as well, but collapses to a
+  // zero-height line box, and the following margin then lands in the wrong place.
+  var absorber = document.createElement('div');
+  absorber.dataset.testid = testId;
+  absorber.setAttribute('aria-hidden', 'true');
+  absorber.contentEditable = 'false';
+  return absorber;
+};
+
+/**
+ * An absorber that occupies a DOM position without generating a box.
+ *
+ * Not interchangeable with `createMarginAbsorber`: a rule that selects the *rendered* sibling of a
+ * leading widget needs an element that generates a box, and this one does not.
+ */
+export var createBoxlessMarginAbsorber = function createBoxlessMarginAbsorber(_ref2) {
+  var testId = _ref2.testId;
+  var absorber = document.createElement('div');
+  absorber.dataset.testid = testId;
+  absorber.setAttribute('aria-hidden', 'true');
+  absorber.contentEditable = 'false';
+  absorber.style.display = 'contents';
+  return absorber;
+};

package/dist/esm/pm-plugins/decorations/utils/createNodeShapedMarginSpacer.js

@@ -0,0 +1,70 @@
+/**
+ * Node types that can safely be reduced to an empty shell.
+ *
+ * A shell only replicates a margin if it collapses to nothing itself, which needs zero height and
+ * no vertical border or padding. Textblocks and lists qualify; nodes with intrinsic sizing (tables
+ * are `display: table`, media has a measured height) or a painted box (a zero-height panel is a
+ * visible stripe of background) do not, and are left alone.
+ */
+var isShapeableNode = function isShapeableNode(node) {
+  return node.isTextblock || ['bulletList', 'orderedList'].includes(node.type.name);
+};
+
+/**
+ * An invisible element shaped like `node`, used to supply the top margin `node` no longer gets.
+ *
+ * A node at the start of its parent has its top margin reset, so a diff widget rendered above it
+ * sits flush against it. The reset cannot simply be taken off the node: the container variants skip
+ * widgets when counting — `nth-child(1 of :not(style, .ProseMirror-gapcursor, .ProseMirror-widget,
+ * span))` in layout columns, expands, sync blocks and table cells — so no amount of extra elements
+ * moves the match. That exclusion is what makes this work instead: the spacer is a
+ * `.ProseMirror-widget`, so it is never the counted first child and keeps its own margin, while the
+ * real node goes on taking the reset.
+ *
+ * The margin is not measured. Reading it off the real node is impossible — by then the reset has
+ * set it to `0`, and both `firstBlockNodeStyles` (`!important`) and block controls' `firstNodeDec`
+ * (an inline style) make it unrecoverable. Instead the spacer carries the node's own tag, classes
+ * and attributes, so the same rules that would have given the node its margin match the spacer
+ * (`.ProseMirror p`, `.ProseMirror h2`, the root-list rule, and so on).
+ *
+ * Returns `null` when the node is not safely shapeable or serialization fails.
+ */
+export var createNodeShapedMarginSpacer = function createNodeShapedMarginSpacer(_ref) {
+  var _node$type$createAndF;
+  var node = _ref.node,
+    serializer = _ref.serializer,
+    testId = _ref.testId;
+  if (!isShapeableNode(node)) {
+    return null;
+  }
+
+  // An empty node of the same type serializes to the same shell without walking real content.
+  var shellNode = (_node$type$createAndF = node.type.createAndFill(node.attrs)) !== null && _node$type$createAndF !== void 0 ? _node$type$createAndF : node;
+  var serialized = serializer.serializeNode(shellNode);
+  if (!(serialized instanceof HTMLElement)) {
+    return null;
+  }
+
+  // Keep the tag, classes and attributes the margin rules select on; drop anything that could
+  // occupy a line box.
+  serialized.replaceChildren();
+  serialized.dataset.testid = testId;
+  serialized.setAttribute('aria-hidden', 'true');
+  serialized.contentEditable = 'false';
+
+  // Zero height with no vertical border or padding keeps the spacer self-collapsing: its margins
+  // stay adjoining, so they collapse with the neighbours into a single margin equal to the largest
+  // rather than adding to them. That is what makes this safe in containers that never reset the
+  // first child — the spacer cannot double the gap there. Deliberately no `overflow: hidden`, which
+  // would open a block formatting context and stop that collapsing.
+  serialized.style.height = '0';
+  serialized.style.minHeight = '0';
+  serialized.style.paddingTop = '0';
+  serialized.style.paddingBottom = '0';
+  serialized.style.borderTopWidth = '0';
+  serialized.style.borderBottomWidth = '0';
+  // Only the top margin is being replicated. Left as-is, a larger bottom margin would win the
+  // self-collapse and overshoot the gap.
+  serialized.style.marginBottom = '0';
+  return serialized;
+};

package/dist/esm/pm-plugins/decorations/utils/safeResolve.js

@@ -0,0 +1,18 @@
+/**
+ * Resolves a document position, or returns `null` if it cannot be resolved.
+ *
+ * `Node.resolve` throws a `RangeError` for a position outside the document. Diff decorations are
+ * built from change ranges computed against a document that may since have moved on, so a position
+ * arriving out of range is a normal outcome rather than a defect — but an exception escaping here
+ * takes down the whole decoration set, leaving the diff unrendered.
+ *
+ * Callers are expected to treat `null` as "cannot tell" and fall back to behaviour that does not
+ * need the resolved position.
+ */
+export var safeResolve = function safeResolve(doc, pos) {
+  try {
+    return doc.resolve(pos);
+  } catch (_unused) {
+    return null;
+  }
+};

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

@@ -54,6 +54,17 @@ function decorationSide(decoration) {
   return isDiffDecoration(decoration) && decoration.spec.side || 0;
 }
 
+/**
+ * Whose change a decoration is part of, or `''` on an unattributed diff — where every decoration
+ * reads as one contributor and the grouping below is unchanged.
+ *
+ * Contributors are kept apart so one stop never covers two of them, since only the tag on the
+ * change stepped to reveals (EDITOR-8932).
+ */
+function contributorOf(decoration) {
+  return isDiffDecoration(decoration) && decoration.spec.attributionKey || '';
+}
+
 /**
  * Collapses decorations that represent one continuous customer-facing edit.
  *
@@ -62,34 +73,52 @@ function decorationSide(decoration) {
  * deletion at the same location should be treated as one replacement. Zero-width decorations
  * (normally deleted-content widgets) can join a group, but cannot extend its range and therefore
  * cannot bridge two otherwise separate edits.
+ *
+ * One group per contributor within a run of touching ranges — see `contributorOf`.
  */
 function groupTouchingDecorations(decorations, isInlineDecoration) {
   if (decorations.length < 2) {
     return decorations;
   }
   var groups = [];
-  var currentGroup = [];
-  var currentGroupFrom = 0;
-  var currentGroupTo = 0;
+  // The groups a following decoration can still join — one per contributor, dropped at every gap.
+  var openGroups = [];
+  var clusterTo = 0;
   var sortedDecorations = _toConsumableArray(decorations).sort(function (a, b) {
     return a.from === b.from ? a.to - b.to : a.from - b.from;
   });
   sortedDecorations.forEach(function (decoration) {
-    if (currentGroup.length === 0 || decoration.from > currentGroupTo) {
-      currentGroup = [decoration];
-      currentGroupFrom = decoration.from;
-      currentGroupTo = decoration.to;
-      groups.push({
-        decorations: currentGroup,
-        from: currentGroupFrom,
-        to: currentGroupTo
-      });
-      return;
+    var _openGroups$find;
+    // A gap ends the run: nothing before it can be joined.
+    if (decoration.from > clusterTo) {
+      openGroups = [];
     }
-    currentGroup.push(decoration);
-    // A zero-width decoration must not extend the group and bridge a gap.
-    currentGroupTo = Math.max(currentGroupTo, decoration.to);
-    groups[groups.length - 1].to = currentGroupTo;
+    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) {
+      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 = {
+        contributor: contributor,
+        decorations: [decoration],
+        from: decoration.from,
+        to: decoration.to
+      };
+      groups.push(group);
+      openGroups = [].concat(_toConsumableArray(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);
+    }
+
+    // A zero-width decoration must not extend the run and bridge a gap.
+    clusterTo = Math.max(clusterTo, decoration.to);
   });
   return groups.map(function (_ref) {
     var _ref2, _group$find;
@@ -136,8 +165,8 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
  * 4. When `doc` is passed: excludes diff-inline decorations whose range has no inline content
  *    (invalid positions, or block-only slices with no text/atoms — e.g. empty blocks)
  * 5. When `confluence_ncs_step_diffing_version_history` is enabled, groups overlapping or
- *    directly touching ranges across decoration types into one result, using the union of all
- *    grouped ranges
+ *    directly touching ranges across decoration types into one result per contributor, using the
+ *    union of all grouped ranges
  *    (zero-width widgets can join a group without extending it). Under
  *    `platform_editor_ai_show_diff_patch_1`, a group that starts with content painting above
  * 	  the content that replaced it — reports that widget as its `scrollTarget` spec,

package/dist/esm/pm-plugins/utils/baseNodeName.js

@@ -0,0 +1,20 @@
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+
+/**
+ * A node type's base name, with a schema variant's suffix stripped: `panel`, `panel_c1` and
+ * `panel_c1_root_only` all resolve to `panel`.
+ *
+ * Package-local rather than `getBaseNodeTypeName` from editor-common, which enumerates the variants
+ * it happens to know (`panel_c1` alone) and is shared with features outside this one. Derived
+ * instead of listed, so a variant added later needs no change here: the schema generator names a
+ * variant `<type>_<variant>`, and every other node name in the ADF schema is camelCase, so the
+ * first `_` is the boundary.
+ *
+ * Gated, so the diff behaves exactly as before for anyone outside the rollout.
+ *
+ * For taggability only — this gate is weaker than the ones attribution needs, so resolving a variant
+ * in the styling decisions would move the legacy diff for readers who see no tags.
+ */
+export var resolveBaseNodeName = function resolveBaseNodeName(name) {
+  return fg('confluence_ncs_step_diffing_version_history') ? name.split('_')[0] : name;
+};

package/dist/esm/pm-plugins/utils/taggableBlockNodes.js

@@ -0,0 +1,32 @@
+import { resolveBaseNodeName } from './baseNodeName';
+
+/**
+ * Block nodes that host a contributor tag of their own — those whose whole box reads as one change.
+ * Everything that draws a box whatever it holds, plus the two lists that are inserted whole: without
+ * them the tag fell through to the text inside the first item (EDITOR-8932). Bullet and ordered lists
+ * are left out, since their items accrue one at a time. Tables and list items decorate per cell and
+ * per item, with no one-tag-per-block design yet. `blockCard` covers the datasource variant, which is
+ * the same node type.
+ *
+ * Base names only — match with the predicates below, never against `type.name` directly.
+ */
+var TAGGABLE_BLOCK_NODES = new Set(['blockCard', 'blockquote', 'bodiedExtension', 'codeBlock', 'decisionList', 'embedCard', 'expand', 'extension', 'media', 'multiBodiedExtension', 'panel', 'rule', 'taskList']);
+
+/**
+ * Whether this node hosts a contributor tag of its own. Navigation grouping does not consult this:
+ * a run of these one contributor inserted is a single stop, tagged on the leading block.
+ *
+ * Resolved through `resolveBaseNodeName` so a schema variant counts as the type it is a variant of:
+ * `panel_c1` is the panel the table-in-panel schema inserts, and matching on `type.name` left it
+ * untagged (EDITOR-8932).
+ *
+ * By name, because the decoration spec carries `nodeName` rather than the type it came from.
+ */
+export var isTaggableBlockNodeName = function isTaggableBlockNodeName(name) {
+  return name !== undefined && TAGGABLE_BLOCK_NODES.has(resolveBaseNodeName(name));
+};
+
+/** As above, from the node type itself. */
+export var isTaggableBlockNode = function isTaggableBlockNode(nodeType) {
+  return isTaggableBlockNodeName(nodeType.name);
+};

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

@@ -325,11 +325,11 @@ export var ContributorTagController = /*#__PURE__*/function () {
 
       // Hand-rolled avatar stack: `@atlaskit/avatar-group` cannot render below 24px and the tag uses
       // 16px avatars.
-      var stack = model.connectedContributor ? [].concat(_toConsumableArray(user ? [{
-        contributor: user,
-        stackIndex: 1
-      }] : []), _toConsumableArray(agent ? [{
+      var stack = model.connectedContributor ? [].concat(_toConsumableArray(agent ? [{
         contributor: agent,
+        stackIndex: 1
+      }] : []), _toConsumableArray(user ? [{
+        contributor: user,
         stackIndex: 0
       }] : [])) : [{
         contributor: model.contributor

package/dist/types/pm-plugins/calculateDiff/simplifyChangesWithAttribution.d.ts

@@ -1,5 +1,17 @@
 import { type Change } from 'prosemirror-changeset';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+type Range = {
+    from: number;
+    to: number;
+};
+/**
+ * A change, plus the block nodes it owns when it is one piece of a split — a piece's own range no
+ * longer covers the container it opened. Absent on an unsplit change, which decorates the blocks
+ * inside its own range as before.
+ */
+export type AttributedChange = Change & {
+    blockNodeRangesB?: Range[];
+};
 /**
  * Collapses changes whose new-document ranges strictly overlap. Attribution runs are simplified
  * independently, so runs either side of an unattributed step can come back covering the same
@@ -8,10 +20,17 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
  * 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.
+ *
+ * Contributors are separated first, by `splitMixedIdentityChanges` and `splitContainedChanges`.
+ * Both leave ranges that only touch, so they survive the collapse.
+ *
+ * Carries no gate of its own: the only caller reaches it through the attributed changeset, which
+ * already requires `confluence_ncs_step_diffing_version_history`.
  */
-export declare const collapseOverlappingChanges: (changes: Change[]) => Change[];
+export declare const collapseOverlappingChanges: (changes: Change[], doc?: PMNode) => AttributedChange[];
 /**
  * Simplifies and optimizes consecutive changes without crossing an attribution boundary.
  * A change which already contains more than one identity is deliberately kept isolated.
  */
 export declare const simplifyChangesWithAttribution: (changes: readonly Change[], doc: PMNode) => Change[];
+export {};

package/dist/types/pm-plugins/decorations/colorSchemes/factory.d.ts

@@ -1,4 +1,4 @@
-import type { AdsAccentColor, DiffColorScheme } from './types';
+import type { AccentColor, DiffColorScheme } from './types';
 /**
  * Hover highlight for deleted text under an 'onEmphasis' scheme. Inline styles cannot express
  * `:hover`, so the resting style resolves its background from this property and
@@ -12,20 +12,13 @@ export declare const DELETED_HIGHLIGHT_BG_VAR = "--show-diff-deleted-highlight-b
  * 'underline' scheme can darken the border without darkening the tint behind it.
  */
 export declare const DELETED_HIGHLIGHT_BORDER_VAR = "--show-diff-deleted-highlight-border";
-/**
- * Presentation tokens for a contributor tag in one diff colour.
- *
- * A `bolder` fill rather than the `subtlest` tint the highlight uses: the tag is a label on the
- * change, and at tag size a tint reads as a second, weaker highlight sitting above the real one.
- * `inverse` is the only text tone that reads on a bolder fill, and it needs no per-colour map —
- * which is also why the tag carries no border: the fill alone bounds it.
- */
-export declare function getAccentTokens(color: AdsAccentColor): {
+/** Contributor tags use a bold fill with a contrasting foreground, including branded schemes. */
+export declare function getAccentTokens(color: AccentColor): {
     background: string;
     text: string;
 };
 /** Border token for a contributor accent, used by the diff indicator. */
-export declare function getAccentBorderColor(color: AdsAccentColor): string;
+export declare function getAccentBorderColor(color: AccentColor): string;
 /** Inline inserted content — default state. */
 export declare function buildInsertStyle(colors: DiffColorScheme): string;
 /** Inline insert style for content within a block node (no background, underline only). */