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

package/dist/cjs/pm-plugins/utils/emptyTextBlocks.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.emptyTextBlockContentPositions = exports.countEmptyTextBlockOnlySlice = void 0;
+/**
+ * The textblock types whose empty form is a blank line the author put there deliberately, and so
+ * worth marking when a change removes it.
+ *
+ * Deliberately not every textblock: an empty `codeBlock` is an empty code block, which renders as a
+ * visible box of its own and needs no stand-in.
+ */
+var BLANK_LINE_NODE_NAMES = new Set(['paragraph', 'heading']);
+
+/**
+ * Structurally empty: no children at all, not merely no measurable content. The two coincide for a
+ * real node, and testing both keeps a node whose children report no size from passing as blank.
+ */
+var isEmptyTextBlock = function isEmptyTextBlock(node) {
+  return BLANK_LINE_NODE_NAMES.has(node.type.name) && node.content.childCount === 0 && node.content.size === 0;
+};
+
+/**
+ * How many empty textblocks a slice holds, or 0 unless that is *all* it holds.
+ *
+ * Counted rather than tested for one, because a run of adjacent blank lines is reported as a single
+ * change covering all of them — the case that made a single-block test miss.
+ */
+var countEmptyTextBlockOnlySlice = exports.countEmptyTextBlockOnlySlice = function countEmptyTextBlockOnlySlice(slice) {
+  var _slice$content$childC;
+  var childCount = (_slice$content$childC = slice === null || slice === void 0 ? void 0 : slice.content.childCount) !== null && _slice$content$childC !== void 0 ? _slice$content$childC : 0;
+  if (!slice || childCount === 0) {
+    return 0;
+  }
+  for (var index = 0; index < childCount; index++) {
+    if (!isEmptyTextBlock(slice.content.child(index))) {
+      return 0;
+    }
+  }
+  return childCount;
+};
+
+/**
+ * The content position of every empty textblock lying wholly within `[from, to]`.
+ *
+ * Used to place a marker on each blank line a change removes. Partially covered blocks are skipped:
+ * the change only took part of one, so it still has text of its own, which the inline decoration
+ * already marks.
+ */
+var emptyTextBlockContentPositions = exports.emptyTextBlockContentPositions = function emptyTextBlockContentPositions(doc, from, to) {
+  var positions = [];
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (node.isTextblock) {
+      if (isEmptyTextBlock(node) && pos >= from && pos + node.nodeSize <= to) {
+        // +1 steps over the block's own open token, into its (empty) content.
+        positions.push(pos + 1);
+      }
+      // A textblock holds inline content only, so there is nothing below it to visit.
+      return false;
+    }
+    // Keep descending: blank lines nest inside cells, columns and panels.
+    return true;
+  });
+  return positions;
+};

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

@@ -4,7 +4,8 @@ import { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
 import { areDocsEqualByBlockStructureAndText } from '@atlaskit/editor-common/utils/areDocsEqualByBlockStructureAndText';
 import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
 import { Mapping } from '@atlaskit/editor-prosemirror/transform';
-import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { UNSAFE_expValNoExposure } from '@atlaskit/platform-feature-experiments/unsafe-exp-val-no-exposure';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
@@ -15,15 +16,19 @@ import { createNodeChangedDecorationWidget } from '../decorations/createNodeChan
 import { createAttributionColorMap, getAttributionKey, getAttributionKeyForChange, getColorSchemeForChange, isAttributionColoringEnabled, isContributorTagsEnabled } from '../decorations/colorSchemes/attributions';
 import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { extractContributorTags } from '../decorations/extractContributorTags';
+import { createDeletedLineBreakDecoration } from '../decorations/utils/createDeletedLineBreakWidget';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
+import { createRemovedLozenge } from '../decorations/utils/wrapBlockNodeView';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { getScrollableDecorations } from '../getScrollableDecorations';
 import { getDefaultDiffType, isExtendedEnabled } from '../isExtendedEnabled';
+import { emptyTextBlockContentPositions } from '../utils/emptyTextBlocks';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { isMarkOnlyChange } from './isMarkOnlyChange';
 import { isOpenTokenOnlyChange } from './isOpenTokenOnlyChange';
 import { optimizeChanges } from './optimizeChanges';
+import { CELL_CONTENT_OFFSET, groupDeletedColumnChanges } from './groupDeletedColumnChanges';
 import { selectTokenEncoder } from './selectTokenEncoder';
 import { collapseOverlappingChanges, simplifyChangesWithAttribution } from './simplifyChangesWithAttribution';
 import { simplifySteps, simplifyStepsWithAttribution } from './simplifySteps';
@@ -485,10 +490,32 @@ const calculateDiffDecorationsInner = ({
 
   // Our default operations are insertions, so it should match the opposite of isInverted.
   const isInserted = !isInverted;
+  if (isExtendedEnabled(diffType)) {
+    changes = groupDeletedColumnChanges(changes, originalDoc, tr.doc, new Mapping(stepMaps), isInverted);
+  }
+  // A whole-table change owns every mark and attribute range inside its bounds, so those ranges
+  // do not also get their own decoration.
+  const tableChanges = changes.filter(change => change.deletedColumns !== undefined);
+  const isHandledByTable = (from, to) => tableChanges.some(change => from >= change.fromB && to <= change.toB);
   const createDecorationsForChange = change => {
     const changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     const attributionKey = showContributorTags ? getAttributionKeyForChange(change, attributedChanges) : undefined;
     const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    const {
+      deletedColumns
+    } = change;
+    // On an inverted diff the table that lost columns is the one in `tr.doc`, so the column
+    // indices address it directly and each label anchors inside its own cell.
+    const table = tr.doc.nodeAt(change.fromB);
+    if (isInverted && !hideDeletedDiffs && deletedColumns !== null && deletedColumns !== void 0 && deletedColumns.length && (table === null || table === void 0 ? void 0 : table.type.name) === 'table') {
+      const tableMap = TableMap.get(table);
+      deletedColumns.forEach(column => {
+        const offset = tableMap.positionAt(0, column, table);
+        decorations.push(Decoration.widget(change.fromB + CELL_CONTENT_OFFSET + offset, () => createRemovedLozenge(intl, isActive, changeColorScheme, true), {
+          side: -1
+        }));
+      });
+    }
 
     // The deleted side of a mark-only change is a byte-identical copy of the new text, so it is
     // suppressed in the clean view. `hideDeletedDiffs` is load-bearing: when false the reviewer
@@ -522,6 +549,32 @@ const calculateDiffDecorationsInner = ({
       // On an inverted diff the inserted side is visually the deleted side.
       const shouldHideDeleted = isExtendedEnabled(diffType) ? isInverted && hideDeletedDiffs : false;
 
+      // A removed blank line — an empty paragraph or heading — has nothing to mark up. On an
+      // inverted diff, the shape AI suggested edits renders, the block is still in the displayed
+      // document, so the removal lands here on the inserted side rather than on the deleted side,
+      // and both the inline and the block decoration paint nothing: an empty textblock has no
+      // inline content to cover, and block decorations return no style for a paragraph or heading.
+      // The reviewer sees an unmarked blank line. Stand the struck-through return glyph in for each
+      // one, anchored inside the block so it renders on the blank line itself.
+      //
+      // One decoration per blank line rather than one per change: a run of adjacent blank lines is
+      // reported as a single change spanning all of them.
+      //
+      // Withheld in the clean view, where removals are hidden rather than struck through.
+      if (fg('platform_editor_ai_show_diff_patch_2') && !isInserted && !shouldHideDeleted) {
+        for (const pos of emptyTextBlockContentPositions(tr.doc, change.fromB, change.toB)) {
+          decorations.push(createDeletedLineBreakDecoration({
+            attributionKey,
+            colorScheme: changeColorScheme,
+            diffType,
+            isActive,
+            pos,
+            reveal,
+            side: -1
+          }));
+        }
+      }
+
       // For `smart` NODE-level promotions the change range spans a whole container
       // (e.g. an entire list/table/layout, using outer node bounds). Applying a SINGLE
       // inline decoration across that whole range would paint the inserted style across
@@ -630,6 +683,7 @@ const calculateDiffDecorationsInner = ({
       });
       if (!shouldHideDeleted) {
         decorations.push(...createNodeChangedDecorationWidget({
+          deletedColumns,
           // The deleted side has no inline decoration, so the widget carries the actor.
           attributionKey,
           // Extended pipeline only, matching the inline path: the non-extended styles have no
@@ -665,6 +719,9 @@ const calculateDiffDecorationsInner = ({
   getMarkChangeRanges(simplifiedSteps, simplifiedStepAttributions, fg('confluence_ncs_step_diffing_version_history') ? stepMaps : undefined).filter(({
     fromB,
     toB
+  }) => !isHandledByTable(fromB, toB)).filter(({
+    fromB,
+    toB
   }) => !fg('confluence_ncs_step_diffing_version_history') || !changes.some(change => change.fromB === fromB && change.toB === toB)).forEach(change => {
     var _attributionColors$ge, _attributionColors;
     const changeColorScheme = change.attributionKey ? (_attributionColors$ge = (_attributionColors = attributionColors) === null || _attributionColors === void 0 ? void 0 : _attributionColors.get(change.attributionKey)) !== null && _attributionColors$ge !== void 0 ? _attributionColors$ge : colorScheme : colorScheme;
@@ -686,6 +743,9 @@ const calculateDiffDecorationsInner = ({
   getAttrChangeRanges(tr.doc, attrStepContexts, originalDoc).filter(({
     fromB,
     toB
+  }) => !isHandledByTable(fromB, toB)).filter(({
+    fromB,
+    toB
   }) => !fg('confluence_ncs_step_diffing_version_history') || !changes.some(change => change.fromB === fromB && change.toB === toB)).forEach(change => {
     var _attributionColors$ge2, _attributionColors2;
     const changeColorScheme = change.attributionKey ? (_attributionColors$ge2 = (_attributionColors2 = attributionColors) === null || _attributionColors2 === void 0 ? void 0 : _attributionColors2.get(change.attributionKey)) !== null && _attributionColors$ge2 !== void 0 ? _attributionColors$ge2 : colorScheme : colorScheme;

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/createChangedRowDecorationWidgets.js

@@ -13,6 +13,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
@@ -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