@atlaskit/editor-plugin-show-diff 20.0.1 → 20.0.2

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

@@ -2,7 +2,6 @@ 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) => {
@@ -47,21 +46,92 @@ const positionMatchedColumns = ({
   }
   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;
+const headerLocalIds = table => {
+  var _table$node$firstChil, _table$node$firstChil2;
+  return ((_table$node$firstChil = (_table$node$firstChil2 = table.node.firstChild) === null || _table$node$firstChil2 === void 0 ? void 0 : _table$node$firstChil2.children) !== null && _table$node$firstChil !== void 0 ? _table$node$firstChil : []).map(cell => {
+    var _cell$attrs$localId;
+    return (_cell$attrs$localId = cell.attrs.localId) !== null && _cell$attrs$localId !== void 0 ? _cell$attrs$localId : undefined;
+  });
+};
+
+/**
+ * Cells keep their `localId` when a column is deleted, so the first row's ids name each remaining
+ * column even when the steps replaced the whole table. Missing or repeated ids, such as in content
+ * pasted from elsewhere, cannot name a column.
+ */
+const localIdMatchedColumns = (before, after) => {
+  const beforeIds = headerLocalIds(before);
+  if (beforeIds.some(id => !id) || new Set(beforeIds).size !== beforeIds.length) {
+    return undefined;
+  }
+  const surviving = new Set();
+  let previousColumn = -1;
+  for (const id of headerLocalIds(after)) {
+    const column = id ? beforeIds.indexOf(id) : -1;
+    if (column <= previousColumn) {
+      return undefined;
+    }
+    surviving.add(column);
+    previousColumn = column;
+  }
+  return surviving;
+};
+const IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
+
+/** Rows may also have been deleted, so the remaining cells only need to appear in order. */
+const isColumnKept = (before, beforeColumn, after, afterColumn) => {
+  let beforeRow = 0;
+  return after.node.children.every(afterRow => {
+    const afterCell = afterRow.maybeChild(afterColumn);
+    while (beforeRow < before.node.childCount) {
+      const beforeCell = before.node.child(beforeRow++).maybeChild(beforeColumn);
+      if (afterCell && beforeCell && areNodesEqualIgnoreAttrs(beforeCell, afterCell, IGNORED_CELL_ATTRS)) {
+        return true;
+      }
+    }
+    return false;
+  });
+};
+
+/**
+ * Pairs each remaining column with an equal original column, keeping their order, and takes each
+ * pair from the `direction` end first. Returns the original column of each remaining column.
+ */
+const pairColumnsInOrder = (beforeWidth, afterWidth, isMatch, direction) => {
+  const step = direction === 'left' ? 1 : -1;
+  const pairing = [];
+  let beforeColumn = direction === 'left' ? 0 : beforeWidth - 1;
+  let afterColumn = direction === 'left' ? 0 : afterWidth - 1;
+  for (; afterColumn >= 0 && afterColumn < afterWidth; afterColumn += step) {
+    while (beforeColumn >= 0 && beforeColumn < beforeWidth && !isMatch(beforeColumn, afterColumn)) {
+      beforeColumn += step;
+    }
+    if (beforeColumn < 0 || beforeColumn >= beforeWidth) {
+      return undefined;
     }
-    surviving.add(matches[0]);
+    pairing.push(beforeColumn);
+    beforeColumn += step;
+  }
+  return direction === 'left' ? pairing : pairing.reverse();
+};
+
+/**
+ * For tables whose cells have no usable ids, such as content created before cells had ids. Every
+ * valid pairing of remaining columns to original ones lies between the leftmost and the rightmost
+ * pairing, so the columns are only reported when those two agree. Otherwise, such as when several
+ * original columns are identical, which of them were removed cannot be known.
+ */
+const uniquelyContentMatchedColumns = (before, after, beforeWidth, afterWidth) => {
+  const isMatch = (beforeColumn, afterColumn) => isColumnKept(before, beforeColumn, after, afterColumn);
+  const leftmost = pairColumnsInOrder(beforeWidth, afterWidth, isMatch, 'left');
+  const rightmost = pairColumnsInOrder(beforeWidth, afterWidth, isMatch, 'right');
+  if (!leftmost || !rightmost || leftmost.some((column, index) => column !== rightmost[index])) {
+    return undefined;
   }
-  const ordered = [...surviving];
-  return !ordered.some((column, index) => index > 0 && column <= ordered[index - 1]);
+  return new Set(leftmost);
 };
 const findDeletedColumns = (before, after, afterToBefore) => {
+  var _localIdMatchedColumn;
   const beforeMap = TableMap.get(before.node);
   const afterMap = TableMap.get(after.node);
   // Merged or malformed tables do not have reliable column indices.
@@ -69,13 +139,14 @@ const findDeletedColumns = (before, after, afterToBefore) => {
     return [];
   }
   const beforeOffsets = columnOffsets(beforeMap, before.node);
-  const surviving = positionMatchedColumns({
+  const positionMatched = positionMatchedColumns({
     before,
     after,
     afterToBefore,
     beforeOffsets
   });
-  if (surviving.size !== afterMap.width && !addContentMatchedColumns(surviving, before, after)) {
+  const surviving = positionMatched.size === afterMap.width ? positionMatched : (_localIdMatchedColumn = localIdMatchedColumns(before, after)) !== null && _localIdMatchedColumn !== void 0 ? _localIdMatchedColumn : uniquelyContentMatchedColumns(before, after, beforeMap.width, afterMap.width);
+  if (!surviving) {
     return [];
   }
   return beforeOffsets.flatMap((_, column) => surviving.has(column) ? [] : [column]);

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

@@ -24,6 +24,7 @@ const getAttributionIdentity = change => {
     mergeable: true
   };
 };
+const hasContributor = change => [...change.deleted, ...change.inserted].some(span => getAttributionKey(span.data) !== undefined);
 const byNewDocRange = (left, right) => left.fromB - right.fromB || left.toB - right.toB;
 
 /** Union of the given ranges, with overlapping and touching ones merged. */
@@ -74,12 +75,28 @@ const blockNodeRanges = (doc, change, ownsPosition) => {
  * whoever wrote last (EDITOR-8932).
  */
 const splitMixedIdentityChanges = (changes, doc) => changes.flatMap(change => {
-  if (getAttributionIdentity(change).mergeable) {
-    return [change];
+  var _change$inserted$;
+  // A replacement can carry an anonymous deletion and an authored insertion. The deleted side
+  // needs its own zero-width change or the insertion's actor claims the deletion too.
+  const deletedKeys = new Set(change.deleted.map(span => getAttributionKey(span.data)));
+  const firstInsertedKey = getAttributionKey((_change$inserted$ = change.inserted[0]) === null || _change$inserted$ === void 0 ? void 0 : _change$inserted$.data);
+  const detachDeleted = change.deleted.length > 0 && change.inserted.length > 0 && deletedKeys.size === 1 && !deletedKeys.has(firstInsertedKey) && (deletedKeys.has(undefined) || firstInsertedKey === undefined);
+  const deletedChange = detachDeleted ? [{
+    ...change,
+    toB: change.fromB,
+    inserted: []
+  }] : [];
+  const contentChange = detachDeleted ? {
+    ...change,
+    fromA: change.toA,
+    deleted: []
+  } : change;
+  if (getAttributionIdentity(contentChange).mergeable) {
+    return [...deletedChange, contentChange];
   }
   const runs = [];
-  let offset = change.fromB;
-  for (const span of change.inserted) {
+  let offset = contentChange.fromB;
+  for (const span of contentChange.inserted) {
     const key = getAttributionKey(span.data);
     const last = runs[runs.length - 1];
     if (last && last.key === key) {
@@ -97,31 +114,31 @@ const splitMixedIdentityChanges = (changes, doc) => changes.flatMap(change => {
   }
 
   // The offsets above are only positions if the spans partition the inserted range.
-  if (runs.length < 2 || offset !== change.toB) {
-    return [change];
+  if (runs.length < 2 || offset !== contentChange.toB) {
+    return [...deletedChange, contentChange];
   }
-  return runs.map((run, index) => {
+  return [...deletedChange, ...runs.map((run, index) => {
     const owned = blockNodeRanges(doc, {
-      from: change.fromB,
-      to: change.toB
+      from: contentChange.fromB,
+      to: contentChange.toB
     }, pos => pos >= run.from && pos < run.to);
     return {
-      ...change,
-      fromA: index === 0 ? change.fromA : change.toA,
+      ...contentChange,
+      fromA: index === 0 ? contentChange.fromA : contentChange.toA,
       fromB: run.from,
       toB: run.to,
-      deleted: index === 0 ? change.deleted : [],
+      deleted: index === 0 ? contentChange.deleted : [],
       inserted: run.spans,
       ...(owned ? {
         blockNodeRangesB: owned
       } : {})
     };
-  });
+  })];
 });
 
 /**
- * Subtracts every other author's contained change from a change's range, so both contributions
- * survive. Applies when the contributors arrive as separate changes rather than as spans of one —
+ * Subtracts every differently attributed contained change from a change's range, including when
+ * one has no contributor. Applies when the changes arrive separately rather than as spans of one —
  * the `step` diff type. A contained change by the same author, and one that only partially
  * overlaps, are left for the collapse below.
  *
@@ -129,11 +146,12 @@ const splitMixedIdentityChanges = (changes, doc) => changes.flatMap(change => {
  */
 const splitContainedChanges = (changes, doc) => changes.flatMap(change => {
   const {
-    key
+    key,
+    mergeable
   } = getAttributionIdentity(change);
   const inner = mergeRanges(changes.filter(other => {
-    const otherKey = getAttributionIdentity(other).key;
-    return other !== change && key !== undefined && otherKey !== undefined && otherKey !== key && isContained(change, other);
+    const otherIdentity = getAttributionIdentity(other);
+    return other !== change && mergeable && otherIdentity.mergeable && otherIdentity.key !== key && isContained(change, other);
   }).map(({
     fromB,
     toB
@@ -196,7 +214,7 @@ const splitContainedChanges = (changes, doc) => changes.flatMap(change => {
  */
 const mergeBlockNodeRanges = (left, right) => left.blockNodeRangesB && right.blockNodeRangesB ? [...left.blockNodeRangesB, ...right.blockNodeRangesB] : undefined;
 
-/** Unions the changes whose new-document ranges strictly overlap, leaving touching ones alone. */
+/** Unions overlapping changes, except when only one side names a contributor. */
 const collapse = changes => {
   // A zero-length new-document range paints no inline decoration, so it is kept aside rather than
   // folded into a neighbouring insertion.
@@ -204,7 +222,9 @@ const collapse = changes => {
   const collapsed = [];
   for (const change of changes.filter(change => change.toB > change.fromB).sort(byNewDocRange)) {
     const current = collapsed[collapsed.length - 1];
-    if (current && change.fromB < current.toB) {
+    const currentHasContributor = current && hasContributor(current);
+    const changeHasContributor = hasContributor(change);
+    if (current && change.fromB < current.toB && currentHasContributor === changeHasContributor) {
       const blockNodeRangesB = mergeBlockNodeRanges(current, change);
       collapsed[collapsed.length - 1] = {
         fromA: Math.min(current.fromA, change.fromA),
@@ -232,8 +252,8 @@ const collapse = changes => {
  * characters — which stacks two inline decorations and renders one contributor tag per copy.
  *
  * Merging keeps every span from both sides, so the latest-writer rule still decides whose tag is
- * shown. Ranges that merely touch are left alone, so an unattributed edit next to an attributed one
- * is not credited to it.
+ * shown among attributed edits. An unattributed change never merges with an attributed one.
+ * Ranges that merely touch are left alone.
  *
  * Contributors are separated first, by `splitMixedIdentityChanges` and `splitContainedChanges`.
  * Both leave ranges that only touch, so they survive the collapse.

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

@@ -183,13 +183,12 @@ const changesOverlap = (change, attributedChange) => {
 const getAttributionKeyForChanges = changes => getAttributionKey(getLatestAttribution(changes));
 
 /**
- * The attribution key owning a change. Inline and step changes retain direct attribution spans, so
- * resolve those first. Grouped and smart-classified changes can lose that data; for those, fall
- * back to the latest overlapping attributed step.
+ * Preserve overlap attribution outside Confluence version history. Within version history, a
+ * recovery step's keyless spans must not inherit an overlapping NCS step's actor.
  */
 export const getAttributionKeyForChange = (change, attributedChanges) => {
-  var _getAttributionKeyFor;
-  return (_getAttributionKeyFor = getAttributionKeyForChanges([change])) !== null && _getAttributionKeyFor !== void 0 ? _getAttributionKeyFor : getAttributionKeyForChanges(attributedChanges.filter(attributedChange => changesOverlap(change, attributedChange)));
+  const directKey = getAttributionKeyForChanges([change]);
+  return directKey !== null && directKey !== void 0 ? directKey : fg('confluence_ncs_step_diffing_version_history') ? undefined : getAttributionKeyForChanges(attributedChanges.filter(attributedChange => changesOverlap(change, attributedChange)));
 };
 export const getColorSchemeForChange = (change, attributedChanges, attributionColors, fallback) => {
   var _attributionColors$ge;

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

@@ -196,7 +196,7 @@ const createChangedRowDOM = ({
   }
   return tr;
 };
-const supportsAnchorPositioning = () => typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)');
+const supportsAnchorPositioning = () => typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)') && CSS.supports('position-anchor', '--a');
 const createAnchoredRemovedLozengeWidget = ({
   anchorName,
   colorScheme,
@@ -207,6 +207,9 @@ const createAnchoredRemovedLozengeWidget = ({
   const lozenge = createRemovedLozenge(intl, isActive, colorScheme, true);
   const inset = lozenge.style.top;
   lozenge.style.setProperty('position', 'fixed');
+  // Fixed labels only follow their default anchor on scroll, and escape scroll-container clipping.
+  lozenge.style.setProperty('position-anchor', `--${anchorName}`);
+  lozenge.style.setProperty('position-visibility', 'anchors-visible');
   lozenge.style.setProperty('top', `calc(anchor(--${anchorName} top) + ${inset})`);
   lozenge.style.setProperty('left', `calc(anchor(--${anchorName} right) - ${inset})`);
   lozenge.style.setProperty('right', 'auto');

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

@@ -139,7 +139,7 @@ export const createNodeChangedDecorationWidget = ({
   // node renders beneath its replacement; otherwise anchor at the start (change.fromB).
   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);
+  const isActive = activeIndexPos && (fg('confluence_ncs_step_diffing_version_history') ? safeInsertPos >= activeIndexPos.from && safeInsertPos <= activeIndexPos.to && (!('attributionKey' in activeIndexPos) || activeIndexPos.attributionKey === attributionKey) : safeInsertPos === activeIndexPos.from && safeInsertPos === activeIndexPos.to);
   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

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

@@ -72,7 +72,7 @@ const owningStop = (target, stops) => stops.reduce((narrowest, stop) => stop.fro
  * group's union range touches, so several tags revealed over each other (EDITOR-8971). Hence
  * containment, and the leading change of what it covers.
  */
-const resolveActiveTarget = (surviving, activeIndexPos) => containedBy(surviving, activeIndexPos)[0];
+const resolveActiveTarget = (surviving, activeIndexPos) => containedBy(surviving, activeIndexPos).find(target => !fg('confluence_ncs_step_diffing_version_history') || !('attributionKey' in activeIndexPos) || target.decoration.spec.attributionKey === activeIndexPos.attributionKey);
 
 /**
  * One model per diff decoration whose attribution resolves to a supplied contributor; anything

package/dist/es2019/pm-plugins/getScrollableDecorations.js

@@ -77,15 +77,12 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
   let clusterTo = 0;
   const sortedDecorations = [...decorations].sort((a, b) => a.from === b.from ? a.to - b.to : a.from - b.from);
   sortedDecorations.forEach(decoration => {
-    var _openGroups$find;
     // A gap ends the run: nothing before it can be joined.
     if (decoration.from > clusterTo) {
       openGroups = [];
     }
     const contributor = contributorOf(decoration);
-    // An unattributed decoration names nobody to keep apart, so it joins whatever is open — a
-    // decision item's own highlight must not split the stop from the tag on its list.
-    const openGroup = (_openGroups$find = openGroups.find(group => group.contributor === contributor)) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(group => group.contributor === '');
+    const openGroup = openGroups.find(group => group.contributor === contributor);
     if (openGroup === undefined) {
       const group = {
         contributor,
@@ -96,8 +93,6 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
       groups.push(group);
       openGroups = [...openGroups, group];
     } else {
-      // The first contributor to join claims the group, so the next one still starts its own.
-      openGroup.contributor = openGroup.contributor || contributor;
       openGroup.decorations.push(decoration);
       openGroup.to = Math.max(openGroup.to, decoration.to);
     }

package/dist/es2019/pm-plugins/main.js

@@ -4,6 +4,7 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform-override';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { getActiveDiffAnnouncement } from '../ui/DiffNavigation/announceActiveDiff';
 import { calculateDiffDecorations } from './calculateDiff/calculateDiffDecorations';
 import { isDiffDecoration, isDiffDecorationSpec } from './decorations/decorationKeys';
@@ -174,7 +175,10 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
                 activeIndex: nextIndex,
                 activeIndexPos: activeDecoration ? {
                   from: activeDecoration.from,
-                  to: activeDecoration.to
+                  to: activeDecoration.to,
+                  ...(fg('confluence_ncs_step_diffing_version_history') ? {
+                    attributionKey: isDiffDecoration(activeDecoration) ? activeDecoration.spec.attributionKey : undefined
+                  } : {})
                 } : undefined
               };
               // Recalculate decorations with the new active index

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

@@ -120,19 +120,18 @@ var leafTextblockRanges = function leafTextblockRanges(doc, from, to) {
 // once it has more leaf textblocks (~cells) than this threshold. Small tables
 // keep the precise per-cell path.
 var LARGE_TABLE_LEAF_THRESHOLD = 40;
-
 /**
- * An active scrollable change may contain several underlying diff changes. Treat ranges that
- * overlap or touch the active range as part of the same active customer-facing edit.
+ * An active scrollable change may contain several underlying diff changes. With attribution, only
+ * ranges belonging to the selected contributor (including the anonymous contributor) are active.
  */
-var isRangeActive = function isRangeActive(activeIndexPos, from, to) {
+var isRangeActive = function isRangeActive(activeIndexPos, from, to, attributionKey) {
   if (activeIndexPos === undefined) {
     return undefined;
   }
   if (!fg('confluence_ncs_step_diffing_version_history')) {
     return from === activeIndexPos.from && to === activeIndexPos.to;
   }
-  return from <= activeIndexPos.to && activeIndexPos.from <= to;
+  return from <= activeIndexPos.to && activeIndexPos.from <= to && (!('attributionKey' in activeIndexPos) || activeIndexPos.attributionKey === attributionKey);
 };
 var isLargeInsertedTableRange = function isLargeInsertedTableRange(doc, from, to) {
   var containsTable = false;
@@ -207,7 +206,7 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
         if (!(node !== null && node !== void 0 && node.isBlock)) {
           continue;
         }
-        var isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+        var isActive = isRangeActive(activeIndexPos, pos, nodeEnd, attributionKey);
         decorations.push.apply(decorations, _toConsumableArray(createBlockChangedDecoration({
           attributionKey: attributionKey,
           change: {
@@ -251,7 +250,7 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
     }
     if (node.isBlock && (!requireContainedBlocks || pos >= from) && pos + node.nodeSize <= to) {
       var _nodeEnd = pos + node.nodeSize;
-      var _isActive = isRangeActive(activeIndexPos, pos, _nodeEnd);
+      var _isActive = isRangeActive(activeIndexPos, pos, _nodeEnd, attributionKey);
       decorations.push.apply(decorations, _toConsumableArray(createBlockChangedDecoration({
         attributionKey: attributionKey,
         change: {
@@ -535,7 +534,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     var leftAnchorId = fg('platform_editor_ai_show_diff_patch_2') ? "replacement-".concat(change.fromA, "-").concat(change.toA, "-").concat(change.fromB, "-").concat(change.toB) : undefined;
     var changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var attributionKey = showContributorTags ? getAttributionKeyForChange(change, attributedChanges) : undefined;
-    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
     var deletedColumns = change.deletedColumns;
     // 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.
@@ -772,7 +771,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     var _attributionColors$ge, _attributionColors;
     var 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;
     var attributionKey = showContributorTags ? change.attributionKey : undefined;
-    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
     decorations.push.apply(decorations, _toConsumableArray(createInlineChangedDecoration({
       attributionKey: attributionKey,
       change: change,
@@ -801,7 +800,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     var attributionKey = showContributorTags ? change.attributionKey : undefined;
     if (change.isInline) {
       // Inline nodes (e.g. date, emoji, mention, status) need an inline decoration rather than a block decoration
-      var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+      var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB, attributionKey);
       decorations.push.apply(decorations, _toConsumableArray(createInlineChangedDecoration({
         attributionKey: attributionKey,
         change: change,

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

@@ -6,7 +6,6 @@ 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 var CELL_CONTENT_OFFSET = 2;
-var IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
 var tablesIn = function tablesIn(doc) {
   var tables = [];
   doc.descendants(function (node, pos) {
@@ -56,41 +55,107 @@ var positionMatchedColumns = function positionMatchedColumns(_ref) {
   }
   return surviving;
 };
-var addContentMatchedColumns = function addContentMatchedColumns(surviving, before, after) {
-  var _before$node$firstChi, _before$node$firstChi2, _after$node$firstChil, _after$node$firstChil2;
-  var 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 : [];
-  var 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 : [];
-  var _iterator = _createForOfIteratorHelper(afterCells),
+var headerLocalIds = function headerLocalIds(table) {
+  var _table$node$firstChil, _table$node$firstChil2;
+  return ((_table$node$firstChil = (_table$node$firstChil2 = table.node.firstChild) === null || _table$node$firstChil2 === void 0 ? void 0 : _table$node$firstChil2.children) !== null && _table$node$firstChil !== void 0 ? _table$node$firstChil : []).map(function (cell) {
+    var _cell$attrs$localId;
+    return (_cell$attrs$localId = cell.attrs.localId) !== null && _cell$attrs$localId !== void 0 ? _cell$attrs$localId : undefined;
+  });
+};
+
+/**
+ * Cells keep their `localId` when a column is deleted, so the first row's ids name each remaining
+ * column even when the steps replaced the whole table. Missing or repeated ids, such as in content
+ * pasted from elsewhere, cannot name a column.
+ */
+var localIdMatchedColumns = function localIdMatchedColumns(before, after) {
+  var beforeIds = headerLocalIds(before);
+  if (beforeIds.some(function (id) {
+    return !id;
+  }) || new Set(beforeIds).size !== beforeIds.length) {
+    return undefined;
+  }
+  var surviving = new Set();
+  var previousColumn = -1;
+  var _iterator = _createForOfIteratorHelper(headerLocalIds(after)),
     _step;
   try {
-    var _loop = function _loop() {
-        var afterCell = _step.value;
-        var matches = beforeCells.flatMap(function (beforeCell, column) {
-          return areNodesEqualIgnoreAttrs(beforeCell, afterCell, IGNORED_CELL_ATTRS) ? [column] : [];
-        });
-        if (matches.length !== 1) {
-          return {
-            v: false
-          };
-        }
-        surviving.add(matches[0]);
-      },
-      _ret;
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      _ret = _loop();
-      if (_ret) return _ret.v;
+      var id = _step.value;
+      var column = id ? beforeIds.indexOf(id) : -1;
+      if (column <= previousColumn) {
+        return undefined;
+      }
+      surviving.add(column);
+      previousColumn = column;
     }
   } catch (err) {
     _iterator.e(err);
   } finally {
     _iterator.f();
   }
-  var ordered = _toConsumableArray(surviving);
-  return !ordered.some(function (column, index) {
-    return index > 0 && column <= ordered[index - 1];
+  return surviving;
+};
+var IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
+
+/** Rows may also have been deleted, so the remaining cells only need to appear in order. */
+var isColumnKept = function isColumnKept(before, beforeColumn, after, afterColumn) {
+  var beforeRow = 0;
+  return after.node.children.every(function (afterRow) {
+    var afterCell = afterRow.maybeChild(afterColumn);
+    while (beforeRow < before.node.childCount) {
+      var beforeCell = before.node.child(beforeRow++).maybeChild(beforeColumn);
+      if (afterCell && beforeCell && areNodesEqualIgnoreAttrs(beforeCell, afterCell, IGNORED_CELL_ATTRS)) {
+        return true;
+      }
+    }
+    return false;
   });
 };
+
+/**
+ * Pairs each remaining column with an equal original column, keeping their order, and takes each
+ * pair from the `direction` end first. Returns the original column of each remaining column.
+ */
+var pairColumnsInOrder = function pairColumnsInOrder(beforeWidth, afterWidth, isMatch, direction) {
+  var step = direction === 'left' ? 1 : -1;
+  var pairing = [];
+  var beforeColumn = direction === 'left' ? 0 : beforeWidth - 1;
+  var afterColumn = direction === 'left' ? 0 : afterWidth - 1;
+  for (; afterColumn >= 0 && afterColumn < afterWidth; afterColumn += step) {
+    while (beforeColumn >= 0 && beforeColumn < beforeWidth && !isMatch(beforeColumn, afterColumn)) {
+      beforeColumn += step;
+    }
+    if (beforeColumn < 0 || beforeColumn >= beforeWidth) {
+      return undefined;
+    }
+    pairing.push(beforeColumn);
+    beforeColumn += step;
+  }
+  return direction === 'left' ? pairing : pairing.reverse();
+};
+
+/**
+ * For tables whose cells have no usable ids, such as content created before cells had ids. Every
+ * valid pairing of remaining columns to original ones lies between the leftmost and the rightmost
+ * pairing, so the columns are only reported when those two agree. Otherwise, such as when several
+ * original columns are identical, which of them were removed cannot be known.
+ */
+var uniquelyContentMatchedColumns = function uniquelyContentMatchedColumns(before, after, beforeWidth, afterWidth) {
+  var isMatch = function isMatch(beforeColumn, afterColumn) {
+    return isColumnKept(before, beforeColumn, after, afterColumn);
+  };
+  var leftmost = pairColumnsInOrder(beforeWidth, afterWidth, isMatch, 'left');
+  var rightmost = pairColumnsInOrder(beforeWidth, afterWidth, isMatch, 'right');
+  if (!leftmost || !rightmost || leftmost.some(function (column, index) {
+    return column !== rightmost[index];
+  })) {
+    return undefined;
+  }
+  return new Set(leftmost);
+};
 var findDeletedColumns = function findDeletedColumns(before, after, afterToBefore) {
+  var _localIdMatchedColumn;
   var beforeMap = TableMap.get(before.node);
   var afterMap = TableMap.get(after.node);
   // Merged or malformed tables do not have reliable column indices.
@@ -98,13 +163,14 @@ var findDeletedColumns = function findDeletedColumns(before, after, afterToBefor
     return [];
   }
   var beforeOffsets = columnOffsets(beforeMap, before.node);
-  var surviving = positionMatchedColumns({
+  var positionMatched = positionMatchedColumns({
     before: before,
     after: after,
     afterToBefore: afterToBefore,
     beforeOffsets: beforeOffsets
   });
-  if (surviving.size !== afterMap.width && !addContentMatchedColumns(surviving, before, after)) {
+  var surviving = positionMatched.size === afterMap.width ? positionMatched : (_localIdMatchedColumn = localIdMatchedColumns(before, after)) !== null && _localIdMatchedColumn !== void 0 ? _localIdMatchedColumn : uniquelyContentMatchedColumns(before, after, beforeMap.width, afterMap.width);
+  if (!surviving) {
     return [];
   }
   return beforeOffsets.flatMap(function (_, column) {