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

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

@@ -72,14 +72,26 @@ var createAttributionScheme = function createAttributionScheme(color) {
   });
 };
 
-/** Maps public schemes and attribution-only accents to their data objects. */
+/** Maps public schemes and attribution-only participant slots to their data objects. */
 var colorSchemeRegistry = exports.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/cjs/pm-plugins/decorations/colorSchemes/types.js

@@ -2,4 +2,19 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+exports.PARTICIPANT_COLOR_SCHEMES = void 0;
+/** Attribution-only participant slots selected by the plugin, never by consumers. */
+var PARTICIPANT_COLOR_SCHEMES = exports.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/cjs/pm-plugins/decorations/createNodeChangedDecorationWidget.js

@@ -347,7 +347,7 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
       decorations.push(leftAnchor);
     }
   }
-  decorations.push(_view.Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread({}, (0, _decorationKeys.buildDiffDecorationSpec)(_objectSpread({
+  decorations.push(_view.Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread(_objectSpread({}, (0, _decorationKeys.buildDiffDecorationSpec)(_objectSpread({
     decorationType: 'widget',
     diffId: diffId,
     isActive: isActive,
@@ -356,7 +356,9 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
     // placeBelow anchors at the end of the new content, so render on the
     // trailing side (1); otherwise render before the new content (-1).
     side: placeBelow ? 1 : -1
-  }))), {}, {
+  }))), (0, _fg.fg)('platform_editor_diff_inline_mark_changes') && {
+    marks: []
+  }), {}, {
     destroy: function destroy() {
       var _constrainMediaObserv2;
       return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();

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

@@ -8,7 +8,7 @@ exports.stepIsValidAttrChange = exports.isInlineAttrChangeNodeName = exports.get
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
 var _omit = _interopRequireDefault(require("lodash/omit"));
-var _steps = require("@atlaskit/adf-schema/steps");
+var _setAttrs = require("@atlaskit/adf-schema/steps/set-attrs");
 var _deprecatedPlatformFeatureExperiments = require("@atlaskit/editor-common/deprecated-platform-feature-experiments");
 var _nodeTypeUtils = require("@atlaskit/editor-common/utils/node-type-utils");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
@@ -72,7 +72,7 @@ var getAttrChangeRanges = exports.getAttrChangeRanges = function getAttrChangeRa
       finalPos = attrStepContext.finalPos,
       originalPos = attrStepContext.originalPos,
       step = attrStepContext.step;
-    if (!(step instanceof _transform.AttrStep) && !(step instanceof _steps.SetAttrsStep)) {
+    if (!(step instanceof _transform.AttrStep) && !(step instanceof _setAttrs.SetAttrsStep)) {
       return undefined;
     }
     var stepAttrs = getStepAttrs(step);
@@ -203,7 +203,7 @@ var getAttrChangeRanges = exports.getAttrChangeRanges = function getAttrChangeRa
  */
 var stepIsValidAttrChange = exports.stepIsValidAttrChange = function stepIsValidAttrChange(step, beforeDoc, afterDoc) {
   try {
-    if (step instanceof _transform.AttrStep || step instanceof _steps.SetAttrsStep) {
+    if (step instanceof _transform.AttrStep || step instanceof _setAttrs.SetAttrsStep) {
       var attrStepAfter = afterDoc.nodeAt(step.pos);
       var attrStepBefore = beforeDoc.nodeAt(step.pos);
       // The change affected the document

package/dist/es2019/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 @@ const encodeNodeWithAttrs = (node, attrNames) => {
   return `${node.type.name}|${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.
-const encodeCharacterWithMarks = (char, marks) => {
-  if (marks.length === 0) {
-    // Fast path: unmarked text keeps the numeric char code (unchanged behaviour).
-    return char;
-  }
-  const markKey = marks.map(mark => {
-    var _mark$attrs;
-    const attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
-    const attrParts = Object.keys(attrs).sort().map(key => {
-      var _attrs$key;
-      return `${key}=${JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null)}`;
-    });
-    return attrParts.length > 0 ? `${mark.type.name}(${attrParts.join(',')})` : mark.type.name;
-  }).sort().join('&');
-  return `${char}\u0000${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/es2019/pm-plugins/calculateDiff/calculateDiffDecorations.js

@@ -17,10 +17,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';
@@ -354,10 +355,11 @@ const calculateDiffDecorationsInner = ({
       };
     }
   }
-  // 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.
-  const 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.
+  const {
+    tokenEncoder,
+    shouldHideMarkOnlyDeletions
+  } = selectTokenEncoder(diffType === 'smart' && fg('platform_editor_ai_smart_diff'));
   let changes;
   let attributedChanges = [];
   let attributionColors;
@@ -409,6 +411,16 @@ const calculateDiffDecorationsInner = ({
     const changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     const 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.
+    const isMarkOnly = shouldHideMarkOnlyDeletions && hideDeletedDiffs && change.deleted.length > 0 && isMarkOnlyChange({
+      change,
+      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.
@@ -439,7 +451,7 @@ const calculateDiffDecorationsInner = ({
       // 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.
-      const willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      const 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
@@ -501,7 +513,7 @@ const calculateDiffDecorationsInner = ({
         coarseTableCellsOnly: useCoarseTableDecoration
       }));
     }
-    if (change.deleted.length > 0) {
+    if (change.deleted.length > 0 && !isMarkOnly) {
       const shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!shouldHideDeleted) {
         decorations.push(...createNodeChangedDecorationWidget({

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

@@ -14,10 +14,10 @@
  * 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';
 /**
@@ -64,11 +64,11 @@ export const computeDiffChanges = ({
     };
   }
 
-  // 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.)
-  const 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.
+  const {
+    tokenEncoder
+  } = selectTokenEncoder(diffType === 'smart');
   const changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {

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

@@ -0,0 +1,36 @@
+/** U+0000 cannot occur in ProseMirror text content, so a token can never be ambiguous. */
+const MARK_KEY_SEPARATOR = '\u0000';
+const buildMarkKey = marks => marks.map(mark => {
+  var _mark$attrs;
+  const attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
+  const attrParts = Object.keys(attrs).sort().map(key => {
+    var _attrs$key;
+    return `${key}=${JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null)}`;
+  });
+  return attrParts.length > 0 ? `${mark.type.name}(${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.
+ */
+const 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 const encodeCharacterWithMarks = (char, marks) => {
+  if (marks.length === 0) {
+    return char;
+  }
+  let markKey = markKeyCache.get(marks);
+  if (markKey === undefined) {
+    markKey = buildMarkKey(marks);
+    markKeyCache.set(marks, markKey);
+  }
+  return `${char}${MARK_KEY_SEPARATOR}${markKey}`;
+};

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

@@ -0,0 +1,47 @@
+/** U+0000 cannot occur in ProseMirror text content, so this cannot collide with document text. */
+const NODE_MARKER = '\u0000';
+
+/**
+ * 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.
+ */
+const markFreeSignature = (doc, from, to) => {
+  const parts = [];
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isText) {
+      var _node$text;
+      const start = Math.max(pos, from) - pos;
+      const 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(`${NODE_MARKER}${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 const isMarkOnlyChange = ({
+  change,
+  newDoc,
+  originalDoc
+}) => {
+  const {
+    fromA,
+    toA,
+    fromB,
+    toB
+  } = change;
+  const isPureInsertionOrDeletion = toA === fromA || toB === fromB;
+  if (isPureInsertionOrDeletion || toA - fromA !== toB - fromB) {
+    return false;
+  }
+  return markFreeSignature(originalDoc, fromA, toA) === markFreeSignature(newDoc, fromB, toB);
+};

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

@@ -0,0 +1,25 @@
+import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
+
+/** Mirrors the library's private (unexported) `typeID` so node-end tokens match. */
+const typeID = type => {
+  const cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  let 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 const markAwareTokenEncoder = {
+  encodeCharacter: (char, marks) => encodeCharacterWithMarks(char, marks),
+  encodeNodeStart: node => node.type.name,
+  encodeNodeEnd: node => -typeID(node.type),
+  compareTokens: (a, b) => a === b
+};

package/dist/es2019/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 const 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/es2019/pm-plugins/calculateDiff/simplifySteps.js

@@ -1,4 +1,4 @@
-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/es2019/pm-plugins/decorations/colorSchemes/attributions.js

@@ -1,18 +1,40 @@
+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';
-const ATTRIBUTION_COLOR_PALETTE = ['purple', 'blue', 'teal', 'magenta', 'orange', 'green'];
-
-/** `userId` is primary; `agentId`, or `agentType` as its fallback, separates shared users. */
-export const 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.
+ */
+const getAttributionIdentity = attribution => {
   var _attribution$userId, _attribution$agentId, _attribution$agentTyp;
   const userId = attribution === null || attribution === void 0 ? void 0 : (_attribution$userId = attribution.userId) === null || _attribution$userId === void 0 ? void 0 : _attribution$userId.trim();
   const agentId = attribution === null || attribution === void 0 ? void 0 : (_attribution$agentId = attribution.agentId) === null || _attribution$agentId === void 0 ? void 0 : _attribution$agentId.trim();
   const agentType = attribution === null || attribution === void 0 ? void 0 : (_attribution$agentTyp = attribution.agentType) === null || _attribution$agentTyp === void 0 ? void 0 : _attribution$agentTyp.trim();
-  if (!userId && !agentId && !agentType) {
+  let colorSeed;
+  if (agentId) {
+    colorSeed = agentId;
+  } else if (agentType) {
+    colorSeed = userId ? `user:${userId}|agent:type:${agentType}` : `agent:type:${agentType}`;
+  } else if (userId) {
+    colorSeed = userId;
+  } else {
     return undefined;
   }
   const agentIdentity = agentId || (agentType ? `type:${agentType}` : '');
-  return `user:${userId !== null && userId !== void 0 ? userId : ''}|agent:${agentIdentity}`;
+  return {
+    colorSeed,
+    key: `user:${userId !== null && userId !== void 0 ? userId : ''}|agent:${agentIdentity}`
+  };
+};
+
+/** `userId` is primary; `agentId`, or `agentType` as its fallback, separates shared users. */
+export const getAttributionKey = attribution => {
+  var _getAttributionIdenti;
+  return (_getAttributionIdenti = getAttributionIdentity(attribution)) === null || _getAttributionIdenti === void 0 ? void 0 : _getAttributionIdenti.key;
 };
 export const areAttributionColorGatesEnabled = () => fg('confluence_ncs_step_diffing_version_history') && isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor');
 export const isAttributionColoringEnabled = stepAttributions => {
@@ -23,8 +45,21 @@ export const isAttributionColoringEnabled = stepAttributions => {
   return attributionKeys.size > 1;
 };
 export const createAttributionColorMap = stepAttributions => {
-  const keys = Array.from(new Set(stepAttributions.map(getAttributionKey).filter(key => key !== undefined))).sort();
-  return new Map(keys.map((key, index) => [key, ATTRIBUTION_COLOR_PALETTE[index % ATTRIBUTION_COLOR_PALETTE.length]]));
+  const colors = new Map();
+  for (const attribution of stepAttributions) {
+    const identity = getAttributionIdentity(attribution);
+    if (!identity || colors.has(identity.key)) {
+      continue;
+    }
+    const {
+      index
+    } = getParticipantColor(identity.colorSeed);
+    const participantColorScheme = PARTICIPANT_COLOR_SCHEMES[index];
+    if (participantColorScheme) {
+      colors.set(identity.key, participantColorScheme);
+    }
+  }
+  return colors;
 };
 const getLatestAttribution = changes => {
   const data = changes.flatMap(change => [...change.deleted, ...change.inserted]).map(span => span.data).filter(value => typeof value === 'object' && value !== null && 'stepIndex' in value && typeof value.stepIndex === 'number');
@@ -36,8 +71,17 @@ const changesOverlap = (change, attributedChange) => {
   const deletedOverlap = change.deleted.length > 0 && attributedChange.deleted.length > 0 && rangesOverlap(change.fromA, change.toA, attributedChange.fromA, attributedChange.toA);
   return insertedOverlap || deletedOverlap;
 };
+const getParticipantColorSchemeForChanges = (changes, attributionColors) => {
+  const key = getAttributionKey(getLatestAttribution(changes));
+  return key ? attributionColors.get(key) : undefined;
+};
 export const getColorSchemeForChange = (change, attributedChanges, attributionColors, fallback) => {
-  var _attributionColors$ge;
-  const key = getAttributionKey(getLatestAttribution(attributedChanges.filter(attributedChange => 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(attributedChange => changesOverlap(change, attributedChange)), attributionColors)) !== null && _ref !== void 0 ? _ref : fallback
+  );
 };

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

@@ -1,4 +1,7 @@
 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.
 
@@ -11,7 +14,8 @@ const 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)"
 };
 const bgSubtlestPressedMap = {
   green: "var(--ds-background-accent-green-subtlest-pressed, #97EDC9)",
@@ -22,7 +26,8 @@ const 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)"
 };
 const bgSubtlerMap = {
   green: "var(--ds-background-accent-green-subtler, #BAF3DB)",
@@ -33,7 +38,8 @@ const 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)"
 };
 const bgSubtlerPressedMap = {
   green: "var(--ds-background-accent-green-subtler-pressed, #7EE2B8)",
@@ -44,7 +50,8 @@ const 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)"
 };
 const borderAccentMap = {
   green: "var(--ds-border-accent-green, #22A06B)",
@@ -55,7 +62,8 @@ const 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)"
 };
 const textAccentMap = {
   green: "var(--ds-text-accent-green, #216E4E)",
@@ -66,25 +74,72 @@ const 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. */
+const 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.
+ */
+const participantColorTokenSets = Object.fromEntries(PARTICIPANT_COLOR_SCHEMES.map((scheme, index) => {
+  const participantColor = participantColors[index];
+  if (!participantColor) {
+    throw new Error(`Missing shared participant colour for show-diff slot ${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
+  }];
+}));
+const participantColorSchemeSet = new Set(PARTICIPANT_COLOR_SCHEMES);
+const isParticipantColorScheme = color => 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. */