@atlaskit/editor-plugin-show-diff 17.0.1 → 17.0.2

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

@@ -20,6 +20,7 @@ import { resolveCellOverlayStyleLegacy, resolveDeletedRowStyleLegacy } from './c
 import { createContributorTagWidget, isContributorTagWidgetEnabled } from './createContributorTagWidget';
 import { AnchorTypeKey, buildAnchorDecorationKey, buildDiffDecorationSpec, scrollMarginTopValue } from './decorationKeys';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
+import { createRemovedLozenge } from './utils/wrapBlockNodeView';
 import { applyCellEdgeAttrs, getRowCellEdgeAttrs, getTableTopAndBottomCellEdgeAttrs } from './utils/tableCellEdgeAttrs';
 /**
  * Extracts information about deleted table rows from a change
@@ -161,17 +162,27 @@ var isEmptyRow = function isEmptyRow(rowNode) {
   });
   return isEmpty;
 };
-
 /**
  * Creates a DOM representation of a deleted table row
  */
-var createChangedRowDOM = function createChangedRowDOM(rowNode, cellEdgeAttrs, nodeViewSerializer, colorScheme, isInserted, diffType) {
+var createChangedRowDOM = function createChangedRowDOM(_ref3) {
+  var rowNode = _ref3.rowNode,
+    cellEdgeAttrs = _ref3.cellEdgeAttrs,
+    nodeViewSerializer = _ref3.nodeViewSerializer,
+    colorScheme = _ref3.colorScheme,
+    isInserted = _ref3.isInserted,
+    diffType = _ref3.diffType,
+    hasAnchoredRemovedLozenge = _ref3.hasAnchoredRemovedLozenge,
+    intl = _ref3.intl,
+    isActive = _ref3.isActive;
   var tr = document.createElement('tr');
   var colors = colorSchemeRegistry[colorScheme !== null && colorScheme !== void 0 ? colorScheme : 'standard'];
+  var deletedTreatment = isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? buildDeletedRowStyle(colors) : resolveDeletedRowStyleLegacy(getLegacyColorScheme(colorScheme));
+  var hostsRemovedLozenge = Boolean(intl) && isExtendedEnabled(diffType) && !isInserted && !hasAnchoredRemovedLozenge;
 
   // Inserted rows keep their natural styling; the row strikethrough is deletions only.
   if (!isExtendedEnabled(diffType) || !isInserted) {
-    tr.setAttribute('style', isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? buildDeletedRowStyle(colors) : resolveDeletedRowStyleLegacy(getLegacyColorScheme(colorScheme)));
+    tr.setAttribute('style', deletedTreatment);
   }
   // Mirrors the strikethrough condition above: under the extended experience an `isInserted` row
   // is ADDED content, so it must not claim the "deleted" testid — page models match that as
@@ -212,17 +223,50 @@ var createChangedRowDOM = function createChangedRowDOM(rowNode, cellEdgeAttrs, n
       cellIndex++;
     }
   });
+
+  // A "Removed" label on the row's last cell, so it reads at the row's top right corner. Deletions
+  // only: an inserted row is added content and carries no removal label.
+  if (intl && hostsRemovedLozenge) {
+    var lastCell = tr.lastElementChild;
+    if (lastCell instanceof HTMLElement) {
+      lastCell.style.position = 'relative';
+      // Append, never prepend. Editor CSS resets the top margin of a cell's first child, so a
+      // prepended label pushes the paragraph out of that reset and the row grows taller.
+      lastCell.append(createRemovedLozenge(intl, isActive, colorScheme, true));
+    }
+  }
   return tr;
 };
+var supportsAnchorPositioning = function supportsAnchorPositioning() {
+  return typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)');
+};
+var createAnchoredRemovedLozengeWidget = function createAnchoredRemovedLozengeWidget(_ref4) {
+  var anchorName = _ref4.anchorName,
+    colorScheme = _ref4.colorScheme,
+    from = _ref4.from,
+    intl = _ref4.intl,
+    isActive = _ref4.isActive;
+  var lozenge = createRemovedLozenge(intl, isActive, colorScheme, true);
+  var inset = lozenge.style.top;
+  lozenge.style.setProperty('position', 'fixed');
+  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');
+  lozenge.style.setProperty('transform', 'translateX(-100%)');
+  return Decoration.widget(from, lozenge, {
+    key: "removed-lozenge-".concat(anchorName),
+    side: -1
+  });
+};
 
 /**
  * Expands a diff to include whole changed rows when table rows are affected
  */
-var expandDiffForChangedRows = function expandDiffForChangedRows(_ref3) {
-  var changes = _ref3.changes,
-    originalDoc = _ref3.originalDoc,
-    newDoc = _ref3.newDoc,
-    diffType = _ref3.diffType;
+var expandDiffForChangedRows = function expandDiffForChangedRows(_ref5) {
+  var changes = _ref5.changes,
+    originalDoc = _ref5.originalDoc,
+    newDoc = _ref5.newDoc,
+    diffType = _ref5.diffType;
   var rowInfo = [];
   var _iterator = _createForOfIteratorHelper(changes),
     _step;
@@ -251,22 +295,23 @@ var expandDiffForChangedRows = function expandDiffForChangedRows(_ref3) {
 /**
  * Main function to handle deleted rows - computes diff and creates decorations
  */
-export var createChangedRowDecorationWidgets = function createChangedRowDecorationWidgets(_ref4) {
-  var attributionKey = _ref4.attributionKey,
-    changes = _ref4.changes,
-    originalDoc = _ref4.originalDoc,
-    newDoc = _ref4.newDoc,
-    nodeViewSerializer = _ref4.nodeViewSerializer,
-    colorScheme = _ref4.colorScheme,
-    isActive = _ref4.isActive,
-    _ref4$isInserted = _ref4.isInserted,
-    isInserted = _ref4$isInserted === void 0 ? false : _ref4$isInserted,
-    diffType = _ref4.diffType,
-    _ref4$showIndicators = _ref4.showIndicators,
-    showIndicators = _ref4$showIndicators === void 0 ? false : _ref4$showIndicators,
-    _ref4$showContributor = _ref4.showContributorTags,
-    showContributorTags = _ref4$showContributor === void 0 ? false : _ref4$showContributor,
-    tagMountContext = _ref4.tagMountContext;
+export var createChangedRowDecorationWidgets = function createChangedRowDecorationWidgets(_ref6) {
+  var attributionKey = _ref6.attributionKey,
+    changes = _ref6.changes,
+    originalDoc = _ref6.originalDoc,
+    newDoc = _ref6.newDoc,
+    nodeViewSerializer = _ref6.nodeViewSerializer,
+    colorScheme = _ref6.colorScheme,
+    isActive = _ref6.isActive,
+    _ref6$isInserted = _ref6.isInserted,
+    isInserted = _ref6$isInserted === void 0 ? false : _ref6$isInserted,
+    diffType = _ref6.diffType,
+    intl = _ref6.intl,
+    _ref6$showIndicators = _ref6.showIndicators,
+    showIndicators = _ref6$showIndicators === void 0 ? false : _ref6$showIndicators,
+    _ref6$showContributor = _ref6.showContributorTags,
+    showContributorTags = _ref6$showContributor === void 0 ? false : _ref6$showContributor,
+    tagMountContext = _ref6.tagMountContext;
   // First, expand the changes to include complete deleted rows
   var changedRows = expandDiffForChangedRows({
     changes: changes.filter(function (change) {
@@ -277,16 +322,25 @@ export var createChangedRowDecorationWidgets = function createChangedRowDecorati
     diffType: diffType
   });
   return changedRows.flatMap(function (changedRow) {
-    var rowDOM = createChangedRowDOM(changedRow.rowNode, changedRow.cellEdgeAttrs, nodeViewSerializer, colorScheme, isInserted, diffType);
+    // Keep the ID stable while contributor tags are enabled so recalculation preserves their state.
+    var diffId = showContributorTags ? "widget-row-".concat(changedRow.fromA, "-").concat(changedRow.toA) : crypto.randomUUID();
+    var hasAnchoredRemovedLozenge = Boolean(intl) && isExtendedEnabled(diffType) && !isInserted && supportsAnchorPositioning();
+    var rowDOM = createChangedRowDOM({
+      rowNode: changedRow.rowNode,
+      cellEdgeAttrs: changedRow.cellEdgeAttrs,
+      nodeViewSerializer: nodeViewSerializer,
+      colorScheme: colorScheme,
+      isInserted: isInserted,
+      diffType: diffType,
+      hasAnchoredRemovedLozenge: hasAnchoredRemovedLozenge,
+      intl: intl,
+      isActive: isActive
+    });
 
     // Find safe insertion position for the deleted row
     var safeInsertPos = findSafeInsertPos(newDoc, changedRow.fromB - 1,
     // -1 to find the first safe position from the table
     originalDoc.slice(changedRow.fromA, changedRow.toA));
-
-    // Stable while contributor tags are enabled so a decoration recalculation preserves the tag's
-    // identity and controller state.
-    var diffId = showContributorTags ? "widget-row-".concat(changedRow.fromA, "-").concat(changedRow.toA) : crypto.randomUUID();
     var decorations = [];
     var rowAnchorNames = [];
 
@@ -315,6 +369,11 @@ export var createChangedRowDecorationWidgets = function createChangedRowDecorati
       diffId: diffId,
       anchorType: AnchorTypeKey.tag
     }) : undefined;
+    var removedLozengeAnchorName = hasAnchoredRemovedLozenge ? tagAnchorName !== null && tagAnchorName !== void 0 ? tagAnchorName : buildAnchorDecorationKey({
+      diffId: diffId,
+      anchorType: AnchorTypeKey.tag
+    }) : undefined;
+    var rowLabelAnchorName = tagAnchorName !== null && tagAnchorName !== void 0 ? tagAnchorName : removedLozengeAnchorName;
     var tagWidget = tagAnchorName ? createContributorTagWidget({
       anchorAtRangeStart: true,
       anchorName: tagAnchorName,
@@ -324,11 +383,9 @@ export var createChangedRowDecorationWidgets = function createChangedRowDecorati
       mountContext: tagMountContext,
       to: safeInsertPos
     }) : undefined;
-    if (tagAnchorName) {
-      // The tag host is a separate, table-safe widget. CSS anchor positioning aligns it to this
-      // synthetic row without placing non-cell DOM inside the `<tr>` or inheriting its deletion
-      // opacity and strikethrough.
-      rowAnchorNames.push(tagAnchorName);
+    if (rowLabelAnchorName) {
+      // Labels stay outside the table row so they do not inherit its deletion treatment.
+      rowAnchorNames.push(rowLabelAnchorName);
     }
     if (rowAnchorNames.length > 0) {
       rowDOM.style.setProperty('anchor-name', rowAnchorNames.map(function (anchorName) {
@@ -349,6 +406,15 @@ export var createChangedRowDecorationWidgets = function createChangedRowDecorati
       diffType: diffType
     })));
     decorations.push(rowWidget);
+    if (intl && removedLozengeAnchorName) {
+      decorations.push(createAnchoredRemovedLozengeWidget({
+        anchorName: removedLozengeAnchorName,
+        colorScheme: colorScheme,
+        from: safeInsertPos,
+        intl: intl,
+        isActive: isActive
+      }));
+    }
     if (tagWidget) {
       decorations.push(tagWidget);
     }

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

@@ -95,14 +95,19 @@ var supportsAnchorPositioning = function supportsAnchorPositioning() {
  * The host for a tag on deleted content, which renders inside its own widget decoration rather than
  * needing one of its own. Unmount with `unmountContributorTag` from that widget's `destroy`.
  */
-export var createContributorTagHost = function createContributorTagHost(diffId, mountContext) {
+export var createContributorTagHost = function createContributorTagHost(_ref2) {
+  var anchorName = _ref2.anchorName,
+    diffId = _ref2.diffId,
+    mountContext = _ref2.mountContext;
   if (!isContributorTagWidgetEnabled()) {
     return undefined;
   }
-  var host = buildContributorTagHost(diffId);
+  var tagAnchorName = anchorName && supportsAnchorPositioning() ? anchorName : undefined;
+  var host = buildContributorTagHost(diffId, tagAnchorName);
   return {
     host: host,
     mount: mountContributorTag({
+      anchorName: tagAnchorName,
       diffId: diffId,
       host: host,
       mountContext: mountContext
@@ -126,7 +131,7 @@ export var createContributorTagHost = function createContributorTagHost(diffId,
  * (see `hasVisibleContent`).
  */
 var resolveTagAnchorPos = function resolveTagAnchorPos(doc, from, to) {
-  var _ref2;
+  var _ref3;
   var edge;
   var visibleEdge;
   doc.nodesBetween(from, to, function (node, nodePos) {
@@ -159,7 +164,7 @@ var resolveTagAnchorPos = function resolveTagAnchorPos(doc, from, to) {
     // Textblocks have no block children to descend into.
     return false;
   });
-  return (_ref2 = visibleEdge !== null && visibleEdge !== void 0 ? visibleEdge : edge) !== null && _ref2 !== void 0 ? _ref2 : from;
+  return (_ref3 = visibleEdge !== null && visibleEdge !== void 0 ? visibleEdge : edge) !== null && _ref3 !== void 0 ? _ref3 : from;
 };
 
 /**
@@ -187,15 +192,15 @@ var resolveCodeBlockStart = function resolveCodeBlockStart(doc, pos) {
  * 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 var createContributorTagWidget = function createContributorTagWidget(_ref3) {
-  var _ref3$anchorAtRangeSt = _ref3.anchorAtRangeStart,
-    anchorAtRangeStart = _ref3$anchorAtRangeSt === void 0 ? false : _ref3$anchorAtRangeSt,
-    anchorName = _ref3.anchorName,
-    doc = _ref3.doc,
-    from = _ref3.from,
-    to = _ref3.to,
-    diffId = _ref3.diffId,
-    mountContext = _ref3.mountContext;
+export var createContributorTagWidget = function createContributorTagWidget(_ref4) {
+  var _ref4$anchorAtRangeSt = _ref4.anchorAtRangeStart,
+    anchorAtRangeStart = _ref4$anchorAtRangeSt === void 0 ? false : _ref4$anchorAtRangeSt,
+    anchorName = _ref4.anchorName,
+    doc = _ref4.doc,
+    from = _ref4.from,
+    to = _ref4.to,
+    diffId = _ref4.diffId,
+    mountContext = _ref4.mountContext;
   if (!isContributorTagWidgetEnabled()) {
     return undefined;
   }

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

@@ -4,17 +4,20 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { isExtendedEnabled } from '../isExtendedEnabled';
+import { countEmptyTextBlockOnlySlice } from '../utils/emptyTextBlocks';
 import { isEmptyParagraphSlice } from '../utils/isEmptyParagraphSlice';
 import { createLeftAnchorWidget } from './createAnchorDecorationWidgets';
 import { createChangedRowDecorationWidgets } from './createChangedRowDecorationWidgets';
 import { createContributorTagHost, unmountContributorTag } from './createContributorTagWidget';
-import { buildDiffDecorationSpec, buildAnchorDecorationKey, scrollMarginTopValue } from './decorationKeys';
+import { AnchorTypeKey, buildDiffDecorationSpec, buildAnchorDecorationKey, scrollMarginTopValue } from './decorationKeys';
 import { absorbFirstChildMarginReset } from './utils/absorbFirstChildMarginReset';
+import { createDeletedLineBreakDecoration } from './utils/createDeletedLineBreakWidget';
 import { createMarginAbsorber } from './utils/createMarginAbsorber';
 import { createNodeShapedMarginSpacer } from './utils/createNodeShapedMarginSpacer';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
 import { safeResolve } from './utils/safeResolve';
-import { wrapBlockNodeView, injectInnerWrapper, createContentWrapper } from './utils/wrapBlockNodeView';
+import { getTableDiffMode } from './utils/tableDiffMode';
+import { wrapBlockNodeView, createRemovedLozenge, injectInnerWrapper, createContentWrapper } from './utils/wrapBlockNodeView';
 var isHeadingLevel = function isHeadingLevel(level) {
   return typeof level === 'number' && level >= 1 && level <= 6;
 };
@@ -122,9 +125,18 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
     _ref2$hideAddedDiffsU = _ref2.hideAddedDiffsUnderline,
     hideAddedDiffsUnderline = _ref2$hideAddedDiffsU === void 0 ? false : _ref2$hideAddedDiffsU,
     reveal = _ref2.reveal,
-    tagMountContext = _ref2.tagMountContext;
+    tagMountContext = _ref2.tagMountContext,
+    deletedColumns = _ref2.deletedColumns;
   var slice = doc.slice(change.fromA, change.toA);
   var shouldSkipDeletedEmptyParagraphDecoration = !isInserted && isEmptyParagraphSlice(slice);
+  // How many blank lines the deletion took, when it took nothing else. Blank means an empty
+  // paragraph or heading — both are a line the author put there deliberately, and neither leaves
+  // the widget any content to serialize.
+  //
+  // Kept separate from `shouldSkipDeletedEmptyParagraphDecoration` and gated, so the ungated early
+  // return below still covers only the single-empty-paragraph case it always did. Everything else
+  // degrades to what it rendered before the gate: an empty block, serialized invisibly.
+  var deletedBlankLineCount = !isInserted && fg('platform_editor_ai_show_diff_patch_2') ? countEmptyTextBlockOnlySlice(slice) : 0;
   // Widget decoration used for deletions as the content is not in the document
   // and we want to display the deleted content with a style.
   // For `placeBelow`, anchor at the END of the new content (change.toB) so the deleted
@@ -132,24 +144,33 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
   var anchorPos = placeBelow ? change.toB : change.fromB;
   var safeInsertPos = findSafeInsertPos(newDoc, anchorPos, slice);
   var isActive = activeIndexPos && (fg('confluence_ncs_step_diffing_version_history') ? safeInsertPos >= activeIndexPos.from && safeInsertPos <= activeIndexPos.to : safeInsertPos === activeIndexPos.from && safeInsertPos === activeIndexPos.to);
-  if (slice.content.content.length === 0 || shouldSkipDeletedEmptyParagraphDecoration) {
+  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
+    // gone from `newDoc`, so they all resolve to the same anchor and separate widgets would stack.
+    //
+    // No attribution: the glyph is not a tag host, matching `canTagWidget` below.
+    return [createDeletedLineBreakDecoration({
+      colorScheme: colorScheme,
+      count: deletedBlankLineCount,
+      diffType: diffType,
+      isActive: isActive,
+      pos: safeInsertPos,
+      reveal: reveal,
+      side: placeBelow ? 1 : -1
+    })];
+  }
+  if (shouldSkipDeletedEmptyParagraphDecoration) {
     return [];
   }
-  var isTableCellContent = slice.content.content.some(function () {
-    return slice.content.content.some(function (siblingNode) {
-      return ['tableHeader', 'tableCell'].includes(siblingNode.type.name);
-    });
-  });
-  var isTableRowContent = slice.content.content.some(function () {
-    return slice.content.content.some(function (siblingNode) {
-      return ['tableRow'].includes(siblingNode.type.name);
-    });
+  if (slice.content.content.length === 0) {
+    return [];
+  }
+  var tableDiffMode = getTableDiffMode({
+    slice: slice,
+    isInserted: isInserted
   });
-
-  // Added whole cells (e.g. "Add table headers"): render per-cell content widgets.
-  // Deleted whole cells (delete row/col) fall through — they don't exist in `newDoc`,
-  // so there's nowhere to anchor content and we keep the original "render nothing".
-  if (isTableCellContent && isInserted) {
+  if (tableDiffMode.kind === 'cells') {
     return createTableCellContentWidgets({
       slice: slice,
       newDoc: newDoc,
@@ -160,11 +181,10 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
       diffType: diffType
     });
   }
-  if (isTableCellContent) {
-    // Deleted whole cells: nothing to render (see note above).
+  if (tableDiffMode.kind === 'none') {
     return [];
   }
-  if (isTableRowContent) {
+  if (tableDiffMode.kind === 'rows') {
     return createChangedRowDecorationWidgets({
       attributionKey: attributionKey,
       changes: [change],
@@ -175,6 +195,7 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
       isActive: isActive,
       isInserted: isInserted,
       diffType: diffType,
+      intl: intl,
       // Needed for the row's own indicator anchor; this path returns before the
       // `anchor-name` assignment further down.
       showIndicators: showIndicators,
@@ -182,6 +203,9 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
       tagMountContext: tagMountContext
     });
   }
+  // `wholeTable` and `generic` both continue into the generic block widget below. Splitting the
+  // whole-table case into its own renderer is the next step of this refactor.
+
   var serializer = nodeViewSerializer;
 
   // For non-table content, use the existing span wrapper approach
@@ -383,6 +407,40 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
       }
     }
   });
+  var contributorTagAnchorName;
+  if (!isInserted && deletedColumns !== null && deletedColumns !== void 0 && deletedColumns.length) {
+    var table = dom.querySelector('table');
+    var firstRow = table === null || table === void 0 ? void 0 : table.rows[0];
+    if (table && canTagWidget) {
+      contributorTagAnchorName = buildAnchorDecorationKey({
+        diffId: diffId,
+        anchorType: AnchorTypeKey.tag
+      });
+      // The widget host sits before the table's preserved block margin. Anchor the tag to the
+      // table itself so its bottom edge meets the table's top edge with no visual gap.
+      table.style.setProperty('anchor-name', "--".concat(contributorTagAnchorName));
+    }
+    deletedColumns.forEach(function (column) {
+      var _table$rows;
+      Array.from((_table$rows = table === null || table === void 0 ? void 0 : table.rows) !== null && _table$rows !== void 0 ? _table$rows : []).forEach(function (row) {
+        var _cell$children;
+        var cell = row.cells[column];
+        Array.from((_cell$children = cell === null || cell === void 0 ? void 0 : cell.children) !== null && _cell$children !== void 0 ? _cell$children : []).forEach(function (child) {
+          if (child instanceof HTMLElement) {
+            child.style.setProperty('text-decoration-line', 'line-through');
+          }
+        });
+      });
+      var headerCell = firstRow === null || firstRow === void 0 ? void 0 : firstRow.cells[column];
+      if (headerCell) {
+        headerCell.style.position = 'relative';
+        // Append, never prepend. Editor CSS resets the top margin of a cell's first child, so
+        // a prepended label pushes the paragraph out of that reset and the cell grows.
+        // The label is absolutely positioned, so DOM order does not move it.
+        headerCell.append(createRemovedLozenge(intl, isActive, colorScheme, true));
+      }
+    });
+  }
   dom.setAttribute('data-testid', 'show-diff-deleted-decoration');
   if (fg('platform_editor_ai_show_diff_patch_1')) {
     dom.style.setProperty('scroll-margin-top', scrollMarginTopValue);
@@ -420,7 +478,11 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
 
     // Hosted at the start of the deleted run rather than on `dom` itself: `dom` is inline, so once
     // the deleted content wraps its box is the union of its line fragments.
-    var tagHost = createContributorTagHost(diffId, tagMountContext);
+    var tagHost = createContributorTagHost({
+      anchorName: contributorTagAnchorName,
+      diffId: diffId,
+      mountContext: tagMountContext
+    });
     if (tagHost) {
       dom.prepend(tagHost.host);
       tagMount = tagHost.mount;

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

@@ -0,0 +1,100 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { isExtendedEnabled } from '../../isExtendedEnabled';
+import { buildDiffDecorationSpec, scrollMarginTopValue } from '../decorationKeys';
+import { createContentWrapper } from './wrapBlockNodeView';
+
+/**
+ * U+2936 ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS — the return-key glyph.
+ *
+ * Exported so tests assert against the glyph actually rendered rather than a copy of it.
+ */
+export var RETURN_GLYPH = '⤶';
+
+/**
+ * The DOM for a removed blank line: the return glyph, struck through in the deleted colours.
+ *
+ * An empty paragraph or heading is a line the author deliberately added, but it has no content for
+ * the deleted-content widget to serialize, so a deletion of one used to render nothing at all — the
+ * reviewer saw the surrounding text close up with no sign of what was removed. Standing the glyph
+ * in for the absent content keeps the deletion visible without inventing content that was not there.
+ *
+ * `createContentWrapper` supplies the highlight and the strikethrough line, so the glyph is styled
+ * exactly like any other run of deleted inline content, including the active and reveal states.
+ *
+ * Hidden from assistive technology: the glyph is a picture of a key, and read out it is announced as
+ * its Unicode name rather than as a removed line.
+ */
+export var createDeletedLineBreakWidget = function createDeletedLineBreakWidget(_ref) {
+  var colorScheme = _ref.colorScheme,
+    _ref$count = _ref.count,
+    count = _ref$count === void 0 ? 1 : _ref$count,
+    diffType = _ref.diffType,
+    _ref$isActive = _ref.isActive,
+    isActive = _ref$isActive === void 0 ? false : _ref$isActive,
+    reveal = _ref.reveal;
+  var dom = document.createElement('span');
+  // The testid deleted content is matched by, so the glyph is found wherever deleted content is.
+  dom.setAttribute('data-testid', 'show-diff-deleted-decoration');
+  dom.setAttribute('aria-hidden', 'true');
+  dom.contentEditable = 'false';
+  // Scroll navigation aligns on the widget itself, as it does for every other deleted widget.
+  dom.style.setProperty('scroll-margin-top', scrollMarginTopValue);
+  for (var index = 0; index < Math.max(count, 1); index++) {
+    if (index > 0) {
+      // Each removed line gets its own line in the widget, so a run of blank lines reads as the
+      // number of lines it was. `br` rather than a block wrapper: the widget is inline, and the
+      // deleted-content wrapper is styled as an inline run.
+      dom.append(dom.ownerDocument.createElement('br'));
+    }
+    var wrapper = createContentWrapper(colorScheme, isActive, false, diffType, reveal);
+    wrapper.append(dom.ownerDocument.createTextNode(RETURN_GLYPH));
+    dom.append(wrapper);
+  }
+  return dom;
+};
+
+/**
+ * The glyph as a widget decoration anchored at `pos`.
+ *
+ * Shared by the two shapes a blank-line removal arrives in. On a forward diff the block is gone from
+ * the new document, so the change lands on the deleted side and the glyph is anchored where the
+ * block used to be. On an inverted diff — what AI suggested edits renders — the block is still in
+ * the displayed document and the change lands on the *inserted* side, so the glyph is anchored
+ * inside the surviving block, on the blank line itself.
+ */
+export var createDeletedLineBreakDecoration = function createDeletedLineBreakDecoration(_ref2) {
+  var attributionKey = _ref2.attributionKey,
+    colorScheme = _ref2.colorScheme,
+    count = _ref2.count,
+    diffType = _ref2.diffType,
+    _ref2$isActive = _ref2.isActive,
+    isActive = _ref2$isActive === void 0 ? false : _ref2$isActive,
+    pos = _ref2.pos,
+    reveal = _ref2.reveal,
+    side = _ref2.side;
+  return Decoration.widget(pos, createDeletedLineBreakWidget({
+    colorScheme: colorScheme,
+    count: count,
+    diffType: diffType,
+    isActive: isActive,
+    reveal: reveal
+  }), _objectSpread(_objectSpread({}, buildDiffDecorationSpec(_objectSpread({
+    attributionKey: attributionKey,
+    colorScheme: colorScheme,
+    decorationType: 'widget',
+    diffId: crypto.randomUUID(),
+    isActive: isActive,
+    // The glyph always stands in for removed content, whichever side of the changeset the
+    // change itself landed on.
+    isInserted: false,
+    diffType: diffType
+  }, isExtendedEnabled(diffType) && side !== undefined && {
+    side: side
+  }))), fg('platform_editor_diff_inline_mark_changes') && {
+    marks: []
+  }));
+};

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

@@ -0,0 +1,30 @@
+var CELL_TYPE_NAMES = ['tableCell', 'tableHeader'];
+export var getTableDiffMode = function getTableDiffMode(_ref) {
+  var slice = _ref.slice,
+    isInserted = _ref.isInserted;
+  var topLevelNodes = slice.content.content;
+  if (topLevelNodes.some(function (node) {
+    return CELL_TYPE_NAMES.includes(node.type.name);
+  })) {
+    return isInserted ? {
+      kind: 'cells'
+    } : {
+      kind: 'none'
+    };
+  }
+  if (topLevelNodes.some(function (node) {
+    return node.type.name === 'tableRow';
+  })) {
+    return {
+      kind: 'rows'
+    };
+  }
+  if (topLevelNodes.length === 1 && topLevelNodes[0].type.name === 'table' && slice.openStart === 0 && slice.openEnd === 0) {
+    return {
+      kind: 'wholeTable'
+    };
+  }
+  return {
+    kind: 'generic'
+  };
+};

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

@@ -141,26 +141,37 @@ var applyCellOverlayStyles = function applyCellOverlayStyles(_ref4) {
 /**
  * Creates a "Removed" lozenge to be displayed at the top right corner of deleted block nodes
  */
-var createRemovedLozenge = function createRemovedLozenge(intl) {
+export var createRemovedLozenge = function createRemovedLozenge(intl) {
   var isActive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   var colorScheme = arguments.length > 2 ? arguments[2] : undefined;
+  var inCell = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   var container = document.createElement('span');
   var containerStyle = convertToInlineCss({
     position: 'absolute',
     top: "var(--ds-space-075, 6px)",
     right: "var(--ds-space-075, 6px)",
-    zIndex: 2,
+    // Rounded table-cell overlays use z-index 2 and are appended after the cell content.
+    // Keep the lozenge above them so the overlay cannot tint or obscure it.
+    zIndex: 3,
     pointerEvents: 'none',
     display: 'flex'
   });
-  container.setAttribute('style', containerStyle);
-  container.setAttribute('data-testid', 'show-diff-removed-lozenge');
 
   // Create vanilla HTML lozenge element with Atlaskit Lozenge styling (visual refresh)
   var lozengeElement = document.createElement('span');
-  var lozengeInnerStyle = resolveRemovedLozengeStyle(colorScheme, isActive);
+
+  // A column label sits over an already-grey deleted cell, so use the red Removed treatment.
+  var lozengeInnerStyle = resolveRemovedLozengeStyle(colorScheme, inCell || isActive);
   lozengeElement.setAttribute('style', lozengeInnerStyle);
   lozengeElement.textContent = intl.formatMessage(trackChangesMessages.removed).toUpperCase();
+  if (inCell) {
+    lozengeElement.setAttribute('style', "".concat(lozengeInnerStyle, ";").concat(containerStyle));
+    lozengeElement.setAttribute('data-testid', 'show-diff-removed-lozenge');
+    lozengeElement.contentEditable = 'false';
+    return lozengeElement;
+  }
+  container.setAttribute('style', containerStyle);
+  container.setAttribute('data-testid', 'show-diff-removed-lozenge');
   container.appendChild(lozengeElement);
   return container;
 };