@atlaskit/editor-plugin-show-diff 16.1.1 → 17.0.0

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

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

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

@@ -1,6 +1,7 @@
 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 { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { getStandardDeletedTextDecorationStyle } from './getStandardDeletedTextDecorationStyle';
 
@@ -118,40 +119,48 @@ var textAccentMap = {
   gray: "var(--ds-text-accent-gray, #505258)",
   lime: "var(--ds-text-accent-lime, #4C6B1F)"
 };
+var getBrand = function getBrand(color) {
+  return Object.prototype.hasOwnProperty.call(agentBrandColorSchemes, color) ? agentBrandColorSchemes[color] : undefined;
+};
 function bgSubtlest(color) {
-  return bgSubtlestMap[color];
+  var _getBrand$background, _getBrand;
+  return (_getBrand$background = (_getBrand = getBrand(color)) === null || _getBrand === void 0 ? void 0 : _getBrand.background) !== null && _getBrand$background !== void 0 ? _getBrand$background : bgSubtlestMap[color];
 }
 function bgSubtlestPressed(color) {
-  return bgSubtlestPressedMap[color];
+  var _getBrand$background2, _getBrand2;
+  return (_getBrand$background2 = (_getBrand2 = getBrand(color)) === null || _getBrand2 === void 0 ? void 0 : _getBrand2.background) !== null && _getBrand$background2 !== void 0 ? _getBrand$background2 : bgSubtlestPressedMap[color];
 }
 function bgSubtler(color) {
-  return bgSubtlerMap[color];
+  var _getBrand$border, _getBrand3;
+  return (_getBrand$border = (_getBrand3 = getBrand(color)) === null || _getBrand3 === void 0 ? void 0 : _getBrand3.border) !== null && _getBrand$border !== void 0 ? _getBrand$border : bgSubtlerMap[color];
 }
 function bgBolder(color) {
-  return bgBolderMap[color];
+  var _getBrand$bold, _getBrand4;
+  return (_getBrand$bold = (_getBrand4 = getBrand(color)) === null || _getBrand4 === void 0 ? void 0 : _getBrand4.bold) !== null && _getBrand$bold !== void 0 ? _getBrand$bold : bgBolderMap[color];
 }
 function bgSubtlerPressed(color) {
-  return bgSubtlerPressedMap[color];
+  var _getBrand$background3, _getBrand5;
+  return (_getBrand$background3 = (_getBrand5 = getBrand(color)) === null || _getBrand5 === void 0 ? void 0 : _getBrand5.background) !== null && _getBrand$background3 !== void 0 ? _getBrand$background3 : bgSubtlerPressedMap[color];
 }
 function borderAccent(color) {
-  return borderAccentMap[color];
+  var _getBrand$border2, _getBrand6;
+  return (_getBrand$border2 = (_getBrand6 = getBrand(color)) === null || _getBrand6 === void 0 ? void 0 : _getBrand6.border) !== null && _getBrand$border2 !== void 0 ? _getBrand$border2 : borderAccentMap[color];
 }
 function textAccent(color) {
-  return textAccentMap[color];
+  var _getBrand$accentText, _getBrand7;
+  return (_getBrand$accentText = (_getBrand7 = getBrand(color)) === null || _getBrand7 === void 0 ? void 0 : _getBrand7.accentText) !== null && _getBrand$accentText !== void 0 ? _getBrand$accentText : textAccentMap[color];
+}
+function deletedBackground(color) {
+  var _getBrand$emphasisBac, _getBrand8;
+  return (_getBrand$emphasisBac = (_getBrand8 = getBrand(color)) === null || _getBrand8 === void 0 ? void 0 : _getBrand8.emphasisBackground) !== null && _getBrand$emphasisBac !== void 0 ? _getBrand$emphasisBac : bgSubtlest(color);
 }
 
-/**
- * Presentation tokens for a contributor tag in one diff colour.
- *
- * A `bolder` fill rather than the `subtlest` tint the highlight uses: the tag is a label on the
- * change, and at tag size a tint reads as a second, weaker highlight sitting above the real one.
- * `inverse` is the only text tone that reads on a bolder fill, and it needs no per-colour map —
- * which is also why the tag carries no border: the fill alone bounds it.
- */
+/** Contributor tags use a bold fill with a contrasting foreground, including branded schemes. */
 export function getAccentTokens(color) {
+  var _getBrand$boldText, _getBrand9;
   return {
     background: bgBolder(color),
-    text: "var(--ds-text-inverse, #FFFFFF)"
+    text: (_getBrand$boldText = (_getBrand9 = getBrand(color)) === null || _getBrand9 === void 0 ? void 0 : _getBrand9.boldText) !== null && _getBrand$boldText !== void 0 ? _getBrand$boldText : "var(--ds-text-inverse, #FFFFFF)"
   };
 }
 
@@ -173,18 +182,23 @@ function deletedCellOutline(colors) {
 // --- Inserted content styles ---
 
 function insertedInlineBorderColor(colors) {
-  return colors.insertedInlineBorderTone === 'backgroundHovered' ? bgSubtlestHoveredMap[colors.insertColor] : borderAccent(colors.insertColor);
+  var _getBrand$border3, _getBrand0;
+  return colors.insertedInlineBorderTone === 'backgroundHovered' ? (_getBrand$border3 = (_getBrand0 = getBrand(colors.insertColor)) === null || _getBrand0 === void 0 ? void 0 : _getBrand0.border) !== null && _getBrand$border3 !== void 0 ? _getBrand$border3 : bgSubtlestHoveredMap[colors.insertColor] : borderAccent(colors.insertColor);
 }
 
 /** Inline inserted content — default state. */
 export function buildInsertStyle(colors) {
-  return convertToInlineCss({
-    background: bgSubtlest(colors.insertColor),
+  var brand = getBrand(colors.insertColor);
+  return convertToInlineCss(_objectSpread(_objectSpread({
+    background: bgSubtlest(colors.insertColor)
+  }, brand ? {
+    color: brand.text
+  } : {}), {}, {
     textDecoration: 'underline',
     textDecorationStyle: colors.insertUnderlineStyle,
     textDecorationThickness: "var(--ds-space-025, 2px)",
     textDecorationColor: borderAccent(colors.insertColor)
-  });
+  }));
 }
 
 /** Inline insert style for content within a block node (no background, underline only). */
@@ -199,11 +213,15 @@ export function buildInsertStyleInBlock(colors) {
 
 /** Extended insert style — background + border-bottom underline. */
 export function buildInsertStyleExtended(colors) {
-  return convertToInlineCss({
-    background: bgSubtlest(colors.insertColor),
+  var brand = getBrand(colors.insertColor);
+  return convertToInlineCss(_objectSpread(_objectSpread({
+    background: bgSubtlest(colors.insertColor)
+  }, brand ? {
+    color: brand.text
+  } : {}), {}, {
     borderBottom: "2px solid ".concat(insertedInlineBorderColor(colors)),
     padding: "1px 0 2px"
-  });
+  }));
 }
 
 /** Extended insert style for content within a block node (border-bottom only, no background). */
@@ -216,27 +234,39 @@ export function buildInsertStyleInBlockExtended(colors) {
 
 /** Active state of the extended insert style. */
 export function buildInsertStyleExtendedActive(colors) {
-  return convertToInlineCss({
-    background: bgSubtlerPressed(colors.insertActiveColor),
+  var brand = getBrand(colors.insertColor);
+  return convertToInlineCss(_objectSpread(_objectSpread({
+    background: bgSubtlerPressed(colors.insertActiveColor)
+  }, brand ? {
+    color: brand.text
+  } : {}), {}, {
     borderBottom: "2px solid ".concat(borderAccent(colors.insertColor)),
     padding: "1px 0 2px"
-  });
+  }));
 }
 
 /** Extended insert style without underline — background + padding only. */
 export function buildInsertStyleExtendedNoUnderline(colors) {
-  return convertToInlineCss({
-    background: bgSubtlest(colors.insertColor),
+  var brand = getBrand(colors.insertColor);
+  return convertToInlineCss(_objectSpread(_objectSpread({
+    background: bgSubtlest(colors.insertColor)
+  }, brand ? {
+    color: brand.text
+  } : {}), {}, {
     padding: "1px 0 2px"
-  });
+  }));
 }
 
 /** Active state of the no-underline extended insert style. */
 export function buildInsertStyleExtendedNoUnderlineActive(colors) {
-  return convertToInlineCss({
-    background: bgSubtlerPressed(colors.insertActiveColor),
+  var brand = getBrand(colors.insertColor);
+  return convertToInlineCss(_objectSpread(_objectSpread({
+    background: bgSubtlerPressed(colors.insertActiveColor)
+  }, brand ? {
+    color: brand.text
+  } : {}), {}, {
     padding: "1px 0 2px"
-  });
+  }));
 }
 
 /** No-underline extended insert style for block content (padding only). */
@@ -248,13 +278,17 @@ export function buildInsertStyleInBlockExtendedNoUnderline(_colors) {
 
 /** Inline inserted content — active/focused state. */
 export function buildInsertStyleActive(colors) {
-  return convertToInlineCss({
-    background: bgSubtlerPressed(colors.insertActiveColor),
+  var brand = getBrand(colors.insertColor);
+  return convertToInlineCss(_objectSpread(_objectSpread({
+    background: bgSubtlerPressed(colors.insertActiveColor)
+  }, brand ? {
+    color: brand.text
+  } : {}), {}, {
     textDecoration: 'underline',
     textDecorationStyle: colors.insertUnderlineStyle,
     textDecorationThickness: "var(--ds-space-025, 2px)",
     textDecorationColor: textAccent(colors.insertActiveColor)
-  });
+  }));
 }
 
 // --- Deleted inline content styles ---
@@ -612,7 +646,7 @@ export function buildDeletedInlineContentStyleExtended(colors) {
   // Under 'underline' emphasis the highlight stays on its resting tint — the same one hover paints —
   // so only the border carries the emphasis.
   var isUnderlineEmphasis = isActive && usesUnderlineEmphasis(colors);
-  var backgroundColor = isActive && !isUnderlineEmphasis && colors.deletedInlineBorderTone === 'background' ? bgSubtlerPressed(colors.deleteActiveColor) : bgSubtlest(colors.deleteColor);
+  var backgroundColor = isActive && !isUnderlineEmphasis && colors.deletedInlineBorderTone === 'background' ? bgSubtlerPressed(colors.deleteActiveColor) : deletedBackground(colors.deleteColor);
   var borderColor = isUnderlineEmphasis ? borderAccent(colors.deleteActiveColor) : colors.deletedInlineBorderTone === 'background' ? backgroundColor : borderAccent(colors.deleteColor);
   return convertToInlineCss({
     backgroundColor: backgroundColor,
@@ -822,7 +856,7 @@ export function getDeletedInlineRevealColors(colors) {
  * paints at rest, so hovering restores the appearance rather than introducing a third one.
  */
 export function getDeletedHighlightHoverColor(colors) {
-  return bgSubtlest(colors.deleteColor);
+  return deletedBackground(colors.deleteColor);
 }
 
 /**

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

@@ -1,6 +1,7 @@
 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 { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { PARTICIPANT_COLOR_SCHEMES } from './types';
 
 /** Green insertions, red deletions. */
@@ -78,9 +79,12 @@ var createAttributionScheme = function createAttributionScheme(color) {
 var attributionColorSchemes = Object.fromEntries(PARTICIPANT_COLOR_SCHEMES.map(function (color) {
   return [color, createAttributionScheme(color)];
 }));
+var brandSchemes = Object.fromEntries(Object.keys(agentBrandColorSchemes).map(function (scheme) {
+  return [scheme, createAttributionScheme(scheme)];
+}));
 
 /** Maps public schemes and attribution-only participant slots to their data objects. */
-export var colorSchemeRegistry = _objectSpread(_objectSpread({}, attributionColorSchemes), {}, {
+export var colorSchemeRegistry = _objectSpread(_objectSpread(_objectSpread({}, attributionColorSchemes), brandSchemes), {}, {
   traditional: traditionalScheme,
   standard: standardScheme
 });

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

@@ -5,8 +5,6 @@ export var PARTICIPANT_COLOR_SCHEMES = ['red', 'blue', 'green', 'yellow', 'purpl
 
 /** 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 show-diff colour scheme. Colour fields are ADS hues that `factory.ts` expands into token paths;
  * the rest encode structural differences no colour can express. Ring widths, padding, radius and

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

@@ -8,6 +8,7 @@ import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { isExtendedEnabled } from '../isExtendedEnabled';
+import { isTaggableBlockNode } from '../utils/taggableBlockNodes';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedBlockNodeStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildInsertedBlockNodeStyle } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
@@ -27,13 +28,6 @@ var UNSTYLED_NODES = ['mediaSingle', 'mediaGroup', 'table',
 'heading', 'hardBreak', 'decisionList', 'taskList', 'bulletList', 'orderedList', 'layoutSection'];
 var CELL_NODES = ['tableCell', 'tableHeader'];
 
-/**
- * Block nodes that host a contributor tag of their own — those whose whole box reads as one change.
- * Lists and tables are excluded: they decorate per item and per cell, with no one-tag-per-block
- * design yet. `blockCard` covers the datasource variant, which is the same node type.
- */
-var TAGGABLE_BLOCK_NODES = new Set(['blockCard', 'blockquote', 'bodiedExtension', 'codeBlock', 'embedCard', 'expand', 'extension', 'media', 'multiBodiedExtension', 'panel', 'rule']);
-
 /** Panels, rules and media can also sit in a table cell, which is out of scope for block tags. */
 var isInsideTable = function isInsideTable(doc, pos) {
   return findParentNodeClosestToPos(doc.resolve(pos), function (node) {
@@ -41,13 +35,23 @@ var isInsideTable = function isInsideTable(doc, pos) {
   }) !== undefined;
 };
 
-/** Whether this block can host a contributor tag of its own. */
+/**
+ * Whether this block can host a contributor tag of its own.
+ *
+ * The node type is resolved from the document rather than matched on `change.name`, so a schema
+ * variant is recognised as the type it varies — see `isTaggableBlockNode`. `from` is the node's own
+ * position, so `nodeAt` returns exactly the node being decorated.
+ */
 var canTagBlock = function canTagBlock(_ref) {
+  var _doc$nodeAt;
   var diffType = _ref.diffType,
     doc = _ref.doc,
-    from = _ref.from,
-    name = _ref.name;
-  return doc !== undefined && isExtendedEnabled(diffType) && TAGGABLE_BLOCK_NODES.has(name) && !isInsideTable(doc, from);
+    from = _ref.from;
+  if (doc === undefined || !isExtendedEnabled(diffType)) {
+    return false;
+  }
+  var nodeType = (_doc$nodeAt = doc.nodeAt(from)) === null || _doc$nodeAt === void 0 ? void 0 : _doc$nodeAt.type;
+  return nodeType !== undefined && isTaggableBlockNode(nodeType) && !isInsideTable(doc, from);
 };
 
 /** Positioning context for the cell overlay widget decorations. */
@@ -189,8 +193,7 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
   var shouldTagBlock = showContributorTags && canTagBlock({
     diffType: diffType,
     doc: doc,
-    from: change.from,
-    name: change.name
+    from: change.from
   });
   // Named so this block's own tag can position against it; see `createContributorTagWidget`.
   var tagAnchorName = shouldTagBlock && isContributorTagWidgetEnabled() ? buildAnchorDecorationKey({
@@ -234,7 +237,9 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
       key: 'cell-overlay-decoration'
     }));
   }
-  // isInserted is only read under the extended experience, so pass it unconditionally.
+  // isInserted is only read under the extended experience, so pass it unconditionally. `change.name`
+  // verbatim: base-name resolution stays in `canTagBlock`, which needs tags on, so a schema
+  // variant's legacy style is untouched — see `resolveBaseNodeName`.
   var nodeStyle = getBlockNodeStyle({
     nodeName: change.name,
     colorScheme: colorScheme,
@@ -265,6 +270,8 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
     })));
   }
   if (decorations.length === 0) {
+    // An unstyled node type (paragraph, heading, list, layout, …) emits no decoration at all, so
+    // there is nothing for a tag to hang off even when the node type would otherwise be taggable.
     return decorations;
   }
   if (showIndicators && doc && isExtendedEnabled(diffType)) {