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

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

@@ -0,0 +1,166 @@
+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 { createElement } from 'react';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { ContributorTagWidget } from '../../ui/ContributorTag/ContributorTagWidget';
+import { clampAnchorPosIntoCell } from './createAnchorDecorationWidgets';
+import { buildContributorTagDecorationSpec, DecorationFamily } from './decorationKeys';
+
+/** Marks the host element of one tag, so a tag can be found in the document by its own diff. */
+export var CONTRIBUTOR_TAG_HOST_ATTRIBUTE = 'data-contributor-tag-host';
+
+// Contributor tags only render behind this gate — see `areAttributionColorGatesEnabled`.
+var isContributorTagWidgetEnabled = function isContributorTagWidgetEnabled() {
+  return fg('confluence_ncs_step_diffing_version_history');
+};
+
+/**
+ * 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.
+ */
+
+/** A mounted tag, so whoever emitted the host can take it down again. */
+
+/**
+ * Unique per mount rather than per diff, because ProseMirror draws a replacement widget before it
+ * destroys the widget being replaced: on a shared key the outgoing widget's `destroy` would
+ * unregister the incoming widget's portal.
+ */
+var nextContributorTagPortalId = 0;
+
+/**
+ * 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 var mountContributorTag = function mountContributorTag(_ref) {
+  var diffId = _ref.diffId,
+    host = _ref.host,
+    mountContext = _ref.mountContext;
+  if (!mountContext) {
+    return undefined;
+  }
+  var api = mountContext.api,
+    getEditorRoot = mountContext.getEditorRoot,
+    portalProviderAPI = mountContext.portalProviderAPI;
+  var key = "".concat(DecorationFamily.contributorTag, "-").concat(diffId, "-").concat(nextContributorTagPortalId++);
+  portalProviderAPI.render(function () {
+    return /*#__PURE__*/createElement(ContributorTagWidget, {
+      api: api,
+      diffId: diffId,
+      getEditorRoot: getEditorRoot
+    });
+  }, host, key);
+  return {
+    key: key,
+    portalProviderAPI: portalProviderAPI
+  };
+};
+export var unmountContributorTag = function unmountContributorTag(mount) {
+  mount === null || mount === void 0 || mount.portalProviderAPI.remove(mount.key);
+};
+
+/**
+ * A zero-size inline host for one contributor tag. `position: relative` makes it the containing
+ * block of the absolutely positioned tag, so the tag sits on the change with no measurement.
+ */
+var buildContributorTagHost = function buildContributorTagHost(diffId) {
+  var host = document.createElement('span');
+  host.setAttribute(CONTRIBUTOR_TAG_HOST_ATTRIBUTE, diffId);
+  host.style.setProperty('position', 'relative');
+  return host;
+};
+
+/**
+ * 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 var createContributorTagHost = function createContributorTagHost(diffId, mountContext) {
+  if (!isContributorTagWidgetEnabled()) {
+    return undefined;
+  }
+  var host = buildContributorTagHost(diffId);
+  return {
+    host: host,
+    mount: mountContributorTag({
+      diffId: diffId,
+      host: host,
+      mountContext: mountContext
+    })
+  };
+};
+
+/**
+ * The start of the inline content that `[from, to)` actually highlights.
+ *
+ * `from` is not sufficient: a range can begin at the tail of one paragraph and only cover text in a
+ * later block, and ProseMirror clips `Decoration.inline` to the content it can paint — so a host
+ * left at `from` would sit lines away from the highlight.
+ */
+var resolveInlineContentStart = function resolveInlineContentStart(doc, from, to) {
+  var edge;
+  doc.nodesBetween(from, to, function (node, nodePos) {
+    if (!node.isTextblock) {
+      return edge === undefined;
+    }
+
+    // The slice of this block the range actually covers; empty means nothing paintable.
+    var contentFrom = Math.max(nodePos + 1, from);
+    var contentTo = Math.min(nodePos + 1 + node.content.size, to);
+    if (contentTo > contentFrom && edge === undefined) {
+      edge = contentFrom;
+    }
+
+    // Textblocks have no block children to descend into.
+    return false;
+  });
+  return edge !== null && edge !== void 0 ? edge : from;
+};
+
+/**
+ * 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 var createContributorTagWidget = function createContributorTagWidget(_ref2) {
+  var doc = _ref2.doc,
+    from = _ref2.from,
+    to = _ref2.to,
+    diffId = _ref2.diffId,
+    mountContext = _ref2.mountContext;
+  if (!isContributorTagWidgetEnabled()) {
+    return undefined;
+  }
+
+  // Reassigned when ProseMirror redraws this decoration, which it may do more than once for the
+  // same `Decoration` instance.
+  var mount;
+  return Decoration.widget(
+  // Keep the host out of the table row's grid (EDITOR-8442).
+  clampAnchorPosIntoCell(doc, resolveInlineContentStart(doc, from, to), 1), function () {
+    var host = buildContributorTagHost(diffId);
+    mount = mountContributorTag({
+      diffId: diffId,
+      host: host,
+      mountContext: mountContext
+    });
+    return host;
+  }, _objectSpread(_objectSpread({}, buildContributorTagDecorationSpec(diffId)), {}, {
+    side: 1,
+    // The tag is chrome: it inherits no surrounding mark, and its own events are not the
+    // document's to handle.
+    marks: [],
+    ignoreSelection: true,
+    stopEvent: function stopEvent() {
+      return true;
+    },
+    destroy: function destroy() {
+      unmountContributorTag(mount);
+      mount = undefined;
+    }
+  }));
+};

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

@@ -9,6 +9,7 @@ import { isExtendedEnabled } from '../isExtendedEnabled';
 import { buildAtomicInlineChangedCSSVariables, buildDeletedInlineContentStyleExtended, buildDeletedInlineStyle, buildDeletedInlineStyleStandard, buildInsertStyle, buildInsertStyleActive, buildInsertStyleExtended, buildInsertStyleExtendedActive, buildInsertStyleExtendedNoUnderline, buildInsertStyleExtendedNoUnderlineActive } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createInlineIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
+import { createContributorTagWidget } from './createContributorTagWidget';
 import { getAtomicInlineNodeClassNameLegacy, resolveInlineChangedStyleLegacy } from './createInlineChangedDecoration.styles.legacy';
 import { buildDiffDecorationSpec } from './decorationKeys';
 var displayNoneStyle = convertToInlineCss({
@@ -102,7 +103,8 @@ export var getAtomicInlineChangedAttrs = function getAtomicInlineChangedAttrs(in
  */
 
 export var createInlineChangedDecoration = function createInlineChangedDecoration(_ref2) {
-  var change = _ref2.change,
+  var attributionKey = _ref2.attributionKey,
+    change = _ref2.change,
     colorScheme = _ref2.colorScheme,
     _ref2$isActive = _ref2.isActive,
     isActive = _ref2$isActive === void 0 ? false : _ref2$isActive,
@@ -112,6 +114,8 @@ export var createInlineChangedDecoration = function createInlineChangedDecoratio
     isAtomicInlineNode = _ref2$isAtomicInlineN === void 0 ? false : _ref2$isAtomicInlineN,
     _ref2$shouldHideDelet = _ref2.shouldHideDeleted,
     shouldHideDeleted = _ref2$shouldHideDelet === void 0 ? false : _ref2$shouldHideDelet,
+    _ref2$showContributor = _ref2.showContributorTags,
+    showContributorTags = _ref2$showContributor === void 0 ? false : _ref2$showContributor,
     _ref2$showIndicators = _ref2.showIndicators,
     showIndicators = _ref2$showIndicators === void 0 ? false : _ref2$showIndicators,
     doc = _ref2.doc,
@@ -122,15 +126,23 @@ export var createInlineChangedDecoration = function createInlineChangedDecoratio
     _ref2$hasDeletedWidge = _ref2.hasDeletedWidget,
     hasDeletedWidget = _ref2$hasDeletedWidge === void 0 ? false : _ref2$hasDeletedWidge,
     _ref2$isDeletedWidget = _ref2.isDeletedWidgetBelow,
-    isDeletedWidgetBelow = _ref2$isDeletedWidget === void 0 ? false : _ref2$isDeletedWidget;
-  var diffId = crypto.randomUUID();
+    isDeletedWidgetBelow = _ref2$isDeletedWidget === void 0 ? false : _ref2$isDeletedWidget,
+    tagMountContext = _ref2.tagMountContext;
+  // Derived from the range so it survives a recalculation: stepping to the next/previous change
+  // rebuilds decorations without touching the doc, and a fresh id would change the React key and the
+  // tag host's key, remounting every tag mid-step. Random ids are kept when tags are off.
+  var diffId = showContributorTags ? "inline-".concat(change.fromB, "-").concat(change.toB) : crypto.randomUUID();
   if (shouldHideDeleted) {
     return [Decoration.inline(change.fromB, change.toB, {
       style: displayNoneStyle
     }, buildDiffDecorationSpec({
+      // No attribution: this decoration paints nothing and emits no tag host, so a tag
+      // resolved from it would have nowhere to render.
+      colorScheme: colorScheme,
       decorationType: 'inline',
       diffId: diffId,
-      isActive: isActive
+      isActive: isActive,
+      isInserted: isInserted
     }))];
   }
   var colors = getColorScheme(colorScheme);
@@ -150,10 +162,15 @@ export var createInlineChangedDecoration = function createInlineChangedDecoratio
     class: atomicInlineAttrs.className
   }), {}, {
     'data-testid': 'show-diff-changed-decoration'
+  }, showContributorTags && {
+    'data-diff-id': diffId
   }), buildDiffDecorationSpec({
+    attributionKey: attributionKey,
+    colorScheme: colorScheme,
     decorationType: 'inline',
     diffId: diffId,
-    isActive: isActive
+    isActive: isActive,
+    isInserted: isInserted
   }))];
   if (showIndicators && doc && isExtendedEnabled(diffType)) {
     // For paragraphs, fromB/toB land on the outer block
@@ -190,5 +207,20 @@ export var createInlineChangedDecoration = function createInlineChangedDecoratio
       diffId: diffId
     })));
   }
+
+  // Built from the raw change range, not the anchors above: a tag lines up with the changed text,
+  // while the bar's anchors are held on a block boundary when a deleted widget renders beside them.
+  if (showContributorTags && doc && isExtendedEnabled(diffType)) {
+    var tagWidget = createContributorTagWidget({
+      doc: doc,
+      from: change.fromB,
+      to: change.toB,
+      diffId: diffId,
+      mountContext: tagMountContext
+    });
+    if (tagWidget) {
+      decorations.push(tagWidget);
+    }
+  }
   return decorations;
 };

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

@@ -6,6 +6,7 @@ import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { isExtendedEnabled } from '../isExtendedEnabled';
 import { createLeftAnchorWidget } from './createAnchorDecorationWidgets';
 import { createChangedRowDecorationWidgets } from './createChangedRowDecorationWidgets';
+import { createContributorTagHost, unmountContributorTag } from './createContributorTagWidget';
 import { buildDiffDecorationSpec, buildAnchorDecorationKey } from './decorationKeys';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
 import { wrapBlockNodeView, injectInnerWrapper, createContentWrapper } from './utils/wrapBlockNodeView';
@@ -91,7 +92,8 @@ var createTableCellContentWidgets = function createTableCellContentWidgets(_ref)
  */
 export var createNodeChangedDecorationWidget = function createNodeChangedDecorationWidget(_ref2) {
   var _slice$content, _slice$content2, _slice$content3, _$safeInsertPos$nodeB, _slice$content$firstC, _newDoc$firstChild, _slice$content$firstC2;
-  var change = _ref2.change,
+  var attributionKey = _ref2.attributionKey,
+    change = _ref2.change,
     doc = _ref2.doc,
     nodeViewSerializer = _ref2.nodeViewSerializer,
     colorScheme = _ref2.colorScheme,
@@ -100,13 +102,16 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
     activeIndexPos = _ref2.activeIndexPos,
     _ref2$isInserted = _ref2.isInserted,
     isInserted = _ref2$isInserted === void 0 ? false : _ref2$isInserted,
+    _ref2$showContributor = _ref2.showContributorTags,
+    showContributorTags = _ref2$showContributor === void 0 ? false : _ref2$showContributor,
     _ref2$showIndicators = _ref2.showIndicators,
     showIndicators = _ref2$showIndicators === void 0 ? false : _ref2$showIndicators,
     _ref2$placeBelow = _ref2.placeBelow,
     placeBelow = _ref2$placeBelow === void 0 ? false : _ref2$placeBelow,
     diffType = _ref2.diffType,
     _ref2$hideAddedDiffsU = _ref2.hideAddedDiffsUnderline,
-    hideAddedDiffsUnderline = _ref2$hideAddedDiffsU === void 0 ? false : _ref2$hideAddedDiffsU;
+    hideAddedDiffsUnderline = _ref2$hideAddedDiffsU === void 0 ? false : _ref2$hideAddedDiffsU,
+    tagMountContext = _ref2.tagMountContext;
   var slice = doc.slice(change.fromA, change.toA);
   var shouldSkipDeletedEmptyParagraphDecoration = !isInserted && (slice === null || slice === void 0 || (_slice$content = slice.content) === null || _slice$content === void 0 ? void 0 : _slice$content.childCount) === 1 && (slice === null || slice === void 0 || (_slice$content2 = slice.content) === null || _slice$content2 === void 0 || (_slice$content2 = _slice$content2.firstChild) === null || _slice$content2 === void 0 ? void 0 : _slice$content2.type.name) === 'paragraph' && (slice === null || slice === void 0 || (_slice$content3 = slice.content) === null || _slice$content3 === void 0 || (_slice$content3 = _slice$content3.firstChild) === null || _slice$content3 === void 0 ? void 0 : _slice$content3.content.size) === 0;
   // Widget decoration used for deletions as the content is not in the document
@@ -204,7 +209,9 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
       subtree: true
     });
   }
-  var diffId = crypto.randomUUID();
+  // Derived from the deleted range so it survives a recalculation — see the same reasoning in
+  // `createInlineChangedDecoration`.
+  var diffId = showContributorTags ? "widget-".concat(change.fromA, "-").concat(change.toA) : crypto.randomUUID();
   var decorations = [];
   var replacementNode = newDoc.nodeAt(change.fromB);
   var firstReplacedNode = slice.content.firstChild;
@@ -327,23 +334,47 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
     }
   });
   dom.setAttribute('data-testid', 'show-diff-deleted-decoration');
+
+  // Needed even when the indicator bar is off, because a contributor tag also anchors against the
+  // widget.
+  if ((showIndicators || showContributorTags) && isExtendedEnabled(diffType)) {
+    dom.style.setProperty('anchor-name', "--".concat(buildAnchorDecorationKey({
+      diffId: diffId
+    })));
+  }
+
+  // Taken down in the widget's `destroy` below: `dom` is rebuilt on every recalculation, so the tag
+  // mounted into it must not outlive the copy ProseMirror is drawing.
+  var tagMount;
+  if (showContributorTags) {
+    // Lets the contributor tag find the deleted content on hover.
+    dom.setAttribute('data-diff-id', diffId);
+
+    // Hosted at the start of the deleted run rather than on `dom` itself: `dom` is inline, so once
+    // the deleted content wraps its box is the union of its line fragments.
+    var tagHost = createContributorTagHost(diffId, tagMountContext);
+    if (tagHost) {
+      dom.prepend(tagHost.host);
+      tagMount = tagHost.mount;
+    }
+  }
   if (showIndicators && isExtendedEnabled(diffType)) {
     var leftAnchor = createLeftAnchorWidget({
       doc: newDoc,
       from: safeInsertPos,
       diffId: diffId
     });
-    dom.style.setProperty('anchor-name', "--".concat(buildAnchorDecorationKey({
-      diffId: diffId
-    })));
     if (leftAnchor) {
       decorations.push(leftAnchor);
     }
   }
   decorations.push(Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread(_objectSpread({}, buildDiffDecorationSpec(_objectSpread({
+    attributionKey: attributionKey,
+    colorScheme: colorScheme,
     decorationType: 'widget',
     diffId: diffId,
     isActive: isActive,
+    isInserted: isInserted,
     diffType: diffType
   }, isExtendedEnabled(diffType) && {
     // placeBelow anchors at the end of the new content, so render on the
@@ -354,7 +385,9 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
   }), {}, {
     destroy: function destroy() {
       var _constrainMediaObserv2;
-      return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();
+      (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 || _constrainMediaObserv2.disconnect();
+      unmountContributorTag(tagMount);
+      tagMount = undefined;
     }
   })));
 

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

@@ -3,14 +3,14 @@ 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 { isExtendedEnabled } from '../isExtendedEnabled';
-
 /**
  * Decoration families produced by the show-diff plugin.
  * Each family owns its own key space and spec shape.
  */
 export var DecorationFamily = {
   diff: 'diff',
-  anchor: 'anchor'
+  anchor: 'anchor',
+  contributorTag: 'contributor-tag'
 };
 export var AnchorTypeKey = {
   from: 'from',
@@ -18,6 +18,12 @@ export var AnchorTypeKey = {
   left: 'left',
   docMargin: 'doc-margin'
 };
+
+/**
+ * The host widget one contributor tag renders into. Its own family, so the tag never reaches the
+ * consumers that read diff decorations — change counting, navigation and `getDeletedWidgets`.
+ */
+
 /**
  * The diff-decoration kinds produced by the show-diff plugin. Each value is
  * the leading segment of the generated key, so a diff decoration's kind can be
@@ -51,13 +57,16 @@ export var buildDiffDecorationKey = function buildDiffDecorationKey(_ref2) {
   return isActive !== undefined ? "".concat(decorationKeyPrefix, "-").concat(isActive ? 'active' : 'inactive') : decorationKeyPrefix;
 };
 export var buildDiffDecorationSpec = function buildDiffDecorationSpec(_ref3) {
-  var decorationType = _ref3.decorationType,
+  var attributionKey = _ref3.attributionKey,
+    colorScheme = _ref3.colorScheme,
+    decorationType = _ref3.decorationType,
     diffId = _ref3.diffId,
     isActive = _ref3.isActive,
+    isInserted = _ref3.isInserted,
     nodeName = _ref3.nodeName,
     side = _ref3.side,
     diffType = _ref3.diffType;
-  return _objectSpread(_objectSpread({
+  return _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({
     decorationFamily: DecorationFamily.diff,
     decorationType: decorationType,
     diffId: diffId,
@@ -67,7 +76,15 @@ export var buildDiffDecorationSpec = function buildDiffDecorationSpec(_ref3) {
       isActive: isActive,
       diffType: diffType
     })
-  }, nodeName ? {
+  }, attributionKey ? {
+    attributionKey: attributionKey
+  } : {}), attributionKey && isActive !== undefined ? {
+    isActive: isActive
+  } : {}), attributionKey && isInserted !== undefined ? {
+    isInserted: isInserted
+  } : {}), attributionKey && colorScheme ? {
+    colorScheme: colorScheme
+  } : {}), nodeName ? {
     nodeName: nodeName
   } : {}), side !== undefined ? {
     side: side
@@ -101,6 +118,14 @@ export function buildAnchorDecorationSpec(_ref4) {
     side: side
   } : {});
 }
+export var buildContributorTagDecorationSpec = function buildContributorTagDecorationSpec(diffId) {
+  return {
+    decorationFamily: DecorationFamily.contributorTag,
+    diffId: diffId,
+    // Stable across recalculations, so ProseMirror keeps the host element the tag is portalled into.
+    key: "".concat(DecorationFamily.contributorTag, "-").concat(diffId)
+  };
+};
 export var isDiffDecorationSpec = function isDiffDecorationSpec(spec) {
   return Boolean(spec && _typeof(spec) === 'object' && 'decorationFamily' in spec && spec.decorationFamily === DecorationFamily.diff);
 };

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

@@ -0,0 +1,122 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["connectedToKey"];
+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; }
+import { isDiffDecoration, isDiffDecorationSpec } from './decorationKeys';
+
+/**
+ * Diff kinds that expose an anchor a tag can be pinned to: `inline` is added/changed content,
+ * `widget` is deleted content. Block diffs carry no attribution.
+ */
+var TAGGABLE_DECORATION_TYPES = new Set(['inline', 'widget']);
+
+/** The connection is an internal key, so it is dropped on the way to the tag. */
+var toTagContributor = function toTagContributor(_ref) {
+  var _connectedToKey = _ref.connectedToKey,
+    tagContributor = _objectWithoutProperties(_ref, _excluded);
+  return tagContributor;
+};
+/**
+ * Whether a deleted-content widget belongs to the same change as an inline decoration. A replacement
+ * renders both — the inserted text inline, the deleted text as a widget anchored to one end of that
+ * inline range — and the two must not each claim a tag.
+ */
+var isSameChange = function isSameChange(widget, inline) {
+  return widget.spec.attributionKey === inline.spec.attributionKey && widget.from >= inline.from && widget.from <= inline.to;
+};
+
+/**
+ * One model per diff decoration whose attribution resolves to a supplied contributor; anything
+ * unattributed, untaggable or unresolved is skipped. A replacement's two decorations are collapsed
+ * into the single inline tag — see `isSameChange`.
+ */
+export var extractContributorTags = function extractContributorTags(decorations, contributors) {
+  if (!contributors) {
+    return [];
+  }
+  var targets = [];
+  var _iterator = _createForOfIteratorHelper(decorations.find(undefined, undefined, isDiffDecorationSpec)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var decoration = _step.value;
+      if (!isDiffDecoration(decoration)) {
+        continue;
+      }
+      var spec = decoration.spec;
+      if (!spec.attributionKey || !TAGGABLE_DECORATION_TYPES.has(spec.decorationType)) {
+        continue;
+      }
+      var contributor = contributors[spec.attributionKey];
+      if (!contributor) {
+        continue;
+      }
+      targets.push({
+        contributor: contributor,
+        decoration: decoration
+      });
+    }
+
+    // The inline decoration keeps the tag: it captions content still in the document.
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var inlineTargets = targets.filter(function (_ref2) {
+    var decoration = _ref2.decoration;
+    return decoration.spec.decorationType === 'inline';
+  });
+  var linkedDiffIds = new Map();
+  var folded = new Set();
+  var _loop = function _loop() {
+      var _linkedDiffIds$get;
+      var target = _targets[_i];
+      if (target.decoration.spec.decorationType !== 'widget') {
+        return 0; // continue
+      }
+      var host = inlineTargets.find(function (_ref3) {
+        var decoration = _ref3.decoration;
+        return isSameChange(target.decoration, decoration);
+      });
+      if (!host) {
+        return 0; // continue
+      }
+      folded.add(target);
+      var hostDiffId = host.decoration.spec.diffId;
+      linkedDiffIds.set(hostDiffId, [].concat(_toConsumableArray((_linkedDiffIds$get = linkedDiffIds.get(hostDiffId)) !== null && _linkedDiffIds$get !== void 0 ? _linkedDiffIds$get : []), [target.decoration.spec.diffId]));
+    },
+    _ret;
+  for (var _i = 0, _targets = targets; _i < _targets.length; _i++) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+  }
+  return targets.filter(function (target) {
+    return !folded.has(target);
+  }).map(function (_ref4) {
+    var contributor = _ref4.contributor,
+      spec = _ref4.decoration.spec;
+    var connected = contributor.connectedToKey ? contributors[contributor.connectedToKey] : undefined;
+    var connectedContributor = connected ? toTagContributor(connected) : undefined;
+    var linked = linkedDiffIds.get(spec.diffId);
+    return _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({
+      contributor: toTagContributor(contributor),
+      diffId: spec.diffId
+    }, connectedContributor ? {
+      connectedContributor: connectedContributor
+    } : {}), spec.colorScheme ? {
+      colorScheme: spec.colorScheme
+    } : {}), spec.isActive !== undefined ? {
+      isActive: spec.isActive
+    } : {}), spec.isInserted !== undefined ? {
+      isInserted: spec.isInserted
+    } : {}), linked ? {
+      linkedDiffIds: linked
+    } : {});
+  });
+};