@atlaskit/editor-plugin-show-diff 14.0.3 → 14.1.0

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

@@ -11,6 +11,7 @@ import { createDocMarginAnchorWidget } from '../decorations/createAnchorDecorati
 import { createBlockChangedDecoration } from '../decorations/createBlockChangedDecoration';
 import { createInlineChangedDecoration } from '../decorations/createInlineChangedDecoration';
 import { createNodeChangedDecorationWidget } from '../decorations/createNodeChangedDecorationWidget';
+import { createAttributionColorMap, getAttributionKey, getColorSchemeForChange, isAttributionColoringEnabled } from '../decorations/colorSchemes/attributions';
 import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
@@ -19,7 +20,8 @@ import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
-import { simplifySteps } from './simplifySteps';
+import { simplifyChangesWithAttribution } from './simplifyChangesWithAttribution';
+import { simplifySteps, simplifyStepsWithAttribution } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
 import { smartChangeLevel } from './smart/helpers';
 const getChanges = ({
@@ -58,6 +60,35 @@ const getChanges = ({
   const changes = simplifyChanges(changeset.changes, tr.doc);
   return optimizeChanges(changes);
 };
+const getAttributedChanges = ({
+  attributedChanges,
+  changeset,
+  originalDoc,
+  steppedDoc,
+  diffType,
+  tr,
+  intl,
+  smartThresholds
+}) => {
+  if (isExtendedEnabled(diffType)) {
+    if (diffType === 'smart' && fg('platform_editor_ai_smart_diff')) {
+      return classifySmartChanges({
+        changes: simplifyChangesWithAttribution(attributedChanges, tr.doc),
+        originalDoc,
+        newDoc: tr.doc,
+        locale: intl.locale,
+        thresholds: smartThresholds
+      });
+    }
+    if (diffType === 'step') {
+      return attributedChanges;
+    }
+    if (diffType === 'block') {
+      return groupChangesByBlock(changeset.changes, originalDoc, steppedDoc);
+    }
+  }
+  return simplifyChangesWithAttribution(attributedChanges, tr.doc);
+};
 
 /**
  * Collect the inline-content ranges of every leaf text-bearing block (paragraph, heading, …)
@@ -101,6 +132,21 @@ const isLargeInsertedTableRange = (doc, from, to) => {
   });
   return containsTable && leafCount > LARGE_TABLE_LEAF_THRESHOLD;
 };
+
+// Collect the [from, to) ranges of every `table` node overlapping `[from, to)`. The coarse
+// large-table path must only suppress decorations inside these ranges
+const tableRanges = (doc, from, to) => {
+  const ranges = [];
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (node.type.name === 'table') {
+      ranges.push([pos, pos + node.nodeSize]);
+      return false;
+    }
+    return true;
+  });
+  return ranges;
+};
+const isInsideTable = (tables, pos) => tables.some(([tFrom, tTo]) => pos >= tFrom && pos < tTo);
 const calculateNodesForBlockDecoration = ({
   doc,
   from,
@@ -114,11 +160,13 @@ const calculateNodesForBlockDecoration = ({
   coarseTableCellsOnly = false
 }) => {
   const decorations = [];
+  // Coarse path: inside the large table, only cell/header overlays are kept — the
+  // table/row/paragraph decorations there are redundant and cause expensive per-cell
+  // re-render. Blocks outside the table keep their normal decorations.
+  const coarseTables = coarseTableCellsOnly ? tableRanges(doc, from, to) : [];
   // Iterate over the document nodes within the range
   doc.nodesBetween(from, to, (node, pos) => {
-    // Coarse path: only cell/header overlays are visible; table/row/paragraph
-    // decorations are redundant and cause expensive per-cell re-render.
-    if (coarseTableCellsOnly) {
+    if (coarseTableCellsOnly && isInsideTable(coarseTables, pos)) {
       const name = node.type.name;
       if (name !== 'tableCell' && name !== 'tableHeader') {
         return;
@@ -189,6 +237,7 @@ const calculateDiffDecorationsInner = ({
   const {
     originalDoc,
     steps,
+    stepAttributions,
     isDisplayingChanges
   } = pluginState;
   if (!originalDoc || !isDisplayingChanges) {
@@ -205,8 +254,21 @@ const calculateDiffDecorationsInner = ({
     tr
   } = state;
   let steppedDoc = originalDoc;
+  const attributionColoringEnabled = isAttributionColoringEnabled(stepAttributions);
+  let simplifiedSteps;
+  let simplifiedStepAttributions = [];
+  if (attributionColoringEnabled) {
+    const simplifiedStepsWithAttribution = simplifyStepsWithAttribution(steps, stepAttributions !== null && stepAttributions !== void 0 ? stepAttributions : [], originalDoc);
+    simplifiedSteps = simplifiedStepsWithAttribution.map(({
+      step
+    }) => step);
+    simplifiedStepAttributions = simplifiedStepsWithAttribution.map(({
+      stepAttribution
+    }) => stepAttribution);
+  } else {
+    simplifiedSteps = simplifySteps(steps, originalDoc);
+  }
   const attrSteps = [];
-  const simplifiedSteps = simplifySteps(steps, originalDoc);
   const stepMaps = [];
   for (const step of simplifiedSteps) {
     const result = step.apply(steppedDoc);
@@ -245,17 +307,42 @@ const calculateDiffDecorationsInner = ({
   // 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;
-  const changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, tr.doc);
-  const changes = getChanges({
-    changeset,
-    originalDoc,
-    steppedDoc,
-    diffType,
-    tr,
-    steps,
-    intl,
-    smartThresholds
-  });
+  let changes;
+  let attributedChanges = [];
+  let attributionColors;
+  if (attributionColoringEnabled) {
+    const changeset = ChangeSet.create(originalDoc, (left, right) => getAttributionKey(left) === getAttributionKey(right) ? left.stepIndex > right.stepIndex ? left : right :
+    // `prosemirror-changeset` uses null as its incompatible-data sentinel even
+    // though its public combine callback is typed as returning Data.
+    null, tokenEncoder).addSteps(steppedDoc, stepMaps, simplifiedStepAttributions.map((attribution, stepIndex) => ({
+      ...attribution,
+      stepIndex
+    })));
+    attributedChanges = diffBySteps(originalDoc, simplifiedSteps, simplifiedStepAttributions);
+    changes = getAttributedChanges({
+      changeset,
+      originalDoc,
+      steppedDoc,
+      diffType,
+      tr,
+      attributedChanges,
+      intl,
+      smartThresholds
+    });
+    attributionColors = createAttributionColorMap(simplifiedStepAttributions);
+  } else {
+    const changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, tr.doc);
+    changes = getChanges({
+      changeset,
+      originalDoc,
+      steppedDoc,
+      diffType,
+      tr,
+      steps: simplifiedSteps,
+      intl,
+      smartThresholds
+    });
+  }
   const decorations = [];
 
   /**
@@ -268,6 +355,7 @@ const calculateDiffDecorationsInner = ({
   // Our default operations are insertions, so it should match the opposite of isInverted.
   const isInserted = !isInverted;
   const createDecorationsForChange = change => {
+    const changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     const isActive = activeIndexPos && change.fromB === activeIndexPos.from && change.toB === activeIndexPos.to;
 
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
@@ -301,18 +389,22 @@ const calculateDiffDecorationsInner = ({
       // 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);
-      if (useCoarseTableDecoration) {
-        // Skip the O(cells) inline decorations; the cell overlays (added below)
-        // provide the highlight without the expensive content re-render.
-      } else if (isSmartNodeLevel) {
+      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
+        // expensive content re-render); leaf blocks outside the table still get theirs.
+        const coarseTables = useCoarseTableDecoration ? tableRanges(tr.doc, change.fromB, change.toB) : [];
         for (const [from, to] of leafTextblockRanges(tr.doc, change.fromB, change.toB)) {
+          if (useCoarseTableDecoration && isInsideTable(coarseTables, from)) {
+            continue;
+          }
           decorations.push(...createInlineChangedDecoration({
             change: {
               fromB: from,
               toB: to
             },
             doc: tr.doc,
-            colorScheme,
+            colorScheme: changeColorScheme,
             isActive,
             diffType,
             ...(isExtendedEnabled(diffType) && {
@@ -329,7 +421,7 @@ const calculateDiffDecorationsInner = ({
         decorations.push(...createInlineChangedDecoration({
           change,
           doc: tr.doc,
-          colorScheme,
+          colorScheme: changeColorScheme,
           isActive,
           diffType,
           ...(isExtendedEnabled(diffType) && {
@@ -346,7 +438,7 @@ const calculateDiffDecorationsInner = ({
         doc: tr.doc,
         from: change.fromB,
         to: change.toB,
-        colorScheme,
+        colorScheme: changeColorScheme,
         ...(isExtendedEnabled(diffType) && {
           isInserted,
           shouldHideDeleted,
@@ -365,7 +457,7 @@ const calculateDiffDecorationsInner = ({
           change,
           doc: originalDoc,
           nodeViewSerializer,
-          colorScheme,
+          colorScheme: changeColorScheme,
           newDoc: tr.doc,
           intl,
           activeIndexPos,
@@ -511,7 +603,7 @@ export const calculateDiffDecorations = memoizeOne(calculateDiffDecorationsInner
   const originalDocIsSame = lastPluginState.originalDoc && pluginState.originalDoc && pluginState.originalDoc.eq(lastPluginState.originalDoc);
   if (isExtendedEnabled(diffType)) {
     var _ref;
-    return (_ref = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement) !== null && _ref !== void 0 ? _ref : false;
+    return (_ref = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement) !== null && _ref !== void 0 ? _ref : false;
   }
-  return (_ref2 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref2 !== void 0 ? _ref2 : false;
+  return (_ref2 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref2 !== void 0 ? _ref2 : false;
 });

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

@@ -1,6 +1,7 @@
 import { simplifyChanges, ChangeSet } from 'prosemirror-changeset';
 import { Mark } from '@atlaskit/editor-prosemirror/model';
 import { Mapping, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { getAttributionKey } from '../decorations/colorSchemes/attributions';
 import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { optimizeChanges } from './optimizeChanges';
 const WORD_CHAR_REGEX = /[\p{L}\p{N}_]/u;
@@ -177,9 +178,9 @@ const createMapping = maps => {
   }
   return mapping;
 };
-const createSpans = length => length > 0 ? [{
+const createSpans = (length, data = null) => length > 0 ? [{
   length,
-  data: null
+  data
 }] : [];
 const mergeOverlappingByNewDocRange = changes => {
   if (changes.length <= 1) {
@@ -191,8 +192,11 @@ const mergeOverlappingByNewDocRange = changes => {
     ...sortedChanges[0]
   };
   for (let i = 1; i < sortedChanges.length; i++) {
+    var _, _2;
     const next = sortedChanges[i];
-    const isOverlapping = next.fromB <= current.toB;
+    const currentIdentity = getAttributionKey((_ = [...current.deleted, ...current.inserted][0]) === null || _ === void 0 ? void 0 : _.data);
+    const nextIdentity = getAttributionKey((_2 = [...next.deleted, ...next.inserted][0]) === null || _2 === void 0 ? void 0 : _2.data);
+    const isOverlapping = next.fromB <= current.toB && currentIdentity === nextIdentity;
     if (isOverlapping) {
       current = {
         fromA: Math.min(current.fromA, next.fromA),
@@ -248,12 +252,12 @@ const shouldCheckGranularDiff = (step, before, from, to) => {
   const isTextContentEqual = (replacedNode === null || replacedNode === void 0 ? void 0 : replacedNode.textContent) === (replacingNode === null || replacingNode === void 0 ? void 0 : replacingNode.textContent);
   return !isTextContentEqual || isTextContentEqual && hasSameChildMarks(replacedNode, replacingNode);
 };
-export const diffBySteps = (originalDoc, steps) => {
+export const diffBySteps = (originalDoc, steps, stepAttributions) => {
   const changes = [];
   let currentDoc = originalDoc;
   const successfulStepMaps = [];
   const rangedSteps = [];
-  for (const step of steps) {
+  for (const [stepIndex, step] of steps.entries()) {
     const before = currentDoc;
     const result = step.apply(currentDoc);
     if (result.failed !== null || !result.doc) {
@@ -268,6 +272,10 @@ export const diffBySteps = (originalDoc, steps) => {
         from: rangeStep.from,
         to: rangeStep.to,
         mapIndex: successfulStepMaps.length,
+        stepAttribution: stepAttributions !== null && stepAttributions !== void 0 && stepAttributions[stepIndex] ? {
+          ...stepAttributions[stepIndex],
+          stepIndex
+        } : null,
         step,
         stepMap
       });
@@ -343,8 +351,8 @@ export const diffBySteps = (originalDoc, steps) => {
           toA: granularToA,
           fromB: granularFromB,
           toB: granularToB,
-          deleted: createSpans(Math.max(0, granularToA - granularFromA)),
-          inserted: createSpans(Math.max(0, granularToB - granularFromB))
+          deleted: createSpans(Math.max(0, granularToA - granularFromA), rangedStep.stepAttribution),
+          inserted: createSpans(Math.max(0, granularToB - granularFromB), rangedStep.stepAttribution)
         });
       }
       continue;
@@ -354,8 +362,8 @@ export const diffBySteps = (originalDoc, steps) => {
       toA,
       fromB,
       toB,
-      deleted: createSpans(Math.max(0, toA - fromA)),
-      inserted: createSpans(Math.max(0, toB - fromB))
+      deleted: createSpans(Math.max(0, toA - fromA), rangedStep.stepAttribution),
+      inserted: createSpans(Math.max(0, toB - fromB), rangedStep.stepAttribution)
     });
   }
   return mergeOverlappingByNewDocRange(changes);

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

@@ -0,0 +1,64 @@
+import { simplifyChanges } from 'prosemirror-changeset';
+import { getAttributionKey } from '../decorations/colorSchemes/attributions';
+import { optimizeChanges } from './optimizeChanges';
+const getAttributionIdentity = change => {
+  const identities = new Set();
+  for (const span of [...change.deleted, ...change.inserted]) {
+    identities.add(getAttributionKey(span.data));
+  }
+  if (identities.size > 1) {
+    return {
+      key: undefined,
+      mergeable: false
+    };
+  }
+  return {
+    key: identities.values().next().value,
+    mergeable: true
+  };
+};
+
+/**
+ * Simplifies and optimizes consecutive changes without crossing an attribution boundary.
+ * A change which already contains more than one identity is deliberately kept isolated.
+ */
+export const simplifyChangesWithAttribution = (changes, doc) => {
+  const result = [];
+  let run = [];
+  let runIdentity;
+  const flush = () => {
+    if (run.length > 0) {
+      // Some show-diff producers use structurally compatible Change objects rather than the
+      // library class. `simplifyChanges` reads runtime `lenA`/`lenB` getters even though they
+      // are intentionally omitted from its public declarations, so add equivalent getters
+      // without calling the library's internal constructor.
+      const normalizedRun = run.map(change => ({
+        ...change,
+        get lenA() {
+          return change.toA - change.fromA;
+        },
+        get lenB() {
+          return change.toB - change.fromB;
+        }
+      }));
+      result.push(...optimizeChanges(simplifyChanges(normalizedRun, doc)));
+    }
+    run = [];
+    runIdentity = undefined;
+  };
+  for (const change of changes) {
+    var _runIdentity;
+    const identity = getAttributionIdentity(change);
+    const canJoinRun = ((_runIdentity = runIdentity) === null || _runIdentity === void 0 ? void 0 : _runIdentity.mergeable) === true && identity.mergeable && runIdentity.key === identity.key;
+    if (run.length > 0 && !canJoinRun) {
+      flush();
+    }
+    run.push(change);
+    runIdentity = identity;
+    if (!identity.mergeable) {
+      flush();
+    }
+  }
+  flush();
+  return result;
+};

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

@@ -1,7 +1,7 @@
 import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
 import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
 import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
-
+import { getAttributionKey } from '../decorations/colorSchemes/attributions';
 /**
  * Attempts to merge two consecutive ReplaceStep operations.
  * This merges steps where:
@@ -41,6 +41,69 @@ export function simplifySteps(steps, originalDoc) {
     return acc;
   }, []);
 }
+const mergeAttributions = (first, second) => {
+  var _second$wasOffline;
+  if (!first) {
+    return second;
+  }
+  if (!second) {
+    return first;
+  }
+  return {
+    ...first,
+    ...second,
+    wasOffline: first.wasOffline === true || second.wasOffline === true ? true : (_second$wasOffline = second.wasOffline) !== null && _second$wasOffline !== void 0 ? _second$wasOffline : first.wasOffline
+  };
+};
+
+/**
+ * Attribution-preserving variant of `simplifySteps`.
+ *
+ * Steps may only merge when they have the same effective actor identity. Keeping the attribution
+ * coupled to the step also ensures filtering a no-op/analytics step cannot shift array indexes.
+ */
+export function simplifyStepsWithAttribution(steps, stepAttributions, originalDoc) {
+  const stepsToFilter = removeUnusedAttributedSteps(steps.map((step, index) => ({
+    step,
+    stepAttribution: stepAttributions[index]
+  })), originalDoc);
+  return stepsToFilter.filter(({
+    step
+  }) => !(step instanceof AnalyticsStep)).reduce((acc, current) => {
+    var _previous$step$merge, _previous$step$merge2, _previous$step;
+    const previous = acc[acc.length - 1];
+    const isSameIdentity = previous && getAttributionKey(previous.stepAttribution) === getAttributionKey(current.stepAttribution);
+    const merged = isSameIdentity ? (_previous$step$merge = (_previous$step$merge2 = (_previous$step = previous.step).merge) === null || _previous$step$merge2 === void 0 ? void 0 : _previous$step$merge2.call(_previous$step, current.step)) !== null && _previous$step$merge !== void 0 ? _previous$step$merge : mergeReplaceSteps(previous.step, current.step) : null;
+    if (merged) {
+      acc[acc.length - 1] = {
+        step: merged,
+        stepAttribution: mergeAttributions(previous.stepAttribution, current.stepAttribution)
+      };
+    } else {
+      acc.push(current);
+    }
+    return acc;
+  }, []);
+}
+
+/**
+ * Does a first pass to remove steps that don't impact the document
+ */
+function removeUnusedAttributedSteps(stepsWithAttribution, originalDoc) {
+  const finalSteps = [];
+  let firstPassDoc = originalDoc;
+  for (const stepWithAttribution of stepsWithAttribution) {
+    const {
+      step
+    } = stepWithAttribution;
+    const result = step.apply(firstPassDoc);
+    if (result.failed === null && result.doc && !areNodesEqualIgnoreAttrs(firstPassDoc, result.doc, ['localId'])) {
+      finalSteps.push(stepWithAttribution);
+      firstPassDoc = result.doc;
+    }
+  }
+  return finalSteps;
+}
 
 /**
  * Does a first pass to remove steps that don't impact the document

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

@@ -0,0 +1,37 @@
+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 => {
+  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) {
+    return undefined;
+  }
+  const agentIdentity = agentId || (agentType ? `type:${agentType}` : '');
+  return `user:${userId !== null && userId !== void 0 ? userId : ''}|agent:${agentIdentity}`;
+};
+export const areAttributionColorGatesEnabled = () => fg('confluence_ncs_step_diffing_version_history') && isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor');
+export const isAttributionColoringEnabled = stepAttributions => areAttributionColorGatesEnabled() && (stepAttributions === null || stepAttributions === void 0 ? void 0 : stepAttributions.some(attribution => getAttributionKey(attribution) !== undefined)) === true;
+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 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');
+  return data.reduce((latest, attribution) => !latest || attribution.stepIndex > latest.stepIndex ? attribution : latest, undefined);
+};
+const rangesOverlap = (fromA, toA, fromB, toB) => fromA < toB && fromB < toA;
+const changesOverlap = (change, attributedChange) => {
+  const insertedOverlap = change.inserted.length > 0 && attributedChange.inserted.length > 0 && rangesOverlap(change.fromB, change.toB, attributedChange.fromB, attributedChange.toB);
+  const deletedOverlap = change.deleted.length > 0 && attributedChange.deleted.length > 0 && rangesOverlap(change.fromA, change.toA, attributedChange.fromA, attributedChange.toA);
+  return insertedOverlap || deletedOverlap;
+};
+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;
+};

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

@@ -52,9 +52,26 @@ export const standardScheme = {
   deletedQuoteNodeActiveTone: 'borderAccent',
   strikesDeletedEmbedCard: false
 };
+const createAttributionScheme = color => ({
+  ...standardScheme,
+  insertColor: color,
+  insertActiveColor: color,
+  deleteColor: color,
+  deleteActiveColor: color,
+  deletedCellColor: color
+});
 
-/** Maps the public ColorScheme string to its data object. Adding a scheme = one entry here. */
+/** Maps public schemes and attribution-only accents 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'),
   traditional: traditionalScheme,
   standard: standardScheme
-};
+};
+
+/** Attribution accents are impossible in the refactor-off cohort; fall back defensively. */
+export const getLegacyColorScheme = colorScheme => colorScheme === 'standard' || colorScheme === 'traditional' ? colorScheme : undefined;

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

@@ -0,0 +1 @@
+export {};

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

@@ -4,7 +4,7 @@ import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-e
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { isExtendedEnabled } from '../isExtendedEnabled';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedBlockNodeStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildInsertedBlockNodeStyle } from './colorSchemes/factory';
-import { colorSchemeRegistry } from './colorSchemes/schemes';
+import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
 import { buildDiffDecorationSpec } from './decorationKeys';
 import { getBlockNodeStyleLegacy, resolveCellOverlayStyleLegacy } from './createBlockChangedDecoration.styles.legacy';
@@ -95,7 +95,10 @@ const getBlockNodeStyleNext = ({
  * OFF cohort of `platform_editor_show_diff_color_scheme_refactor`. Both are built to emit the
  * same style strings for both shipped schemes; see EDITOR-8281.
  */
-const getBlockNodeStyle = props => isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? getBlockNodeStyleNext(props) : getBlockNodeStyleLegacy(props);
+const getBlockNodeStyle = props => isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? getBlockNodeStyleNext(props) : getBlockNodeStyleLegacy({
+  ...props,
+  colorScheme: getLegacyColorScheme(props.colorScheme)
+});
 
 /**
  * A table cell is "empty" only when it has no content at all — no text AND no
@@ -165,7 +168,7 @@ export const createBlockChangedDecoration = ({
     const isEmptyCellBeingFilled = !isInserted && !!cellNode && isCellEmpty(cellNode);
     const useAddedStyle = isInserted || isEmptyCellBeingFilled;
     const cellOverlayStyle = isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? useAddedStyle ? isRoundedTable ? buildAddedCellOverlayRoundedStyle(colors) : buildAddedCellOverlayStyle(colors) : isRoundedTable ? buildDeletedCellOverlayRoundedStyle(colors) : buildDeletedCellOverlayStyle(colors) : resolveCellOverlayStyleLegacy({
-      colorScheme,
+      colorScheme: getLegacyColorScheme(colorScheme),
       isRoundedTable,
       useAddedStyle
     });

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

@@ -6,7 +6,7 @@ import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-e
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { isExtendedEnabled } from '../isExtendedEnabled';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildDeletedRowStyle } from './colorSchemes/factory';
-import { colorSchemeRegistry } from './colorSchemes/schemes';
+import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { resolveCellOverlayStyleLegacy, resolveDeletedRowStyleLegacy } from './createChangedRowDecorationWidgets.styles.legacy';
 import { buildDiffDecorationSpec } from './decorationKeys';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
@@ -120,7 +120,7 @@ const createChangedRowDOM = (rowNode, cellEdgeAttrs, nodeViewSerializer, colorSc
 
   // Inserted rows keep their natural styling; the row strikethrough is deletions only.
   if (!isExtendedEnabled(diffType) || !isInserted) {
-    tr.setAttribute('style', isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? buildDeletedRowStyle(colors) : resolveDeletedRowStyleLegacy(colorScheme));
+    tr.setAttribute('style', isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? buildDeletedRowStyle(colors) : resolveDeletedRowStyleLegacy(getLegacyColorScheme(colorScheme)));
   }
   tr.setAttribute('data-testid', 'show-diff-deleted-row');
 
@@ -136,7 +136,7 @@ const createChangedRowDOM = (rowNode, cellEdgeAttrs, nodeViewSerializer, colorSc
             const overlay = document.createElement('span');
             const isRoundedTable = expValEquals('platform_editor_table_diff_rounded_corners', 'isEnabled', true);
             const overlayStyle = isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? isInserted ? isRoundedTable ? buildAddedCellOverlayRoundedStyle(colors) : buildAddedCellOverlayStyle(colors) : isRoundedTable ? buildDeletedCellOverlayRoundedStyle(colors) : buildDeletedCellOverlayStyle(colors) : resolveCellOverlayStyleLegacy({
-              colorScheme,
+              colorScheme: getLegacyColorScheme(colorScheme),
               isInserted,
               isRoundedTable
             });

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

@@ -3,7 +3,7 @@ import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { isExtendedEnabled } from '../isExtendedEnabled';
 import { buildAtomicInlineChangedCSSVariables, buildDeletedInlineContentStyleExtended, buildDeletedInlineStyle, buildDeletedInlineStyleStandard, buildInsertStyle, buildInsertStyleActive, buildInsertStyleExtended, buildInsertStyleExtendedActive, buildInsertStyleExtendedNoUnderline, buildInsertStyleExtendedNoUnderlineActive } from './colorSchemes/factory';
-import { colorSchemeRegistry } from './colorSchemes/schemes';
+import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createInlineIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
 import { getAtomicInlineNodeClassNameLegacy, resolveInlineChangedStyleLegacy } from './createInlineChangedDecoration.styles.legacy';
 import { buildDiffDecorationSpec } from './decorationKeys';
@@ -64,7 +64,10 @@ const resolveInlineChangedStyleRefactored = ({
  * Single gate for the inline `style` string: registry + factory when the refactor is on, the
  * verbatim pre-refactor per-scheme constants when it is off.
  */
-const resolveInlineChangedStyle = args => isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? resolveInlineChangedStyleRefactored(args) : resolveInlineChangedStyleLegacy(args);
+const resolveInlineChangedStyle = args => isExperimentEnabled('platform_editor_show_diff_color_scheme_refactor') ? resolveInlineChangedStyleRefactored(args) : resolveInlineChangedStyleLegacy({
+  ...args,
+  colorScheme: getLegacyColorScheme(args.colorScheme)
+});
 
 /**
  * Single gate for the atomic-inline-node decoration attributes. The two cohorts differ in the DOM:
@@ -76,7 +79,7 @@ const resolveAtomicInlineAttrs = (inlineNodeName, colorScheme, colors) => isExpe
   className: getAtomicInlineNodeClassName(inlineNodeName),
   styleSuffix: buildAtomicInlineChangedCSSVariables(colors)
 } : {
-  className: getAtomicInlineNodeClassNameLegacy(inlineNodeName, colorScheme),
+  className: getAtomicInlineNodeClassNameLegacy(inlineNodeName, getLegacyColorScheme(colorScheme)),
   styleSuffix: ''
 };