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

package/dist/es2019/pm-plugins/decorations/createBlockChangedDecoration.js

@@ -4,6 +4,7 @@ import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { isExtendedEnabled } from '../isExtendedEnabled';
+import { isTaggableBlockNode } from '../utils/taggableBlockNodes';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedBlockNodeStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildInsertedBlockNodeStyle } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
@@ -23,23 +24,28 @@ const UNSTYLED_NODES = ['mediaSingle', 'mediaGroup', 'table',
 'heading', 'hardBreak', 'decisionList', 'taskList', 'bulletList', 'orderedList', 'layoutSection'];
 const CELL_NODES = ['tableCell', 'tableHeader'];
 
-/**
- * Block nodes that host a contributor tag of their own — those whose whole box reads as one change.
- * Lists and tables are excluded: they decorate per item and per cell, with no one-tag-per-block
- * design yet. `blockCard` covers the datasource variant, which is the same node type.
- */
-const TAGGABLE_BLOCK_NODES = new Set(['blockCard', 'blockquote', 'bodiedExtension', 'codeBlock', 'embedCard', 'expand', 'extension', 'media', 'multiBodiedExtension', 'panel', 'rule']);
-
 /** Panels, rules and media can also sit in a table cell, which is out of scope for block tags. */
 const isInsideTable = (doc, pos) => findParentNodeClosestToPos(doc.resolve(pos), node => node.type.name === 'table') !== undefined;
 
-/** Whether this block can host a contributor tag of its own. */
+/**
+ * Whether this block can host a contributor tag of its own.
+ *
+ * The node type is resolved from the document rather than matched on `change.name`, so a schema
+ * variant is recognised as the type it varies — see `isTaggableBlockNode`. `from` is the node's own
+ * position, so `nodeAt` returns exactly the node being decorated.
+ */
 const canTagBlock = ({
   diffType,
   doc,
-  from,
-  name
-}) => doc !== undefined && isExtendedEnabled(diffType) && TAGGABLE_BLOCK_NODES.has(name) && !isInsideTable(doc, from);
+  from
+}) => {
+  var _doc$nodeAt;
+  if (doc === undefined || !isExtendedEnabled(diffType)) {
+    return false;
+  }
+  const nodeType = (_doc$nodeAt = doc.nodeAt(from)) === null || _doc$nodeAt === void 0 ? void 0 : _doc$nodeAt.type;
+  return nodeType !== undefined && isTaggableBlockNode(nodeType) && !isInsideTable(doc, from);
+};
 
 /** Positioning context for the cell overlay widget decorations. */
 const cellPositionStyle = convertToInlineCss({
@@ -176,8 +182,7 @@ export const createBlockChangedDecoration = ({
   const shouldTagBlock = showContributorTags && canTagBlock({
     diffType,
     doc,
-    from: change.from,
-    name: change.name
+    from: change.from
   });
   // Named so this block's own tag can position against it; see `createContributorTagWidget`.
   const tagAnchorName = shouldTagBlock && isContributorTagWidgetEnabled() ? buildAnchorDecorationKey({
@@ -221,7 +226,9 @@ export const createBlockChangedDecoration = ({
       key: 'cell-overlay-decoration'
     }));
   }
-  // isInserted is only read under the extended experience, so pass it unconditionally.
+  // isInserted is only read under the extended experience, so pass it unconditionally. `change.name`
+  // verbatim: base-name resolution stays in `canTagBlock`, which needs tags on, so a schema
+  // variant's legacy style is untouched — see `resolveBaseNodeName`.
   const nodeStyle = getBlockNodeStyle({
     nodeName: change.name,
     colorScheme,
@@ -254,6 +261,8 @@ export const createBlockChangedDecoration = ({
     })));
   }
   if (decorations.length === 0) {
+    // An unstyled node type (paragraph, heading, list, layout, …) emits no decoration at all, so
+    // there is nothing for a tag to hang off even when the node type would otherwise be taggable.
     return decorations;
   }
   if (showIndicators && doc && isExtendedEnabled(diffType)) {

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

@@ -34,6 +34,12 @@ const leadsReplacement = widget => fg('confluence_ncs_step_diffing_version_histo
  */
 const isSameBlockChange = (inner, block) => 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).
+ */
+const containsBlock = (outer, inner) => 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
@@ -52,6 +58,15 @@ const containedBy = (targets, {
   decoration
 }) => from <= decoration.from && decoration.to <= to).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).
+ */
+const owningStop = (target, stops) => stops.reduce((narrowest, stop) => 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
@@ -108,6 +123,10 @@ export const extractContributorTags = (decorations, contributors, activeIndexPos
   }) => decoration.spec.decorationType === 'widget');
   const linkedDiffIds = new Map();
   const folded = new Set();
+
+  /**
+   * A folded target keeps no tag of its own — it becomes a hover target of the host instead.
+   */
   const fold = (host, target) => {
     var _linkedDiffIds$get, _linkedDiffIds$get2;
     folded.add(target);
@@ -158,20 +177,54 @@ export const extractContributorTags = (decorations, contributors, activeIndexPos
     }
   }
 
+  // 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')) {
+    const blocksByContributor = new Map();
+    for (const target of blockTargets) {
+      var _target$decoration$sp, _blocksByContributor$;
+      const key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
+      blocksByContributor.set(key, [...((_blocksByContributor$ = blocksByContributor.get(key)) !== null && _blocksByContributor$ !== void 0 ? _blocksByContributor$ : []), target]);
+    }
+    for (const contributorBlocks of blocksByContributor.values()) {
+      // 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.
+      const nested = [...contributorBlocks].sort((left, right) => left.decoration.from - right.decoration.from || right.decoration.to - left.decoration.to);
+      const open = [];
+      for (const target of nested) {
+        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);
+      }
+    }
+  }
+
   // 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.
-  for (const stop of stops !== null && stops !== void 0 ? stops : []) {
-    const byContributor = new Map();
-    for (const target of containedBy(targets.filter(target => !folded.has(target)), stop)) {
-      var _target$decoration$sp, _byContributor$get;
-      const key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
-      byContributor.set(key, [...((_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) {
+    const byStopAndContributor = new Map();
+    for (const target of targets.filter(target => !folded.has(target))) {
+      var _target$decoration$sp2, _byStopAndContributor;
+      const stop = owningStop(target, stops);
+      if (stop === undefined) {
+        continue;
+      }
+      const key = `${stop.from}-${stop.to}|${(_target$decoration$sp2 = target.decoration.spec.attributionKey) !== null && _target$decoration$sp2 !== void 0 ? _target$decoration$sp2 : ''}`;
+      byStopAndContributor.set(key, [...((_byStopAndContributor = byStopAndContributor.get(key)) !== null && _byStopAndContributor !== void 0 ? _byStopAndContributor : []), target]);
     }
-    for (const [leader, ...trailing] of byContributor.values()) {
+    for (const members of byStopAndContributor.values()) {
+      const [leader, ...trailing] = [...members].sort(byLeadingPosition);
       trailing.forEach(target => fold(leader, target));
     }
   }

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

@@ -1,3 +1,4 @@
+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';
@@ -96,6 +97,7 @@ export const resolveRevealStyle = ({
     return undefined;
   }
   const colors = getColorScheme(colorScheme);
+  const brand = isInserted && Object.prototype.hasOwnProperty.call(agentBrandColorSchemes, colors.insertColor) ? agentBrandColorSchemes[colors.insertColor] : undefined;
   const {
     background,
     border
@@ -106,7 +108,9 @@ export const resolveRevealStyle = ({
   });
   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,
       border
     })

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

@@ -49,6 +49,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.
  *
@@ -57,32 +68,46 @@ 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;
   }
   const groups = [];
-  let currentGroup = [];
-  let currentGroupFrom = 0;
-  let currentGroupTo = 0;
+  // The groups a following decoration can still join — one per contributor, dropped at every gap.
+  let openGroups = [];
+  let clusterTo = 0;
   const sortedDecorations = [...decorations].sort((a, b) => a.from === b.from ? a.to - b.to : a.from - b.from);
   sortedDecorations.forEach(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;
+    const 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.
+    const openGroup = (_openGroups$find = openGroups.find(group => group.contributor === contributor)) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(group => group.contributor === '');
+    if (openGroup === undefined) {
+      const group = {
+        contributor,
+        decorations: [decoration],
+        from: decoration.from,
+        to: decoration.to
+      };
+      groups.push(group);
+      openGroups = [...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(({
     decorations: group,
@@ -127,8 +152,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/es2019/pm-plugins/utils/baseNodeName.js

@@ -0,0 +1,18 @@
+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 const resolveBaseNodeName = name => fg('confluence_ncs_step_diffing_version_history') ? name.split('_')[0] : name;

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

@@ -0,0 +1,28 @@
+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.
+ */
+const 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 const isTaggableBlockNodeName = name => name !== undefined && TAGGABLE_BLOCK_NODES.has(resolveBaseNodeName(name));
+
+/** As above, from the node type itself. */
+export const isTaggableBlockNode = nodeType => isTaggableBlockNodeName(nodeType.name);

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

@@ -190,8 +190,51 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
     diffType = _ref5.diffType,
     _ref5$coarseTableCell = _ref5.coarseTableCellsOnly,
     coarseTableCellsOnly = _ref5$coarseTableCell === void 0 ? false : _ref5$coarseTableCell,
-    tagMountContext = _ref5.tagMountContext;
+    tagMountContext = _ref5.tagMountContext,
+    nodeRanges = _ref5.nodeRanges;
   var decorations = [];
+
+  // Exact-nodes path: only reached for a split change (EDITOR-8932), which names the nodes it
+  // owns. Deliberately kept separate from the walk below rather than sharing it.
+  if (nodeRanges) {
+    var _iterator = _createForOfIteratorHelper(nodeRanges),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _step.value,
+          pos = _step$value.from,
+          nodeEnd = _step$value.to;
+        var node = doc.nodeAt(pos);
+        if (!(node !== null && node !== void 0 && node.isBlock)) {
+          continue;
+        }
+        var isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+        decorations.push.apply(decorations, _toConsumableArray(createBlockChangedDecoration({
+          attributionKey: attributionKey,
+          change: {
+            from: pos,
+            to: nodeEnd,
+            name: node.type.name
+          },
+          colorScheme: colorScheme,
+          isInserted: isInserted,
+          isActive: isActive,
+          shouldHideDeleted: shouldHideDeleted,
+          showContributorTags: showContributorTags,
+          showIndicators: showIndicators,
+          doc: doc,
+          diffType: diffType,
+          tagMountContext: tagMountContext
+        })));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return decorations;
+  }
+
   // Coarse path: inside the large table, only cell/header overlays are kept — the
   // table/row/paragraph decorations there are redundant and cause expensive per-cell
   // re-render. Blocks outside the table keep their normal decorations.
@@ -205,18 +248,18 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
       }
     }
     if (node.isBlock && (!isExtendedEnabled(diffType) || pos + node.nodeSize <= to)) {
-      var nodeEnd = pos + node.nodeSize;
-      var isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+      var _nodeEnd = pos + node.nodeSize;
+      var _isActive = isRangeActive(activeIndexPos, pos, _nodeEnd);
       decorations.push.apply(decorations, _toConsumableArray(createBlockChangedDecoration({
         attributionKey: attributionKey,
         change: {
           from: pos,
-          to: nodeEnd,
+          to: _nodeEnd,
           name: node.type.name
         },
         colorScheme: colorScheme,
         isInserted: isInserted,
-        isActive: isActive,
+        isActive: _isActive,
         shouldHideDeleted: shouldHideDeleted,
         showContributorTags: showContributorTags,
         showIndicators: showIndicators,
@@ -339,13 +382,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
   }
   var pendingAttrSteps = [];
   var stepMaps = [];
-  var _iterator = _createForOfIteratorHelper(simplifiedSteps.entries()),
-    _step;
+  var _iterator2 = _createForOfIteratorHelper(simplifiedSteps.entries()),
+    _step2;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        stepIndex = _step$value[0],
-        step = _step$value[1];
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _slicedToArray(_step2.value, 2),
+        stepIndex = _step2$value[0],
+        step = _step2$value[1];
       var result = step.apply(steppedDoc);
       if (result.failed === null && result.doc) {
         if (stepIsValidAttrChange(step, steppedDoc, result.doc)) {
@@ -364,9 +407,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     // Gate the complete attribution fix: mapped positions and step-time nodes are used together.
     // The fallback deliberately preserves the legacy raw-position lookups for rollout safety.
   } catch (err) {
-    _iterator.e(err);
+    _iterator2.e(err);
   } finally {
-    _iterator.f();
+    _iterator2.f();
   }
   var attrStepContexts = fg('platform_editor_reduce_diff_attr_sensitivity') ? pendingAttrSteps.flatMap(function (_ref1) {
     var afterNode = _ref1.afterNode,
@@ -454,7 +497,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       tr: tr,
       attributedChanges: attributedChanges
     });
-    changes = collapseOverlappingChanges(uncollapsedChanges);
+    changes = collapseOverlappingChanges(uncollapsedChanges, tr.doc);
 
     // Still colours-only: a tags-only diff keeps the plain colour scheme.
     if (attributionColoringEnabled) {
@@ -551,13 +594,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
         // table (the cell overlays added below provide the highlight without the
         // expensive content re-render); leaf blocks outside the table still get theirs.
         var coarseTables = useCoarseTableDecoration ? tableRanges(tr.doc, change.fromB, change.toB) : [];
-        var _iterator2 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
-          _step2;
+        var _iterator3 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
+          _step3;
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var _step2$value = _slicedToArray(_step2.value, 2),
-              from = _step2$value[0],
-              to = _step2$value[1];
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _step3$value = _slicedToArray(_step3.value, 2),
+              from = _step3$value[0],
+              to = _step3$value[1];
             if (useCoarseTableDecoration && isInsideTable(coarseTables, from)) {
               continue;
             }
@@ -584,9 +627,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
             }))));
           }
         } catch (err) {
-          _iterator2.e(err);
+          _iterator3.e(err);
         } finally {
-          _iterator2.f();
+          _iterator3.f();
         }
       } else {
         decorations.push.apply(decorations, _toConsumableArray(createInlineChangedDecoration(_objectSpread({
@@ -613,6 +656,8 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
         doc: tr.doc,
         from: change.fromB,
         to: change.toB,
+        // A split piece's own range no longer covers the container it opened (EDITOR-8932).
+        nodeRanges: change.blockNodeRangesB,
         colorScheme: changeColorScheme
       }, isExtendedEnabled(diffType) && {
         isInserted: isInserted,