@atlaskit/editor-plugin-show-diff 16.1.0 → 16.2.0

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

@@ -190,8 +190,51 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
     diffType = _ref5.diffType,
     _ref5$coarseTableCell = _ref5.coarseTableCellsOnly,
     coarseTableCellsOnly = _ref5$coarseTableCell === void 0 ? false : _ref5$coarseTableCell,
-    tagMountContext = _ref5.tagMountContext;
+    tagMountContext = _ref5.tagMountContext,
+    nodeRanges = _ref5.nodeRanges;
   var decorations = [];
+
+  // Exact-nodes path: only reached for a split change (EDITOR-8932), which names the nodes it
+  // owns. Deliberately kept separate from the walk below rather than sharing it.
+  if (nodeRanges) {
+    var _iterator = _createForOfIteratorHelper(nodeRanges),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _step.value,
+          pos = _step$value.from,
+          nodeEnd = _step$value.to;
+        var node = doc.nodeAt(pos);
+        if (!(node !== null && node !== void 0 && node.isBlock)) {
+          continue;
+        }
+        var isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+        decorations.push.apply(decorations, _toConsumableArray(createBlockChangedDecoration({
+          attributionKey: attributionKey,
+          change: {
+            from: pos,
+            to: nodeEnd,
+            name: node.type.name
+          },
+          colorScheme: colorScheme,
+          isInserted: isInserted,
+          isActive: isActive,
+          shouldHideDeleted: shouldHideDeleted,
+          showContributorTags: showContributorTags,
+          showIndicators: showIndicators,
+          doc: doc,
+          diffType: diffType,
+          tagMountContext: tagMountContext
+        })));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return decorations;
+  }
+
   // Coarse path: inside the large table, only cell/header overlays are kept — the
   // table/row/paragraph decorations there are redundant and cause expensive per-cell
   // re-render. Blocks outside the table keep their normal decorations.
@@ -205,18 +248,18 @@ var calculateNodesForBlockDecoration = function calculateNodesForBlockDecoration
       }
     }
     if (node.isBlock && (!isExtendedEnabled(diffType) || pos + node.nodeSize <= to)) {
-      var nodeEnd = pos + node.nodeSize;
-      var isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+      var _nodeEnd = pos + node.nodeSize;
+      var _isActive = isRangeActive(activeIndexPos, pos, _nodeEnd);
       decorations.push.apply(decorations, _toConsumableArray(createBlockChangedDecoration({
         attributionKey: attributionKey,
         change: {
           from: pos,
-          to: nodeEnd,
+          to: _nodeEnd,
           name: node.type.name
         },
         colorScheme: colorScheme,
         isInserted: isInserted,
-        isActive: isActive,
+        isActive: _isActive,
         shouldHideDeleted: shouldHideDeleted,
         showContributorTags: showContributorTags,
         showIndicators: showIndicators,
@@ -339,13 +382,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
   }
   var pendingAttrSteps = [];
   var stepMaps = [];
-  var _iterator = _createForOfIteratorHelper(simplifiedSteps.entries()),
-    _step;
+  var _iterator2 = _createForOfIteratorHelper(simplifiedSteps.entries()),
+    _step2;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        stepIndex = _step$value[0],
-        step = _step$value[1];
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _slicedToArray(_step2.value, 2),
+        stepIndex = _step2$value[0],
+        step = _step2$value[1];
       var result = step.apply(steppedDoc);
       if (result.failed === null && result.doc) {
         if (stepIsValidAttrChange(step, steppedDoc, result.doc)) {
@@ -364,9 +407,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
     // Gate the complete attribution fix: mapped positions and step-time nodes are used together.
     // The fallback deliberately preserves the legacy raw-position lookups for rollout safety.
   } catch (err) {
-    _iterator.e(err);
+    _iterator2.e(err);
   } finally {
-    _iterator.f();
+    _iterator2.f();
   }
   var attrStepContexts = fg('platform_editor_reduce_diff_attr_sensitivity') ? pendingAttrSteps.flatMap(function (_ref1) {
     var afterNode = _ref1.afterNode,
@@ -454,7 +497,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       tr: tr,
       attributedChanges: attributedChanges
     });
-    changes = collapseOverlappingChanges(uncollapsedChanges);
+    changes = collapseOverlappingChanges(uncollapsedChanges, tr.doc);
 
     // Still colours-only: a tags-only diff keeps the plain colour scheme.
     if (attributionColoringEnabled) {
@@ -551,13 +594,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
         // table (the cell overlays added below provide the highlight without the
         // expensive content re-render); leaf blocks outside the table still get theirs.
         var coarseTables = useCoarseTableDecoration ? tableRanges(tr.doc, change.fromB, change.toB) : [];
-        var _iterator2 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
-          _step2;
+        var _iterator3 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
+          _step3;
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var _step2$value = _slicedToArray(_step2.value, 2),
-              from = _step2$value[0],
-              to = _step2$value[1];
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _step3$value = _slicedToArray(_step3.value, 2),
+              from = _step3$value[0],
+              to = _step3$value[1];
             if (useCoarseTableDecoration && isInsideTable(coarseTables, from)) {
               continue;
             }
@@ -584,9 +627,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
             }))));
           }
         } catch (err) {
-          _iterator2.e(err);
+          _iterator3.e(err);
         } finally {
-          _iterator2.f();
+          _iterator3.f();
         }
       } else {
         decorations.push.apply(decorations, _toConsumableArray(createInlineChangedDecoration(_objectSpread({
@@ -613,6 +656,8 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
         doc: tr.doc,
         from: change.fromB,
         to: change.toB,
+        // A split piece's own range no longer covers the container it opened (EDITOR-8932).
+        nodeRanges: change.blockNodeRangesB,
         colorScheme: changeColorScheme
       }, isExtendedEnabled(diffType) && {
         isInserted: isInserted,

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

@@ -1,13 +1,20 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { simplifyChanges } from 'prosemirror-changeset';
 import { getAttributionKey } from '../decorations/colorSchemes/attributions';
 import { optimizeChanges } from './optimizeChanges';
+
+/**
+ * A change, plus the block nodes it owns when it is one piece of a split — a piece's own range no
+ * longer covers the container it opened. Absent on an unsplit change, which decorates the blocks
+ * inside its own range as before.
+ */
+
 var getAttributionIdentity = function getAttributionIdentity(change) {
   var identities = new Set();
   for (var _i = 0, _arr = [].concat(_toConsumableArray(change.deleted), _toConsumableArray(change.inserted)); _i < _arr.length; _i++) {
@@ -29,55 +36,265 @@ var byNewDocRange = function byNewDocRange(left, right) {
   return left.fromB - right.fromB || left.toB - right.toB;
 };
 
+/** Union of the given ranges, with overlapping and touching ones merged. */
+var mergeRanges = function mergeRanges(ranges) {
+  return _toConsumableArray(ranges).sort(function (left, right) {
+    return left.from - right.from;
+  }).reduce(function (merged, range) {
+    var last = merged[merged.length - 1];
+    if (last && range.from <= last.to) {
+      last.to = Math.max(last.to, range.to);
+      return merged;
+    }
+    return [].concat(_toConsumableArray(merged), [_objectSpread({}, range)]);
+  }, []);
+};
+
+/** Whether `inner` sits wholly inside `outer` and covers less of the document. */
+var isContained = function isContained(outer, inner) {
+  return inner.toB > inner.fromB && outer.fromB <= inner.fromB && inner.toB <= outer.toB && inner.toB - inner.fromB < outer.toB - outer.fromB;
+};
+
 /**
- * Collapses changes whose new-document ranges strictly overlap. Attribution runs are simplified
- * independently, so runs either side of an unattributed step can come back covering the same
- * 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.
+ * The block nodes in `change` whose opening position `ownsPosition` claims. Ownership is by opening
+ * position so a block another contributor added inside a container is not claimed by whoever opened
+ * the container. `undefined` for a range this document cannot resolve, which falls the piece back
+ * to decorating its own range.
  */
-export var collapseOverlappingChanges = function collapseOverlappingChanges(changes) {
-  if (changes.length <= 1) {
-    return changes;
+var blockNodeRanges = function blockNodeRanges(doc, change, ownsPosition) {
+  if (!doc || change.from >= change.to || change.to > doc.content.size) {
+    return undefined;
   }
+  var ranges = [];
+  doc.nodesBetween(change.from, change.to, function (node, pos) {
+    if (node.isBlock && ownsPosition(pos) && pos + node.nodeSize <= change.to) {
+      ranges.push({
+        from: pos,
+        to: pos + node.nodeSize
+      });
+    }
+    return true;
+  });
+  return ranges;
+};
+
+/**
+ * Splits a change whose spans name more than one contributor into one change per run of consecutive
+ * spans sharing a key.
+ *
+ * `prosemirror-changeset` merges contiguous inserted content into one change while keeping per-span
+ * data, so a panel inserted by one contributor and edited inside by another arrives as a single
+ * change holding every span — and the latest-writer rule credited all of it, panel included, to
+ * whoever wrote last (EDITOR-8932).
+ */
+var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc) {
+  return changes.flatMap(function (change) {
+    if (getAttributionIdentity(change).mergeable) {
+      return [change];
+    }
+    var runs = [];
+    var offset = change.fromB;
+    var _iterator = _createForOfIteratorHelper(change.inserted),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var span = _step.value;
+        var key = getAttributionKey(span.data);
+        var last = runs[runs.length - 1];
+        if (last && last.key === key) {
+          last.to = offset + span.length;
+          last.spans.push(span);
+        } else {
+          runs.push({
+            key: key,
+            from: offset,
+            to: offset + span.length,
+            spans: [span]
+          });
+        }
+        offset += span.length;
+      }
+
+      // The offsets above are only positions if the spans partition the inserted range.
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    if (runs.length < 2 || offset !== change.toB) {
+      return [change];
+    }
+    return runs.map(function (run, index) {
+      var owned = blockNodeRanges(doc, {
+        from: change.fromB,
+        to: change.toB
+      }, function (pos) {
+        return pos >= run.from && pos < run.to;
+      });
+      return _objectSpread(_objectSpread({}, change), {}, {
+        fromA: index === 0 ? change.fromA : change.toA,
+        fromB: run.from,
+        toB: run.to,
+        deleted: index === 0 ? change.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 —
+ * the `step` diff type. A contained change by the same author, and one that only partially
+ * overlaps, are left for the collapse below.
+ *
+ * The leading fragment keeps the deleted side, so one deletion is not drawn once per fragment.
+ */
+var splitContainedChanges = function splitContainedChanges(changes, doc) {
+  return changes.flatMap(function (change) {
+    var _getAttributionIdenti = getAttributionIdentity(change),
+      key = _getAttributionIdenti.key;
+    var inner = mergeRanges(changes.filter(function (other) {
+      var otherKey = getAttributionIdentity(other).key;
+      return other !== change && key !== undefined && otherKey !== undefined && otherKey !== key && isContained(change, other);
+    }).map(function (_ref) {
+      var fromB = _ref.fromB,
+        toB = _ref.toB;
+      return {
+        from: fromB,
+        to: toB
+      };
+    }));
+    if (inner.length === 0) {
+      return [change];
+    }
+    var gaps = [];
+    var cursor = change.fromB;
+    var _iterator2 = _createForOfIteratorHelper(inner),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _step2.value,
+          from = _step2$value.from,
+          to = _step2$value.to;
+        if (from > cursor) {
+          gaps.push({
+            from: cursor,
+            to: from
+          });
+        }
+        cursor = Math.max(cursor, to);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    if (change.toB > cursor) {
+      gaps.push({
+        from: cursor,
+        to: change.toB
+      });
+    }
+
+    // Subtracted end to end, so nothing is left to highlight — but the blocks are still owned.
+    var fragments = gaps.length > 0 ? gaps : [{
+      from: change.toB,
+      to: change.toB
+    }];
+    // The outer author's: every block in their range that no inner change opened.
+    var owned = blockNodeRanges(doc, {
+      from: change.fromB,
+      to: change.toB
+    }, function (pos) {
+      return !inner.some(function (_ref2) {
+        var from = _ref2.from,
+          to = _ref2.to;
+        return pos >= from && pos < to;
+      });
+    });
+    return fragments.map(function (fragment, index) {
+      return _objectSpread(_objectSpread({}, change), {}, {
+        fromA: index === 0 ? change.fromA : change.toA,
+        fromB: fragment.from,
+        toB: fragment.to,
+        deleted: index === 0 ? change.deleted : []
+      }, owned ? {
+        blockNodeRangesB: index === 0 ? owned : []
+      } : {});
+    });
+  });
+};
+
+/**
+ * The blocks a merged change owns. Both sides must name theirs, or the merge falls back to its own
+ * range — narrowing it could drop a block altogether.
+ */
+var mergeBlockNodeRanges = function mergeBlockNodeRanges(left, right) {
+  return left.blockNodeRangesB && right.blockNodeRangesB ? [].concat(_toConsumableArray(left.blockNodeRangesB), _toConsumableArray(right.blockNodeRangesB)) : undefined;
+};
+
+/** Unions the changes whose new-document ranges strictly overlap, leaving touching ones alone. */
+var collapse = function collapse(changes) {
   // A zero-length new-document range paints no inline decoration, so it is kept aside rather than
   // folded into a neighbouring insertion.
   var emptyRanges = changes.filter(function (change) {
     return change.toB <= change.fromB;
   });
   var collapsed = [];
-  var _iterator = _createForOfIteratorHelper(changes.filter(function (change) {
+  var _iterator3 = _createForOfIteratorHelper(changes.filter(function (change) {
       return change.toB > change.fromB;
     }).sort(byNewDocRange)),
-    _step;
+    _step3;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var change = _step.value;
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var change = _step3.value;
       var current = collapsed[collapsed.length - 1];
       if (current && change.fromB < current.toB) {
-        collapsed[collapsed.length - 1] = {
+        var blockNodeRangesB = mergeBlockNodeRanges(current, change);
+        collapsed[collapsed.length - 1] = _objectSpread({
           fromA: Math.min(current.fromA, change.fromA),
           toA: Math.max(current.toA, change.toA),
           fromB: Math.min(current.fromB, change.fromB),
           toB: Math.max(current.toB, change.toB),
           deleted: [].concat(_toConsumableArray(current.deleted), _toConsumableArray(change.deleted)),
           inserted: [].concat(_toConsumableArray(current.inserted), _toConsumableArray(change.inserted))
-        };
+        }, blockNodeRangesB ? {
+          blockNodeRangesB: blockNodeRangesB
+        } : {});
       } else {
         collapsed.push(_objectSpread({}, change));
       }
     }
   } catch (err) {
-    _iterator.e(err);
+    _iterator3.e(err);
   } finally {
-    _iterator.f();
+    _iterator3.f();
   }
   return [].concat(collapsed, _toConsumableArray(emptyRanges)).sort(byNewDocRange);
 };
 
+/**
+ * Collapses changes whose new-document ranges strictly overlap. Attribution runs are simplified
+ * independently, so runs either side of an unattributed step can come back covering the same
+ * 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.
+ *
+ * Contributors are separated first, by `splitMixedIdentityChanges` and `splitContainedChanges`.
+ * Both leave ranges that only touch, so they survive the collapse.
+ *
+ * Carries no gate of its own: the only caller reaches it through the attributed changeset, which
+ * already requires `confluence_ncs_step_diffing_version_history`.
+ */
+export var collapseOverlappingChanges = function collapseOverlappingChanges(changes, doc) {
+  return collapse(splitContainedChanges(splitMixedIdentityChanges(changes, doc), doc));
+};
+
 /**
  * Simplifies and optimizes consecutive changes without crossing an attribution boundary.
  * A change which already contains more than one identity is deliberately kept isolated.
@@ -107,12 +324,12 @@ export var simplifyChangesWithAttribution = function simplifyChangesWithAttribut
     run = [];
     runIdentity = undefined;
   };
-  var _iterator2 = _createForOfIteratorHelper(changes),
-    _step2;
+  var _iterator4 = _createForOfIteratorHelper(changes),
+    _step4;
   try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
       var _runIdentity;
-      var change = _step2.value;
+      var change = _step4.value;
       var identity = getAttributionIdentity(change);
       var canJoinRun = ((_runIdentity = runIdentity) === null || _runIdentity === void 0 ? void 0 : _runIdentity.mergeable) === true && identity.mergeable && runIdentity.key === identity.key;
       if (run.length > 0 && !canJoinRun) {
@@ -125,9 +342,9 @@ export var simplifyChangesWithAttribution = function simplifyChangesWithAttribut
       }
     }
   } catch (err) {
-    _iterator2.e(err);
+    _iterator4.e(err);
   } finally {
-    _iterator2.f();
+    _iterator4.f();
   }
   flush();
   return result;