@atlaskit/editor-plugin-show-diff 15.0.0 → 15.1.1

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

@@ -157,6 +157,7 @@ const tableRanges = (doc, from, to) => {
 };
 const isInsideTable = (tables, pos) => tables.some(([tFrom, tTo]) => pos >= tFrom && pos < tTo);
 const calculateNodesForBlockDecoration = ({
+  attributionKey,
   doc,
   from,
   to,
@@ -164,9 +165,11 @@ const calculateNodesForBlockDecoration = ({
   isInserted = true,
   activeIndexPos,
   shouldHideDeleted = false,
+  showContributorTags = false,
   showIndicators = false,
   diffType,
-  coarseTableCellsOnly = false
+  coarseTableCellsOnly = false,
+  tagMountContext
 }) => {
   const decorations = [];
   // Coarse path: inside the large table, only cell/header overlays are kept — the
@@ -185,6 +188,7 @@ const calculateNodesForBlockDecoration = ({
       const nodeEnd = pos + node.nodeSize;
       const isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
       decorations.push(...createBlockChangedDecoration({
+        attributionKey,
         change: {
           from: pos,
           to: nodeEnd,
@@ -194,9 +198,11 @@ const calculateNodesForBlockDecoration = ({
         isInserted,
         isActive,
         shouldHideDeleted,
+        showContributorTags,
         showIndicators,
         doc,
-        diffType
+        diffType,
+        tagMountContext
       }));
     }
   });
@@ -226,6 +232,25 @@ export const isDeletedContentPlacedBelow = ({
   // Inline-level (undefined) and sentence-level changes.
   return inlineDeletedDiffPlacement === 'after';
 };
+
+/**
+ * Single place `platform_editor_diff_hide_pure_deletions` is read, shared by the widget-anchor
+ * calculation and the decoration push below so the two cannot drift.
+ *
+ * The clean view ("new state") historically only suppressed a deleted side when the same change
+ * also carried an insertion. A PURE deletion — text removed with nothing put in its place — fell
+ * through and leaked struck-through text into a view that is supposed to show none. `smart` never
+ * showed this because it pairs a rewrite into a single change that always carries an insertion;
+ * `inline` emits delete-only changes, so it did.
+ *
+ * With the gate off this returns exactly what both callers computed before it existed.
+ */
+const shouldHideDeletedSide = ({
+  change,
+  diffType,
+  hideDeletedDiffs,
+  isInverted
+}) => isExtendedEnabled(diffType) && !isInverted && !!hideDeletedDiffs && (change.inserted.length > 0 || fg('platform_editor_diff_hide_pure_deletions'));
 const calculateDiffDecorationsInner = ({
   state,
   pluginState,
@@ -242,6 +267,7 @@ const calculateDiffDecorationsInner = ({
   smartThresholds,
   deletedDiffPlacement = 'top',
   inlineDeletedDiffPlacement = 'before',
+  reveal,
   tagMountContext
 }) => {
   const {
@@ -457,7 +483,12 @@ const calculateDiffDecorationsInner = ({
       // change. Used to decide if indicator anchor positions should be adjusted
       // inward — when the widget is present the anchor must stay at the block
       // boundary to keep the indicator bar continuous with the deleted content.
-      const willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      const willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !shouldHideDeletedSide({
+        change,
+        diffType,
+        hideDeletedDiffs,
+        isInverted
+      });
       if (isSmartNodeLevel) {
         // For a large inserted table, skip the O(cells) inline decorations inside the
         // table (the cell overlays added below provide the highlight without the
@@ -485,6 +516,7 @@ const calculateDiffDecorationsInner = ({
               hideAddedDiffsUnderline,
               hasDeletedWidget: willRenderDeletedWidget,
               isDeletedWidgetBelow,
+              reveal,
               tagMountContext
             })
           }));
@@ -505,11 +537,13 @@ const calculateDiffDecorationsInner = ({
             hideAddedDiffsUnderline,
             hasDeletedWidget: willRenderDeletedWidget,
             isDeletedWidgetBelow,
+            reveal,
             tagMountContext
           })
         }));
       }
       decorations.push(...calculateNodesForBlockDecoration({
+        attributionKey,
         doc: tr.doc,
         from: change.fromB,
         to: change.toB,
@@ -517,7 +551,9 @@ const calculateDiffDecorationsInner = ({
         ...(isExtendedEnabled(diffType) && {
           isInserted,
           shouldHideDeleted,
-          showIndicators
+          showContributorTags,
+          showIndicators,
+          tagMountContext
         }),
         activeIndexPos,
         intl,
@@ -526,11 +562,19 @@ const calculateDiffDecorationsInner = ({
       }));
     }
     if (change.deleted.length > 0 && !isMarkOnly) {
-      const shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
+      const shouldHideDeleted = shouldHideDeletedSide({
+        change,
+        diffType,
+        hideDeletedDiffs,
+        isInverted
+      });
       if (!shouldHideDeleted) {
         decorations.push(...createNodeChangedDecorationWidget({
           // The deleted side has no inline decoration, so the widget carries the actor.
           attributionKey,
+          // Extended pipeline only, matching the inline path: the non-extended styles have no
+          // background for the wipe to act on.
+          reveal: isExtendedEnabled(diffType) ? reveal : undefined,
           change,
           doc: originalDoc,
           nodeViewSerializer,
@@ -568,7 +612,8 @@ const calculateDiffDecorationsInner = ({
       colorScheme,
       diffType,
       isActive,
-      isInserted: true
+      isInserted: true,
+      reveal
     }));
   });
   getAttrChangeRanges(tr.doc, attrStepContexts, originalDoc).forEach(change => {
@@ -671,7 +716,8 @@ export const calculateDiffDecorations = memoizeOne(calculateDiffDecorationsInner
   showIndicators,
   smartThresholds,
   deletedDiffPlacement,
-  inlineDeletedDiffPlacement
+  inlineDeletedDiffPlacement,
+  reveal
 }], [{
   pluginState: lastPluginState,
   state: lastState,
@@ -685,7 +731,8 @@ export const calculateDiffDecorations = memoizeOne(calculateDiffDecorationsInner
   showIndicators: lastShowIndicators,
   smartThresholds: lastSmartThresholds,
   deletedDiffPlacement: lastDeletedDiffPlacement,
-  inlineDeletedDiffPlacement: lastInlineDeletedDiffPlacement
+  inlineDeletedDiffPlacement: lastInlineDeletedDiffPlacement,
+  reveal: lastReveal
 }]) => {
   var _ref2;
   const originalDocIsSame = lastPluginState.originalDoc && pluginState.originalDoc && pluginState.originalDoc.eq(lastPluginState.originalDoc);
@@ -693,7 +740,10 @@ export const calculateDiffDecorations = memoizeOne(calculateDiffDecorationsInner
     var _ref;
     return (_ref = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) &&
     // Contributors can arrive after the first calculation; without this, tags never appear.
-    isEqual(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement) !== null && _ref !== void 0 ? _ref : false;
+    isEqual(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement &&
+    // Turning the reveal on or off changes the emitted styles, so a cached result from the
+    // other setting would leave the diff painted in the wrong resting state.
+    isEqual(reveal, lastReveal)) !== null && _ref !== void 0 ? _ref : false;
   }
   return (_ref2 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) && isEqual(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref2 !== void 0 ? _ref2 : false;
 });

package/dist/es2019/pm-plugins/decorations/colorSchemes/factory.js

@@ -683,6 +683,36 @@ export function buildInsertedInlineStyle(colors, isActive, hideAddedDiffsUnderli
   return hideAddedDiffsUnderline ? buildInsertStyleExtendedNoUnderline(colors) : buildInsertStyleExtended(colors);
 }
 
+/**
+ * The colours `buildInsertedInlineStyle()` above would paint, for the reveal to animate towards.
+ *
+ * MUST mirror that function: the reveal replaces the flat highlight with a sized gradient, so a
+ * divergence here means the animation settles on a different colour than a static render produces.
+ * `revealStyles.ts` in the test package asserts the two agree across the isActive /
+ * hideAddedDiffsUnderline matrix.
+ *
+ * A transparent border is how "no underline" is expressed: the box still reserves the 2px so the
+ * text does not shift when the underline arrives.
+ */
+export function getInsertedInlineRevealColors(colors, isActive, hideAddedDiffsUnderline) {
+  return {
+    background: isActive ? bgSubtlerPressed(colors.insertActiveColor) : bgSubtlest(colors.insertColor),
+    border: hideAddedDiffsUnderline ? 'transparent' : borderAccent(colors.insertColor)
+  };
+}
+
+/**
+ * The colours `buildDeletedInlineContentStyleExtended()` paints, for the reveal to animate towards.
+ * Deleted content's highlight does not vary with the active state — only its text does, which the
+ * reveal keeps as-is.
+ */
+export function getDeletedInlineRevealColors(colors) {
+  return {
+    background: bgSubtlest(colors.deleteColor),
+    border: borderAccent(colors.deleteColor)
+  };
+}
+
 /** The three visual states deleted inline content can be in. */
 
 /**

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

@@ -1,10 +1,12 @@
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { isExtendedEnabled } from '../isExtendedEnabled';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedBlockNodeStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildInsertedBlockNodeStyle } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
+import { createContributorTagWidget } from './createContributorTagWidget';
 import { buildDiffDecorationSpec } from './decorationKeys';
 import { getBlockNodeStyleLegacy, resolveCellOverlayStyleLegacy } from './createBlockChangedDecoration.styles.legacy';
 const displayNoneStyle = convertToInlineCss({
@@ -20,6 +22,24 @@ 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. */
+const canTagBlock = ({
+  diffType,
+  doc,
+  from,
+  name
+}) => doc !== undefined && isExtendedEnabled(diffType) && TAGGABLE_BLOCK_NODES.has(name) && !isInsideTable(doc, from);
+
 /** Positioning context for the cell overlay widget decorations. */
 const cellPositionStyle = convertToInlineCss({
   position: 'relative'
@@ -134,17 +154,28 @@ const isCellEmpty = cellNode => {
  * @returns Prosemirror node decoration or undefined
  */
 export const createBlockChangedDecoration = ({
+  attributionKey,
   change,
   colorScheme,
   isInserted = true,
   isActive = false,
   shouldHideDeleted = false,
+  showContributorTags = false,
   showIndicators = false,
   doc,
-  diffType
+  diffType,
+  tagMountContext
 }) => {
   const decorations = [];
-  const diffId = crypto.randomUUID();
+  // Derived from the node range so it survives a recalculation, as in
+  // `createInlineChangedDecoration`. Changes are disjoint, so no two of them decorate one node.
+  const diffId = showContributorTags ? `block-${change.from}-${change.to}` : crypto.randomUUID();
+  const shouldTagBlock = showContributorTags && canTagBlock({
+    diffType,
+    doc,
+    from: change.from,
+    name: change.name
+  });
   if (shouldHideDeleted) {
     return [Decoration.node(change.from, change.to, {
       style: displayNoneStyle
@@ -193,16 +224,26 @@ export const createBlockChangedDecoration = ({
     decorations.push(Decoration.node(change.from, change.to, {
       style: style,
       'data-testid': 'show-diff-changed-decoration-node',
-      class: className
+      class: className,
+      // Lets the contributor tag find the block it captions on hover.
+      ...(shouldTagBlock && {
+        'data-diff-id': diffId
+      })
     }, buildDiffDecorationSpec({
+      attributionKey: shouldTagBlock ? attributionKey : undefined,
+      colorScheme,
       decorationType: 'block',
       diffId,
       isActive,
+      isInserted,
       nodeName: change.name,
       diffType
     })));
   }
-  if (decorations.length > 0 && showIndicators && doc && isExtendedEnabled(diffType)) {
+  if (decorations.length === 0) {
+    return decorations;
+  }
+  if (showIndicators && doc && isExtendedEnabled(diffType)) {
     decorations.push(...createBlockIndicatorAnchorWidgets({
       doc,
       from: change.from,
@@ -210,5 +251,22 @@ export const createBlockChangedDecoration = ({
       diffId
     }));
   }
+
+  // `change.from` is just before the node, so the host sits outside it and the tag renders on the
+  // block's own top-left corner. Resolving inline content instead would put the host inside a
+  // container block's content DOM (panel, expand, blockquote).
+  if (shouldTagBlock && doc) {
+    const tagWidget = createContributorTagWidget({
+      anchorAtRangeStart: true,
+      doc,
+      from: change.from,
+      to: change.to,
+      diffId,
+      mountContext: tagMountContext
+    });
+    if (tagWidget) {
+      decorations.push(tagWidget);
+    }
+  }
   return decorations;
 };

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

@@ -103,13 +103,32 @@ const resolveInlineContentStart = (doc, from, to) => {
 };
 
 /**
- * A widget hosting the contributor tag of one inline diff range, placed on the first character the
- * range highlights.
+ * The position just before the code block enclosing `pos`, or `undefined` when nothing does.
+ *
+ * `.code-block-content-wrapper` hides its block-axis overflow, so a host left inside the code has
+ * its tag clipped away. Hosting it before the block puts the tag on the block's top-left corner,
+ * where a whole-code-block change is tagged too (EDITOR-8766).
+ */
+const resolveCodeBlockStart = (doc, pos) => {
+  const $pos = doc.resolve(pos);
+  for (let depth = $pos.depth; depth > 0; depth--) {
+    if ($pos.node(depth).type.name === 'codeBlock') {
+      return $pos.before(depth);
+    }
+  }
+  return undefined;
+};
+
+/**
+ * A widget hosting the contributor tag of one diff range, placed on the first character the range
+ * highlights — or, with `anchorAtRangeStart`, at `from` itself. Either way a host that would land
+ * inside a code block is hoisted out in front of it; see `resolveCodeBlockStart`.
  *
  * The tag is mounted in `toDOM` and taken down in `destroy`, so it lives exactly as long as the host
  * element ProseMirror drew it into — see `mountContributorTag`.
  */
 export const createContributorTagWidget = ({
+  anchorAtRangeStart = false,
   doc,
   from,
   to,
@@ -123,9 +142,12 @@ export const createContributorTagWidget = ({
   // Reassigned when ProseMirror redraws this decoration, which it may do more than once for the
   // same `Decoration` instance.
   let mount;
+  const anchorPos = anchorAtRangeStart ? from : resolveInlineContentStart(doc, from, to);
+  // A change inside a code block is hoisted out of it; anything else keeps its own anchor.
+  const codeBlockPos = resolveCodeBlockStart(doc, anchorPos);
   return Decoration.widget(
   // Keep the host out of the table row's grid (EDITOR-8442).
-  clampAnchorPosIntoCell(doc, resolveInlineContentStart(doc, from, to), 1), () => {
+  clampAnchorPosIntoCell(doc, codeBlockPos !== null && codeBlockPos !== void 0 ? codeBlockPos : anchorPos, 1), () => {
     const host = buildContributorTagHost(diffId);
     mount = mountContributorTag({
       diffId,

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

@@ -8,6 +8,7 @@ import { createInlineIndicatorAnchorWidgets } from './createAnchorDecorationWidg
 import { createContributorTagWidget } from './createContributorTagWidget';
 import { getAtomicInlineNodeClassNameLegacy, resolveInlineChangedStyleLegacy } from './createInlineChangedDecoration.styles.legacy';
 import { buildDiffDecorationSpec } from './decorationKeys';
+import { REVEAL_ATTR, resolveRevealStyle } from './revealStyles';
 const displayNoneStyle = convertToInlineCss({
   display: 'none'
 });
@@ -107,8 +108,10 @@ export const createInlineChangedDecoration = ({
   inlineNodeName,
   hasDeletedWidget = false,
   isDeletedWidgetBelow = false,
+  reveal,
   tagMountContext
 }) => {
+  var _revealed$style;
   // Derived from the range so it survives a recalculation: stepping to the next/previous change
   // rebuilds decorations without touching the doc, and a fresh id would change the React key and the
   // tag host's key, remounting every tag mid-step. Random ids are kept when tags are off.
@@ -127,7 +130,18 @@ export const createInlineChangedDecoration = ({
     }))];
   }
   const colors = getColorScheme(colorScheme);
-  const style = resolveInlineChangedStyle({
+
+  // The reveal withholds the static highlight so the wipe has something to reveal, so it supplies
+  // the whole style rather than adding to the usual one. Extended pipeline only — the AI review
+  // surface is the only consumer, and the non-extended styles have no background to wipe.
+  const revealed = isExtendedEnabled(diffType) ? resolveRevealStyle({
+    colorScheme,
+    hideAddedDiffsUnderline,
+    isActive,
+    isInserted,
+    reveal
+  }) : undefined;
+  const style = (_revealed$style = revealed === null || revealed === void 0 ? void 0 : revealed.style) !== null && _revealed$style !== void 0 ? _revealed$style : resolveInlineChangedStyle({
     colors,
     colorScheme,
     diffType,
@@ -142,6 +156,9 @@ export const createInlineChangedDecoration = ({
     ...(atomicInlineAttrs && {
       class: atomicInlineAttrs.className
     }),
+    ...(revealed && {
+      [REVEAL_ATTR]: revealed.role
+    }),
     'data-testid': 'show-diff-changed-decoration',
     // Lets the contributor tag find its highlight on hover.
     ...(showContributorTags && {

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

@@ -108,6 +108,7 @@ export const createNodeChangedDecorationWidget = ({
   placeBelow = false,
   diffType,
   hideAddedDiffsUnderline = false,
+  reveal,
   tagMountContext
 }) => {
   var _slice$content, _slice$content2, _slice$content2$first, _slice$content3, _slice$content3$first, _$safeInsertPos$nodeB, _slice$content$firstC, _newDoc$firstChild, _slice$content$firstC2;
@@ -277,7 +278,7 @@ export const createNodeChangedDecorationWidget = ({
     const nodeView = serializer.tryCreateNodeView(node);
     if (nodeView) {
       if (node.isInline) {
-        const wrapper = createContentWrapper(colorScheme, isActive, isInserted, diffType);
+        const wrapper = createContentWrapper(colorScheme, isActive, isInserted, diffType, reveal);
         wrapper.append(nodeView);
         dom.append(wrapper);
       } else {
@@ -307,11 +308,12 @@ export const createNodeChangedDecorationWidget = ({
             colorScheme,
             isActive,
             isInserted,
-            diffType
+            diffType,
+            reveal
           });
           dom.append(injectedNode);
         } else {
-          const wrapper = createContentWrapper(colorScheme, isActive, isInserted, diffType);
+          const wrapper = createContentWrapper(colorScheme, isActive, isInserted, diffType, reveal);
           wrapper.append(fallbackNode);
           dom.append(wrapper);
         }

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

@@ -2,9 +2,9 @@ import { isDiffDecoration, isDiffDecorationSpec } from './decorationKeys';
 
 /**
  * Diff kinds that expose an anchor a tag can be pinned to: `inline` is added/changed content,
- * `widget` is deleted content. Block diffs carry no attribution.
+ * `widget` is deleted content, `block` a whole changed block node.
  */
-const TAGGABLE_DECORATION_TYPES = new Set(['inline', 'widget']);
+const TAGGABLE_DECORATION_TYPES = new Set(['block', 'inline', 'widget']);
 
 /** The connection is an internal key, so it is dropped on the way to the tag. */
 const toTagContributor = ({
@@ -18,6 +18,13 @@ const toTagContributor = ({
  */
 const isSameChange = (widget, inline) => widget.spec.attributionKey === inline.spec.attributionKey && widget.from >= inline.from && widget.from <= inline.to;
 
+/**
+ * Whether `inner` captions the same change as the block decoration `block`, in which case only the
+ * block keeps the tag — one tag per block. Containment counts in either direction: a leaf block's
+ * highlight spans the wrapper the block sits in. Merely adjacent ranges keep a tag each.
+ */
+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);
+
 /**
  * One model per diff decoration whose attribution resolves to a supplied contributor; anything
  * unattributed, untaggable or unresolved is skipped. A replacement's two decorations are collapsed
@@ -52,22 +59,42 @@ export const extractContributorTags = (decorations, contributors) => {
   const inlineTargets = targets.filter(({
     decoration
   }) => decoration.spec.decorationType === 'inline');
+  const blockTargets = targets.filter(({
+    decoration
+  }) => decoration.spec.decorationType === 'block');
   const linkedDiffIds = new Map();
   const folded = new Set();
-  for (const target of targets) {
+  const fold = (host, target) => {
     var _linkedDiffIds$get;
-    if (target.decoration.spec.decorationType !== 'widget') {
+    folded.add(target);
+    const hostDiffId = host.decoration.spec.diffId;
+    linkedDiffIds.set(hostDiffId, [...((_linkedDiffIds$get = linkedDiffIds.get(hostDiffId)) !== null && _linkedDiffIds$get !== void 0 ? _linkedDiffIds$get : []), target.decoration.spec.diffId]);
+  };
+  for (const target of targets) {
+    const {
+      decorationType
+    } = target.decoration.spec;
+    if (decorationType === 'block') {
+      continue;
+    }
+
+    // A block outranks both other kinds, so it is tried first.
+    const block = blockTargets.find(({
+      decoration
+    }) => isSameBlockChange(target.decoration, decoration));
+    if (block) {
+      fold(block, target);
+      continue;
+    }
+    if (decorationType !== 'widget') {
       continue;
     }
     const host = inlineTargets.find(({
       decoration
     }) => isSameChange(target.decoration, decoration));
-    if (!host) {
-      continue;
+    if (host) {
+      fold(host, target);
     }
-    folded.add(target);
-    const hostDiffId = host.decoration.spec.diffId;
-    linkedDiffIds.set(hostDiffId, [...((_linkedDiffIds$get = linkedDiffIds.get(hostDiffId)) !== null && _linkedDiffIds$get !== void 0 ? _linkedDiffIds$get : []), target.decoration.spec.diffId]);
   }
   return targets.filter(target => !folded.has(target)).map(({
     contributor,