@atlaskit/editor-plugin-show-diff 20.0.10 → 21.0.0

package/dist/esm/pm-plugins/NodeViewSerializer.js

@@ -1,7 +1,12 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import { expandedState } from '@atlaskit/editor-common/expand';
 import { DOMSerializer } from '@atlaskit/editor-prosemirror/model';
+import { contains } from '@atlaskit/editor-prosemirror/utils';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { createEditorProxy } from './createEditorProxy';
+import { wrapInMarkViews } from './markViews';
 
 /**
  * Utilities for working with ProseMirror node views and DOM serialization within the
@@ -30,6 +35,16 @@ export function isEditorViewWithNodeViews(view) {
   return view.nodeViews !== undefined;
 }
 
+/** Expand-family nodes whose expanded state lives in a node-keyed WeakMap. */
+var EXPAND_TYPES = new Set(['expand', 'nestedExpand']);
+
+/** Tables are the only node views that read and write positions, so only they need a preview. */
+var containsTable = function containsTable(node) {
+  var table = node.type.schema.nodes.table;
+  // `contains` only checks descendants, so the node itself is checked separately.
+  return !!table && (node.type === table || contains(node, table));
+};
+
 /**
  * Encapsulates DOM serialization and node view access/creation.
  *
@@ -75,11 +90,18 @@ export var NodeViewSerializer = /*#__PURE__*/function () {
     key: "appendChildNodes",
     value: function appendChildNodes(children, contentDOM) {
       var _this = this;
+      var basePos = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var editorProxy = arguments.length > 3 ? arguments[3] : undefined;
+      // A node's first child sits one position inside it, and each subsequent
+      // child is offset by the previous child's `nodeSize`. Tracking this lets nested node
+      // views resolve to their real depth instead of every one of them seeing depth 0.
+      var childPos = basePos + 1;
       children.forEach(function (child) {
-        var childNode = _this.tryCreateNodeView(child) || _this.serializeNode(child);
+        var childNode = _this.tryCreateNodeViewInner(child, childPos, editorProxy) || _this.serializeNode(child);
         if (childNode) {
           contentDOM === null || contentDOM === void 0 || contentDOM.append(childNode);
         }
+        childPos += child.nodeSize;
       });
     }
 
@@ -88,11 +110,29 @@ export var NodeViewSerializer = /*#__PURE__*/function () {
      *
      * Returns `null` when there is no `EditorView`, no constructor for the node type,
      * or the node type is blocklisted. Otherwise returns the constructed node view instance.
+     *
+     * `$sourcePos` is where the node sits in the doc it came from, so nested tables keep their depth.
      */
   }, {
     key: "tryCreateNodeView",
     value: function tryCreateNodeView(targetNode) {
+      var _preview$rootPos;
+      var basePos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var $sourcePos = arguments.length > 2 ? arguments[2] : undefined;
+      if (!this.editorView) {
+        return null;
+      }
+      // The preview becomes the document every nested node view resolves its position against,
+      // so positions stay internally consistent.
+      var preview = fg('platform_editor_ai_show_diff_patch_2') && containsTable(targetNode) ? createEditorProxy(this.editorView, targetNode, $sourcePos) : null;
+      return this.tryCreateNodeViewInner(targetNode, (_preview$rootPos = preview === null || preview === void 0 ? void 0 : preview.rootPos) !== null && _preview$rootPos !== void 0 ? _preview$rootPos : basePos, preview === null || preview === void 0 ? void 0 : preview.editorProxy);
+    }
+  }, {
+    key: "tryCreateNodeViewInner",
+    value: function tryCreateNodeViewInner(targetNode) {
       var _this$nodeViews;
+      var basePos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var editorProxy = arguments.length > 2 ? arguments[2] : undefined;
       if (!this.editorView) {
         return null;
       }
@@ -138,23 +178,47 @@ export var NodeViewSerializer = /*#__PURE__*/function () {
             if (!isExperimentEnabled('platform_editor_show_diff_deleted_nodeview_content') && targetNode.type.name === 'paragraph' && targetNode.children.length === 1) {
               return this.serializeFragment(targetNode.content);
             }
-            this.appendChildNodes(targetNode.children, _contentDOM);
+            this.appendChildNodes(targetNode.children, _contentDOM, basePos, editorProxy);
           }
-          return _dom;
+          return this.withMarkViews(targetNode, _dom, editorProxy);
         }
-        var _constructor = constructor(targetNode, this.editorView, function () {
-            return 0;
+
+        // The expand node view reads `expandedState.get(node) ?? false`, never `attrs.__expanded`.
+        // Open the preview so its tables get real layout; an existing entry is the live expand's
+        // own state, so leave it alone.
+        if (EXPAND_TYPES.has(targetNode.type.name) && !expandedState.has(targetNode) && fg('platform_editor_ai_show_diff_patch_2')) {
+          expandedState.set(targetNode, true);
+        }
+
+        // `isTableNested` is `doc.resolve(pos).depth > 0`, so the old hardcoded `0` made nested
+        // tables size as top-level. Positions are resolved against the preview document, so
+        // they are only meaningful with an editor proxy.
+        var view = editorProxy !== null && editorProxy !== void 0 ? editorProxy : this.editorView;
+        var docSize = view.state.doc.content.size;
+        var resolvedPos = editorProxy ? Math.max(0, Math.min(basePos, docSize)) : 0;
+        var _constructor = constructor(targetNode, view, function () {
+            return resolvedPos;
           }, [], {}),
           dom = _constructor.dom,
           contentDOM = _constructor.contentDOM;
         // Iteratively populate children
-        this.appendChildNodes(targetNode.children, contentDOM);
-        return dom;
+        this.appendChildNodes(targetNode.children, contentDOM, basePos, editorProxy);
+        return this.withMarkViews(targetNode, dom, editorProxy);
       } catch (_unused) {
         return null;
       }
     }
 
+    /** Wraps rendered DOM in its marks, rendered against the editor proxy when there is one. */
+  }, {
+    key: "withMarkViews",
+    value: function withMarkViews(targetNode, nodeDom, editorProxy) {
+      return wrapInMarkViews(targetNode, nodeDom, {
+        nodeViews: this.nodeViews,
+        view: editorProxy !== null && editorProxy !== void 0 ? editorProxy : this.editorView
+      });
+    }
+
     /**
      * Serializes a node to a DOM `Node` using the schema's `DOMSerializer`.
      */

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

@@ -1,5 +1,7 @@
 import { getBaseNodeTypeName } from '@atlaskit/editor-common/utils/node-type-utils';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { getDiffableAttrNames } from '../decorations/utils/diffableAttrs';
+import { getComparableExcerptIncludeAttrs, isExcerptInclude } from '../decorations/utils/excerptIncludeAttrs';
 import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
 
 /**
@@ -11,14 +13,12 @@ import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
  */
 
 // Stable composite token; attr names are pre-ordered by the caller.
-var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
-  var _node$attrs;
-  var attrs = (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 ? _node$attrs : {};
+var encodeNodeWithAttrs = function encodeNodeWithAttrs(nodeTypeName, attrs, attrNames) {
   var parts = attrNames.map(function (name) {
     var _attrs$name;
     return "".concat(name, "=").concat(JSON.stringify((_attrs$name = attrs[name]) !== null && _attrs$name !== void 0 ? _attrs$name : null));
   });
-  return "".concat(node.type.name, "|").concat(parts.join('|'));
+  return "".concat(nodeTypeName, "|").concat(parts.join('|'));
 };
 
 // Like the library default, but node types with a `diffableAttrs` rule fold their
@@ -29,11 +29,13 @@ export var attrAwareTokenEncoder = {
     return encodeCharacterWithMarks(char, marks);
   },
   encodeNodeStart: function encodeNodeStart(node) {
-    var _node$attrs2;
+    // A one-sided reference is not comparable from an isolated token. Attribute-step comparison
+    // checks the reference when both versions have one.
+    var attrs = fg('platform_editor_normalize_excerpt_diff') && node.type.name === 'extension' && isExcerptInclude(node.attrs) ? getComparableExcerptIncludeAttrs(node.attrs) : node.attrs;
     // Normalise variants (e.g. `panel_c1` → `panel`) so `diffableAttrs` needs one entry.
-    var attrNames = getDiffableAttrNames(getBaseNodeTypeName(node.type), (_node$attrs2 = node.attrs) !== null && _node$attrs2 !== void 0 ? _node$attrs2 : {});
+    var attrNames = getDiffableAttrNames(getBaseNodeTypeName(node.type), attrs !== null && attrs !== void 0 ? attrs : {});
     if (attrNames && attrNames.length > 0) {
-      return encodeNodeWithAttrs(node, attrNames);
+      return encodeNodeWithAttrs(node.type.name, attrs, attrNames);
     }
     return node.type.name;
   },

package/dist/esm/pm-plugins/createEditorProxy.js

@@ -0,0 +1,78 @@
+import { GapCursorSelection, Side } from '@atlaskit/editor-common/selection/gap-cursor/selection';
+/**
+ * A preview is rendered by the live view's own node views, which read `getPos()` against
+ * `view.state.doc` for both layout (`isTableNested`) and writes (`scaleTable` builds attribute
+ * steps at `getPos() + 1`). Handing them live positions makes the layout correct but points the
+ * writes at unrelated live nodes, so give them a view whose document *is* the preview instead.
+ *
+ * With `$sourcePos` (the node's position in the doc it came from) the node is swapped into a copy
+ * of its real top-level ancestor, so a table inside an expand still resolves as nested.
+ *
+ * Returns `null` when the node cannot be a top-level child (e.g. a bare `tableCell`), in which
+ * case the caller falls back to the live view and the previous stubbed positions.
+ */
+export function createEditorProxy(liveView, rootNode, $sourcePos) {
+  var liveState = liveView.state;
+  var createDoc = function createDoc(topLevel) {
+    return liveState.schema.topNodeType.createChecked(null, topLevel);
+  };
+  var previewDoc;
+  var rootPos = 0;
+  try {
+    var _$sourcePos$nodeAfter;
+    if ($sourcePos && $sourcePos.depth > 0 && ((_$sourcePos$nodeAfter = $sourcePos.nodeAfter) === null || _$sourcePos$nodeAfter === void 0 ? void 0 : _$sourcePos$nodeAfter.type) === rootNode.type) {
+      var topLevel = rootNode;
+      for (var depth = $sourcePos.depth; depth > 0; depth--) {
+        var ancestor = $sourcePos.node(depth);
+        topLevel = ancestor.copy(ancestor.content.replaceChild($sourcePos.index(depth), topLevel));
+      }
+      previewDoc = createDoc(topLevel);
+      rootPos = $sourcePos.pos - $sourcePos.before(1);
+    } else {
+      previewDoc = createDoc(rootNode);
+    }
+  } catch (_unused) {
+    return null;
+  }
+
+  // A gap cursor just before the node selects nothing, so the table's node view doesn't render
+  // as selected or show its controls.
+  var previewSelection = new GapCursorSelection(previewDoc.resolve(rootPos), Side.LEFT);
+  // Proxy rather than `EditorState.create` so plugin state is shared as-is: re-initialising
+  // every plugin per preview would be costly and re-runs their side effects.
+  var stateProxy = new Proxy(liveState, {
+    get: function get(target, prop, receiver) {
+      if (prop === 'doc') {
+        return previewDoc;
+      }
+      if (prop === 'selection') {
+        return previewSelection;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  var editorProxy = new Proxy(liveView, {
+    get: function get(target, prop, receiver) {
+      if (prop === 'state') {
+        return stateProxy;
+      }
+      if (prop === 'dispatch') {
+        // Keep the transaction inside the preview. It was built against `previewDoc`, so
+        // applying it to the live state would corrupt the real document.
+        return function (tr) {
+          try {
+            stateProxy = stateProxy.apply(tr);
+          } catch (_unused2) {
+            // A preview is throwaway; a failed self-update is not worth surfacing.
+          }
+        };
+      }
+      var value = Reflect.get(target, prop, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    }
+  });
+  return {
+    editorProxy: editorProxy,
+    rootPos: rootPos
+  };
+}

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

@@ -5,8 +5,8 @@ import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { ContributorTagController } from '../../ui/ContributorTag/contributorTagController';
 import { buildCharsByOffset, isWhitespaceChar } from '../utils/charsByOffset';
-import { clampAnchorPosIntoCell } from './createAnchorDecorationWidgets';
-import { AnchorTypeKey, buildAnchorDecorationKey, buildContributorTagDecorationSpec } from './decorationKeys';
+import { clampAnchorPosIntoCell, createAnchorNameSpan } from './createAnchorDecorationWidgets';
+import { AnchorTypeKey, buildAnchorDecorationKey, buildAnchorDecorationSpec, buildContributorTagDecorationSpec } 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';
@@ -218,13 +218,14 @@ export var resolveHoistedCodeBlockAnchor = function resolveHoistedCodeBlockAncho
  * highlights — or, with `anchorAtRangeStart`, at `from` itself. A host inside a code block is
  * hoisted in front of it instead, anchored via `resolveHoistedCodeBlockAnchor` (EDITOR-9045).
  *
- * Returns one decoration normally, two (marker + tag) when hoisted out of a code block.
+ * Returns one decoration when a caller-supplied `anchorName` is used, two (marker + tag)
+ * otherwise — hoisted out of a code block, or anchored to its own point marker.
  *
  * 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(_ref4) {
-  var _hoisted$anchorName, _hoisted$codeBlockSta;
+  var _hoisted$codeBlockSta, _ref5, _hoisted$anchorName;
   var _ref4$anchorAtRangeSt = _ref4.anchorAtRangeStart,
     anchorAtRangeStart = _ref4$anchorAtRangeSt === void 0 ? false : _ref4$anchorAtRangeSt,
     anchorName = _ref4.anchorName,
@@ -244,15 +245,33 @@ export var createContributorTagWidget = function createContributorTagWidget(_ref
   // A change inside a code block is hoisted out of it, anchored to its own marker; anything else
   // keeps its own anchor.
   var hoisted = resolveHoistedCodeBlockAnchor(doc, anchorPos, diffId);
-  var effectiveAnchorName = (_hoisted$anchorName = hoisted === null || hoisted === void 0 ? void 0 : hoisted.anchorName) !== null && _hoisted$anchorName !== void 0 ? _hoisted$anchorName : anchorName;
+  // Keep the host out of the table row's grid (EDITOR-8442).
+  var hostPos = clampAnchorPosIntoCell(doc, (_hoisted$codeBlockSta = hoisted === null || hoisted === void 0 ? void 0 : hoisted.codeBlockStart) !== null && _hoisted$codeBlockSta !== void 0 ? _hoisted$codeBlockSta : anchorPos, 1);
+
+  // Inline diffs pass no anchorName. Give them their own point anchor instead of the
+  // `position: relative` fallback, which drifts left once the range wraps a line (EDITOR-9286).
+  var ownAnchorName = buildAnchorDecorationKey({
+    diffId: diffId,
+    anchorType: AnchorTypeKey.tag
+  });
+  var effectiveAnchorName = (_ref5 = (_hoisted$anchorName = hoisted === null || hoisted === void 0 ? void 0 : hoisted.anchorName) !== null && _hoisted$anchorName !== void 0 ? _hoisted$anchorName : anchorName) !== null && _ref5 !== void 0 ? _ref5 : ownAnchorName;
   var tagAnchorName = effectiveAnchorName && supportsAnchorPositioning() ? effectiveAnchorName : undefined;
   var decorations = [];
   if (hoisted) {
     decorations.push(hoisted.marker);
+  } else if (!anchorName && tagAnchorName) {
+    decorations.push(Decoration.widget(hostPos, function () {
+      return createAnchorNameSpan(ownAnchorName);
+    }, _objectSpread(_objectSpread({}, buildAnchorDecorationSpec({
+      diffId: diffId,
+      anchorType: AnchorTypeKey.tag,
+      side: -1
+    })), {}, {
+      marks: [],
+      ignoreSelection: true
+    })));
   }
-  decorations.push(Decoration.widget(
-  // Keep the host out of the table row's grid (EDITOR-8442).
-  clampAnchorPosIntoCell(doc, (_hoisted$codeBlockSta = hoisted === null || hoisted === void 0 ? void 0 : hoisted.codeBlockStart) !== null && _hoisted$codeBlockSta !== void 0 ? _hoisted$codeBlockSta : anchorPos, 1), function () {
+  decorations.push(Decoration.widget(hostPos, function () {
     var host = buildContributorTagHost(diffId, tagAnchorName);
     mount = mountContributorTag({
       anchorName: tagAnchorName,

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

@@ -5,7 +5,7 @@ import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { countEmptyTextBlockOnlySlice } from '../utils/emptyTextBlocks';
 import { isEmptyParagraphSlice } from '../utils/isEmptyParagraphSlice';
-import { clampAnchorPosIntoCell, createLeftAnchorWidget } from './createAnchorDecorationWidgets';
+import { clampAnchorPosIntoCell, createAnchorNameSpan, createLeftAnchorWidget } from './createAnchorDecorationWidgets';
 import { createChangedRowDecorationWidgets } from './createChangedRowDecorationWidgets';
 import { createContributorTagHost, resolveHoistedCodeBlockAnchor, unmountContributorTag } from './createContributorTagWidget';
 import { AnchorTypeKey, buildContributorTagDecorationSpec, buildDiffDecorationSpec, buildAnchorDecorationKey, scrollMarginTopValue } from './decorationKeys';
@@ -17,6 +17,22 @@ import { findSafeInsertPos } from './utils/findSafeInsertPos';
 import { safeResolve } from './utils/safeResolve';
 import { getTableDiffMode } from './utils/tableDiffMode';
 import { wrapBlockNodeView, createRemovedLozenge, injectInnerWrapper, createContentWrapper } from './utils/wrapBlockNodeView';
+
+/**
+ * Where a slice's `index`th child sits in `doc`: the children belong to the ancestor `openStart`
+ * levels above the change. `null` if out of range — `posAtIndex` throws past the last child.
+ */
+var getSourcePos = function getSourcePos(doc, $changeFrom, openStart, index) {
+  var depth = $changeFrom ? $changeFrom.depth - openStart : -1;
+  if (!$changeFrom || depth < 0) {
+    return null;
+  }
+  var childIndex = $changeFrom.index(depth) + index;
+  if (childIndex >= $changeFrom.node(depth).childCount) {
+    return null;
+  }
+  return safeResolve(doc, $changeFrom.posAtIndex(childIndex, depth));
+};
 var isHeadingLevel = function isHeadingLevel(level) {
   return typeof level === 'number' && level >= 1 && level <= 6;
 };
@@ -284,7 +300,7 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
    * and if it's the first or last content, we go in however many the sliced Open
    * or sliced End depth is and match only the entire node.
    */
-  slice.content.forEach(function (node) {
+  slice.content.forEach(function (node, _offset, index) {
     var isFirst = firstReplacedNode === node;
     var isLast = lastReplacedNode === node;
     var isOpenAtSliceBoundary = isFirst && slice.openStart > 0 || isLast && slice.openEnd > 0;
@@ -355,7 +371,8 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
     }
 
     // Try to create node view, fallback to serialization
-    var nodeView = serializer.tryCreateNodeView(node);
+    var $sourcePos = fg('platform_editor_ai_show_diff_patch_2') ? getSourcePos(doc, $changeFromA, slice.openStart, index) : null;
+    var nodeView = serializer.tryCreateNodeView(node, 0, $sourcePos !== null && $sourcePos !== void 0 ? $sourcePos : undefined);
     if (nodeView) {
       if (node.isInline) {
         var wrapper = createContentWrapper(colorScheme, isActive, isInserted, reveal);
@@ -458,18 +475,27 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
     });
   }
 
-  // Needed even when the indicator bar is off, because a contributor tag also anchors against the
-  // widget.
+  // Needed even with the indicator bar off, since it anchors its top/bottom to the widget.
   if (showIndicators || showContributorTags) {
     dom.style.setProperty('anchor-name', "--".concat(buildAnchorDecorationKey({
       diffId: diffId
     })));
-    // The tag built below only anchors via `anchor()` if `contributorTagAnchorName` is set; without
-    // it the tag falls back to a non-anchored position (EDITOR-9045).
-    if (fg('confluence_ncs_step_diffing_version_history')) {
-      contributorTagAnchorName !== null && contributorTagAnchorName !== void 0 ? contributorTagAnchorName : contributorTagAnchorName = buildAnchorDecorationKey({
-        diffId: diffId
+    // `dom` is inline, so its box fragments across a line wrap and `anchor()` resolves to the
+    // wrong edge. The tag anchors to its own point marker instead (EDITOR-9286).
+    if (fg('confluence_ncs_step_diffing_version_history') && !contributorTagAnchorName) {
+      var tagPointAnchorName = buildAnchorDecorationKey({
+        diffId: diffId,
+        anchorType: AnchorTypeKey.tag
       });
+      contributorTagAnchorName = tagPointAnchorName;
+      decorations.push(Decoration.widget(safeInsertPos, function () {
+        return createAnchorNameSpan(tagPointAnchorName);
+      }, {
+        key: "contributor-tag-anchor-".concat(diffId),
+        side: -1,
+        marks: [],
+        ignoreSelection: true
+      }));
     }
   }
 
@@ -504,8 +530,7 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
         }
       })));
     } else {
-      // 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.
+      // Anchored to the point marker pushed above, not to `dom` (EDITOR-9286).
       var tagHost = createContributorTagHost({
         anchorName: contributorTagAnchorName,
         diffId: diffId,

package/dist/esm/pm-plugins/decorations/utils/excerptIncludeAttrs.js

@@ -0,0 +1,20 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import pick from 'lodash/pick';
+var asRecord = function asRecord(value) {
+  return value !== null && _typeof(value) === 'object' && !Array.isArray(value) ? value : undefined;
+};
+export var isExcerptInclude = function isExcerptInclude(attrs) {
+  return attrs.extensionKey === 'excerpt-include';
+};
+export var getReferencedContentId = function getReferencedContentId(attrs) {
+  var _asRecord;
+  var parameters = asRecord(attrs.parameters);
+  var macroParams = asRecord(parameters === null || parameters === void 0 ? void 0 : parameters.macroParams);
+  var value = (_asRecord = asRecord(macroParams === null || macroParams === void 0 ? void 0 : macroParams._referencedContentId)) === null || _asRecord === void 0 ? void 0 : _asRecord.value;
+  return typeof value === 'string' ? value : undefined;
+};
+
+/** Compare macro identity and authored options, excluding publish-time rendering metadata. */
+export var getComparableExcerptIncludeAttrs = function getComparableExcerptIncludeAttrs(attrs) {
+  return pick(attrs, ['extensionType', 'layout', 'parameters.macroMetadata.macroId.value', 'parameters.macroParams[""].value', 'parameters.macroParams.name.value', 'parameters.macroParams.nopanel.value', 'parameters.macroParams.inline.value']);
+};

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

@@ -6,7 +6,9 @@ import omit from 'lodash/omit';
 import { SetAttrsStep } from '@atlaskit/adf-schema/steps/set-attrs';
 import { getBaseNodeTypeName } from '@atlaskit/editor-common/utils/node-type-utils';
 import { AttrStep } from '@atlaskit/editor-prosemirror/transform';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { getRequiredIncludedDiffableAttrs, isDiffableAttr } from './diffableAttrs';
+import { getComparableExcerptIncludeAttrs, getReferencedContentId, isExcerptInclude } from './excerptIncludeAttrs';
 var filterUndefined = function filterUndefined(x) {
   return !!x;
 };
@@ -44,6 +46,11 @@ var getComparableExtensionAttrs = function getComparableExtensionAttrs(node) {
   return omit(node.attrs, transientExtensionAttrPaths);
 };
 var haveSameRelevantExtensionAttrs = function haveSameRelevantExtensionAttrs(beforeNode, afterNode) {
+  if (fg('platform_editor_normalize_excerpt_diff') && isExcerptInclude(beforeNode.attrs) && isExcerptInclude(afterNode.attrs)) {
+    var beforeReference = getReferencedContentId(beforeNode.attrs);
+    var afterReference = getReferencedContentId(afterNode.attrs);
+    return isEqual(getComparableExcerptIncludeAttrs(beforeNode.attrs), getComparableExcerptIncludeAttrs(afterNode.attrs)) && (beforeReference === undefined || afterReference === undefined || beforeReference === afterReference);
+  }
   return isEqual(getComparableExtensionAttrs(beforeNode), getComparableExtensionAttrs(afterNode));
 };
 var getStepAttrs = function getStepAttrs(step) {

package/dist/esm/pm-plugins/decorations/utils/wrapBlockNodeView.js

@@ -314,6 +314,21 @@ var applyTextLikeBlockNodeStyles = function applyTextLikeBlockNodeStyles(_ref8)
 /**
  * Creates a content wrapper with deleted styles for a block node
  */
+/**
+ * The element that spans breakout width, for nodes carrying a `breakout` mark. The wrapper divs
+ * stay at editor-column width, so anything that should align to the node's visible edges —
+ * outlines, absolutely positioned lozenges — has to attach here instead.
+ */
+var findBreakoutElement = function findBreakoutElement(targetNode, nodeView) {
+  var _targetNode$marks;
+  var hasBreakoutMark = (_targetNode$marks = targetNode.marks) === null || _targetNode$marks === void 0 ? void 0 : _targetNode$marks.some(function (mark) {
+    return mark.type.name === 'breakout';
+  });
+  if (!hasBreakoutMark || !(nodeView instanceof HTMLElement)) {
+    return null;
+  }
+  return nodeView.matches('[data-node-type]') ? nodeView : nodeView.querySelector('[data-node-type]');
+};
 var createBlockNodeContentWrapper = function createBlockNodeContentWrapper(_ref9) {
   var nodeView = _ref9.nodeView,
     targetNode = _ref9.targetNode,
@@ -331,7 +346,16 @@ var createBlockNodeContentWrapper = function createBlockNodeContentWrapper(_ref9
   // should not also get the inline content style (borderBottom underline) on their container.
   var shouldSkipContentStyle = isInserted && nodeStyle !== undefined;
   var contentStyle = shouldSkipContentStyle ? '' : getChangedContentStyle(colorScheme, isActive, isInserted, hideAddedDiffsUnderline);
-  contentWrapper.setAttribute('style', "".concat(contentStyle).concat(nodeStyle || ''));
+
+  // A `breakout` node renders wider than the editor column while the wrapper divs
+  // stay at column width, so paint the outline on the node element that spans that width.
+  var breakoutTarget = nodeStyle ? findBreakoutElement(targetNode, nodeView) : null;
+  if (fg('platform_editor_ai_show_diff_patch_2') && breakoutTarget) {
+    appendStyleToElement(breakoutTarget, nodeStyle !== null && nodeStyle !== void 0 ? nodeStyle : '');
+    contentWrapper.setAttribute('style', contentStyle || '');
+  } else {
+    contentWrapper.setAttribute('style', "".concat(contentStyle).concat(nodeStyle || ''));
+  }
   contentWrapper.append(nodeView);
   return contentWrapper;
 };
@@ -461,7 +485,19 @@ var wrapBlockNode = function wrapBlockNode(_ref10) {
     })) {
       return;
     }
-    blockWrapper.append(lozenge);
+
+    // `lozenge` is absolutely positioned, so it lands on the nearest positioned ancestor. For a
+    // breakout node that is the column-width wrapper, leaving the pill short of the node's
+    // right edge — host it on the breakout element, which must establish a containing block.
+    var breakoutHost = fg('platform_editor_ai_show_diff_patch_2') ? findBreakoutElement(targetNode, nodeView) : null;
+    if (breakoutHost) {
+      appendStyleToElement(breakoutHost, convertToInlineCss({
+        position: 'relative'
+      }));
+      breakoutHost.append(lozenge);
+    } else {
+      blockWrapper.append(lozenge);
+    }
   }
   var contentWrapper = createBlockNodeContentWrapper({
     nodeView: nodeView,

package/dist/esm/pm-plugins/markViews.js

@@ -0,0 +1,60 @@
+import { DOMSerializer } from '@atlaskit/editor-prosemirror/model';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+
+/**
+ * `@atlaskit/editor-prosemirror/view` doesn't re-export prosemirror-view's `MarkViewConstructor`,
+ * so it's typed locally, as `EditorSSRRenderer` does.
+ */
+
+/** Where to look up a mark's renderer, and the view to render it against. */
+
+/**
+ * Renders a mark as ProseMirror does: `view.nodeViews` also holds mark views, keyed by mark name,
+ * so `breakout` resolves whether it's registered under `markViews` or `nodeViews`. Falls back to
+ * `toDOM` — they can differ: `breakout` renders `.fabric-editor-breakout-mark-dom`, which the width
+ * CSS targets.
+ */
+var renderMarkView = function renderMarkView(mark, inline, _ref) {
+  var nodeViews = _ref.nodeViews,
+    view = _ref.view;
+  try {
+    var markView = nodeViews === null || nodeViews === void 0 ? void 0 : nodeViews[mark.type.name];
+    if (markView && view) {
+      var rendered = markView(mark, view, inline);
+      return {
+        dom: rendered.dom,
+        contentDOM: rendered.contentDOM
+      };
+    }
+    var toDOM = mark.type.spec.toDOM;
+    if (!toDOM) {
+      return null;
+    }
+    return DOMSerializer.renderSpec(document, toDOM(mark, inline));
+  } catch (_unused) {
+    return null;
+  }
+};
+
+/**
+ * Wraps rendered DOM in its marks, as ProseMirror does for the live document. Without this a
+ * block node loses `breakout`, whose wrapper supplies the width. Marks nest
+ * outside-in, so `marks[0]` is outermost.
+ */
+export var wrapInMarkViews = function wrapInMarkViews(targetNode, nodeDom, sources) {
+  if (targetNode.marks.length === 0 || !fg('platform_editor_ai_show_diff_patch_2')) {
+    return nodeDom;
+  }
+  var wrapped = nodeDom;
+  for (var index = targetNode.marks.length - 1; index >= 0; index--) {
+    var _mark = targetNode.marks[index];
+    var rendered = renderMarkView(_mark, targetNode.isInline, sources);
+    // No content hole means nowhere to nest the node, so skip the mark, not the node.
+    if (!(rendered !== null && rendered !== void 0 && rendered.contentDOM)) {
+      continue;
+    }
+    rendered.contentDOM.appendChild(wrapped);
+    wrapped = rendered.dom;
+  }
+  return wrapped;
+};

package/dist/types/pm-plugins/NodeViewSerializer.d.ts

@@ -1,5 +1,5 @@
 import type { NodeViewConstructor } from '@atlaskit/editor-common/lazy-node-view';
-import type { Node as PMNode, Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { Node as PMNode, Fragment, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 /**
  * Utilities for working with ProseMirror node views and DOM serialization within the
@@ -58,8 +58,13 @@ export declare class NodeViewSerializer {
      *
      * Returns `null` when there is no `EditorView`, no constructor for the node type,
      * or the node type is blocklisted. Otherwise returns the constructed node view instance.
+     *
+     * `$sourcePos` is where the node sits in the doc it came from, so nested tables keep their depth.
      */
-    tryCreateNodeView(targetNode: PMNode): Node | null;
+    tryCreateNodeView(targetNode: PMNode, basePos?: number, $sourcePos?: ResolvedPos): Node | null;
+    private tryCreateNodeViewInner;
+    /** Wraps rendered DOM in its marks, rendered against the editor proxy when there is one. */
+    private withMarkViews;
     /**
      * Serializes a node to a DOM `Node` using the schema's `DOMSerializer`.
      */

package/dist/types/pm-plugins/createEditorProxy.d.ts

@@ -0,0 +1,18 @@
+import type { Node as PMNode, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+/**
+ * A preview is rendered by the live view's own node views, which read `getPos()` against
+ * `view.state.doc` for both layout (`isTableNested`) and writes (`scaleTable` builds attribute
+ * steps at `getPos() + 1`). Handing them live positions makes the layout correct but points the
+ * writes at unrelated live nodes, so give them a view whose document *is* the preview instead.
+ *
+ * With `$sourcePos` (the node's position in the doc it came from) the node is swapped into a copy
+ * of its real top-level ancestor, so a table inside an expand still resolves as nested.
+ *
+ * Returns `null` when the node cannot be a top-level child (e.g. a bare `tableCell`), in which
+ * case the caller falls back to the live view and the previous stubbed positions.
+ */
+export declare function createEditorProxy(liveView: EditorView, rootNode: PMNode, $sourcePos?: ResolvedPos): {
+    editorProxy: EditorView;
+    rootPos: number;
+} | null;

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

@@ -68,7 +68,8 @@ export declare const resolveHoistedCodeBlockAnchor: (doc: PMNode, pos: number, d
  * highlights — or, with `anchorAtRangeStart`, at `from` itself. A host inside a code block is
  * hoisted in front of it instead, anchored via `resolveHoistedCodeBlockAnchor` (EDITOR-9045).
  *
- * Returns one decoration normally, two (marker + tag) when hoisted out of a code block.
+ * Returns one decoration when a caller-supplied `anchorName` is used, two (marker + tag)
+ * otherwise — hoisted out of a code block, or anchored to its own point marker.
  *
  * 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`.

package/dist/types/pm-plugins/decorations/utils/excerptIncludeAttrs.d.ts

@@ -0,0 +1,6 @@
+type ExtensionAttrs = Record<string, unknown>;
+export declare const isExcerptInclude: (attrs: ExtensionAttrs) => boolean;
+export declare const getReferencedContentId: (attrs: ExtensionAttrs) => string | undefined;
+/** Compare macro identity and authored options, excluding publish-time rendering metadata. */
+export declare const getComparableExcerptIncludeAttrs: (attrs: ExtensionAttrs) => ExtensionAttrs;
+export {};