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

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

@@ -32,6 +32,11 @@ var getAttributionIdentity = function getAttributionIdentity(change) {
     mergeable: true
   };
 };
+var hasContributor = function hasContributor(change) {
+  return [].concat(_toConsumableArray(change.deleted), _toConsumableArray(change.inserted)).some(function (span) {
+    return getAttributionKey(span.data) !== undefined;
+  });
+};
 var byNewDocRange = function byNewDocRange(left, right) {
   return left.fromB - right.fromB || left.toB - right.toB;
 };
@@ -89,12 +94,28 @@ var blockNodeRanges = function blockNodeRanges(doc, change, ownsPosition) {
  */
 var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc) {
   return changes.flatMap(function (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.
+    var deletedKeys = new Set(change.deleted.map(function (span) {
+      return getAttributionKey(span.data);
+    }));
+    var firstInsertedKey = getAttributionKey((_change$inserted$ = change.inserted[0]) === null || _change$inserted$ === void 0 ? void 0 : _change$inserted$.data);
+    var detachDeleted = change.deleted.length > 0 && change.inserted.length > 0 && deletedKeys.size === 1 && !deletedKeys.has(firstInsertedKey) && (deletedKeys.has(undefined) || firstInsertedKey === undefined);
+    var deletedChange = detachDeleted ? [_objectSpread(_objectSpread({}, change), {}, {
+      toB: change.fromB,
+      inserted: []
+    })] : [];
+    var contentChange = detachDeleted ? _objectSpread(_objectSpread({}, change), {}, {
+      fromA: change.toA,
+      deleted: []
+    }) : change;
+    if (getAttributionIdentity(contentChange).mergeable) {
+      return [].concat(deletedChange, [contentChange]);
     }
     var runs = [];
-    var offset = change.fromB;
-    var _iterator = _createForOfIteratorHelper(change.inserted),
+    var offset = contentChange.fromB;
+    var _iterator = _createForOfIteratorHelper(contentChange.inserted),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -121,32 +142,32 @@ var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc)
     } finally {
       _iterator.f();
     }
-    if (runs.length < 2 || offset !== change.toB) {
-      return [change];
+    if (runs.length < 2 || offset !== contentChange.toB) {
+      return [].concat(deletedChange, [contentChange]);
     }
-    return runs.map(function (run, index) {
+    return [].concat(deletedChange, _toConsumableArray(runs.map(function (run, index) {
       var owned = blockNodeRanges(doc, {
-        from: change.fromB,
-        to: change.toB
+        from: contentChange.fromB,
+        to: contentChange.toB
       }, function (pos) {
         return pos >= run.from && pos < run.to;
       });
-      return _objectSpread(_objectSpread({}, change), {}, {
-        fromA: index === 0 ? change.fromA : change.toA,
+      return _objectSpread(_objectSpread({}, 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.
  *
@@ -155,10 +176,11 @@ var splitMixedIdentityChanges = function splitMixedIdentityChanges(changes, doc)
 var splitContainedChanges = function splitContainedChanges(changes, doc) {
   return changes.flatMap(function (change) {
     var _getAttributionIdenti = getAttributionIdentity(change),
-      key = _getAttributionIdenti.key;
+      key = _getAttributionIdenti.key,
+      mergeable = _getAttributionIdenti.mergeable;
     var inner = mergeRanges(changes.filter(function (other) {
-      var otherKey = getAttributionIdentity(other).key;
-      return other !== change && key !== undefined && otherKey !== undefined && otherKey !== key && isContained(change, other);
+      var otherIdentity = getAttributionIdentity(other);
+      return other !== change && mergeable && otherIdentity.mergeable && otherIdentity.key !== key && isContained(change, other);
     }).map(function (_ref) {
       var fromB = _ref.fromB,
         toB = _ref.toB;
@@ -236,7 +258,7 @@ 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. */
+/** Unions overlapping changes, except when only one side names a contributor. */
 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.
@@ -252,7 +274,9 @@ var collapse = function collapse(changes) {
     for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
       var change = _step3.value;
       var current = collapsed[collapsed.length - 1];
-      if (current && change.fromB < current.toB) {
+      var currentHasContributor = current && hasContributor(current);
+      var changeHasContributor = hasContributor(change);
+      if (current && change.fromB < current.toB && currentHasContributor === changeHasContributor) {
         var blockNodeRangesB = mergeBlockNodeRanges(current, change);
         collapsed[collapsed.length - 1] = _objectSpread({
           fromA: Math.min(current.fromA, change.fromA),
@@ -282,8 +306,8 @@ var collapse = function 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/esm/pm-plugins/decorations/colorSchemes/attributions.js

@@ -238,13 +238,12 @@ var getAttributionKeyForChanges = function getAttributionKeyForChanges(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 var getAttributionKeyForChange = function getAttributionKeyForChange(change, attributedChanges) {
-  var _getAttributionKeyFor;
-  return (_getAttributionKeyFor = getAttributionKeyForChanges([change])) !== null && _getAttributionKeyFor !== void 0 ? _getAttributionKeyFor : getAttributionKeyForChanges(attributedChanges.filter(function (attributedChange) {
+  var directKey = getAttributionKeyForChanges([change]);
+  return directKey !== null && directKey !== void 0 ? directKey : fg('confluence_ncs_step_diffing_version_history') ? undefined : getAttributionKeyForChanges(attributedChanges.filter(function (attributedChange) {
     return changesOverlap(change, attributedChange);
   }));
 };

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

@@ -215,7 +215,7 @@ var createChangedRowDOM = function createChangedRowDOM(_ref3) {
   return tr;
 };
 var supportsAnchorPositioning = function supportsAnchorPositioning() {
-  return typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)');
+  return typeof CSS !== 'undefined' && typeof CSS.supports === 'function' && CSS.supports('top', 'anchor(--a top)') && CSS.supports('position-anchor', '--a');
 };
 var createAnchoredRemovedLozengeWidget = function createAnchoredRemovedLozengeWidget(_ref4) {
   var anchorName = _ref4.anchorName,
@@ -226,6 +226,9 @@ var createAnchoredRemovedLozengeWidget = function createAnchoredRemovedLozengeWi
   var lozenge = createRemovedLozenge(intl, isActive, colorScheme, true);
   var 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', "--".concat(anchorName));
+  lozenge.style.setProperty('position-visibility', 'anchors-visible');
   lozenge.style.setProperty('top', "calc(anchor(--".concat(anchorName, " top) + ").concat(inset, ")"));
   lozenge.style.setProperty('left', "calc(anchor(--".concat(anchorName, " right) - ").concat(inset, ")"));
   lozenge.style.setProperty('right', 'auto');

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

@@ -141,7 +141,7 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
   // node renders beneath its replacement; otherwise anchor at the start (change.fromB).
   var anchorPos = placeBelow ? change.toB : change.fromB;
   var safeInsertPos = findSafeInsertPos(newDoc, anchorPos, slice);
-  var isActive = activeIndexPos && (fg('confluence_ncs_step_diffing_version_history') ? safeInsertPos >= activeIndexPos.from && safeInsertPos <= activeIndexPos.to : safeInsertPos === activeIndexPos.from && safeInsertPos === activeIndexPos.to);
+  var 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/esm/pm-plugins/decorations/extractContributorTags.js

@@ -98,7 +98,9 @@ var owningStop = function owningStop(target, stops) {
  * containment, and the leading change of what it covers.
  */
 var resolveActiveTarget = function resolveActiveTarget(surviving, activeIndexPos) {
-  return containedBy(surviving, activeIndexPos)[0];
+  return containedBy(surviving, activeIndexPos).find(function (target) {
+    return !fg('confluence_ncs_step_diffing_version_history') || !('attributionKey' in activeIndexPos) || target.decoration.spec.attributionKey === activeIndexPos.attributionKey;
+  });
 };
 
 /**

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

@@ -83,18 +83,13 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
     return a.from === b.from ? a.to - b.to : a.from - b.from;
   });
   sortedDecorations.forEach(function (decoration) {
-    var _openGroups$find;
     // A gap ends the run: nothing before it can be joined.
     if (decoration.from > clusterTo) {
       openGroups = [];
     }
     var 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.
-    var openGroup = (_openGroups$find = openGroups.find(function (group) {
+    var openGroup = openGroups.find(function (group) {
       return group.contributor === contributor;
-    })) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(function (group) {
-      return group.contributor === '';
     });
     if (openGroup === undefined) {
       var group = {
@@ -106,8 +101,6 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
       groups.push(group);
       openGroups = [].concat(_toConsumableArray(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/esm/pm-plugins/main.js

@@ -7,6 +7,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';
@@ -170,10 +171,12 @@ export var createPlugin = function createPlugin(config, getIntl, api, onEditorVi
               var activeDecoration = _decorations[nextIndex];
               newPluginState = _objectSpread(_objectSpread({}, currentPluginState), {}, {
                 activeIndex: nextIndex,
-                activeIndexPos: activeDecoration ? {
+                activeIndexPos: activeDecoration ? _objectSpread({
                   from: activeDecoration.from,
                   to: activeDecoration.to
-                } : undefined
+                }, fg('confluence_ncs_step_diffing_version_history') ? {
+                  attributionKey: isDiffDecoration(activeDecoration) ? activeDecoration.spec.attributionKey : undefined
+                } : {}) : undefined
               });
               // Recalculate decorations with the new active index
               var _calculateDiffDecorat2 = calculateDiffDecorations({

package/dist/types/pm-plugins/calculateDiff/calculateDiffDecorations.d.ts

@@ -14,6 +14,11 @@ type CalculatedDiffs = {
     decorations: DecorationSet;
     diffDescriptors: DiffDescriptor[];
 };
+type ActiveIndexPos = {
+    attributionKey?: string;
+    from: number;
+    to: number;
+};
 /**
  * Whether deleted content for `change` renders after the new content instead of before it.
  *
@@ -31,10 +36,7 @@ export declare const isDeletedContentPlacedBelow: ({ change, deletedDiffPlacemen
     inlineDeletedDiffPlacement?: InlineDeletedDiffPlacement;
 }) => boolean;
 export declare const calculateDiffDecorations: MemoizedFn<({ state, pluginState, nodeViewSerializer, colorScheme, intl, activeIndexPos, api, hideDeletedDiffs, hideAddedDiffsUnderline, showIndicators, }: {
-    activeIndexPos?: {
-        from: number;
-        to: number;
-    };
+    activeIndexPos?: ActiveIndexPos;
     api: ExtractInjectionAPI<ShowDiffPlugin> | undefined;
     colorScheme?: ColorScheme;
     deletedDiffPlacement?: DeletedDiffPlacement;

package/dist/types/pm-plugins/calculateDiff/simplifyChangesWithAttribution.d.ts

@@ -18,8 +18,8 @@ export type AttributedChange = Change & {
  * 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/types/pm-plugins/decorations/colorSchemes/attributions.d.ts

@@ -26,9 +26,8 @@ export declare const isAttributionColoringEnabled: (stepAttributions: Array<Diff
 export declare const isContributorTagsEnabled: (stepAttributions: Array<DiffStepAttribution | undefined> | undefined, contributors: ResolvedDiffContributors | undefined) => boolean;
 export declare const createAttributionColorMap: (stepAttributions: Array<DiffStepAttribution | undefined>, contributors?: ResolvedDiffContributors) => Map<string, AdsAccentColor>;
 /**
- * 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 declare const getAttributionKeyForChange: (change: Change, attributedChanges: Change[]) => string | undefined;
 export declare const getColorSchemeForChange: (change: Change, attributedChanges: Change[], attributionColors: Map<string, AdsAccentColor>, fallback: ColorScheme | undefined) => ColorScheme | undefined;

package/dist/types/pm-plugins/decorations/createNodeChangedDecorationWidget.d.ts

@@ -12,6 +12,7 @@ import { type ContributorTagMountContext } from './createContributorTagWidget';
  */
 export declare const createNodeChangedDecorationWidget: ({ attributionKey, change, doc, nodeViewSerializer, colorScheme, newDoc, intl, activeIndexPos, isInserted, leftAnchorId, showContributorTags, showIndicators, placeBelow, hideAddedDiffsUnderline, reveal, tagMountContext, deletedColumns, }: {
     activeIndexPos?: {
+        attributionKey?: string;
         from: number;
         to: number;
     };

package/dist/types/pm-plugins/decorations/extractContributorTags.d.ts

@@ -14,6 +14,7 @@ import type { ResolvedDiffContributors } from './colorSchemes/attributions';
  * leading one would ever be reachable. Absent, every decoration keeps its own tag.
  */
 export declare const extractContributorTags: (decorations: DecorationSet, contributors: ResolvedDiffContributors | undefined, activeIndexPos?: {
+    attributionKey?: string;
     from: number;
     to: number;
 }, stops?: ReadonlyArray<{

package/dist/types/pm-plugins/main.d.ts

@@ -12,6 +12,7 @@ export declare const showDiffPluginKey: PluginKey<ShowDiffPluginState>;
 export type ShowDiffPluginState = {
     activeIndex?: number;
     activeIndexPos?: {
+        attributionKey?: string;
         from: number;
         to: number;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "20.0.1",
+	"version": "20.0.3",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -39,7 +39,7 @@
 		"@atlaskit/platform-feature-experiments": "^0.3.0",
 		"@atlaskit/platform-feature-flags": "^2.2.0",
 		"@atlaskit/primitives": "^22.5.0",
-		"@atlaskit/tmp-editor-statsig": "^210.0.0",
+		"@atlaskit/tmp-editor-statsig": "^212.0.0",
 		"@atlaskit/tokens": "^20.1.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^1.0.2",