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

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

@@ -22,6 +22,7 @@ var _createChangedRowDecorationWidgetsStyles = require("./createChangedRowDecora
 var _createContributorTagWidget = require("./createContributorTagWidget");
 var _decorationKeys = require("./decorationKeys");
 var _findSafeInsertPos = require("./utils/findSafeInsertPos");
+var _wrapBlockNodeView = require("./utils/wrapBlockNodeView");
 var _tableCellEdgeAttrs = require("./utils/tableCellEdgeAttrs");
 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) { (0, _defineProperty2.default)(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; }
@@ -168,17 +169,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 = _schemes.colorSchemeRegistry[colorScheme !== null && colorScheme !== void 0 ? colorScheme : 'standard'];
+  var deletedTreatment = (0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_show_diff_color_scheme_refactor') ? (0, _factory.buildDeletedRowStyle)(colors) : (0, _createChangedRowDecorationWidgetsStyles.resolveDeletedRowStyleLegacy)((0, _schemes.getLegacyColorScheme)(colorScheme));
+  var hostsRemovedLozenge = Boolean(intl) && (0, _isExtendedEnabled.isExtendedEnabled)(diffType) && !isInserted && !hasAnchoredRemovedLozenge;
 
   // Inserted rows keep their natural styling; the row strikethrough is deletions only.
   if (!(0, _isExtendedEnabled.isExtendedEnabled)(diffType) || !isInserted) {
-    tr.setAttribute('style', (0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_show_diff_color_scheme_refactor') ? (0, _factory.buildDeletedRowStyle)(colors) : (0, _createChangedRowDecorationWidgetsStyles.resolveDeletedRowStyleLegacy)((0, _schemes.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
@@ -219,17 +230,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((0, _wrapBlockNodeView.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 = (0, _wrapBlockNodeView.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 _view.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;
@@ -258,22 +302,23 @@ var expandDiffForChangedRows = function expandDiffForChangedRows(_ref3) {
 /**
  * Main function to handle deleted rows - computes diff and creates decorations
  */
-var createChangedRowDecorationWidgets = exports.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;
+var createChangedRowDecorationWidgets = exports.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) {
@@ -284,16 +329,25 @@ var createChangedRowDecorationWidgets = exports.createChangedRowDecorationWidget
     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) && (0, _isExtendedEnabled.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 = (0, _findSafeInsertPos.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 = [];
 
@@ -322,6 +376,11 @@ var createChangedRowDecorationWidgets = exports.createChangedRowDecorationWidget
       diffId: diffId,
       anchorType: _decorationKeys.AnchorTypeKey.tag
     }) : undefined;
+    var removedLozengeAnchorName = hasAnchoredRemovedLozenge ? tagAnchorName !== null && tagAnchorName !== void 0 ? tagAnchorName : (0, _decorationKeys.buildAnchorDecorationKey)({
+      diffId: diffId,
+      anchorType: _decorationKeys.AnchorTypeKey.tag
+    }) : undefined;
+    var rowLabelAnchorName = tagAnchorName !== null && tagAnchorName !== void 0 ? tagAnchorName : removedLozengeAnchorName;
     var tagWidget = tagAnchorName ? (0, _createContributorTagWidget.createContributorTagWidget)({
       anchorAtRangeStart: true,
       anchorName: tagAnchorName,
@@ -331,11 +390,9 @@ var createChangedRowDecorationWidgets = exports.createChangedRowDecorationWidget
       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) {
@@ -356,6 +413,15 @@ var createChangedRowDecorationWidgets = exports.createChangedRowDecorationWidget
       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/cjs/pm-plugins/decorations/createContributorTagWidget.js

@@ -101,14 +101,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`.
  */
-var createContributorTagHost = exports.createContributorTagHost = function createContributorTagHost(diffId, mountContext) {
+var createContributorTagHost = exports.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
@@ -132,7 +137,7 @@ var createContributorTagHost = exports.createContributorTagHost = function creat
  * (see `hasVisibleContent`).
  */
 var resolveTagAnchorPos = function resolveTagAnchorPos(doc, from, to) {
-  var _ref2;
+  var _ref3;
   var edge;
   var visibleEdge;
   doc.nodesBetween(from, to, function (node, nodePos) {
@@ -165,7 +170,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;
 };
 
 /**
@@ -193,15 +198,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`.
  */
-var createContributorTagWidget = exports.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;
+var createContributorTagWidget = exports.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/cjs/pm-plugins/decorations/createNodeChangedDecorationWidget.js

@@ -9,16 +9,19 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _isExtendedEnabled = require("../isExtendedEnabled");
+var _emptyTextBlocks = require("../utils/emptyTextBlocks");
 var _isEmptyParagraphSlice = require("../utils/isEmptyParagraphSlice");
 var _createAnchorDecorationWidgets = require("./createAnchorDecorationWidgets");
 var _createChangedRowDecorationWidgets = require("./createChangedRowDecorationWidgets");
 var _createContributorTagWidget = require("./createContributorTagWidget");
 var _decorationKeys = require("./decorationKeys");
 var _absorbFirstChildMarginReset = require("./utils/absorbFirstChildMarginReset");
+var _createDeletedLineBreakWidget = require("./utils/createDeletedLineBreakWidget");
 var _createMarginAbsorber = require("./utils/createMarginAbsorber");
 var _createNodeShapedMarginSpacer = require("./utils/createNodeShapedMarginSpacer");
 var _findSafeInsertPos = require("./utils/findSafeInsertPos");
 var _safeResolve = require("./utils/safeResolve");
+var _tableDiffMode = require("./utils/tableDiffMode");
 var _wrapBlockNodeView = require("./utils/wrapBlockNodeView");
 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) { (0, _defineProperty2.default)(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; }
@@ -129,9 +132,18 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
     _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 && (0, _isEmptyParagraphSlice.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 && (0, _fg.fg)('platform_editor_ai_show_diff_patch_2') ? (0, _emptyTextBlocks.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
@@ -139,24 +151,33 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
   var anchorPos = placeBelow ? change.toB : change.fromB;
   var safeInsertPos = (0, _findSafeInsertPos.findSafeInsertPos)(newDoc, anchorPos, slice);
   var isActive = activeIndexPos && ((0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? safeInsertPos >= activeIndexPos.from && safeInsertPos <= activeIndexPos.to : safeInsertPos === activeIndexPos.from && safeInsertPos === activeIndexPos.to);
-  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 [(0, _createDeletedLineBreakWidget.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 = (0, _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,
@@ -167,11 +188,10 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
       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 (0, _createChangedRowDecorationWidgets.createChangedRowDecorationWidgets)({
       attributionKey: attributionKey,
       changes: [change],
@@ -182,6 +202,7 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
       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,
@@ -189,6 +210,9 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
       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
@@ -390,6 +414,40 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
       }
     }
   });
+  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 = (0, _decorationKeys.buildAnchorDecorationKey)({
+        diffId: diffId,
+        anchorType: _decorationKeys.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((0, _wrapBlockNodeView.createRemovedLozenge)(intl, isActive, colorScheme, true));
+      }
+    });
+  }
   dom.setAttribute('data-testid', 'show-diff-deleted-decoration');
   if ((0, _fg.fg)('platform_editor_ai_show_diff_patch_1')) {
     dom.style.setProperty('scroll-margin-top', _decorationKeys.scrollMarginTopValue);
@@ -427,7 +485,11 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
 
     // 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 = (0, _createContributorTagWidget.createContributorTagHost)(diffId, tagMountContext);
+    var tagHost = (0, _createContributorTagWidget.createContributorTagHost)({
+      anchorName: contributorTagAnchorName,
+      diffId: diffId,
+      mountContext: tagMountContext
+    });
     if (tagHost) {
       dom.prepend(tagHost.host);
       tagMount = tagHost.mount;

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

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDeletedLineBreakWidget = exports.createDeletedLineBreakDecoration = exports.RETURN_GLYPH = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _view = require("@atlaskit/editor-prosemirror/view");
+var _fg = require("@atlaskit/platform-feature-flags/fg");
+var _isExtendedEnabled = require("../../isExtendedEnabled");
+var _decorationKeys = require("../decorationKeys");
+var _wrapBlockNodeView = require("./wrapBlockNodeView");
+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) { (0, _defineProperty2.default)(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; }
+/**
+ * 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.
+ */
+var RETURN_GLYPH = exports.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.
+ */
+var createDeletedLineBreakWidget = exports.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', _decorationKeys.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 = (0, _wrapBlockNodeView.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.
+ */
+var createDeletedLineBreakDecoration = exports.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 _view.Decoration.widget(pos, createDeletedLineBreakWidget({
+    colorScheme: colorScheme,
+    count: count,
+    diffType: diffType,
+    isActive: isActive,
+    reveal: reveal
+  }), _objectSpread(_objectSpread({}, (0, _decorationKeys.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
+  }, (0, _isExtendedEnabled.isExtendedEnabled)(diffType) && side !== undefined && {
+    side: side
+  }))), (0, _fg.fg)('platform_editor_diff_inline_mark_changes') && {
+    marks: []
+  }));
+};

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTableDiffMode = void 0;
+var CELL_TYPE_NAMES = ['tableCell', 'tableHeader'];
+var getTableDiffMode = exports.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/cjs/pm-plugins/decorations/utils/wrapBlockNodeView.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.wrapBlockNodeView = exports.injectInnerWrapper = exports.createContentWrapper = void 0;
+exports.wrapBlockNodeView = exports.injectInnerWrapper = exports.createRemovedLozenge = exports.createContentWrapper = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _lazyNodeView = require("@atlaskit/editor-common/lazy-node-view");
 var _messages = require("@atlaskit/editor-common/messages");
@@ -148,26 +148,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) {
+var createRemovedLozenge = exports.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 = (0, _lazyNodeView.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 = (0, _wrapBlockNodeViewStyles.resolveRemovedLozengeStyle)(colorScheme, isActive);
+
+  // A column label sits over an already-grey deleted cell, so use the red Removed treatment.
+  var lozengeInnerStyle = (0, _wrapBlockNodeViewStyles.resolveRemovedLozengeStyle)(colorScheme, inCell || isActive);
   lozengeElement.setAttribute('style', lozengeInnerStyle);
   lozengeElement.textContent = intl.formatMessage(_messages.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;
 };