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

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

@@ -0,0 +1,210 @@
+import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+export const CELL_CONTENT_OFFSET = 2;
+const IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
+const tablesIn = doc => {
+  const tables = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name === 'table') {
+      tables.push({
+        node,
+        pos
+      });
+      return false;
+    }
+    return true;
+  });
+  return tables;
+};
+const tableEnd = table => table.pos + table.node.nodeSize;
+const documentsDifferOnlyByTable = (originalDoc, newDoc, before, after) => {
+  try {
+    return originalDoc.replace(before.pos, tableEnd(before), new Slice(Fragment.from(after.node), 0, 0)).eq(newDoc);
+  } catch {
+    return false;
+  }
+};
+const columnOffsets = (map, table) => Array.from({
+  length: map.width
+}, (_, column) => map.positionAt(0, column, table));
+const positionMatchedColumns = ({
+  before,
+  after,
+  afterToBefore,
+  beforeOffsets
+}) => {
+  const afterMap = TableMap.get(after.node);
+  const surviving = new Set();
+  for (let column = 0; column < afterMap.width; column++) {
+    const offset = afterMap.positionAt(0, column, after.node);
+    const mapped = afterToBefore.mapResult(after.pos + CELL_CONTENT_OFFSET + offset);
+    const beforeColumn = beforeOffsets.indexOf(mapped.pos - before.pos - CELL_CONTENT_OFFSET);
+    if (mapped.deleted || beforeColumn === -1) {
+      return new Set();
+    }
+    surviving.add(beforeColumn);
+  }
+  return surviving;
+};
+const addContentMatchedColumns = (surviving, before, after) => {
+  var _before$node$firstChi, _before$node$firstChi2, _after$node$firstChil, _after$node$firstChil2;
+  const beforeCells = (_before$node$firstChi = (_before$node$firstChi2 = before.node.firstChild) === null || _before$node$firstChi2 === void 0 ? void 0 : _before$node$firstChi2.children) !== null && _before$node$firstChi !== void 0 ? _before$node$firstChi : [];
+  const afterCells = (_after$node$firstChil = (_after$node$firstChil2 = after.node.firstChild) === null || _after$node$firstChil2 === void 0 ? void 0 : _after$node$firstChil2.children) !== null && _after$node$firstChil !== void 0 ? _after$node$firstChil : [];
+  for (const afterCell of afterCells) {
+    const matches = beforeCells.flatMap((beforeCell, column) => areNodesEqualIgnoreAttrs(beforeCell, afterCell, IGNORED_CELL_ATTRS) ? [column] : []);
+    if (matches.length !== 1) {
+      return false;
+    }
+    surviving.add(matches[0]);
+  }
+  const ordered = [...surviving];
+  return !ordered.some((column, index) => index > 0 && column <= ordered[index - 1]);
+};
+const findDeletedColumns = (before, after, afterToBefore) => {
+  const beforeMap = TableMap.get(before.node);
+  const afterMap = TableMap.get(after.node);
+  // Merged or malformed tables do not have reliable column indices.
+  if (beforeMap.hasMergedCells() || afterMap.hasMergedCells() || beforeMap.problems || afterMap.problems) {
+    return [];
+  }
+  const beforeOffsets = columnOffsets(beforeMap, before.node);
+  const surviving = positionMatchedColumns({
+    before,
+    after,
+    afterToBefore,
+    beforeOffsets
+  });
+  if (surviving.size !== afterMap.width && !addContentMatchedColumns(surviving, before, after)) {
+    return [];
+  }
+  return beforeOffsets.flatMap((_, column) => surviving.has(column) ? [] : [column]);
+};
+const findCounterpart = ({
+  table,
+  index,
+  originalTables,
+  newTables,
+  mapping
+}) => {
+  const from = mapping.map(table.pos, -1);
+  const to = mapping.map(tableEnd(table), 1);
+  const inside = mapping.mapResult(table.pos + 1);
+  const candidates = newTables.filter(candidate => inside.deleted ? candidate.pos >= from && tableEnd(candidate) <= to : candidate.pos < inside.pos && inside.pos < tableEnd(candidate));
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  return originalTables.length === newTables.length ? newTables[index] : undefined;
+};
+const orient = ({
+  table,
+  counterpart,
+  mapping,
+  isInverted
+}) => ({
+  before: isInverted ? counterpart : table,
+  after: isInverted ? table : counterpart,
+  afterToBefore: (isInverted ? mapping.invert() : mapping).invert()
+});
+const changesInTable = (changes, table) => changes.filter(change => change.fromA < tableEnd(table) && change.toA > table.pos);
+const isNarrowingSafe = ({
+  replacedChanges,
+  table,
+  counterpart,
+  originalDoc,
+  newDoc
+}) => {
+  const staysInside = replacedChanges.every(change => change.fromA >= table.pos && change.toA <= tableEnd(table) && change.fromB >= counterpart.pos && change.toB <= tableEnd(counterpart));
+  return staysInside || documentsDifferOnlyByTable(originalDoc, newDoc, table, counterpart);
+};
+const planTableChange = ({
+  table,
+  index,
+  originalTables,
+  newTables,
+  changes,
+  originalDoc,
+  newDoc,
+  mapping,
+  isInverted
+}) => {
+  const counterpart = findCounterpart({
+    table,
+    index,
+    originalTables,
+    newTables,
+    mapping
+  });
+  if (!counterpart) {
+    return undefined;
+  }
+  const {
+    before,
+    after,
+    afterToBefore
+  } = orient({
+    table,
+    counterpart,
+    mapping,
+    isInverted
+  });
+  if (TableMap.get(before.node).width <= TableMap.get(after.node).width) {
+    return undefined;
+  }
+  const replacedChanges = changesInTable(changes, table);
+  if (!replacedChanges.length) {
+    return undefined;
+  }
+  if (!isNarrowingSafe({
+    replacedChanges,
+    table,
+    counterpart,
+    originalDoc,
+    newDoc
+  })) {
+    return undefined;
+  }
+  const spans = replacedChanges.flatMap(change => [...change.deleted, ...change.inserted]);
+  return {
+    replacedChanges,
+    tableChange: {
+      deletedColumns: findDeletedColumns(before, after, afterToBefore),
+      fromA: table.pos,
+      toA: tableEnd(table),
+      fromB: counterpart.pos,
+      toB: tableEnd(counterpart),
+      deleted: spans,
+      inserted: spans
+    }
+  };
+};
+
+/** Groups a deleted column's cell changes into one whole-table change. */
+export const groupDeletedColumnChanges = (changes, originalDoc, newDoc, mapping, isInverted) => {
+  const originalTables = tablesIn(originalDoc);
+  const newTables = tablesIn(newDoc);
+  const plans = [];
+  const replaced = new Set();
+  originalTables.forEach((table, index) => {
+    const plan = planTableChange({
+      table,
+      index,
+      originalTables,
+      newTables,
+      changes: changes.filter(change => !replaced.has(change)),
+      originalDoc,
+      newDoc,
+      mapping,
+      isInverted
+    });
+    if (!plan) {
+      return;
+    }
+    plans.push(plan);
+    plan.replacedChanges.forEach(change => replaced.add(change));
+  });
+  if (!plans.length) {
+    return [...changes];
+  }
+  return [...changes.filter(change => !replaced.has(change)), ...plans.map(plan => plan.tableChange)].sort((left, right) => left.fromB - right.fromB);
+};

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

@@ -1,6 +1,7 @@
 import { getParticipantColor } from '@atlaskit/editor-shared-styles/utils';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { DIFF_AGENT_BRANDS } from '../../../showDiffPluginType';
 import { PARTICIPANT_COLOR_SCHEMES } from './types';
 
 /** A contributor with both of its identities collapsed to internal attribution keys. */
@@ -77,6 +78,14 @@ export const getAttributionKey = attribution => {
   var _getAttributionIdenti;
   return (_getAttributionIdenti = getAttributionIdentity(attribution)) === null || _getAttributionIdenti === void 0 ? void 0 : _getAttributionIdenti.key;
 };
+const isDiffAgentBrand = agentBrand => agentBrand !== undefined && DIFF_AGENT_BRANDS.has(agentBrand);
+
+/** Prefers the resolved branded profile over the raw attribution agent type. */
+const getAgentBrandForColor = (attribution, contributors) => {
+  var _contributors, _getAttributionKey;
+  const agentBrand = contributors === null || contributors === void 0 ? void 0 : (_contributors = contributors[(_getAttributionKey = getAttributionKey(attribution)) !== null && _getAttributionKey !== void 0 ? _getAttributionKey : '']) === null || _contributors === void 0 ? void 0 : _contributors.agentKind;
+  return isDiffAgentBrand(agentBrand) ? agentBrand : attribution === null || attribution === void 0 ? void 0 : attribution.agentType;
+};
 
 /**
  * Public contributor list to internal key-addressed record. A contributor whose attribution carries
@@ -123,7 +132,7 @@ export const isAttributionColoringEnabled = stepAttributions => {
  * a tag only has to name one.
  */
 export const isContributorTagsEnabled = (stepAttributions, contributors) => areAttributionColorGatesEnabled() && Boolean(stepAttributions === null || stepAttributions === void 0 ? void 0 : stepAttributions.some(attribution => getAttributionKey(attribution) !== undefined)) && contributors !== undefined && Object.keys(contributors).length > 0;
-export const createAttributionColorMap = stepAttributions => {
+export const createAttributionColorMap = (stepAttributions, contributors) => {
   const colors = new Map();
   const allocatedColors = new Set();
 
@@ -137,7 +146,7 @@ export const createAttributionColorMap = stepAttributions => {
     const {
       index,
       isFixed
-    } = getParticipantColor(identity.colorSeed, attribution === null || attribution === void 0 ? void 0 : attribution.agentType);
+    } = getParticipantColor(identity.colorSeed, getAgentBrandForColor(attribution, contributors));
     const color = HASHED_PARTICIPANT_COLOR_SCHEMES[index];
     if (isFixed && color) {
       colors.set(identity.key, color);
@@ -151,7 +160,7 @@ export const createAttributionColorMap = stepAttributions => {
     }
     const {
       index
-    } = getParticipantColor(identity.colorSeed, attribution === null || attribution === void 0 ? void 0 : attribution.agentType);
+    } = getParticipantColor(identity.colorSeed, getAgentBrandForColor(attribution, contributors));
     const hashedColor = getSlotColor(index);
     if (!hashedColor) {
       continue;

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

@@ -1,7 +1,6 @@
 import { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { getStandardDeletedTextDecorationStyle } from './getStandardDeletedTextDecorationStyle';
-
 /**
  * Hover highlight for deleted text under an 'onEmphasis' scheme. Inline styles cannot express
  * `:hover`, so the resting style resolves its background from this property and

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

@@ -8,9 +8,9 @@ import { isTaggableBlockNode } from '../utils/taggableBlockNodes';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedBlockNodeStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildInsertedBlockNodeStyle } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
+import { getBlockNodeStyleLegacy, resolveCellOverlayStyleLegacy } from './createBlockChangedDecoration.styles.legacy';
 import { createContributorTagWidget, isContributorTagWidgetEnabled } from './createContributorTagWidget';
 import { AnchorTypeKey, buildDiffDecorationSpec, buildAnchorDecorationKey, scrollMarginTopStyle } from './decorationKeys';
-import { getBlockNodeStyleLegacy, resolveCellOverlayStyleLegacy } from './createBlockChangedDecoration.styles.legacy';
 const displayNoneStyle = convertToInlineCss({
   display: 'none'
 });

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

@@ -14,6 +14,7 @@ import { createContributorTagWidget, isContributorTagWidgetEnabled } from './cre
 import { AnchorTypeKey, buildAnchorDecorationKey, buildDiffDecorationSpec, scrollMarginTopValue } from './decorationKeys';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
 import { applyCellEdgeAttrs, getRowCellEdgeAttrs, getTableTopAndBottomCellEdgeAttrs } from './utils/tableCellEdgeAttrs';
+import { createRemovedLozenge } from './utils/wrapBlockNodeView';
 /**
  * Extracts information about deleted table rows from a change
  */
@@ -144,17 +145,28 @@ const isEmptyRow = rowNode => {
   });
   return isEmpty;
 };
-
 /**
  * Creates a DOM representation of a deleted table row
  */
-const createChangedRowDOM = (rowNode, cellEdgeAttrs, nodeViewSerializer, colorScheme, isInserted, diffType) => {
+const createChangedRowDOM = ({
+  rowNode,
+  cellEdgeAttrs,
+  nodeViewSerializer,
+  colorScheme,
+  isInserted,
+  diffType,
+  hasAnchoredRemovedLozenge,
+  intl,
+  isActive
+}) => {
   const tr = document.createElement('tr');
   const colors = colorSchemeRegistry[colorScheme !== null && colorScheme !== void 0 ? colorScheme : 'standard'];
+  const deletedTreatment = isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? buildDeletedRowStyle(colors) : resolveDeletedRowStyleLegacy(getLegacyColorScheme(colorScheme));
+  const 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
@@ -195,8 +207,40 @@ const createChangedRowDOM = (rowNode, cellEdgeAttrs, nodeViewSerializer, colorSc
       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) {
+    const 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;
 };
+const supportsAnchorPositioning = () => typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)');
+const createAnchoredRemovedLozengeWidget = ({
+  anchorName,
+  colorScheme,
+  from,
+  intl,
+  isActive
+}) => {
+  const lozenge = createRemovedLozenge(intl, isActive, colorScheme, true);
+  const inset = lozenge.style.top;
+  lozenge.style.setProperty('position', 'fixed');
+  lozenge.style.setProperty('top', `calc(anchor(--${anchorName} top) + ${inset})`);
+  lozenge.style.setProperty('left', `calc(anchor(--${anchorName} right) - ${inset})`);
+  lozenge.style.setProperty('right', 'auto');
+  lozenge.style.setProperty('transform', 'translateX(-100%)');
+  return Decoration.widget(from, lozenge, {
+    key: `removed-lozenge-${anchorName}`,
+    side: -1
+  });
+};
 
 /**
  * Expands a diff to include whole changed rows when table rows are affected
@@ -236,6 +280,7 @@ export const createChangedRowDecorationWidgets = ({
   isActive,
   isInserted = false,
   diffType,
+  intl,
   showIndicators = false,
   showContributorTags = false,
   tagMountContext
@@ -248,16 +293,25 @@ export const createChangedRowDecorationWidgets = ({
     diffType
   });
   return changedRows.flatMap(changedRow => {
-    const rowDOM = createChangedRowDOM(changedRow.rowNode, changedRow.cellEdgeAttrs, nodeViewSerializer, colorScheme, isInserted, diffType);
+    // Keep the ID stable while contributor tags are enabled so recalculation preserves their state.
+    const diffId = showContributorTags ? `widget-row-${changedRow.fromA}-${changedRow.toA}` : crypto.randomUUID();
+    const hasAnchoredRemovedLozenge = Boolean(intl) && isExtendedEnabled(diffType) && !isInserted && supportsAnchorPositioning();
+    const rowDOM = createChangedRowDOM({
+      rowNode: changedRow.rowNode,
+      cellEdgeAttrs: changedRow.cellEdgeAttrs,
+      nodeViewSerializer,
+      colorScheme,
+      isInserted,
+      diffType,
+      hasAnchoredRemovedLozenge,
+      intl,
+      isActive
+    });
 
     // Find safe insertion position for the deleted row
     const 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.
-    const diffId = showContributorTags ? `widget-row-${changedRow.fromA}-${changedRow.toA}` : crypto.randomUUID();
     const decorations = [];
     const rowAnchorNames = [];
 
@@ -286,6 +340,11 @@ export const createChangedRowDecorationWidgets = ({
       diffId,
       anchorType: AnchorTypeKey.tag
     }) : undefined;
+    const removedLozengeAnchorName = hasAnchoredRemovedLozenge ? tagAnchorName !== null && tagAnchorName !== void 0 ? tagAnchorName : buildAnchorDecorationKey({
+      diffId,
+      anchorType: AnchorTypeKey.tag
+    }) : undefined;
+    const rowLabelAnchorName = tagAnchorName !== null && tagAnchorName !== void 0 ? tagAnchorName : removedLozengeAnchorName;
     const tagWidget = tagAnchorName ? createContributorTagWidget({
       anchorAtRangeStart: true,
       anchorName: tagAnchorName,
@@ -295,11 +354,9 @@ export const createChangedRowDecorationWidgets = ({
       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(anchorName => `--${anchorName}`).join(', '));
@@ -320,6 +377,15 @@ export const createChangedRowDecorationWidgets = ({
       })
     });
     decorations.push(rowWidget);
+    if (intl && removedLozengeAnchorName) {
+      decorations.push(createAnchoredRemovedLozengeWidget({
+        anchorName: removedLozengeAnchorName,
+        colorScheme,
+        from: safeInsertPos,
+        intl,
+        isActive
+      }));
+    }
     if (tagWidget) {
       decorations.push(tagWidget);
     }

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

@@ -88,14 +88,20 @@ const supportsAnchorPositioning = () => typeof CSS !== 'undefined' && typeof CSS
  * 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 const createContributorTagHost = (diffId, mountContext) => {
+export const createContributorTagHost = ({
+  anchorName,
+  diffId,
+  mountContext
+}) => {
   if (!isContributorTagWidgetEnabled()) {
     return undefined;
   }
-  const host = buildContributorTagHost(diffId);
+  const tagAnchorName = anchorName && supportsAnchorPositioning() ? anchorName : undefined;
+  const host = buildContributorTagHost(diffId, tagAnchorName);
   return {
     host,
     mount: mountContributorTag({
+      anchorName: tagAnchorName,
       diffId,
       host,
       mountContext

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

@@ -1,17 +1,20 @@
 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';
 const isHeadingLevel = level => typeof level === 'number' && level >= 1 && level <= 6;
 
 /**
@@ -119,11 +122,20 @@ export const createNodeChangedDecorationWidget = ({
   diffType,
   hideAddedDiffsUnderline = false,
   reveal,
-  tagMountContext
+  tagMountContext,
+  deletedColumns
 }) => {
   var _$safeInsertPos$nodeB, _slice$content$firstC, _newDoc$firstChild, _slice$content$firstC2;
   const slice = doc.slice(change.fromA, change.toA);
   const 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.
+  const 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
@@ -131,16 +143,33 @@ export const createNodeChangedDecorationWidget = ({
   const anchorPos = placeBelow ? change.toB : change.fromB;
   const safeInsertPos = findSafeInsertPos(newDoc, anchorPos, slice);
   const 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,
+      count: deletedBlankLineCount,
+      diffType,
+      isActive,
+      pos: safeInsertPos,
+      reveal,
+      side: placeBelow ? 1 : -1
+    })];
+  }
+  if (shouldSkipDeletedEmptyParagraphDecoration) {
     return [];
   }
-  const isTableCellContent = slice.content.content.some(() => slice.content.content.some(siblingNode => ['tableHeader', 'tableCell'].includes(siblingNode.type.name)));
-  const isTableRowContent = slice.content.content.some(() => slice.content.content.some(siblingNode => ['tableRow'].includes(siblingNode.type.name)));
-
-  // 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 (slice.content.content.length === 0) {
+    return [];
+  }
+  const tableDiffMode = getTableDiffMode({
+    slice,
+    isInserted
+  });
+  if (tableDiffMode.kind === 'cells') {
     return createTableCellContentWidgets({
       slice,
       newDoc,
@@ -151,11 +180,10 @@ export const createNodeChangedDecorationWidget = ({
       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,
       changes: [change],
@@ -166,6 +194,7 @@ export const createNodeChangedDecorationWidget = ({
       isActive,
       isInserted,
       diffType,
+      intl,
       // Needed for the row's own indicator anchor; this path returns before the
       // `anchor-name` assignment further down.
       showIndicators,
@@ -173,6 +202,9 @@ export const createNodeChangedDecorationWidget = ({
       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.
+
   const serializer = nodeViewSerializer;
 
   // For non-table content, use the existing span wrapper approach
@@ -368,6 +400,40 @@ export const createNodeChangedDecorationWidget = ({
       }
     }
   });
+  let contributorTagAnchorName;
+  if (!isInserted && deletedColumns !== null && deletedColumns !== void 0 && deletedColumns.length) {
+    const table = dom.querySelector('table');
+    const firstRow = table === null || table === void 0 ? void 0 : table.rows[0];
+    if (table && canTagWidget) {
+      contributorTagAnchorName = buildAnchorDecorationKey({
+        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', `--${contributorTagAnchorName}`);
+    }
+    deletedColumns.forEach(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(row => {
+        var _cell$children;
+        const 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(child => {
+          if (child instanceof HTMLElement) {
+            child.style.setProperty('text-decoration-line', 'line-through');
+          }
+        });
+      });
+      const 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);
@@ -405,7 +471,11 @@ export const createNodeChangedDecorationWidget = ({
 
     // 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.
-    const tagHost = createContributorTagHost(diffId, tagMountContext);
+    const tagHost = createContributorTagHost({
+      anchorName: contributorTagAnchorName,
+      diffId,
+      mountContext: tagMountContext
+    });
     if (tagHost) {
       dom.prepend(tagHost.host);
       tagMount = tagHost.mount;