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

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

@@ -61,14 +61,26 @@ const createAttributionScheme = color => ({
   deletedCellColor: color
 });
 
-/** Maps public schemes and attribution-only accents to their data objects. */
+/** Maps public schemes and attribution-only participant slots to their data objects. */
 export const colorSchemeRegistry = {
-  blue: createAttributionScheme('blue'),
-  green: createAttributionScheme('green'),
-  magenta: createAttributionScheme('magenta'),
-  orange: createAttributionScheme('orange'),
-  purple: createAttributionScheme('purple'),
-  teal: createAttributionScheme('teal'),
+  'red-bolder': createAttributionScheme('red-bolder'),
+  'blue-bolder': createAttributionScheme('blue-bolder'),
+  'green-bolder': createAttributionScheme('green-bolder'),
+  'yellow-bolder': createAttributionScheme('yellow-bolder'),
+  'purple-bolder': createAttributionScheme('purple-bolder'),
+  'magenta-bolder': createAttributionScheme('magenta-bolder'),
+  'teal-bolder': createAttributionScheme('teal-bolder'),
+  'orange-bolder': createAttributionScheme('orange-bolder'),
+  'lime-bolder': createAttributionScheme('lime-bolder'),
+  'gray-bolder': createAttributionScheme('gray-bolder'),
+  'blue-subtle': createAttributionScheme('blue-subtle'),
+  'red-subtle': createAttributionScheme('red-subtle'),
+  'orange-subtle': createAttributionScheme('orange-subtle'),
+  'yellow-subtle': createAttributionScheme('yellow-subtle'),
+  'green-subtle': createAttributionScheme('green-subtle'),
+  'teal-subtle': createAttributionScheme('teal-subtle'),
+  'purple-subtle': createAttributionScheme('purple-subtle'),
+  'magenta-subtle': createAttributionScheme('magenta-subtle'),
   traditional: traditionalScheme,
   standard: standardScheme
 };

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

@@ -1 +1,14 @@
-export {};
+/** Attribution-only participant slots selected by the plugin, never by consumers. */
+export const PARTICIPANT_COLOR_SCHEMES = ['red-bolder', 'blue-bolder', 'green-bolder', 'yellow-bolder', 'purple-bolder', 'magenta-bolder', 'teal-bolder', 'orange-bolder', 'lime-bolder', 'gray-bolder', 'blue-subtle', 'red-subtle', 'orange-subtle', 'yellow-subtle', 'green-subtle', 'teal-subtle', 'purple-subtle', 'magenta-subtle'];
+
+/** ADS accent hues used by the public and participant colour schemes. */
+
+/** A public scheme or an attribution participant slot resolved internally for one change. */
+
+/** A colour value that the factory expands into a complete set of diff-safe ADS tokens. */
+
+/**
+ * A show-diff colour scheme. Colour fields are ADS hues or shared participant slots that
+ * `factory.ts` expands into token paths; the rest encode structural differences no colour can
+ * express. Ring widths, padding, radius and pointer-events are fixed in the factory, not per scheme.
+ */

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

@@ -338,6 +338,13 @@ export const createNodeChangedDecorationWidget = ({
         side: placeBelow ? 1 : -1
       })
     }),
+    // Without an explicit mark set, prosemirror-view wraps the widget in the marks of the
+    // adjacent text in the NEW document. `dom` already carries the original marks, so a
+    // formatting change would render the deleted side wrapped in the very mark the edit
+    // introduced — unbolded text shown struck through but still bold.
+    ...(fg('platform_editor_diff_inline_mark_changes') && {
+      marks: []
+    }),
     destroy: () => {
       var _constrainMediaObserv2;
       return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();

package/dist/es2019/pm-plugins/decorations/utils/getAttrChangeRanges.js

@@ -1,6 +1,6 @@
 import isEqual from 'lodash/isEqual';
 import omit from 'lodash/omit';
-import { SetAttrsStep } from '@atlaskit/adf-schema/steps';
+import { SetAttrsStep } from '@atlaskit/adf-schema/steps/set-attrs';
 import { isExperimentEnabled } from '@atlaskit/editor-common/deprecated-platform-feature-experiments';
 import { getBaseNodeTypeName } from '@atlaskit/editor-common/utils/node-type-utils';
 import { AttrStep } from '@atlaskit/editor-prosemirror/transform';

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

@@ -1,5 +1,6 @@
 import { getBaseNodeTypeName } from '@atlaskit/editor-common/utils/node-type-utils';
 import { getDiffableAttrNames } from '../decorations/utils/diffableAttrs';
+import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
 
 /**
  * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
@@ -20,27 +21,6 @@ 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`.

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

@@ -25,10 +25,11 @@ import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { getDefaultDiffType, isExtendedEnabled } from '../isExtendedEnabled';
-import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
+import { isMarkOnlyChange } from './isMarkOnlyChange';
 import { optimizeChanges } from './optimizeChanges';
+import { selectTokenEncoder } from './selectTokenEncoder';
 import { simplifyChangesWithAttribution } from './simplifyChangesWithAttribution';
 import { simplifySteps, simplifyStepsWithAttribution } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
@@ -382,10 +383,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' && fg('platform_editor_ai_smart_diff') ? attrAwareTokenEncoder : undefined;
+  // The attribute-aware encoder is only needed by the smart classifier and is gated with it.
+  var _selectTokenEncoder = selectTokenEncoder(diffType === 'smart' && fg('platform_editor_ai_smart_diff')),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder,
+    shouldHideMarkOnlyDeletions = _selectTokenEncoder.shouldHideMarkOnlyDeletions;
   var changes;
   var attributedChanges = [];
   var attributionColors;
@@ -440,6 +441,16 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
     var changeColorScheme = attributionColors ? 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 && 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.
@@ -470,7 +481,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 && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      var willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !(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
@@ -541,7 +552,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
         coarseTableCellsOnly: useCoarseTableDecoration
       }))));
     }
-    if (change.deleted.length > 0) {
+    if (change.deleted.length > 0 && !isMarkOnly) {
       var _shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, _toConsumableArray(createNodeChangedDecorationWidget(_objectSpread(_objectSpread({

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

@@ -17,10 +17,10 @@ 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';
+import { selectTokenEncoder } from './selectTokenEncoder';
 import { simplifySteps } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
 /**
@@ -77,11 +77,10 @@ export var computeDiffChanges = function computeDiffChanges(_ref) {
     };
   }
 
-  // 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;
+  // This utility does not apply the smart-diff gate (see the file docstring); a caller
+  // requesting `smart` is already behind it.
+  var _selectTokenEncoder = selectTokenEncoder(diffType === 'smart'),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder;
   var changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {

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

@@ -0,0 +1,38 @@
+/** 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.
+ */
+export var 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/esm/pm-plugins/calculateDiff/isMarkOnlyChange.js

@@ -0,0 +1,44 @@
+/** 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.
+ */
+export var 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/esm/pm-plugins/calculateDiff/markAwareTokenEncoder.js

@@ -0,0 +1,33 @@
+import { encodeCharacterWithMarks } from './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.
+ */
+export var markAwareTokenEncoder = {
+  encodeCharacter: function encodeCharacter(char, marks) {
+    return 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/esm/pm-plugins/calculateDiff/selectTokenEncoder.js

@@ -0,0 +1,30 @@
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
+import { markAwareTokenEncoder } from './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.
+ */
+export var selectTokenEncoder = function selectTokenEncoder(useAttrAwareEncoder) {
+  if (useAttrAwareEncoder) {
+    return {
+      tokenEncoder: attrAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: false
+    };
+  }
+  if (fg('platform_editor_diff_inline_mark_changes')) {
+    return {
+      tokenEncoder: markAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: true
+    };
+  }
+  return {
+    tokenEncoder: undefined,
+    shouldHideMarkOnlyDeletions: false
+  };
+};

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

@@ -4,7 +4,7 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 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 { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps/analytics';
 import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
 import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
 import { getAttributionKey } from '../decorations/colorSchemes/attributions';

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

@@ -1,20 +1,45 @@
 import _typeof from "@babel/runtime/helpers/typeof";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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; }
+import { getParticipantColor } from '@atlaskit/editor-shared-styles/utils';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { fg } from '@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. */
-export var getAttributionKey = function getAttributionKey(attribution) {
+import { PARTICIPANT_COLOR_SCHEMES } from './types';
+/**
+ * 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. */
+export var getAttributionKey = function getAttributionKey(attribution) {
+  var _getAttributionIdenti;
+  return (_getAttributionIdenti = getAttributionIdentity(attribution)) === null || _getAttributionIdenti === void 0 ? void 0 : _getAttributionIdenti.key;
 };
 export var areAttributionColorGatesEnabled = function areAttributionColorGatesEnabled() {
   return fg('confluence_ncs_step_diffing_version_history') && isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor');
@@ -29,12 +54,29 @@ export var isAttributionColoringEnabled = function isAttributionColoringEnabled(
   return attributionKeys.size > 1;
 };
 export var 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 = getParticipantColor(identity.colorSeed),
+        index = _getParticipantColor.index;
+      var participantColorScheme = 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) {
@@ -56,10 +98,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;
+};
 export var 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/esm/pm-plugins/decorations/colorSchemes/factory.js

@@ -2,6 +2,9 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 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 { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
+import { participantColors } from '@atlaskit/editor-shared-styles/constants';
+import { PARTICIPANT_COLOR_SCHEMES } from './types';
+
 // token() is a build-time transform needing static literals, so pre-compute every colour's
 // tokens here and index by name at runtime.
 
@@ -14,7 +17,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)",
@@ -25,7 +29,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)",
@@ -36,7 +41,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)",
@@ -47,7 +53,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)",
@@ -58,7 +65,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)",
@@ -69,25 +77,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(PARTICIPANT_COLOR_SCHEMES.map(function (scheme, index) {
+  var participantColor = 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(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. */