@atlaskit/editor-plugin-show-diff 14.2.10 → 14.3.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 14.3.0
+
+### Minor Changes
+
+- [`8093f00408d76`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/8093f00408d76) -
+  Align attributed diff colours with all 18 editor participant colour slots under
+  confluence_ncs_step_diffing_version_history and platform_editor_show_diff_color_scheme_refactor.
+
+## 14.2.11
+
+### Patch Changes
+
+- [`15abc159d8096`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/15abc159d8096) -
+  Add mark (formatting) support to the non-smart diff types behind
+  `platform_editor_diff_inline_mark_changes`. A mark-only agent edit arrives as a `ReplaceStep`,
+  which the default `prosemirror-changeset` token encoder tokenises identically on both sides, so
+  bold/italic/code/link changes were silently invisible in the inline diff. A mark-aware token
+  encoder now folds marks into the character token, and mark-only changes render as an added-side
+  highlight without duplicating the unchanged text. No behaviour change with the gate off.
+- Updated dependencies
+
 ## 14.2.10
 
 ### Patch Changes

package/afm-cc/tsconfig.json

@@ -32,6 +32,9 @@
 		{
 			"path": "../../editor-prosemirror/afm-cc/tsconfig.json"
 		},
+		{
+			"path": "../../editor-shared-styles/afm-cc/tsconfig.json"
+		},
 		{
 			"path": "../../editor-tables/afm-cc/tsconfig.json"
 		},

package/afm-products/tsconfig.json

@@ -32,6 +32,9 @@
 		{
 			"path": "../../editor-prosemirror/afm-products/tsconfig.json"
 		},
+		{
+			"path": "../../editor-shared-styles/afm-products/tsconfig.json"
+		},
 		{
 			"path": "../../editor-tables/afm-products/tsconfig.json"
 		},

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.attrAwareTokenEncoder = void 0;
 var _nodeTypeUtils = require("@atlaskit/editor-common/utils/node-type-utils");
 var _diffableAttrs = require("../decorations/utils/diffableAttrs");
+var _encodeCharacterWithMarks = require("./encodeCharacterWithMarks");
 /**
  * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
  * reduces a node to `node.type.name`, so an attribute-only change (e.g. a table
@@ -25,33 +26,12 @@ var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
   return "".concat(node.type.name, "|").concat(parts.join('|'));
 };
 
-// Fold a character's marks (type + attrs) into its token so a formatting-only change
-// (bold/italic/link/colour, or a link whose `href` changes) registers as a real diff.
-// The default encoder returns just the char code, so marked and unmarked text tokenise
-// identically. Marks and their attrs are sorted so the token is order-independent.
-var encodeCharacterWithMarks = function encodeCharacterWithMarks(char, marks) {
-  if (marks.length === 0) {
-    // Fast path: unmarked text keeps the numeric char code (unchanged behaviour).
-    return char;
-  }
-  var markKey = marks.map(function (mark) {
-    var _mark$attrs;
-    var attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
-    var attrParts = Object.keys(attrs).sort().map(function (key) {
-      var _attrs$key;
-      return "".concat(key, "=").concat(JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null));
-    });
-    return attrParts.length > 0 ? "".concat(mark.type.name, "(").concat(attrParts.join(','), ")") : mark.type.name;
-  }).sort().join('&');
-  return "".concat(char, "\0").concat(markKey);
-};
-
 // Like the library default, but node types with a `diffableAttrs` rule fold their
 // attrs into the open token, and text characters fold in their marks. Node-end is
 // unchanged, hence `string | number`.
 var attrAwareTokenEncoder = exports.attrAwareTokenEncoder = {
   encodeCharacter: function encodeCharacter(char, marks) {
-    return encodeCharacterWithMarks(char, marks);
+    return (0, _encodeCharacterWithMarks.encodeCharacterWithMarks)(char, marks);
   },
   encodeNodeStart: function encodeNodeStart(node) {
     var _node$attrs2;

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

@@ -27,10 +27,11 @@ var _decorationKeys = require("../decorations/decorationKeys");
 var _getAttrChangeRanges = require("../decorations/utils/getAttrChangeRanges");
 var _getMarkChangeRanges = require("../decorations/utils/getMarkChangeRanges");
 var _isExtendedEnabled = require("../isExtendedEnabled");
-var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
+var _isMarkOnlyChange = require("./isMarkOnlyChange");
 var _optimizeChanges = require("./optimizeChanges");
+var _selectTokenEncoder2 = require("./selectTokenEncoder");
 var _simplifyChangesWithAttribution = require("./simplifyChangesWithAttribution");
 var _simplifySteps = require("./simplifySteps");
 var _classifySmartChanges = require("./smart/classifySmartChanges");
@@ -389,10 +390,10 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
       };
     }
   }
-  // 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' && (0, _fg.fg)('platform_editor_ai_smart_diff') ? _attrAwareTokenEncoder.attrAwareTokenEncoder : undefined;
+  // The attribute-aware encoder is only needed by the smart classifier and is gated with it.
+  var _selectTokenEncoder = (0, _selectTokenEncoder2.selectTokenEncoder)(diffType === 'smart' && (0, _fg.fg)('platform_editor_ai_smart_diff')),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder,
+    shouldHideMarkOnlyDeletions = _selectTokenEncoder.shouldHideMarkOnlyDeletions;
   var changes;
   var attributedChanges = [];
   var attributionColors;
@@ -447,6 +448,16 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
     var changeColorScheme = attributionColors ? (0, _attributions.getColorSchemeForChange)(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
 
+    // The deleted side of a mark-only change is a byte-identical copy of the new text, so it is
+    // suppressed in the clean view. `hideDeletedDiffs` is load-bearing: when false the reviewer
+    // asked to compare against the original, and the deleted side is the only place the
+    // previous formatting is visible.
+    var isMarkOnly = shouldHideMarkOnlyDeletions && hideDeletedDiffs && change.deleted.length > 0 && (0, _isMarkOnlyChange.isMarkOnlyChange)({
+      change: change,
+      originalDoc: originalDoc,
+      newDoc: tr.doc
+    });
+
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
     // widget pins whichever end of the range it sits at — how the indicator anchors below are
     // allowed to move.
@@ -477,7 +488,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
       // 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 && !((0, _isExtendedEnabled.isExtendedEnabled)(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      var willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !((0, _isExtendedEnabled.isExtendedEnabled)(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
       if (isSmartNodeLevel) {
         // For a large inserted table, skip the O(cells) inline decorations inside the
         // table (the cell overlays added below provide the highlight without the
@@ -548,7 +559,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
         coarseTableCellsOnly: useCoarseTableDecoration
       }))));
     }
-    if (change.deleted.length > 0) {
+    if (change.deleted.length > 0 && !isMarkOnly) {
       var _shouldHideDeleted = (0, _isExtendedEnabled.isExtendedEnabled)(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createNodeChangedDecorationWidget.createNodeChangedDecorationWidget)(_objectSpread(_objectSpread({

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

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.computeDiffChanges = void 0;
 var _prosemirrorChangeset = require("prosemirror-changeset");
-var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
 var _optimizeChanges = require("./optimizeChanges");
+var _selectTokenEncoder2 = require("./selectTokenEncoder");
 var _simplifySteps = require("./simplifySteps");
 var _classifySmartChanges = require("./smart/classifySmartChanges");
 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; } } }; }
@@ -82,11 +82,10 @@ var computeDiffChanges = exports.computeDiffChanges = function computeDiffChange
     };
   }
 
-  // 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.attrAwareTokenEncoder : undefined;
+  // This utility does not apply the smart-diff gate (see the file docstring); a caller
+  // requesting `smart` is already behind it.
+  var _selectTokenEncoder = (0, _selectTokenEncoder2.selectTokenEncoder)(diffType === 'smart'),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder;
   var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {

package/dist/cjs/pm-plugins/calculateDiff/encodeCharacterWithMarks.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encodeCharacterWithMarks = void 0;
+/** U+0000 cannot occur in ProseMirror text content, so a token can never be ambiguous. */
+var MARK_KEY_SEPARATOR = "\0";
+var buildMarkKey = function buildMarkKey(marks) {
+  return marks.map(function (mark) {
+    var _mark$attrs;
+    var attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
+    var attrParts = Object.keys(attrs).sort().map(function (key) {
+      var _attrs$key;
+      return "".concat(key, "=").concat(JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null));
+    });
+    return attrParts.length > 0 ? "".concat(mark.type.name, "(").concat(attrParts.join(','), ")") : mark.type.name;
+  }).sort().join('&');
+};
+
+/**
+ * Keyed on array identity: `prosemirror-changeset` passes the same `child.marks` reference for
+ * every character in a text node, so this collapses the key building to once per node.
+ */
+var markKeyCache = new WeakMap();
+
+/**
+ * Folds a character's marks into its `prosemirror-changeset` token. The library default returns
+ * only the char code, so marked and unmarked text tokenise identically and a formatting-only edit
+ * is invisible to the changeset.
+ *
+ * Marks and attrs are sorted so the token is order-independent.
+ */
+var encodeCharacterWithMarks = exports.encodeCharacterWithMarks = function encodeCharacterWithMarks(char, marks) {
+  if (marks.length === 0) {
+    return char;
+  }
+  var markKey = markKeyCache.get(marks);
+  if (markKey === undefined) {
+    markKey = buildMarkKey(marks);
+    markKeyCache.set(marks, markKey);
+  }
+  return "".concat(char).concat(MARK_KEY_SEPARATOR).concat(markKey);
+};

package/dist/cjs/pm-plugins/calculateDiff/isMarkOnlyChange.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMarkOnlyChange = void 0;
+/** U+0000 cannot occur in ProseMirror text content, so this cannot collide with document text. */
+var NODE_MARKER = "\0";
+
+/**
+ * Node types and text only; marks and attrs excluded.
+ *
+ * Text is unprefixed so adjacent runs concatenate — a run only splits because its marks differ, so
+ * `strong("hello")` and `strong("hel") + em("lo")` must match. Attrs are excluded because a
+ * reconstructed agent edit regenerates `localId`s; `getAttrChangeRanges` reports attrs separately.
+ */
+var markFreeSignature = function markFreeSignature(doc, from, to) {
+  var parts = [];
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (node.isText) {
+      var _node$text;
+      var start = Math.max(pos, from) - pos;
+      var end = Math.min(pos + node.nodeSize, to) - pos;
+      parts.push(((_node$text = node.text) !== null && _node$text !== void 0 ? _node$text : '').slice(start, end));
+    } else {
+      parts.push("".concat(NODE_MARKER).concat(node.type.name));
+    }
+    return true;
+  });
+  return parts.join('');
+};
+
+/**
+ * Whether a change differs only in marks, with identical structure and text on both sides. Only
+ * produced when a mark-aware token encoder is in use.
+ */
+var isMarkOnlyChange = exports.isMarkOnlyChange = function isMarkOnlyChange(_ref) {
+  var change = _ref.change,
+    newDoc = _ref.newDoc,
+    originalDoc = _ref.originalDoc;
+  var fromA = change.fromA,
+    toA = change.toA,
+    fromB = change.fromB,
+    toB = change.toB;
+  var isPureInsertionOrDeletion = toA === fromA || toB === fromB;
+  if (isPureInsertionOrDeletion || toA - fromA !== toB - fromB) {
+    return false;
+  }
+  return markFreeSignature(originalDoc, fromA, toA) === markFreeSignature(newDoc, fromB, toB);
+};

package/dist/cjs/pm-plugins/calculateDiff/markAwareTokenEncoder.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.markAwareTokenEncoder = void 0;
+var _encodeCharacterWithMarks = require("./encodeCharacterWithMarks");
+/** Mirrors the library's private (unexported) `typeID` so node-end tokens match. */
+var typeID = 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;
+};
+
+/**
+ * The library default encoder plus mark folding on text characters.
+ *
+ * Deliberately narrower than `attrAwareTokenEncoder`: node-start tokens keep the library default
+ * and do not fold in diffable attributes, which `getAttrChangeRanges` already reports for every
+ * diff type.
+ */
+var markAwareTokenEncoder = exports.markAwareTokenEncoder = {
+  encodeCharacter: function encodeCharacter(char, marks) {
+    return (0, _encodeCharacterWithMarks.encodeCharacterWithMarks)(char, marks);
+  },
+  encodeNodeStart: function encodeNodeStart(node) {
+    return node.type.name;
+  },
+  encodeNodeEnd: function encodeNodeEnd(node) {
+    return -typeID(node.type);
+  },
+  compareTokens: function compareTokens(a, b) {
+    return a === b;
+  }
+};

package/dist/cjs/pm-plugins/calculateDiff/selectTokenEncoder.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectTokenEncoder = void 0;
+var _fg = require("@atlaskit/platform-feature-flags/fg");
+var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
+var _markAwareTokenEncoder = require("./markAwareTokenEncoder");
+/**
+ * Single place `platform_editor_diff_inline_mark_changes` is read, shared by
+ * `calculateDiffDecorations` and `computeDiffChanges` so the two cannot drift.
+ *
+ * With the gate off this returns what both callers computed before it existed.
+ *
+ * @param useAttrAwareEncoder Caller is running the smart classifier, which needs node attrs folded
+ * into the token.
+ */
+var selectTokenEncoder = exports.selectTokenEncoder = function selectTokenEncoder(useAttrAwareEncoder) {
+  if (useAttrAwareEncoder) {
+    return {
+      tokenEncoder: _attrAwareTokenEncoder.attrAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: false
+    };
+  }
+  if ((0, _fg.fg)('platform_editor_diff_inline_mark_changes')) {
+    return {
+      tokenEncoder: _markAwareTokenEncoder.markAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: true
+    };
+  }
+  return {
+    tokenEncoder: undefined,
+    shouldHideMarkOnlyDeletions: false
+  };
+};

package/dist/cjs/pm-plugins/calculateDiff/simplifySteps.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.simplifySteps = simplifySteps;
 exports.simplifyStepsWithAttribution = simplifyStepsWithAttribution;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _steps = require("@atlaskit/adf-schema/steps");
+var _analytics = require("@atlaskit/adf-schema/steps/analytics");
 var _document = require("@atlaskit/editor-common/utils/document");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _attributions = require("../decorations/colorSchemes/attributions");
@@ -42,7 +42,7 @@ function simplifySteps(steps, originalDoc) {
   return stepsToFilter
   // Remove steps that don't affect document structure or content
   .filter(function (step) {
-    return !(step instanceof _steps.AnalyticsStep);
+    return !(step instanceof _analytics.AnalyticsStep);
   })
   // Merge consecutive steps where possible
   .reduce(function (acc, step) {
@@ -85,7 +85,7 @@ function simplifyStepsWithAttribution(steps, stepAttributions, originalDoc) {
   }), originalDoc);
   return stepsToFilter.filter(function (_ref) {
     var step = _ref.step;
-    return !(step instanceof _steps.AnalyticsStep);
+    return !(step instanceof _analytics.AnalyticsStep);
   }).reduce(function (acc, current) {
     var _previous$step$merge, _previous$step$merge2, _previous$step;
     var previous = acc[acc.length - 1];

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

@@ -7,21 +7,46 @@ Object.defineProperty(exports, "__esModule", {
 exports.isAttributionColoringEnabled = exports.getColorSchemeForChange = exports.getAttributionKey = exports.createAttributionColorMap = exports.areAttributionColorGatesEnabled = void 0;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _utils = require("@atlaskit/editor-shared-styles/utils");
 var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
-var ATTRIBUTION_COLOR_PALETTE = ['purple', 'blue', 'teal', 'magenta', 'orange', 'green'];
-
-/** `userId` is primary; `agentId`, or `agentType` as its fallback, separates shared users. */
-var getAttributionKey = exports.getAttributionKey = function getAttributionKey(attribution) {
+var _types = require("./types");
+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; }
+/**
+ * Normalise the attribution identity once so a valid lookup key always has a valid participant
+ * colour seed. `userId` is primary; `agentId`, or `agentType` as its fallback, separates shared
+ * users. The colour seed matches collaboration: the user ID for a human and the agent ID for an
+ * agent. The agent-type fallback includes the user so different users' agents do not collapse onto
+ * one colour when NCS omits an agent ID.
+ */
+var getAttributionIdentity = function getAttributionIdentity(attribution) {
   var _attribution$userId, _attribution$agentId, _attribution$agentTyp;
   var userId = attribution === null || attribution === void 0 || (_attribution$userId = attribution.userId) === null || _attribution$userId === void 0 ? void 0 : _attribution$userId.trim();
   var agentId = attribution === null || attribution === void 0 || (_attribution$agentId = attribution.agentId) === null || _attribution$agentId === void 0 ? void 0 : _attribution$agentId.trim();
   var agentType = attribution === null || attribution === void 0 || (_attribution$agentTyp = attribution.agentType) === null || _attribution$agentTyp === void 0 ? void 0 : _attribution$agentTyp.trim();
-  if (!userId && !agentId && !agentType) {
+  var colorSeed;
+  if (agentId) {
+    colorSeed = agentId;
+  } else if (agentType) {
+    colorSeed = userId ? "user:".concat(userId, "|agent:type:").concat(agentType) : "agent:type:".concat(agentType);
+  } else if (userId) {
+    colorSeed = userId;
+  } else {
     return undefined;
   }
   var agentIdentity = agentId || (agentType ? "type:".concat(agentType) : '');
-  return "user:".concat(userId !== null && userId !== void 0 ? userId : '', "|agent:").concat(agentIdentity);
+  return {
+    colorSeed: colorSeed,
+    key: "user:".concat(userId !== null && userId !== void 0 ? userId : '', "|agent:").concat(agentIdentity)
+  };
+};
+
+/** `userId` is primary; `agentId`, or `agentType` as its fallback, separates shared users. */
+var getAttributionKey = exports.getAttributionKey = function getAttributionKey(attribution) {
+  var _getAttributionIdenti;
+  return (_getAttributionIdenti = getAttributionIdentity(attribution)) === null || _getAttributionIdenti === void 0 ? void 0 : _getAttributionIdenti.key;
 };
 var areAttributionColorGatesEnabled = exports.areAttributionColorGatesEnabled = function areAttributionColorGatesEnabled() {
   return (0, _fg.fg)('confluence_ncs_step_diffing_version_history') && (0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_show_diff_color_scheme_refactor');
@@ -36,12 +61,29 @@ var isAttributionColoringEnabled = exports.isAttributionColoringEnabled = functi
   return attributionKeys.size > 1;
 };
 var createAttributionColorMap = exports.createAttributionColorMap = function createAttributionColorMap(stepAttributions) {
-  var keys = Array.from(new Set(stepAttributions.map(getAttributionKey).filter(function (key) {
-    return key !== undefined;
-  }))).sort();
-  return new Map(keys.map(function (key, index) {
-    return [key, ATTRIBUTION_COLOR_PALETTE[index % ATTRIBUTION_COLOR_PALETTE.length]];
-  }));
+  var colors = new Map();
+  var _iterator = _createForOfIteratorHelper(stepAttributions),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var attribution = _step.value;
+      var identity = getAttributionIdentity(attribution);
+      if (!identity || colors.has(identity.key)) {
+        continue;
+      }
+      var _getParticipantColor = (0, _utils.getParticipantColor)(identity.colorSeed),
+        index = _getParticipantColor.index;
+      var participantColorScheme = _types.PARTICIPANT_COLOR_SCHEMES[index];
+      if (participantColorScheme) {
+        colors.set(identity.key, participantColorScheme);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return colors;
 };
 var getLatestAttribution = function getLatestAttribution(changes) {
   var data = changes.flatMap(function (change) {
@@ -63,10 +105,19 @@ var changesOverlap = function changesOverlap(change, attributedChange) {
   var deletedOverlap = change.deleted.length > 0 && attributedChange.deleted.length > 0 && rangesOverlap(change.fromA, change.toA, attributedChange.fromA, attributedChange.toA);
   return insertedOverlap || deletedOverlap;
 };
+var getParticipantColorSchemeForChanges = function getParticipantColorSchemeForChanges(changes, attributionColors) {
+  var key = getAttributionKey(getLatestAttribution(changes));
+  return key ? attributionColors.get(key) : undefined;
+};
 var getColorSchemeForChange = exports.getColorSchemeForChange = function getColorSchemeForChange(change, attributedChanges, attributionColors, fallback) {
-  var _attributionColors$ge;
-  var key = getAttributionKey(getLatestAttribution(attributedChanges.filter(function (attributedChange) {
-    return changesOverlap(change, attributedChange);
-  })));
-  return key ? (_attributionColors$ge = attributionColors.get(key)) !== null && _attributionColors$ge !== void 0 ? _attributionColors$ge : fallback : fallback;
+  var _ref, _getParticipantColorS;
+  return (// Inline and step changes retain their own attribution spans. Resolve those first so a broader
+    // change is not recoloured by a later contributor whose nested range happens to overlap it.
+    (_ref = (_getParticipantColorS = getParticipantColorSchemeForChanges([change], attributionColors)) !== null && _getParticipantColorS !== void 0 ? _getParticipantColorS :
+    // Grouping and smart classification can produce changes without direct attribution data. For
+    // those transformed changes, retain the overlap-based lookup as a fallback.
+    getParticipantColorSchemeForChanges(attributedChanges.filter(function (attributedChange) {
+      return changesOverlap(change, attributedChange);
+    }), attributionColors)) !== null && _ref !== void 0 ? _ref : fallback
+  );
 };

package/dist/cjs/pm-plugins/decorations/colorSchemes/factory.js

@@ -67,6 +67,8 @@ exports.buildInsertedBlockNodeStyle = buildInsertedBlockNodeStyle;
 exports.buildInsertedInlineStyle = buildInsertedInlineStyle;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _lazyNodeView = require("@atlaskit/editor-common/lazy-node-view");
+var _constants = require("@atlaskit/editor-shared-styles/constants");
+var _types = require("./types");
 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) { (0, _defineProperty2.default)(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; }
 // token() is a build-time transform needing static literals, so pre-compute every colour's
@@ -81,7 +83,8 @@ var bgSubtlestMap = {
   orange: "var(--ds-background-accent-orange-subtlest, #FFF5DB)",
   yellow: "var(--ds-background-accent-yellow-subtlest, #FEF7C8)",
   magenta: "var(--ds-background-accent-magenta-subtlest, #FFECF8)",
-  gray: "var(--ds-background-accent-gray-subtlest, #F0F1F2)"
+  gray: "var(--ds-background-accent-gray-subtlest, #F0F1F2)",
+  lime: "var(--ds-background-accent-lime-subtlest, #EFFFD6)"
 };
 var bgSubtlestPressedMap = {
   green: "var(--ds-background-accent-green-subtlest-pressed, #97EDC9)",
@@ -92,7 +95,8 @@ var bgSubtlestPressedMap = {
   orange: "var(--ds-background-accent-orange-subtlest-pressed, #FBD779)",
   yellow: "var(--ds-background-accent-yellow-subtlest-pressed, #EFDD4E)",
   magenta: "var(--ds-background-accent-magenta-subtlest-pressed, #FCB6E1)",
-  gray: "var(--ds-background-accent-gray-subtlest-pressed, #B7B9BE)"
+  gray: "var(--ds-background-accent-gray-subtlest-pressed, #B7B9BE)",
+  lime: "var(--ds-background-accent-lime-subtlest-pressed, #BDE97C)"
 };
 var bgSubtlerMap = {
   green: "var(--ds-background-accent-green-subtler, #BAF3DB)",
@@ -103,7 +107,8 @@ var bgSubtlerMap = {
   orange: "var(--ds-background-accent-orange-subtler, #FCE4A6)",
   yellow: "var(--ds-background-accent-yellow-subtler, #F5E989)",
   magenta: "var(--ds-background-accent-magenta-subtler, #FDD0EC)",
-  gray: "var(--ds-background-accent-gray-subtler, #DDDEE1)"
+  gray: "var(--ds-background-accent-gray-subtler, #DDDEE1)",
+  lime: "var(--ds-background-accent-lime-subtler, #D3F1A7)"
 };
 var bgSubtlerPressedMap = {
   green: "var(--ds-background-accent-green-subtler-pressed, #7EE2B8)",
@@ -114,7 +119,8 @@ var bgSubtlerPressedMap = {
   orange: "var(--ds-background-accent-orange-subtler-pressed, #FBC828)",
   yellow: "var(--ds-background-accent-yellow-subtler-pressed, #EED12B)",
   magenta: "var(--ds-background-accent-magenta-subtler-pressed, #F797D2)",
-  gray: "var(--ds-background-accent-gray-subtler-pressed, #8C8F97)"
+  gray: "var(--ds-background-accent-gray-subtler-pressed, #8C8F97)",
+  lime: "var(--ds-background-accent-lime-subtler-pressed, #B3DF72)"
 };
 var borderAccentMap = {
   green: "var(--ds-border-accent-green, #22A06B)",
@@ -125,7 +131,8 @@ var borderAccentMap = {
   orange: "var(--ds-border-accent-orange, #E06C00)",
   yellow: "var(--ds-border-accent-yellow, #B38600)",
   magenta: "var(--ds-border-accent-magenta, #CD519D)",
-  gray: "var(--ds-border-accent-gray, #7D818A)"
+  gray: "var(--ds-border-accent-gray, #7D818A)",
+  lime: "var(--ds-border-accent-lime, #6A9A23)"
 };
 var textAccentMap = {
   green: "var(--ds-text-accent-green, #216E4E)",
@@ -136,25 +143,74 @@ var textAccentMap = {
   orange: "var(--ds-text-accent-orange, #9E4C00)",
   yellow: "var(--ds-text-accent-yellow, #7F5F01)",
   magenta: "var(--ds-text-accent-magenta, #943D73)",
-  gray: "var(--ds-text-accent-gray, #505258)"
+  gray: "var(--ds-text-accent-gray, #505258)",
+  lime: "var(--ds-text-accent-lime, #4C6B1F)"
+};
+
+/** Pressed counterpart of each participant's diff-safe SVG background tint. */
+var participantPressedBackgroundMap = {
+  'red-bolder': bgSubtlerPressedMap.red,
+  'blue-bolder': bgSubtlerPressedMap.blue,
+  'green-bolder': bgSubtlerPressedMap.green,
+  'yellow-bolder': bgSubtlerPressedMap.yellow,
+  'purple-bolder': bgSubtlerPressedMap.purple,
+  'magenta-bolder': bgSubtlerPressedMap.magenta,
+  'teal-bolder': bgSubtlerPressedMap.teal,
+  'orange-bolder': bgSubtlerPressedMap.orange,
+  'lime-bolder': bgSubtlerPressedMap.lime,
+  'gray-bolder': bgSubtlerPressedMap.gray,
+  'blue-subtle': bgSubtlestPressedMap.blue,
+  'red-subtle': bgSubtlestPressedMap.red,
+  'orange-subtle': bgSubtlestPressedMap.orange,
+  'yellow-subtle': bgSubtlestPressedMap.yellow,
+  'green-subtle': bgSubtlestPressedMap.green,
+  'teal-subtle': bgSubtlestPressedMap.teal,
+  'purple-subtle': bgSubtlestPressedMap.purple,
+  'magenta-subtle': bgSubtlestPressedMap.magenta
+};
+/**
+ * Telepointers can put inverse text directly on their bolder colour. Diff colours sit behind
+ * arbitrary document content, so use the participant SVG tint and its matching pressed token for
+ * diff backgrounds. Borders and rings use the exact participant colour, preserving all 18
+ * bolder/subtle slots while keeping every value in the shared ADS participant palette.
+ */
+var participantColorTokenSets = Object.fromEntries(_types.PARTICIPANT_COLOR_SCHEMES.map(function (scheme, index) {
+  var participantColor = _constants.participantColors[index];
+  if (!participantColor) {
+    throw new Error("Missing shared participant colour for show-diff slot ".concat(index));
+  }
+  return [scheme, {
+    backgroundSubtlest: participantColor.svgBackgroundColor,
+    backgroundSubtlestPressed: participantPressedBackgroundMap[scheme],
+    backgroundSubtler: participantColor.svgBackgroundColor,
+    backgroundSubtlerPressed: participantPressedBackgroundMap[scheme],
+    borderAccent: participantColor.backgroundColor,
+    // The first ten bolder colours are safe as accents on the editor surface. The
+    // remaining subtle colours use their paired dark participant text colour.
+    textAccent: index < 10 ? participantColor.backgroundColor : participantColor.textColor
+  }];
+}));
+var participantColorSchemeSet = new Set(_types.PARTICIPANT_COLOR_SCHEMES);
+var isParticipantColorScheme = function isParticipantColorScheme(color) {
+  return participantColorSchemeSet.has(color);
 };
 function bgSubtlest(color) {
-  return bgSubtlestMap[color];
+  return isParticipantColorScheme(color) ? participantColorTokenSets[color].backgroundSubtlest : bgSubtlestMap[color];
 }
 function bgSubtlestPressed(color) {
-  return bgSubtlestPressedMap[color];
+  return isParticipantColorScheme(color) ? participantColorTokenSets[color].backgroundSubtlestPressed : bgSubtlestPressedMap[color];
 }
 function bgSubtler(color) {
-  return bgSubtlerMap[color];
+  return isParticipantColorScheme(color) ? participantColorTokenSets[color].backgroundSubtler : bgSubtlerMap[color];
 }
 function bgSubtlerPressed(color) {
-  return bgSubtlerPressedMap[color];
+  return isParticipantColorScheme(color) ? participantColorTokenSets[color].backgroundSubtlerPressed : bgSubtlerPressedMap[color];
 }
 function borderAccent(color) {
-  return borderAccentMap[color];
+  return isParticipantColorScheme(color) ? participantColorTokenSets[color].borderAccent : borderAccentMap[color];
 }
 function textAccent(color) {
-  return textAccentMap[color];
+  return isParticipantColorScheme(color) ? participantColorTokenSets[color].textAccent : textAccentMap[color];
 }
 
 /** Ring colour for an active (scroll-target) deleted block outline. */