@atlaskit/editor-plugin-show-diff 14.3.2 → 14.4.0

package/dist/esm/ui/ContributorTag/ContributorTag.js

@@ -0,0 +1,375 @@
+/* ContributorTag.tsx generated by @compiled/babel-plugin v2.0.0 */
+import _extends from "@babel/runtime/helpers/extends";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import "./ContributorTag.compiled.css";
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { bindAll } from 'bind-event-listener';
+import { useIntl } from 'react-intl';
+import Avatar from '@atlaskit/avatar/avatar';
+import { AvatarContent } from '@atlaskit/avatar/avatar-content';
+import AiBotIcon from '@atlaskit/icon-lab/core/ai-bot';
+import { RovoHexIcon } from '@atlaskit/logo/rovo-hex/icon';
+import Tooltip from '@atlaskit/tooltip/Tooltip';
+import VisuallyHidden from '@atlaskit/visually-hidden/visually-hidden';
+import { getAccentTokens } from '../../pm-plugins/decorations/colorSchemes/factory';
+import { colorSchemeRegistry } from '../../pm-plugins/decorations/colorSchemes/schemes';
+import { contributorTagMessages } from './messages';
+
+// Floor for the tag width (~one 16px avatar plus padding), so the highlight-width clamp below
+// cannot collapse the box on a very short highlight.
+var MIN_TAG_WIDTH = '28px';
+var styles = {
+  constraint: "_1e0c1ule _kqswstnw _94n51osq _1e02idpf _1ul9idpf _1pbykb7n _uiztglyw",
+  tag: "_zulp1b66 _1reo15vq _18m915vq _2rko12b0 _11c8wadc _18zr1b66 _1rjcv77o _1e0c116y _4cvr1h6o _p12f1osq _1ul9idpf _1il9nqa1 _1doc1dm9 _16qs130s _o5721q9c _vchhusvi",
+  hidden: "_tzy4idpf _lcxvglyw",
+  visible: "_tzy4kb7n _lcxv1wug",
+  avatars: "_1e0c116y _4cvr1h6o _1o9zidpf",
+  leadingAvatar: "_1e0c116y _12l2r5cr",
+  name: "_1reo15vq _18m915vq _1e0c1ule _1ul9idpf _1bto1l2s _o5721q9c"
+};
+var getContributorName = function getContributorName(contributor, formatMessage) {
+  var _contributor$name, _contributor$agentKin;
+  var name = (_contributor$name = contributor.name) === null || _contributor$name === void 0 ? void 0 : _contributor$name.trim();
+  if (name) {
+    return name;
+  }
+
+  // `agentKind` defaults to `'external'` per the plugin type contract; an unidentified external
+  // agent falls back to a generic label rather than rendering a nameless tag.
+  if (contributor.kind === 'agent' && ((_contributor$agentKin = contributor.agentKind) !== null && _contributor$agentKin !== void 0 ? _contributor$agentKin : 'external') === 'external') {
+    return formatMessage(contributorTagMessages.externalAgentName);
+  }
+  return '';
+};
+var ContributorAvatar = function ContributorAvatar(_ref) {
+  var contributor = _ref.contributor,
+    name = _ref.name,
+    ringColor = _ref.ringColor,
+    stackIndex = _ref.stackIndex;
+  if (contributor.kind === 'user') {
+    return /*#__PURE__*/React.createElement(Avatar, {
+      appearance: "circle",
+      size: "xxsmall",
+      src: contributor.avatarUrl,
+      name: name,
+      stackIndex: stackIndex,
+      borderColor: ringColor
+    });
+  }
+  return /*#__PURE__*/React.createElement(Avatar, {
+    appearance: "hexagon",
+    size: "xxsmall",
+    src: contributor.avatarUrl,
+    name: name,
+    stackIndex: stackIndex,
+    borderColor: ringColor
+  }, contributor.avatarUrl ? undefined : /*#__PURE__*/React.createElement(AvatarContent, null, contributor.agentKind === 'rovo' ? /*#__PURE__*/React.createElement(RovoHexIcon, {
+    size: "xxsmall",
+    label: ""
+  }) :
+  /*#__PURE__*/
+  // `small` (12px) fits inside the 16px hexagon.
+  React.createElement(AiBotIcon, {
+    label: "",
+    size: "small"
+  })));
+};
+/**
+ * Resolves the tag's accent from the same scheme value and token maps the highlight used, so the two
+ * can never drift.
+ */
+var getTagAccent = function getTagAccent(_ref2) {
+  var colorScheme = _ref2.colorScheme,
+    isActive = _ref2.isActive,
+    isInserted = _ref2.isInserted;
+  var colors = colorSchemeRegistry[colorScheme !== null && colorScheme !== void 0 ? colorScheme : 'standard'];
+  var accent = isInserted ? isActive ? colors.insertActiveColor : colors.insertColor : isActive ? colors.deleteActiveColor : colors.deleteColor;
+  return getAccentTokens(accent);
+};
+
+/** The line the change starts on: topmost of its fragments, leftmost among those. */
+var findChangeStartLine = function findChangeStartLine(highlights) {
+  var start;
+  var _iterator = _createForOfIteratorHelper(highlights),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var highlight = _step.value;
+      var _iterator2 = _createForOfIteratorHelper(highlight.getClientRects()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var rect = _step2.value;
+          if (!start || rect.top < start.top - 1 || Math.abs(rect.top - start.top) <= 1 && rect.left < start.left) {
+            start = rect;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return start;
+};
+
+/**
+ * Observes the highlight this tag describes, for what CSS here cannot see: its hover state (the
+ * highlight is a ProseMirror decoration in a different DOM subtree, so listeners are bound
+ * imperatively via `data-diff-id`) and the width the tag is clamped to.
+ *
+ * Deliberately not routed through plugin state: a transaction per pointer move would re-run the
+ * memoised decoration calculation.
+ */
+var useHighlightState = function useHighlightState(diffId, highlightSelector, getEditorRoot) {
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isHovered = _useState2[0],
+    setIsHovered = _useState2[1];
+  var _useState3 = useState(undefined),
+    _useState4 = _slicedToArray(_useState3, 2),
+    maxWidthPx = _useState4[0],
+    setMaxWidthPx = _useState4[1];
+  useEffect(function () {
+    // Both queries are scoped to this editor's content root, so a tag can only ever bind to the
+    // decorations its own plugin instance rendered — another editor on the page, or one nested
+    // inside this one, cannot supply the geometry.
+    var editorRoot = getEditorRoot();
+    var highlights = editorRoot === null || editorRoot === void 0 ? void 0 : editorRoot.querySelectorAll(highlightSelector);
+    if (!editorRoot || !(highlights !== null && highlights !== void 0 && highlights.length)) {
+      return;
+    }
+    var elements = Array.from(highlights);
+    // The width comes from this tag's OWN decoration; sibling halves of the change are here for
+    // hover only.
+    var ownElements = Array.from(editorRoot.querySelectorAll("[data-diff-id=\"".concat(diffId, "\"]")));
+    var measure = function measure() {
+      var _findChangeStartLine;
+      // Counted by distinct line box, not by client rect: an inline node inside the change (a
+      // mention, emoji, date) splits the highlight into several rects on the same line, and
+      // treating that as a wrap would drop the width clamp on changes that never wrapped.
+      var lineTops = new Set();
+      for (var _i = 0, _ownElements = ownElements; _i < _ownElements.length; _i++) {
+        var highlight = _ownElements[_i];
+        var _iterator3 = _createForOfIteratorHelper(highlight.getClientRects()),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var rect = _step3.value;
+            lineTops.add(Math.round(rect.top));
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+
+      // A wrapped change's first line says nothing useful about how wide the tag may be.
+      var width = lineTops.size > 1 ? undefined : (_findChangeStartLine = findChangeStartLine(ownElements)) === null || _findChangeStartLine === void 0 ? void 0 : _findChangeStartLine.width;
+      setMaxWidthPx(width);
+    };
+    measure();
+
+    // An inline element cannot be observed itself (ResizeObserver skips boxes with no principal
+    // box), so the block it sits in is observed instead.
+    var resizeObserver = new ResizeObserver(measure);
+    var _iterator4 = _createForOfIteratorHelper(new Set(ownElements.map(function (_ref3) {
+        var parentElement = _ref3.parentElement;
+        return parentElement;
+      }))),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var parent = _step4.value;
+        if (parent) {
+          resizeObserver.observe(parent);
+        }
+      }
+
+      // `bindAll` takes a single target, and a change can render more than one highlight.
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    var unbinds = elements.map(function (highlight) {
+      return bindAll(highlight, [{
+        type: 'mouseenter',
+        listener: function listener() {
+          return setIsHovered(true);
+        }
+      }, {
+        type: 'mouseleave',
+        listener: function listener() {
+          return setIsHovered(false);
+        }
+      }]);
+    });
+    return function () {
+      resizeObserver.disconnect();
+      unbinds.forEach(function (unbind) {
+        return unbind();
+      });
+    };
+  }, [diffId, getEditorRoot, highlightSelector]);
+  return {
+    isHovered: isHovered,
+    maxWidthPx: maxWidthPx
+  };
+};
+
+/**
+ * A small tag naming who made one diff, rendered into the host widget its decoration places on the
+ * change's first character and positioned above it.
+ */
+export function ContributorTag(_ref4) {
+  var colorScheme = _ref4.colorScheme,
+    connectedContributor = _ref4.connectedContributor,
+    contributor = _ref4.contributor,
+    diffId = _ref4.diffId,
+    getEditorRoot = _ref4.getEditorRoot,
+    isActive = _ref4.isActive,
+    _ref4$isInserted = _ref4.isInserted,
+    isInserted = _ref4$isInserted === void 0 ? true : _ref4$isInserted,
+    linkedDiffIds = _ref4.linkedDiffIds;
+  var _useIntl = useIntl(),
+    formatMessage = _useIntl.formatMessage;
+  // A plain string, so the hook's effect is not re-run by a fresh array on every render.
+  var highlightSelector = [diffId].concat(_toConsumableArray(linkedDiffIds !== null && linkedDiffIds !== void 0 ? linkedDiffIds : [])).map(function (id) {
+    return "[data-diff-id=\"".concat(id, "\"]");
+  }).join(', ');
+  var _useHighlightState = useHighlightState(diffId, highlightSelector, getEditorRoot),
+    isHighlightHovered = _useHighlightState.isHovered,
+    maxWidthPx = _useHighlightState.maxWidthPx;
+  var accent = getTagAccent({
+    colorScheme: colorScheme,
+    isActive: Boolean(isActive),
+    isInserted: isInserted
+  });
+  var nameRef = useRef(null);
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    isTruncated = _useState6[0],
+    setIsTruncated = _useState6[1];
+  var _useState7 = useState(false),
+    _useState8 = _slicedToArray(_useState7, 2),
+    isHoveredOrFocused = _useState8[0],
+    setIsHoveredOrFocused = _useState8[1];
+  var isConnectedPair = Boolean(connectedContributor);
+  var isPrimaryAgent = contributor.kind === 'agent';
+  var primaryName = getContributorName(contributor, formatMessage);
+  var secondaryName = connectedContributor ? getContributorName(connectedContributor, formatMessage) : '';
+
+  // Resolved by `kind` so a reverse `connectedTo` (an attributed user pointing at its agent)
+  // renders identically.
+  var agentName = isPrimaryAgent ? primaryName : secondaryName;
+  var userName = isPrimaryAgent ? secondaryName : primaryName;
+  var userContributor = isPrimaryAgent ? connectedContributor : contributor;
+  var agentContributor = isPrimaryAgent ? contributor : connectedContributor;
+  var displayName = isConnectedPair ? agentName || primaryName : primaryName;
+  var fullLabel = isConnectedPair ? formatMessage(contributorTagMessages.changedByConnected, {
+    agentName: agentName,
+    userName: userName
+  }) : formatMessage(contributorTagMessages.changedBy, {
+    name: primaryName
+  });
+  var measureTruncation = useCallback(function () {
+    var element = nameRef.current;
+    if (element) {
+      setIsTruncated(element.scrollWidth > element.clientWidth);
+    }
+  }, []);
+  var isVisible = Boolean(isActive) || isHighlightHovered || isHoveredOrFocused;
+
+  // A connected pair only ever renders the agent name, so it always gets a tooltip; a single
+  // contributor only when its name is clipped.
+  var tooltipContent = isTruncated || isConnectedPair ? fullLabel : null;
+  return /*#__PURE__*/React.createElement("span", {
+    style: {
+      // Clamped to the highlight's own width, floored at `MIN_TAG_WIDTH` so a one-character
+      // change still shows an avatar.
+      maxWidth: maxWidthPx === undefined ? undefined : "max(".concat(Math.round(maxWidthPx), "px, ").concat(MIN_TAG_WIDTH, ")")
+    },
+    className: ax([styles.constraint])
+  }, /*#__PURE__*/React.createElement(Tooltip, {
+    content: tooltipContent
+    // A tooltip below would cover the highlighted text the tag describes.
+    ,
+    position: "top"
+    // The label is already exposed by the visually hidden text below.
+    ,
+    isScreenReaderAnnouncementDisabled: true
+  }, function (tooltipProps) {
+    return /*#__PURE__*/React.createElement("span", _extends({}, tooltipProps, {
+      "data-testid": "diff-contributor-tag"
+      // Deliberately no `aria-label`: it would be announced ahead of the element's
+      // contents, but design requires the contributor *after* the change — hence the
+      // visually hidden last child.
+      ,
+      role: "note"
+      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex, @atlassian/a11y/no-noninteractive-tabindex
+      ,
+      tabIndex: 0,
+      style: {
+        backgroundColor: accent.background,
+        borderBottomColor: accent.border
+      },
+      onMouseOver: function onMouseOver(event) {
+        tooltipProps.onMouseOver(event);
+        measureTruncation();
+        setIsHoveredOrFocused(true);
+      },
+      onMouseOut: function onMouseOut(event) {
+        tooltipProps.onMouseOut(event);
+        setIsHoveredOrFocused(false);
+      },
+      onFocus: function onFocus(event) {
+        tooltipProps.onFocus(event);
+        measureTruncation();
+        setIsHoveredOrFocused(true);
+      },
+      onBlur: function onBlur(event) {
+        tooltipProps.onBlur(event);
+        setIsHoveredOrFocused(false);
+      },
+      className: ax([styles.tag, isVisible ? styles.visible : styles.hidden])
+    }), /*#__PURE__*/React.createElement("span", {
+      className: ax([styles.avatars])
+    }, isConnectedPair && userContributor ? /*#__PURE__*/React.createElement("span", {
+      className: ax([styles.leadingAvatar])
+    }, /*#__PURE__*/React.createElement(ContributorAvatar, {
+      contributor: userContributor,
+      name: userName,
+      ringColor: accent.background,
+      stackIndex: 1
+    })) : null, isConnectedPair && agentContributor ? /*#__PURE__*/React.createElement(ContributorAvatar, {
+      contributor: agentContributor,
+      name: agentName,
+      ringColor: accent.background,
+      stackIndex: 0
+    }) : null, !isConnectedPair ? /*#__PURE__*/React.createElement(ContributorAvatar, {
+      contributor: contributor,
+      name: primaryName,
+      ringColor: accent.background
+    }) : null), /*#__PURE__*/React.createElement("span", {
+      "data-testid": "diff-contributor-tag-name",
+      ref: nameRef,
+      style: {
+        color: accent.text
+      },
+      className: ax([styles.name])
+    }, displayName), /*#__PURE__*/React.createElement(VisuallyHidden, null, fullLabel));
+  }));
+}

package/dist/esm/ui/ContributorTag/ContributorTagWidget.js

@@ -0,0 +1,43 @@
+/* ContributorTagWidget.tsx generated by @compiled/babel-plugin v2.0.0 */
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+import { useSharedPluginStateWithSelector } from '@atlaskit/editor-common/hooks';
+import { ContributorTag } from './ContributorTag';
+
+/**
+ * One contributor tag, mounted by its diff decoration into the host element that decoration draws
+ * (see `mountContributorTag`).
+ *
+ * The model is read from plugin state here rather than passed in, because ProseMirror skips `toDOM`
+ * for a widget it reuses: stepping to the next change republishes the tags without redrawing their
+ * hosts, so anything the tag needs to react to — `isActive` above all — has to arrive through a
+ * subscription of its own. Renders nothing when this diff has no tag, which is the case for the
+ * deleted half of a replacement: that half is folded into the inline tag.
+ */
+export var ContributorTagWidget = function ContributorTagWidget(_ref) {
+  var api = _ref.api,
+    diffId = _ref.diffId,
+    getEditorRoot = _ref.getEditorRoot;
+  var _useSharedPluginState = useSharedPluginStateWithSelector(api, ['showDiff'], function (state) {
+      var _state$showDiffState;
+      return {
+        model: (_state$showDiffState = state.showDiffState) === null || _state$showDiffState === void 0 || (_state$showDiffState = _state$showDiffState.contributorTags) === null || _state$showDiffState === void 0 ? void 0 : _state$showDiffState.find(function (tag) {
+          return tag.diffId === diffId;
+        })
+      };
+    }),
+    model = _useSharedPluginState.model;
+  if (!model) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(ContributorTag, {
+    colorScheme: model.colorScheme,
+    connectedContributor: model.connectedContributor,
+    contributor: model.contributor,
+    diffId: model.diffId,
+    getEditorRoot: getEditorRoot,
+    isActive: model.isActive,
+    isInserted: model.isInserted,
+    linkedDiffIds: model.linkedDiffIds
+  });
+};

package/dist/esm/ui/ContributorTag/messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl';
+export var contributorTagMessages = defineMessages({
+  changedBy: {
+    id: 'editor-plugin-show-diff.ContributorTag.changedBy',
+    defaultMessage: 'Changed by {name}',
+    description: 'Screen-reader label and tooltip for the tag pinned to a highlighted change in the version-history diff, naming the single person or agent that made the change. The name placeholder is the contributor display name.'
+  },
+  changedByConnected: {
+    id: 'editor-plugin-show-diff.ContributorTag.changedByConnected',
+    defaultMessage: 'Changed by {agentName} with {userName}',
+    description: 'Screen-reader label and tooltip for the tag pinned to a highlighted change in the version-history diff when an AI agent made the change on behalf of a user. The agentName placeholder is the agent display name. The userName placeholder is the display name of the user that invoked the agent.'
+  },
+  externalAgentName: {
+    id: 'editor-plugin-show-diff.ContributorTag.externalAgentName',
+    defaultMessage: 'External agent',
+    description: 'Fallback display name shown in the contributor tag of the version-history diff for an unidentified third-party agent (for example an MCP or CLI client) that has no name of its own.'
+  }
+});

package/dist/types/entry-points/show-diff-plugin-type.d.ts

@@ -1 +1 @@
-export type { DeletedDiffPlacement, DeletedDiffWidget, DiffParams, DiffStepAttribution, DiffType, PMDiffParams, ShowDiffParams, ShowDiffPlugin, SmartDiffThresholds, StepWithAttribution, } from '../showDiffPluginType';
+export type { DeletedDiffPlacement, DeletedDiffWidget, DiffContributorProfile, DiffParams, DiffStepAttribution, DiffType, PMDiffParams, ShowDiffParams, ShowDiffPlugin, SmartDiffThresholds, StepWithAttribution, } from '../showDiffPluginType';

package/dist/types/pm-plugins/calculateDiff/calculateDiffDecorations.d.ts

@@ -4,10 +4,13 @@ import type { IntlShape } from 'react-intl';
 import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import type { ColorScheme, DeletedDiffPlacement, DiffDescriptor, InlineDeletedDiffPlacement, ShowDiffPlugin, SmartDiffThresholds } from '../../showDiffPluginType';
+import type { ColorScheme, ContributorTagModel, DeletedDiffPlacement, DiffDescriptor, DiffType, InlineDeletedDiffPlacement, ShowDiffPlugin, SmartDiffThresholds } from '../../showDiffPluginType';
+import type { ContributorTagMountContext } from '../decorations/createContributorTagWidget';
 import type { ShowDiffPluginState } from '../main';
 import type { NodeViewSerializer } from '../NodeViewSerializer';
 type CalculatedDiffs = {
+    /** Resolved here, not in React, so the attribution keys and contributor lookup stay internal. */
+    contributorTags: ContributorTagModel[];
     decorations: DecorationSet;
     diffDescriptors: DiffDescriptor[];
 };
@@ -35,14 +38,17 @@ export declare const calculateDiffDecorations: MemoizedFn<({ state, pluginState,
     api: ExtractInjectionAPI<ShowDiffPlugin> | undefined;
     colorScheme?: ColorScheme;
     deletedDiffPlacement?: DeletedDiffPlacement;
+    diffType?: DiffType;
     hideAddedDiffsUnderline?: boolean;
     hideDeletedDiffs?: boolean;
     inlineDeletedDiffPlacement?: InlineDeletedDiffPlacement;
     intl: IntlShape;
+    isInverted?: boolean;
     nodeViewSerializer: NodeViewSerializer;
     pluginState: Omit<ShowDiffPluginState, 'decorations'>;
     showIndicators?: boolean;
     smartThresholds?: Partial<SmartDiffThresholds>;
     state: EditorState;
+    tagMountContext?: ContributorTagMountContext;
 }) => CalculatedDiffs>;
 export {};

package/dist/types/pm-plugins/calculateDiff/simplifyChangesWithAttribution.d.ts

@@ -1,5 +1,15 @@
 import { type Change } from 'prosemirror-changeset';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/**
+ * 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.
+ */
+export declare const collapseOverlappingChanges: (changes: Change[]) => Change[];
 /**
  * Simplifies and optimizes consecutive changes without crossing an attribution boundary.
  * A change which already contains more than one identity is deliberately kept isolated.

package/dist/types/pm-plugins/decorations/colorSchemes/attributions.d.ts

@@ -1,12 +1,34 @@
 import type { Change } from 'prosemirror-changeset';
-import type { ColorScheme as PublicColorScheme, DiffStepAttribution } from '../../../showDiffPluginType';
-import { type ColorScheme, type DiffParticipantColorScheme } from './types';
+import type { DiffContributors, DiffStepAttribution, TagContributor } from '../../../showDiffPluginType';
+import { type ColorScheme, type DiffParticipantColorScheme, type PublicColorScheme } from './types';
 export type DiffAttributionSpanData = DiffStepAttribution & {
     stepIndex: number;
 };
+/** A contributor with both of its identities collapsed to internal attribution keys. */
+export type ResolvedDiffContributor = TagContributor & {
+    connectedToKey?: string;
+};
+/** Contributors addressed by attribution key. The key format is internal. */
+export type ResolvedDiffContributors = Record<string, ResolvedDiffContributor>;
 /** `userId` is primary; `agentId`, or `agentType` as its fallback, separates shared users. */
 export declare const getAttributionKey: (attribution: DiffStepAttribution | undefined) => string | undefined;
+/**
+ * Public contributor list to internal key-addressed record. A contributor whose attribution carries
+ * no identity is dropped, since it could never match a step. Later entries win.
+ */
+export declare const resolveContributors: (contributors: DiffContributors | undefined) => ResolvedDiffContributors | undefined;
 export declare const areAttributionColorGatesEnabled: () => boolean;
 export declare const isAttributionColoringEnabled: (stepAttributions: Array<DiffStepAttribution | undefined> | undefined) => boolean;
+/**
+ * Shares the colours' gates, but with a lower bar: colouring needs two actors to tell apart, whereas
+ * a tag only has to name one.
+ */
+export declare const isContributorTagsEnabled: (stepAttributions: Array<DiffStepAttribution | undefined> | undefined, contributors: ResolvedDiffContributors | undefined) => boolean;
 export declare const createAttributionColorMap: (stepAttributions: Array<DiffStepAttribution | undefined>) => Map<string, DiffParticipantColorScheme>;
+/**
+ * The attribution key owning a change. Inline and step changes retain direct attribution spans, so
+ * resolve those first. Grouped and smart-classified changes can lose that data; for those, fall
+ * back to the latest overlapping attributed step.
+ */
+export declare const getAttributionKeyForChange: (change: Change, attributedChanges: Change[]) => string | undefined;
 export declare const getColorSchemeForChange: (change: Change, attributedChanges: Change[], attributionColors: Map<string, DiffParticipantColorScheme>, fallback: PublicColorScheme | undefined) => ColorScheme | undefined;

package/dist/types/pm-plugins/decorations/colorSchemes/factory.d.ts

@@ -1,4 +1,10 @@
-import { type DiffColorScheme } from './types';
+import { type DiffColorScheme, type DiffSchemeColor } from './types';
+/** Presentation tokens for one diff colour, shared by highlights and contributor tags. */
+export declare function getAccentTokens(color: DiffSchemeColor): {
+    background: string;
+    border: string;
+    text: string;
+};
 /** Inline inserted content — default state. */
 export declare function buildInsertStyle(colors: DiffColorScheme): string;
 /** Inline insert style for content within a block node (no background, underline only). */

package/dist/types/pm-plugins/decorations/colorSchemes/schemes.d.ts

@@ -1,5 +1,4 @@
-import type { ColorScheme as PublicColorScheme } from '../../../showDiffPluginType';
-import type { ColorScheme, DiffColorScheme } from './types';
+import type { ColorScheme, DiffColorScheme, PublicColorScheme } from './types';
 /** Green insertions, red deletions. */
 export declare const traditionalScheme: DiffColorScheme;
 /** Purple insertions, gray deletions (red on active). */

package/dist/types/pm-plugins/decorations/colorSchemes/types.d.ts

@@ -1,4 +1,5 @@
-import type { ColorScheme as PublicColorScheme } from '../../../showDiffPluginType';
+/** Schemes consumers may explicitly request through the show-diff API. */
+export type PublicColorScheme = 'standard' | 'traditional';
 /** Attribution-only participant slots selected by the plugin, never by consumers. */
 export declare const PARTICIPANT_COLOR_SCHEMES: readonly ['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'];
 export type DiffParticipantColorScheme = (typeof PARTICIPANT_COLOR_SCHEMES)[number];

package/dist/types/pm-plugins/decorations/createAnchorDecorationWidgets.d.ts

@@ -38,6 +38,20 @@ export declare const createBlockIndicatorAnchorWidgets: ({ doc, from, to, diffId
     from: number;
     to: number;
 }) => Decoration[];
+/**
+ * A `from`/`to` on a `tableRow` boundary makes the anchor a direct `<tr>` (CSS grid)
+ * child, adding a phantom column that collapses the cells (EDITOR-8442). Clamp it
+ * inward into the neighbouring cell (`direction: 1` forward, `-1` back). Positions
+ * not on a row boundary are returned as-is.
+ */
+export declare const clampAnchorPosIntoCell: (doc: PMNode, pos: number, direction: 1 | -1) => number;
+/**
+ * A zero-size inline span carrying nothing but the `anchor-name` an overlay aligns against. A
+ * fragmented inline element reports the union of its line fragments, so aligning against one
+ * horizontally gives the enclosing block's content edge; a zero-size span is always a single
+ * fragment.
+ */
+export declare const createAnchorNameSpan: (anchorKey: string) => HTMLSpanElement;
 /**
  * Invisible `from`/`to` (and optional `left`) anchor widgets for one inline diff
  * range, so the `IndicatorBar` can align itself via CSS anchor positioning.

package/dist/types/pm-plugins/decorations/createContributorTagWidget.d.ts

@@ -0,0 +1,55 @@
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { ShowDiffPlugin } from '../../showDiffPluginType';
+/** Marks the host element of one tag, so a tag can be found in the document by its own diff. */
+export declare const CONTRIBUTOR_TAG_HOST_ATTRIBUTE = "data-contributor-tag-host";
+/**
+ * Everything a tag needs to mount itself into the document, plumbed down from the plugin. Absent in
+ * unit tests that build decorations directly: the hosts are still emitted, they just stay empty.
+ */
+export type ContributorTagMountContext = {
+    api?: ExtractInjectionAPI<ShowDiffPlugin>;
+    /** This editor's own content root — see `ContributorTagProps.getEditorRoot`. */
+    getEditorRoot: () => HTMLElement | null;
+    portalProviderAPI: PortalProviderAPI;
+};
+/** A mounted tag, so whoever emitted the host can take it down again. */
+export type ContributorTagMount = {
+    key: string;
+    portalProviderAPI: PortalProviderAPI;
+};
+/**
+ * Renders the tag into `host` through the editor's portal provider, the way the rest of the editor
+ * mounts React into decorations. The tag resolves its own model from plugin state, so a redraw of
+ * the host re-parents the tag instead of stranding it, and `isActive` changes arrive as a re-render.
+ */
+export declare const mountContributorTag: ({ diffId, host, mountContext, }: {
+    diffId: string;
+    host: HTMLElement;
+    mountContext: ContributorTagMountContext | undefined;
+}) => ContributorTagMount | undefined;
+export declare const unmountContributorTag: (mount: ContributorTagMount | undefined) => void;
+/**
+ * The host for a tag on deleted content, which renders inside its own widget decoration rather than
+ * needing one of its own. Unmount with `unmountContributorTag` from that widget's `destroy`.
+ */
+export declare const createContributorTagHost: (diffId: string, mountContext?: ContributorTagMountContext) => {
+    host: HTMLSpanElement;
+    mount: ContributorTagMount | undefined;
+} | undefined;
+/**
+ * A widget hosting the contributor tag of one inline diff range, placed on the first character the
+ * range highlights.
+ *
+ * The tag is mounted in `toDOM` and taken down in `destroy`, so it lives exactly as long as the host
+ * element ProseMirror drew it into — see `mountContributorTag`.
+ */
+export declare const createContributorTagWidget: ({ doc, from, to, diffId, mountContext, }: {
+    diffId: string;
+    doc: PMNode;
+    from: number;
+    mountContext?: ContributorTagMountContext;
+    to: number;
+}) => Decoration | undefined;