@atlaskit/editor-plugin-show-diff 12.1.2 → 12.1.4

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

@@ -0,0 +1,70 @@
+/**
+ * Attribute-aware token encoder for `prosemirror-changeset`.
+ *
+ * The library's default encoder reduces a node's open token to `node.type.name`,
+ * ignoring attributes. An attribute-only change (e.g. recolouring a table cell's
+ * `background`) therefore tokenises identically on both sides and reports no
+ * change at all.
+ *
+ * This encoder folds an allow-listed set of attributes into the open token so
+ * such changes register. Everything else encodes exactly as the default. The
+ * allow-list is deliberately narrow — folding in ephemeral attrs like `localId`
+ * would produce phantom diffs.
+ */
+
+var DIFFED_ATTRS_BY_NODE_TYPE = {
+  tableCell: ['background', 'colspan', 'rowspan'],
+  tableHeader: ['background', 'colspan', 'rowspan']
+};
+
+/**
+ * Builds a stable composite token. Iterates the allow-list rather than
+ * `Object.keys` so ordering is deterministic for string comparison.
+ */
+var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
+  var _node$attrs;
+  var attrs = (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 ? _node$attrs : {};
+  // Deterministic order: iterate the allow-list, not `Object.keys(attrs)`.
+  var parts = attrNames.map(function (name) {
+    var _attrs$name;
+    return "".concat(name, "=").concat(JSON.stringify((_attrs$name = attrs[name]) !== null && _attrs$name !== void 0 ? _attrs$name : null));
+  });
+  return "".concat(node.type.name, "|").concat(parts.join('|'));
+};
+
+/**
+ * Identical to the library default except that allow-listed node types encode
+ * their allow-listed attributes into the open token. Characters and node-end
+ * tokens are left as-is, hence the `string | number` token type.
+ */
+export var attrAwareTokenEncoder = {
+  encodeCharacter: function encodeCharacter(char, _marks) {
+    return char;
+  },
+  encodeNodeStart: function encodeNodeStart(node) {
+    var attrNames = DIFFED_ATTRS_BY_NODE_TYPE[node.type.name];
+    if (attrNames) {
+      return encodeNodeWithAttrs(node, attrNames);
+    }
+    return node.type.name;
+  },
+  encodeNodeEnd: function encodeNodeEnd(node) {
+    return -typeID(node.type);
+  },
+  compareTokens: function compareTokens(a, b) {
+    return a === b;
+  }
+};
+
+/**
+ * Mirrors the library's private `typeID` so node-end tokens match the default
+ * encoding exactly. Reimplemented here because it is not exported.
+ */
+function typeID(type) {
+  var cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  var id = cache[type.name];
+  if (id == null) {
+    cache[type.name] = id = Object.keys(type.schema.nodes).indexOf(type.name) + 1;
+  }
+  return id;
+}

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

@@ -18,14 +18,14 @@ import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { areDocsEqualByBlockStructureAndText } from '../areDocsEqualByBlockStructureAndText';
 import { createDocMarginAnchorWidget } from '../decorations/createAnchorDecorationWidgets';
 import { createBlockChangedDecoration } from '../decorations/createBlockChangedDecoration';
-import { createGranularBlockReferenceWidget } from '../decorations/createGranularBlockReferenceWidget';
 import { createInlineChangedDecoration } from '../decorations/createInlineChangedDecoration';
 import { createNodeChangedDecorationWidget } from '../decorations/createNodeChangedDecorationWidget';
 import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { isExtendedEnabled } from '../isExtendedEnabled';
-import { diffBySteps, getStepChanges } from './diffBySteps';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
+import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
 import { simplifySteps } from './simplifySteps';
@@ -232,7 +232,11 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       };
     }
   }
-  var changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, tr.doc);
+  // The attribute-aware encoder is only needed by the smart classifier and is
+  // gated with it; other diff types keep the library default so their output is
+  // unchanged.
+  var tokenEncoder = diffType === 'smart' && fg('platform_editor_ai_smart_diff') ? attrAwareTokenEncoder : undefined;
+  var changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, tr.doc);
   var changes = getChanges({
     changeset: changeset,
     originalDoc: originalDoc,
@@ -254,7 +258,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
 
   // Our default operations are insertions, so it should match the opposite of isInverted.
   var isInserted = !isInverted;
-  var createDecorationsForChange = function createDecorationsForChange(change, showGranularWithBlock) {
+  var createDecorationsForChange = function createDecorationsForChange(change) {
     var isActive = activeIndexPos && change.fromB === activeIndexPos.from && change.toB === activeIndexPos.to;
 
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
@@ -266,10 +270,8 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       inlineDeletedDiffPlacement: inlineDeletedDiffPlacement
     });
     if (change.inserted.length > 0) {
-      // shouldHideDeleted for block/node decorations: suppressed when isInverted + hideDeletedDiffs,
-      // or when showGranularWithBlock (block reference widget is shown instead).
-      // isInverted gates both — on an inverted diff the inserted side is visually the deleted side.
-      var shouldHideDeleted = isExtendedEnabled(diffType) ? isInverted && (hideDeletedDiffs || showGranularWithBlock && change.deleted.length > 0) : false;
+      // On an inverted diff the inserted side is visually the deleted side.
+      var shouldHideDeleted = isExtendedEnabled(diffType) ? isInverted && hideDeletedDiffs : false;
 
       // 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
@@ -286,7 +288,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       // change. Used to decide if indicator anchor positions should be adjusted
       // inward — when the widget is present the anchor must stay at the block
       // boundary to keep the indicator bar continuous with the deleted content.
-      var willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && (hideDeletedDiffs || showGranularWithBlock) && change.inserted.length > 0);
+      var willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
       if (isSmartNodeLevel) {
         var _iterator2 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
           _step2;
@@ -350,7 +352,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       }))));
     }
     if (change.deleted.length > 0) {
-      var _shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && (hideDeletedDiffs || showGranularWithBlock) && change.inserted.length > 0 : false;
+      var _shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, _toConsumableArray(createNodeChangedDecorationWidget(_objectSpread(_objectSpread({
           change: change,
@@ -371,88 +373,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
       }
     }
   };
-  if (diffType === 'step' && expValEquals('platform_editor_diff_granular_extended', 'isEnabled', true)) {
-    // Uses getStepChanges instead of getChanges so that we have per-step granularity metadata.
-    // Specifically, we need to know how many granular changes each step produced in order to
-    // apply the shouldHideDeleted suppression threshold (> 3 granular changes per step).
-    // getChanges returns a flat Change[] with no per-step grouping, making this count impossible
-    // to derive after the fact without re-introducing per-change metadata.
-    var stepChanges = getStepChanges(originalDoc, steps);
-    stepChanges.forEach(function (_ref5) {
-      var isGranular = _ref5.isGranular,
-        stepChangeList = _ref5.changes;
-      var granularCount = isGranular ? stepChangeList.length : 0;
-
-      // Calculate the average ratio of changed content on both A (original) and B (new)
-      // sides of the diff. If 30% or more of the block has changed on average, we show
-      // the block reference widget even if the granular change count is below the threshold.
-      // Block length is derived from the enclosing text block boundaries rather than the
-      // first/last change positions, so unchanged words at the start/end are accounted for.
-      var avgChangedRatio = 0;
-      if (isGranular && stepChangeList.length > 0) {
-        var first = stepChangeList[0];
-        var last = stepChangeList[stepChangeList.length - 1];
-        var resolvedA = originalDoc.resolve(first.fromA);
-        var resolvedB = tr.doc.resolve(first.fromB);
-        var blockStartA = first.fromA;
-        var blockEndA = last.toA;
-        var blockStartB = first.fromB;
-        var blockEndB = last.toB;
-        for (var depth = resolvedA.depth; depth >= 0; depth--) {
-          var node = resolvedA.node(depth);
-          if (node.isTextblock) {
-            blockStartA = resolvedA.start(depth);
-            blockEndA = blockStartA + node.nodeSize - 2; // exclude open/close tokens
-            break;
-          }
-        }
-        for (var _depth = resolvedB.depth; _depth >= 0; _depth--) {
-          var _node = resolvedB.node(_depth);
-          if (_node.isTextblock) {
-            blockStartB = resolvedB.start(_depth);
-            blockEndB = blockStartB + _node.nodeSize - 2; // exclude open/close tokens
-            break;
-          }
-        }
-        var blockLengthA = blockEndA - blockStartA;
-        var blockLengthB = blockEndB - blockStartB;
-        var totalChangedA = stepChangeList.reduce(function (sum, c) {
-          return sum + (c.toA - c.fromA);
-        }, 0);
-        var totalChangedB = stepChangeList.reduce(function (sum, c) {
-          return sum + (c.toB - c.fromB);
-        }, 0);
-        var ratioA = blockLengthA > 0 ? totalChangedA / blockLengthA : 0;
-        var ratioB = blockLengthB > 0 ? totalChangedB / blockLengthB : 0;
-        avgChangedRatio = (ratioA + ratioB) / 2;
-      }
-      var showGranularWithBlock = isGranular && granularCount !== 1 && (granularCount > 3 || avgChangedRatio >= 0.3);
-      stepChangeList.forEach(function (change) {
-        createDecorationsForChange(change, showGranularWithBlock);
-      });
-      if (showGranularWithBlock && stepChangeList.length > 0 && !hideDeletedDiffs) {
-        var lastChange = stepChangeList[stepChangeList.length - 1];
-        var granularBlockDiffId = crypto.randomUUID();
-        var blockWidgets = createGranularBlockReferenceWidget({
-          change: lastChange,
-          originalDoc: originalDoc,
-          newDoc: tr.doc,
-          isInverted: isInverted,
-          nodeViewSerializer: nodeViewSerializer,
-          colorScheme: colorScheme,
-          intl: intl,
-          activeIndexPos: activeIndexPos,
-          diffId: granularBlockDiffId,
-          showIndicators: showIndicators
-        });
-        decorations.push.apply(decorations, _toConsumableArray(blockWidgets));
-      }
-    });
-  } else {
-    changes.forEach(function (change) {
-      createDecorationsForChange(change, /* showGranularWithBlock */false);
-    });
-  }
+  changes.forEach(function (change) {
+    createDecorationsForChange(change);
+  });
   getMarkChangeRanges(steps).forEach(function (change) {
     var isActive = activeIndexPos && change.fromB === activeIndexPos.from && change.toB === activeIndexPos.to;
     decorations.push.apply(decorations, _toConsumableArray(createInlineChangedDecoration({
@@ -524,42 +447,42 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref4
 };
 export var calculateDiffDecorations = memoizeOne(calculateDiffDecorationsInner,
 // Cache results unless relevant inputs change
-function (_ref6, _ref7) {
-  var _ref1;
+function (_ref5, _ref6) {
+  var _ref0;
+  var _ref7 = _slicedToArray(_ref5, 1),
+    _ref7$ = _ref7[0],
+    pluginState = _ref7$.pluginState,
+    state = _ref7$.state,
+    colorScheme = _ref7$.colorScheme,
+    intl = _ref7$.intl,
+    activeIndexPos = _ref7$.activeIndexPos,
+    isInverted = _ref7$.isInverted,
+    diffType = _ref7$.diffType,
+    hideDeletedDiffs = _ref7$.hideDeletedDiffs,
+    hideAddedDiffsUnderline = _ref7$.hideAddedDiffsUnderline,
+    showIndicators = _ref7$.showIndicators,
+    smartThresholds = _ref7$.smartThresholds,
+    deletedDiffPlacement = _ref7$.deletedDiffPlacement,
+    inlineDeletedDiffPlacement = _ref7$.inlineDeletedDiffPlacement;
   var _ref8 = _slicedToArray(_ref6, 1),
     _ref8$ = _ref8[0],
-    pluginState = _ref8$.pluginState,
-    state = _ref8$.state,
-    colorScheme = _ref8$.colorScheme,
-    intl = _ref8$.intl,
-    activeIndexPos = _ref8$.activeIndexPos,
-    isInverted = _ref8$.isInverted,
-    diffType = _ref8$.diffType,
-    hideDeletedDiffs = _ref8$.hideDeletedDiffs,
-    hideAddedDiffsUnderline = _ref8$.hideAddedDiffsUnderline,
-    showIndicators = _ref8$.showIndicators,
-    smartThresholds = _ref8$.smartThresholds,
-    deletedDiffPlacement = _ref8$.deletedDiffPlacement,
-    inlineDeletedDiffPlacement = _ref8$.inlineDeletedDiffPlacement;
-  var _ref9 = _slicedToArray(_ref7, 1),
-    _ref9$ = _ref9[0],
-    lastPluginState = _ref9$.pluginState,
-    lastState = _ref9$.state,
-    lastColorScheme = _ref9$.colorScheme,
-    lastIntl = _ref9$.intl,
-    lastActiveIndexPos = _ref9$.activeIndexPos,
-    lastIsInverted = _ref9$.isInverted,
-    lastDiffType = _ref9$.diffType,
-    lastHideDeletedDiffs = _ref9$.hideDeletedDiffs,
-    lastHideAddedDiffsUnderline = _ref9$.hideAddedDiffsUnderline,
-    lastShowIndicators = _ref9$.showIndicators,
-    lastSmartThresholds = _ref9$.smartThresholds,
-    lastDeletedDiffPlacement = _ref9$.deletedDiffPlacement,
-    lastInlineDeletedDiffPlacement = _ref9$.inlineDeletedDiffPlacement;
+    lastPluginState = _ref8$.pluginState,
+    lastState = _ref8$.state,
+    lastColorScheme = _ref8$.colorScheme,
+    lastIntl = _ref8$.intl,
+    lastActiveIndexPos = _ref8$.activeIndexPos,
+    lastIsInverted = _ref8$.isInverted,
+    lastDiffType = _ref8$.diffType,
+    lastHideDeletedDiffs = _ref8$.hideDeletedDiffs,
+    lastHideAddedDiffsUnderline = _ref8$.hideAddedDiffsUnderline,
+    lastShowIndicators = _ref8$.showIndicators,
+    lastSmartThresholds = _ref8$.smartThresholds,
+    lastDeletedDiffPlacement = _ref8$.deletedDiffPlacement,
+    lastInlineDeletedDiffPlacement = _ref8$.inlineDeletedDiffPlacement;
   var originalDocIsSame = lastPluginState.originalDoc && pluginState.originalDoc && pluginState.originalDoc.eq(lastPluginState.originalDoc);
   if (isExtendedEnabled(diffType)) {
-    var _ref0;
-    return (_ref0 = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement) !== null && _ref0 !== void 0 ? _ref0 : false;
+    var _ref9;
+    return (_ref9 = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement) !== null && _ref9 !== void 0 ? _ref9 : false;
   }
-  return (_ref1 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref1 !== void 0 ? _ref1 : false;
+  return (_ref0 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref0 !== void 0 ? _ref0 : false;
 });

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

@@ -17,6 +17,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * reconstructed by applying the (simplified) steps to `originalDoc`.
  */
 import { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
@@ -75,7 +76,13 @@ export var computeDiffChanges = function computeDiffChanges(_ref) {
       newDoc: originalDoc
     };
   }
-  var changeset = ChangeSet.create(originalDoc).addSteps(steppedDoc, stepMaps, steppedDoc);
+
+  // The attribute-aware encoder only affects the `smart` classification, so it is
+  // applied only for that type. (This utility intentionally applies no feature
+  // gate — see the file docstring — but a caller requesting `smart` is already
+  // behind the smart-diff gate.)
+  var tokenEncoder = diffType === 'smart' ? attrAwareTokenEncoder : undefined;
+  var changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {
       changes: classifySmartChanges({

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

@@ -8,6 +8,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 import { simplifyChanges, ChangeSet } from 'prosemirror-changeset';
 import { Mark } from '@atlaskit/editor-prosemirror/model';
 import { Mapping, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { optimizeChanges } from './optimizeChanges';
 
 // @ts-ignore TS1501: This regular expression flag is only available when targeting 'es6' or later.
@@ -322,7 +323,7 @@ export var diffBySteps = function diffBySteps(originalDoc, steps) {
     var fromB = mapPosition(afterStepToFinal, fromAfterStep);
     var toB = mapPosition(afterStepToFinal, toAfterStep);
     if (shouldCheckGranularDiff(rangedStep.step, rangedStep.before, rangedStep.from, rangedStep.to)) {
-      var granularStepChanges = ChangeSet.create(rangedStep.before).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
+      var granularStepChanges = ChangeSet.create(rangedStep.before, undefined, attrAwareTokenEncoder).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
 
       // `simplifyChanges` reads text using `Change.fromB`/`toB`, which are
       // positions in the post-step doc (the "B" doc). Passing the pre-step
@@ -401,127 +402,4 @@ export var diffBySteps = function diffBySteps(originalDoc, steps) {
     });
   }
   return mergeOverlappingByNewDocRange(changes);
-};
-
-/**
- * A fork of `diffBySteps` that returns changes grouped per step, rather than as a flat list.
- *
- * Why forked rather than refactoring `diffBySteps`:
- * - `diffBySteps` returns a flat `Change[]` and is consumed by the existing decoration path.
- *   Changing its return shape would require threading per-step metadata through all callers,
- *   adding complexity to a stable code path.
- * - The per-step grouping is only needed for the `platform_editor_diff_granular_extended` gate,
- *   where we need to know how many granular changes a single step produced in order to decide
- *   whether to suppress deleted decorations (threshold: > 3 granular changes per step).
- * - Keeping the two functions separate means each has a clear, focused contract and neither
- *   accumulates the other's concerns. Shared logic (mapping helpers, `mergeOverlappingByNewDocRange`,
- *   `shouldCheckGranularDiff`, etc.) is already extracted and reused by both.
- */
-export var getStepChanges = function getStepChanges(originalDoc, steps) {
-  var result = [];
-  var currentDoc = originalDoc;
-  var successfulStepMaps = [];
-  var rangedSteps = [];
-  var _iterator4 = _createForOfIteratorHelper(steps),
-    _step4;
-  try {
-    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-      var step = _step4.value;
-      var before = currentDoc;
-      var stepResult = step.apply(currentDoc);
-      if (stepResult.failed !== null || !stepResult.doc) {
-        continue;
-      }
-      var stepMap = step.getMap();
-      var rangeStep = step;
-      if (typeof rangeStep.from === 'number' && typeof rangeStep.to === 'number') {
-        rangedSteps.push({
-          before: before,
-          doc: stepResult.doc,
-          from: rangeStep.from,
-          to: rangeStep.to,
-          mapIndex: successfulStepMaps.length,
-          step: step,
-          stepMap: stepMap
-        });
-      }
-      successfulStepMaps.push(stepMap);
-      currentDoc = stepResult.doc;
-    }
-  } catch (err) {
-    _iterator4.e(err);
-  } finally {
-    _iterator4.f();
-  }
-  for (var _i2 = 0, _rangedSteps2 = rangedSteps; _i2 < _rangedSteps2.length; _i2++) {
-    var rangedStep = _rangedSteps2[_i2];
-    var originalToBeforeStep = createMapping(successfulStepMaps.slice(0, rangedStep.mapIndex));
-    var beforeStepToOriginal = originalToBeforeStep.invert();
-    var fromA = mapPosition(beforeStepToOriginal, rangedStep.from);
-    var toA = mapPosition(beforeStepToOriginal, rangedStep.to);
-    var fromAfterStep = rangedStep.stepMap.map(rangedStep.from, -1);
-    var toAfterStep = rangedStep.stepMap.map(rangedStep.to, 1);
-    var afterStepToFinal = createMapping(successfulStepMaps.slice(rangedStep.mapIndex + 1));
-    var fromB = mapPosition(afterStepToFinal, fromAfterStep);
-    var toB = mapPosition(afterStepToFinal, toAfterStep);
-    if (shouldCheckGranularDiff(rangedStep.step, rangedStep.before, rangedStep.from, rangedStep.to)) {
-      var granularStepChanges = ChangeSet.create(rangedStep.before).addSteps(rangedStep.doc, [rangedStep.stepMap], null);
-      var optimizedGranularStepChanges = optimizeChanges(simplifyChanges(granularStepChanges.changes, rangedStep.doc));
-      var stepChanges = [];
-      var _iterator5 = _createForOfIteratorHelper(optimizedGranularStepChanges),
-        _step5;
-      try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var granularChange = _step5.value;
-          var expandedA = expandToWordBoundaries(rangedStep.before, granularChange.fromA, granularChange.toA);
-          var expandedB = expandToWordBoundaries(rangedStep.doc, granularChange.fromB, granularChange.toB);
-          var aLeftDelta = granularChange.fromA - expandedA.from;
-          var aRightDelta = expandedA.to - granularChange.toA;
-          var bLeftDelta = granularChange.fromB - expandedB.from;
-          var bRightDelta = expandedB.to - granularChange.toB;
-          var finalA = expandedA;
-          var finalB = expandedB;
-          if (aLeftDelta > bLeftDelta || aRightDelta > bRightDelta) {
-            var extraLeft = Math.max(0, aLeftDelta - bLeftDelta);
-            var extraRight = Math.max(0, aRightDelta - bRightDelta);
-            finalB = expandToWordBoundaries(rangedStep.doc, Math.max(expandedB.from - extraLeft, 0), expandedB.to + extraRight);
-          }
-          if (bLeftDelta > aLeftDelta || bRightDelta > aRightDelta) {
-            var _extraLeft2 = Math.max(0, bLeftDelta - aLeftDelta);
-            var _extraRight2 = Math.max(0, bRightDelta - aRightDelta);
-            finalA = expandToWordBoundaries(rangedStep.before, Math.max(expandedA.from - _extraLeft2, 0), expandedA.to + _extraRight2);
-          }
-          stepChanges.push({
-            fromA: mapPosition(beforeStepToOriginal, finalA.from),
-            toA: mapPosition(beforeStepToOriginal, finalA.to),
-            fromB: mapPosition(afterStepToFinal, finalB.from),
-            toB: mapPosition(afterStepToFinal, finalB.to),
-            deleted: createSpans(Math.max(0, finalA.to - finalA.from)),
-            inserted: createSpans(Math.max(0, finalB.to - finalB.from))
-          });
-        }
-      } catch (err) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
-      }
-      result.push({
-        isGranular: true,
-        changes: mergeOverlappingByNewDocRange(stepChanges)
-      });
-      continue;
-    }
-    result.push({
-      isGranular: false,
-      changes: [{
-        fromA: fromA,
-        toA: toA,
-        fromB: fromB,
-        toB: toB,
-        deleted: createSpans(Math.max(0, toA - fromA)),
-        inserted: createSpans(Math.max(0, toB - fromB))
-      }]
-    });
-  }
-  return result;
 };

package/dist/esm/pm-plugins/calculateDiff/smart/classifySmartChanges.js

@@ -765,6 +765,15 @@ var _classifyChild = function classifyChild(childA, childB, changes, originalDoc
     var childrenB = childRefs(blockB);
     var childrenA = wrapperA ? childRefs(wrapperA) : [];
     var out = [];
+
+    // An attribute-only change on the wrapper itself (e.g. a table cell's
+    // `background`) sits on the node boundary, not inside any inner child, so the
+    // recursion below would emit nothing and the change would be dropped. Emit a
+    // whole-wrapper change instead, which also subsumes any inner content change.
+    if (wrapperA && !wrapperA.node.sameMarkup(blockB.node)) {
+      out.push(makePromotedChange(wrapperA.from, wrapperA.to, blockB.from, blockB.to, 'node'));
+      return out;
+    }
     // LCS-align inner children (mirrors classifyContainer) so a paragraph inserted/deleted
     // inside the cell/column does not mis-pair every subsequent inner child by index. We never
     // promote the wrapper itself here — we only classify each inner child.