@atlaskit/editor-plugin-annotation 29.0.6 → 29.1.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @atlaskit/editor-plugin-annotation
 
+## 29.1.0
+
+### Minor Changes
+
+- [`afd887e901de1`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/afd887e901de1) -
+  Discover annotations in legacy content macros and refresh their state when nested annotations are
+  added while platform_editor_fix_lcm_editor_annotations is enabled. Editor-scoped renderers can
+  load nested LCM annotations independently of the renderer experiment.
+
+  Allow the ProseMirror test editor helper to be checked with unused declaration checks enabled.
+
 ## 29.0.6
 
 ### Patch Changes

package/dist/cjs/pm-plugins/inline-comment.js

@@ -14,6 +14,7 @@ var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
 var _annotation2 = require("@atlaskit/editor-common/utils/annotation");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
+var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _editorCommands = require("../editor-commands");
 var _utils = require("../editor-commands/utils");
 var _nodeviews = require("../nodeviews");
@@ -409,6 +410,12 @@ var inlineCommentPlugin = exports.inlineCommentPlugin = function inlineCommentPl
           if (!(event.target instanceof HTMLElement)) {
             return false;
           }
+          if ((0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_fix_lcm_editor_annotations')) {
+            // The LCM renderer bridge owns selection so its draft-close guard runs first.
+            if (event.target.closest('[data-lcm-annotation-renderer]')) {
+              return false;
+            }
+          }
 
           // Find the nearest ancestor (or self) with the data-id attribute
           var annotationId = (_event$target$closest = event.target.closest('[data-id]')) === null || _event$target$closest === void 0 ? void 0 : _event$target$closest.getAttribute('data-id');

package/dist/cjs/pm-plugins/plugin-factory.js

@@ -5,8 +5,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.shouldClearBookMarkCheck = exports.createPluginState = exports.createCommand = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _pluginStateFactory = require("@atlaskit/editor-common/utils/plugin-state-factory");
+var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _reducer = _interopRequireDefault(require("./reducer"));
@@ -14,12 +16,11 @@ var _utils = require("./utils");
 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) { (0, _defineProperty2.default)(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; }
 /**
- * Creates a handleDocChanged function with its own deleted annotations cache.
- * This ensures each editor instance has its own cache, avoiding cross-contamination.
+ * Creates a document-sync handler with a deleted annotations cache in its closure.
  */
 var createHandleDocChanged = function createHandleDocChanged() {
   // Cache for preserving deleted annotation resolved states through delete/undo cycles
-  // This lives in closure scope per editor instance to avoid serialization and reduce state size
+  // This stays outside plugin state so the undo cache is not serialized.
   var deletedAnnotationsCache = {};
   return function (tr, prevPluginState) {
     if (tr.getMeta('replaceDocument')) {
@@ -28,16 +29,24 @@ var createHandleDocChanged = function createHandleDocChanged() {
       });
     }
     var updatedState = getSelectionChangedHandler(false)(tr, prevPluginState);
+    var legacyContentExperimentEnabled = (0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_fix_lcm_editor_annotations');
+    var currentDiscovery = legacyContentExperimentEnabled ? (0, _utils.getAnnotationDiscovery)(tr.doc) : undefined;
+    var previousAnnotationIds = currentDiscovery ? new Set((0, _utils.getAnnotationDiscovery)(tr.before).annotationIds) : undefined;
+    var newNestedAnnotationIds = currentDiscovery ? currentDiscovery.nestedAnnotationIds.filter(function (id) {
+      return !(previousAnnotationIds !== null && previousAnnotationIds !== void 0 && previousAnnotationIds.has(id)) && prevPluginState.annotations[id] === undefined && deletedAnnotationsCache[id] === undefined;
+    }) : [];
 
     // Collect annotation IDs currently in the document
-    var annotationIdsInDocument = new Set();
-    tr.doc.descendants(function (node) {
-      node.marks.forEach(function (mark) {
-        if (mark.type.name === 'annotation') {
-          annotationIdsInDocument.add(mark.attrs.id);
-        }
+    var annotationIdsInDocument = currentDiscovery ? new Set([].concat((0, _toConsumableArray2.default)(currentDiscovery.rootAnnotationIds), (0, _toConsumableArray2.default)(currentDiscovery.nestedAnnotationIds))) : new Set();
+    if (!currentDiscovery) {
+      tr.doc.descendants(function (node) {
+        node.marks.forEach(function (mark) {
+          if (mark.type.name === 'annotation') {
+            annotationIdsInDocument.add(mark.attrs.id);
+          }
+        });
       });
-    });
+    }
     var annotationIdsInState = Object.keys(prevPluginState.annotations);
 
     // Early return if annotations haven't changed
@@ -45,7 +54,9 @@ var createHandleDocChanged = function createHandleDocChanged() {
       return !annotationIdsInDocument.has(id);
     });
     if (!annotationsHaveChanged) {
-      return updatedState;
+      return newNestedAnnotationIds.length > 0 ? _objectSpread(_objectSpread({}, updatedState), {}, {
+        dirtyAnnotations: true
+      }) : updatedState;
     }
 
     // Cache deleted annotations to be able to restore their resolved states on undo
@@ -68,6 +79,8 @@ var createHandleDocChanged = function createHandleDocChanged() {
     });
     return _objectSpread(_objectSpread({}, updatedState), {}, {
       annotations: updatedAnnotations
+    }, newNestedAnnotationIds.length > 0 && {
+      dirtyAnnotations: true
     });
   };
 };
@@ -195,47 +208,52 @@ var getSelectionChangedHandler = function getSelectionChangedHandler(reopenComme
     getSelectionChangeHandlerOld(reopenCommentView)(tr, pluginState);
   };
 };
+var createAnnotationPluginFactory = function createAnnotationPluginFactory(onDocChanged) {
+  return (0, _pluginStateFactory.pluginFactory)(_utils.inlineCommentPluginKey, _reducer.default, {
+    onSelectionChanged: getSelectionChangedHandler(true),
+    onDocChanged: onDocChanged,
+    mapping: function mapping(tr, pluginState, editorState) {
+      var draftDecorationSet = pluginState.draftDecorationSet,
+        bookmark = pluginState.bookmark;
+      var mappedDecorationSet = _view.DecorationSet.empty,
+        mappedBookmark;
+      var hasMappedDecorations = false;
+      if (draftDecorationSet) {
+        mappedDecorationSet = draftDecorationSet.map(tr.mapping, tr.doc);
+      }
+      hasMappedDecorations = mappedDecorationSet.find(undefined, undefined, function (spec) {
+        return Object.values(_utils.decorationKey).includes(spec.key);
+      }).length > 0;
 
-// Create the handler with cache once at module level
-var handleDocChangedWithSync = createHandleDocChanged();
-var dest = (0, _pluginStateFactory.pluginFactory)(_utils.inlineCommentPluginKey, _reducer.default, {
-  onSelectionChanged: getSelectionChangedHandler(true),
-  onDocChanged: handleDocChangedWithSync,
-  mapping: function mapping(tr, pluginState, editorState) {
-    var draftDecorationSet = pluginState.draftDecorationSet,
-      bookmark = pluginState.bookmark;
-    var mappedDecorationSet = _view.DecorationSet.empty,
-      mappedBookmark;
-    var hasMappedDecorations = false;
-    if (draftDecorationSet) {
-      mappedDecorationSet = draftDecorationSet.map(tr.mapping, tr.doc);
-    }
-    hasMappedDecorations = mappedDecorationSet.find(undefined, undefined, function (spec) {
-      return Object.values(_utils.decorationKey).includes(spec.key);
-    }).length > 0;
+      // When changes to decoration target make decoration invalid (e.g. delete text, add mark to node),
+      // we need to reset bookmark to hide create component and to avoid invalid draft being published
+      // We only perform this change when document selection has changed.
+      if (!hasMappedDecorations && shouldClearBookMarkCheck(tr, editorState, bookmark)) {
+        return _objectSpread(_objectSpread({}, pluginState), {}, {
+          draftDecorationSet: mappedDecorationSet,
+          bookmark: undefined
+        });
+      }
+      if (bookmark) {
+        mappedBookmark = bookmark.map(tr.mapping);
+      }
 
-    // When changes to decoration target make decoration invalid (e.g. delete text, add mark to node),
-    // we need to reset bookmark to hide create component and to avoid invalid draft being published
-    // We only perform this change when document selection has changed.
-    if (!hasMappedDecorations && shouldClearBookMarkCheck(tr, editorState, bookmark)) {
+      // return same pluginState if mappings did not change
+      if (mappedBookmark === bookmark && mappedDecorationSet === draftDecorationSet) {
+        return pluginState;
+      }
       return _objectSpread(_objectSpread({}, pluginState), {}, {
         draftDecorationSet: mappedDecorationSet,
-        bookmark: undefined
+        bookmark: mappedBookmark
       });
     }
-    if (bookmark) {
-      mappedBookmark = bookmark.map(tr.mapping);
-    }
-
-    // return same pluginState if mappings did not change
-    if (mappedBookmark === bookmark && mappedDecorationSet === draftDecorationSet) {
-      return pluginState;
-    }
-    return _objectSpread(_objectSpread({}, pluginState), {}, {
-      draftDecorationSet: mappedDecorationSet,
-      bookmark: mappedBookmark
-    });
-  }
-});
-var createPluginState = exports.createPluginState = dest.createPluginState;
-var createCommand = exports.createCommand = dest.createCommand;
+  });
+};
+var handleDocChangedWithSync = createHandleDocChanged();
+// Keep the control cohort's existing module-level cache lifetime unchanged.
+var legacyDest = createAnnotationPluginFactory(handleDocChangedWithSync);
+var commandFactory = (0, _pluginStateFactory.pluginFactory)(_utils.inlineCommentPluginKey, _reducer.default);
+var createPluginState = exports.createPluginState = function createPluginState(dispatch, initialState) {
+  return ((0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_fix_lcm_editor_annotations') ? createAnnotationPluginFactory(createHandleDocChanged()) : legacyDest).createPluginState(dispatch, initialState);
+};
+var createCommand = exports.createCommand = commandFactory.createCommand;

package/dist/cjs/pm-plugins/utils.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.addDraftDecoration = void 0;
 exports.annotationExists = annotationExists;
-exports.getPluginState = exports.getDraftCommandAnalyticsPayload = exports.getAnnotationViewKey = exports.getAllAnnotations = exports.findAnnotationsInSelection = exports.decorationKey = void 0;
+exports.getPluginState = exports.getDraftCommandAnalyticsPayload = exports.getAnnotationViewKey = exports.getAnnotationDiscovery = exports.getAllAnnotations = exports.findAnnotationsInSelection = exports.decorationKey = void 0;
 exports.getSelectionPositions = getSelectionPositions;
 exports.hasInvalidNodes = exports.hasAnyUnResolvedAnnotationInPage = void 0;
 exports.hasInvalidWhitespaceNode = hasInvalidWhitespaceNode;
@@ -16,12 +16,14 @@ exports.shouldHideRemixAnnotation = exports.resolveDraftBookmark = exports.isSup
 exports.stripNonExistingAnnotations = stripNonExistingAnnotations;
 exports.surroundingMarks = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _annotation = require("@atlaskit/adf-schema/annotation");
 var _enums = require("@atlaskit/editor-common/analytics/types/enums");
 var _mediaSingle = require("@atlaskit/editor-common/media-single");
 var _annotation2 = require("@atlaskit/editor-common/styles/annotation");
 var _annotation3 = require("@atlaskit/editor-common/utils/annotation");
 var _nodes = require("@atlaskit/editor-common/utils/nodes");
+var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
@@ -79,7 +81,111 @@ var reorderAnnotations = function reorderAnnotations(annotations, $from) {
     });
   });
 };
+var legacyContentAnnotationsByDoc = new WeakMap();
+var legacyContentAnnotationIdsByExtension = new WeakMap();
+var readNestedContentNodes = function readNestedContentNodes(parameters) {
+  if (!parameters || (0, _typeof2.default)(parameters) !== 'object') {
+    return undefined;
+  }
+  var nestedContent = parameters.nestedContent;
+  if (!nestedContent || (0, _typeof2.default)(nestedContent) !== 'object') {
+    return undefined;
+  }
+  var nestedDocument = nestedContent;
+  return nestedDocument.type === 'doc' && Array.isArray(nestedDocument.content) ? nestedDocument.content : undefined;
+};
+var getNestedContentAnnotationIds = function getNestedContentAnnotationIds(extension) {
+  var cachedIds = legacyContentAnnotationIdsByExtension.get(extension);
+  if (cachedIds) {
+    return cachedIds;
+  }
+  var nestedNodes = readNestedContentNodes(extension.attrs.parameters);
+  if (!nestedNodes) {
+    var noIds = Object.freeze([]);
+    legacyContentAnnotationIdsByExtension.set(extension, noIds);
+    return noIds;
+  }
+  var annotationIds = new Set();
+  var visitedAdfNodes = new WeakSet();
+  var pending = (0, _toConsumableArray2.default)(nestedNodes).reverse();
+  while (pending.length > 0) {
+    var _adfNode$attrs;
+    var value = pending.pop();
+    if (!value || (0, _typeof2.default)(value) !== 'object' || visitedAdfNodes.has(value)) {
+      continue;
+    }
+    visitedAdfNodes.add(value);
+    var adfNode = value;
+    if (Array.isArray(adfNode.marks)) {
+      adfNode.marks.forEach(function (rawMark) {
+        if (!rawMark || (0, _typeof2.default)(rawMark) !== 'object') {
+          return;
+        }
+        var annotationMark = rawMark;
+        var attrs = annotationMark.attrs;
+        if (annotationMark.type !== 'annotation' || !validateAnnotationAttributes(attrs)) {
+          return;
+        }
+        annotationIds.add(attrs.id);
+      });
+    }
+    if (adfNode.type === 'extension' && ((_adfNode$attrs = adfNode.attrs) === null || _adfNode$attrs === void 0 ? void 0 : _adfNode$attrs.extensionType) === 'com.atlassian.confluence.migration' && adfNode.attrs.extensionKey === 'legacy-content') {
+      var _nestedNodes = readNestedContentNodes(adfNode.attrs.parameters);
+      if (_nestedNodes) {
+        for (var i = _nestedNodes.length - 1; i >= 0; i--) {
+          pending.push(_nestedNodes[i]);
+        }
+      }
+    }
+    if (Array.isArray(adfNode.content)) {
+      for (var _i = adfNode.content.length - 1; _i >= 0; _i--) {
+        pending.push(adfNode.content[_i]);
+      }
+    }
+  }
+  var ids = Object.freeze((0, _toConsumableArray2.default)(annotationIds));
+  legacyContentAnnotationIdsByExtension.set(extension, ids);
+  return ids;
+};
+
+/** Discover annotation IDs from immutable legacy-content ADF without repeatedly scanning it. */
+var getAnnotationDiscovery = exports.getAnnotationDiscovery = function getAnnotationDiscovery(doc) {
+  var cachedDiscovery = legacyContentAnnotationsByDoc.get(doc);
+  if (cachedDiscovery) {
+    return cachedDiscovery;
+  }
+  var allAnnotationIds = new Set();
+  var rootAnnotationIds = new Set();
+  var nestedAnnotationIds = new Set();
+  doc.descendants(function (node) {
+    node.marks.filter(function (mark) {
+      return mark.type.name === 'annotation';
+    }).forEach(function (mark) {
+      if (validateAnnotationMark(mark)) {
+        rootAnnotationIds.add(mark.attrs.id);
+        allAnnotationIds.add(mark.attrs.id);
+      }
+    });
+    if (node.type.name === 'extension' && node.attrs.extensionType === 'com.atlassian.confluence.migration' && node.attrs.extensionKey === 'legacy-content') {
+      getNestedContentAnnotationIds(node).forEach(function (id) {
+        nestedAnnotationIds.add(id);
+        allAnnotationIds.add(id);
+      });
+    }
+    return true;
+  });
+  var discovery = {
+    annotationIds: Object.freeze((0, _toConsumableArray2.default)(allAnnotationIds)),
+    rootAnnotationIds: Object.freeze((0, _toConsumableArray2.default)(rootAnnotationIds)),
+    nestedAnnotationIds: Object.freeze((0, _toConsumableArray2.default)(nestedAnnotationIds))
+  };
+  legacyContentAnnotationsByDoc.set(doc, discovery);
+  return discovery;
+};
 var getAllAnnotations = exports.getAllAnnotations = function getAllAnnotations(doc) {
+  if ((0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_fix_lcm_editor_annotations')) {
+    return (0, _toConsumableArray2.default)(getAnnotationDiscovery(doc).annotationIds);
+  }
   var allAnnotationIds = new Set();
   doc.descendants(function (node) {
     node.marks.filter(function (mark) {
@@ -93,29 +199,30 @@ var getAllAnnotations = exports.getAllAnnotations = function getAllAnnotations(d
   });
   return Array.from(allAnnotationIds);
 };
-
-/*
- * verifies if annotation mark contains valid attributes
- */
-var validateAnnotationMark = function validateAnnotationMark(annotationMark) {
-  var _ref = annotationMark.attrs,
-    id = _ref.id,
-    annotationType = _ref.annotationType;
-  return validateAnnotationId(id) && validateAnnotationType(annotationType);
-  function validateAnnotationId(id) {
-    if (!id || typeof id !== 'string') {
-      return false;
-    }
-    var invalidIds = ['null', 'undefined'];
-    return !invalidIds.includes(id.toLowerCase());
+var validateAnnotationId = function validateAnnotationId(id) {
+  if (!id || typeof id !== 'string') {
+    return false;
   }
-  function validateAnnotationType(type) {
-    if (!type || typeof type !== 'string') {
-      return false;
-    }
-    var allowedTypes = Object.values(_annotation.AnnotationTypes);
-    return allowedTypes.includes(type);
+  var invalidIds = ['null', 'undefined'];
+  return !invalidIds.includes(id.toLowerCase());
+};
+var validateAnnotationType = function validateAnnotationType(type) {
+  if (!type || typeof type !== 'string') {
+    return false;
   }
+  var allowedTypes = Object.values(_annotation.AnnotationTypes);
+  return allowedTypes.some(function (allowedType) {
+    return allowedType === type;
+  });
+};
+var validateAnnotationAttributes = function validateAnnotationAttributes(attrs) {
+  if (!attrs || (0, _typeof2.default)(attrs) !== 'object') {
+    return false;
+  }
+  return 'id' in attrs && 'annotationType' in attrs && validateAnnotationId(attrs.id) && validateAnnotationType(attrs.annotationType);
+};
+var validateAnnotationMark = function validateAnnotationMark(annotationMark) {
+  return validateAnnotationAttributes(annotationMark.attrs);
 };
 var decorationKey = exports.decorationKey = {
   block: 'blockCommentDecoration',
@@ -306,8 +413,8 @@ var getDraftCommandAnalyticsPayload = exports.getDraftCommandAnalyticsPayload =
       };
     }
     if ((0, _fg.fg)('editor_inline_comments_on_inline_nodes')) {
-      var _ref2 = getPluginState(state) || {},
-        bookmark = _ref2.bookmark;
+      var _ref = getPluginState(state) || {},
+        bookmark = _ref.bookmark;
       attributes.inlineNodeNames = (0, _annotation3.getRangeInlineNodeNames)({
         doc: state.doc,
         pos: resolveDraftBookmark(state, bookmark)
@@ -328,8 +435,8 @@ var isSelectionValid = exports.isSelectionValid = function isSelectionValid(stat
   var supportedBlockNodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   var isBlockNodeSupported = arguments.length > 2 ? arguments[2] : undefined;
   var selection = state.selection;
-  var _ref3 = getPluginState(state) || {},
-    disallowOnWhitespace = _ref3.disallowOnWhitespace;
+  var _ref2 = getPluginState(state) || {},
+    disallowOnWhitespace = _ref2.disallowOnWhitespace;
   var allowedInlineNodes = ['emoji', 'status', 'date', 'mention', 'inlineCard'];
   var isSelectionEmpty = selection.empty;
   var isTextOrAllSelection = selection instanceof _state.TextSelection || selection instanceof _state.AllSelection;

package/dist/es2019/pm-plugins/inline-comment.js

@@ -4,6 +4,7 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { getAnnotationInlineNodeTypes } from '@atlaskit/editor-common/utils/annotation';
 import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { clearDirtyMark, closeComponent, setHoveredAnnotation, setInlineCommentsVisibility, setSelectedAnnotation, flushPendingSelections, updateInlineCommentResolvedState, updateMouseState, setPendingSelectedAnnotation, setInlineCommentDraftState, setInlineCommentsFetched } from '../editor-commands';
 import { resetUserIntent, setUserIntent } from '../editor-commands/utils';
 import { getAnnotationViewClassname, getBlockAnnotationViewClassname } from '../nodeviews';
@@ -353,6 +354,12 @@ export const inlineCommentPlugin = options => {
           if (!(event.target instanceof HTMLElement)) {
             return false;
           }
+          if (isExperimentEnabled('platform_editor_fix_lcm_editor_annotations')) {
+            // The LCM renderer bridge owns selection so its draft-close guard runs first.
+            if (event.target.closest('[data-lcm-annotation-renderer]')) {
+              return false;
+            }
+          }
 
           // Find the nearest ancestor (or self) with the data-id attribute
           const annotationId = (_event$target$closest = event.target.closest('[data-id]')) === null || _event$target$closest === void 0 ? void 0 : _event$target$closest.getAttribute('data-id');

package/dist/es2019/pm-plugins/plugin-factory.js

@@ -1,16 +1,16 @@
 import { pluginFactory } from '@atlaskit/editor-common/utils/plugin-state-factory';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import reducer from './reducer';
-import { decorationKey, findAnnotationsInSelection, inlineCommentPluginKey, isBlockNodeAnnotationsSelected, isSelectedAnnotationsChanged } from './utils';
+import { decorationKey, getAnnotationDiscovery, findAnnotationsInSelection, inlineCommentPluginKey, isBlockNodeAnnotationsSelected, isSelectedAnnotationsChanged } from './utils';
 
 /**
- * Creates a handleDocChanged function with its own deleted annotations cache.
- * This ensures each editor instance has its own cache, avoiding cross-contamination.
+ * Creates a document-sync handler with a deleted annotations cache in its closure.
  */
 const createHandleDocChanged = () => {
   // Cache for preserving deleted annotation resolved states through delete/undo cycles
-  // This lives in closure scope per editor instance to avoid serialization and reduce state size
+  // This stays outside plugin state so the undo cache is not serialized.
   const deletedAnnotationsCache = {};
   return (tr, prevPluginState) => {
     if (tr.getMeta('replaceDocument')) {
@@ -20,22 +20,31 @@ const createHandleDocChanged = () => {
       };
     }
     const updatedState = getSelectionChangedHandler(false)(tr, prevPluginState);
+    const legacyContentExperimentEnabled = isExperimentEnabled('platform_editor_fix_lcm_editor_annotations');
+    const currentDiscovery = legacyContentExperimentEnabled ? getAnnotationDiscovery(tr.doc) : undefined;
+    const previousAnnotationIds = currentDiscovery ? new Set(getAnnotationDiscovery(tr.before).annotationIds) : undefined;
+    const newNestedAnnotationIds = currentDiscovery ? currentDiscovery.nestedAnnotationIds.filter(id => !(previousAnnotationIds !== null && previousAnnotationIds !== void 0 && previousAnnotationIds.has(id)) && prevPluginState.annotations[id] === undefined && deletedAnnotationsCache[id] === undefined) : [];
 
     // Collect annotation IDs currently in the document
-    const annotationIdsInDocument = new Set();
-    tr.doc.descendants(node => {
-      node.marks.forEach(mark => {
-        if (mark.type.name === 'annotation') {
-          annotationIdsInDocument.add(mark.attrs.id);
-        }
+    const annotationIdsInDocument = currentDiscovery ? new Set([...currentDiscovery.rootAnnotationIds, ...currentDiscovery.nestedAnnotationIds]) : new Set();
+    if (!currentDiscovery) {
+      tr.doc.descendants(node => {
+        node.marks.forEach(mark => {
+          if (mark.type.name === 'annotation') {
+            annotationIdsInDocument.add(mark.attrs.id);
+          }
+        });
       });
-    });
+    }
     const annotationIdsInState = Object.keys(prevPluginState.annotations);
 
     // Early return if annotations haven't changed
     const annotationsHaveChanged = annotationIdsInDocument.size !== annotationIdsInState.length || annotationIdsInState.some(id => !annotationIdsInDocument.has(id));
     if (!annotationsHaveChanged) {
-      return updatedState;
+      return newNestedAnnotationIds.length > 0 ? {
+        ...updatedState,
+        dirtyAnnotations: true
+      } : updatedState;
     }
 
     // Cache deleted annotations to be able to restore their resolved states on undo
@@ -58,7 +67,10 @@ const createHandleDocChanged = () => {
     });
     return {
       ...updatedState,
-      annotations: updatedAnnotations
+      annotations: updatedAnnotations,
+      ...(newNestedAnnotationIds.length > 0 && {
+        dirtyAnnotations: true
+      })
     };
   };
 };
@@ -194,12 +206,9 @@ const getSelectionChangedHandler = reopenCommentView => (tr, pluginState) => plu
 getSelectionChangeHandlerNew(reopenCommentView)(tr, pluginState) :
 // else if platform_editor_comments_api_manager == false
 getSelectionChangeHandlerOld(reopenCommentView)(tr, pluginState);
-
-// Create the handler with cache once at module level
-const handleDocChangedWithSync = createHandleDocChanged();
-const dest = pluginFactory(inlineCommentPluginKey, reducer, {
+const createAnnotationPluginFactory = onDocChanged => pluginFactory(inlineCommentPluginKey, reducer, {
   onSelectionChanged: getSelectionChangedHandler(true),
-  onDocChanged: handleDocChangedWithSync,
+  onDocChanged,
   mapping: (tr, pluginState, editorState) => {
     const {
       draftDecorationSet,
@@ -238,5 +247,9 @@ const dest = pluginFactory(inlineCommentPluginKey, reducer, {
     };
   }
 });
-export const createPluginState = dest.createPluginState;
-export const createCommand = dest.createCommand;
+const handleDocChangedWithSync = createHandleDocChanged();
+// Keep the control cohort's existing module-level cache lifetime unchanged.
+const legacyDest = createAnnotationPluginFactory(handleDocChangedWithSync);
+const commandFactory = pluginFactory(inlineCommentPluginKey, reducer);
+export const createPluginState = (dispatch, initialState) => (isExperimentEnabled('platform_editor_fix_lcm_editor_annotations') ? createAnnotationPluginFactory(createHandleDocChanged()) : legacyDest).createPluginState(dispatch, initialState);
+export const createCommand = commandFactory.createCommand;

package/dist/es2019/pm-plugins/utils.js

@@ -4,6 +4,7 @@ import { currentMediaNodeWithPos } from '@atlaskit/editor-common/media-single';
 import { AnnotationSharedClassNames, BlockAnnotationSharedClassNames } from '@atlaskit/editor-common/styles/annotation';
 import { canApplyAnnotationOnRange, getAnnotationIdsFromRange, getRangeInlineNodeNames, hasAnnotationMark, isEmptyTextSelection } from '@atlaskit/editor-common/utils/annotation';
 import { isParagraph, isText } from '@atlaskit/editor-common/utils/nodes';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { AllSelection, NodeSelection, PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
@@ -53,7 +54,109 @@ const reorderAnnotations = (annotations, $from) => {
   const idSet = surroundingMarks($from).map(filterAnnotationIds);
   annotations.sort((a, b) => sum(idSet, ids => ids.indexOf(a.id)) - sum(idSet, ids => ids.indexOf(b.id)));
 };
+const legacyContentAnnotationsByDoc = new WeakMap();
+const legacyContentAnnotationIdsByExtension = new WeakMap();
+const readNestedContentNodes = parameters => {
+  if (!parameters || typeof parameters !== 'object') {
+    return undefined;
+  }
+  const nestedContent = parameters.nestedContent;
+  if (!nestedContent || typeof nestedContent !== 'object') {
+    return undefined;
+  }
+  const nestedDocument = nestedContent;
+  return nestedDocument.type === 'doc' && Array.isArray(nestedDocument.content) ? nestedDocument.content : undefined;
+};
+const getNestedContentAnnotationIds = extension => {
+  const cachedIds = legacyContentAnnotationIdsByExtension.get(extension);
+  if (cachedIds) {
+    return cachedIds;
+  }
+  const nestedNodes = readNestedContentNodes(extension.attrs.parameters);
+  if (!nestedNodes) {
+    const noIds = Object.freeze([]);
+    legacyContentAnnotationIdsByExtension.set(extension, noIds);
+    return noIds;
+  }
+  const annotationIds = new Set();
+  const visitedAdfNodes = new WeakSet();
+  const pending = [...nestedNodes].reverse();
+  while (pending.length > 0) {
+    var _adfNode$attrs;
+    const value = pending.pop();
+    if (!value || typeof value !== 'object' || visitedAdfNodes.has(value)) {
+      continue;
+    }
+    visitedAdfNodes.add(value);
+    const adfNode = value;
+    if (Array.isArray(adfNode.marks)) {
+      adfNode.marks.forEach(rawMark => {
+        if (!rawMark || typeof rawMark !== 'object') {
+          return;
+        }
+        const annotationMark = rawMark;
+        const attrs = annotationMark.attrs;
+        if (annotationMark.type !== 'annotation' || !validateAnnotationAttributes(attrs)) {
+          return;
+        }
+        annotationIds.add(attrs.id);
+      });
+    }
+    if (adfNode.type === 'extension' && ((_adfNode$attrs = adfNode.attrs) === null || _adfNode$attrs === void 0 ? void 0 : _adfNode$attrs.extensionType) === 'com.atlassian.confluence.migration' && adfNode.attrs.extensionKey === 'legacy-content') {
+      const nestedNodes = readNestedContentNodes(adfNode.attrs.parameters);
+      if (nestedNodes) {
+        for (let i = nestedNodes.length - 1; i >= 0; i--) {
+          pending.push(nestedNodes[i]);
+        }
+      }
+    }
+    if (Array.isArray(adfNode.content)) {
+      for (let i = adfNode.content.length - 1; i >= 0; i--) {
+        pending.push(adfNode.content[i]);
+      }
+    }
+  }
+  const ids = Object.freeze([...annotationIds]);
+  legacyContentAnnotationIdsByExtension.set(extension, ids);
+  return ids;
+};
+
+/** Discover annotation IDs from immutable legacy-content ADF without repeatedly scanning it. */
+export const getAnnotationDiscovery = doc => {
+  const cachedDiscovery = legacyContentAnnotationsByDoc.get(doc);
+  if (cachedDiscovery) {
+    return cachedDiscovery;
+  }
+  const allAnnotationIds = new Set();
+  const rootAnnotationIds = new Set();
+  const nestedAnnotationIds = new Set();
+  doc.descendants(node => {
+    node.marks.filter(mark => mark.type.name === 'annotation').forEach(mark => {
+      if (validateAnnotationMark(mark)) {
+        rootAnnotationIds.add(mark.attrs.id);
+        allAnnotationIds.add(mark.attrs.id);
+      }
+    });
+    if (node.type.name === 'extension' && node.attrs.extensionType === 'com.atlassian.confluence.migration' && node.attrs.extensionKey === 'legacy-content') {
+      getNestedContentAnnotationIds(node).forEach(id => {
+        nestedAnnotationIds.add(id);
+        allAnnotationIds.add(id);
+      });
+    }
+    return true;
+  });
+  const discovery = {
+    annotationIds: Object.freeze([...allAnnotationIds]),
+    rootAnnotationIds: Object.freeze([...rootAnnotationIds]),
+    nestedAnnotationIds: Object.freeze([...nestedAnnotationIds])
+  };
+  legacyContentAnnotationsByDoc.set(doc, discovery);
+  return discovery;
+};
 export const getAllAnnotations = doc => {
+  if (isExperimentEnabled('platform_editor_fix_lcm_editor_annotations')) {
+    return [...getAnnotationDiscovery(doc).annotationIds];
+  }
   const allAnnotationIds = new Set();
   doc.descendants(node => {
     node.marks.filter(mark => mark.type.name === 'annotation')
@@ -63,31 +166,27 @@ export const getAllAnnotations = doc => {
   });
   return Array.from(allAnnotationIds);
 };
-
-/*
- * verifies if annotation mark contains valid attributes
- */
-const validateAnnotationMark = annotationMark => {
-  const {
-    id,
-    annotationType
-  } = annotationMark.attrs;
-  return validateAnnotationId(id) && validateAnnotationType(annotationType);
-  function validateAnnotationId(id) {
-    if (!id || typeof id !== 'string') {
-      return false;
-    }
-    const invalidIds = ['null', 'undefined'];
-    return !invalidIds.includes(id.toLowerCase());
+const validateAnnotationId = id => {
+  if (!id || typeof id !== 'string') {
+    return false;
   }
-  function validateAnnotationType(type) {
-    if (!type || typeof type !== 'string') {
-      return false;
-    }
-    const allowedTypes = Object.values(AnnotationTypes);
-    return allowedTypes.includes(type);
+  const invalidIds = ['null', 'undefined'];
+  return !invalidIds.includes(id.toLowerCase());
+};
+const validateAnnotationType = type => {
+  if (!type || typeof type !== 'string') {
+    return false;
+  }
+  const allowedTypes = Object.values(AnnotationTypes);
+  return allowedTypes.some(allowedType => allowedType === type);
+};
+const validateAnnotationAttributes = attrs => {
+  if (!attrs || typeof attrs !== 'object') {
+    return false;
   }
+  return 'id' in attrs && 'annotationType' in attrs && validateAnnotationId(attrs.id) && validateAnnotationType(attrs.annotationType);
 };
+const validateAnnotationMark = annotationMark => validateAnnotationAttributes(annotationMark.attrs);
 export const decorationKey = {
   block: 'blockCommentDecoration',
   inline: 'inlineCommentDecoration'

package/dist/esm/pm-plugins/inline-comment.js

@@ -7,6 +7,7 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { getAnnotationInlineNodeTypes } from '@atlaskit/editor-common/utils/annotation';
 import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { clearDirtyMark, closeComponent, setHoveredAnnotation, setInlineCommentsVisibility, setSelectedAnnotation, flushPendingSelections, updateInlineCommentResolvedState, updateMouseState, setPendingSelectedAnnotation, setInlineCommentDraftState, setInlineCommentsFetched } from '../editor-commands';
 import { resetUserIntent, setUserIntent } from '../editor-commands/utils';
 import { getAnnotationViewClassname, getBlockAnnotationViewClassname } from '../nodeviews';
@@ -402,6 +403,12 @@ export var inlineCommentPlugin = function inlineCommentPlugin(options) {
           if (!(event.target instanceof HTMLElement)) {
             return false;
           }
+          if (isExperimentEnabled('platform_editor_fix_lcm_editor_annotations')) {
+            // The LCM renderer bridge owns selection so its draft-close guard runs first.
+            if (event.target.closest('[data-lcm-annotation-renderer]')) {
+              return false;
+            }
+          }
 
           // Find the nearest ancestor (or self) with the data-id attribute
           var annotationId = (_event$target$closest = event.target.closest('[data-id]')) === null || _event$target$closest === void 0 ? void 0 : _event$target$closest.getAttribute('data-id');

package/dist/esm/pm-plugins/plugin-factory.js

@@ -1,19 +1,20 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 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 { pluginFactory } from '@atlaskit/editor-common/utils/plugin-state-factory';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import reducer from './reducer';
-import { decorationKey, findAnnotationsInSelection, inlineCommentPluginKey, isBlockNodeAnnotationsSelected, isSelectedAnnotationsChanged } from './utils';
+import { decorationKey, getAnnotationDiscovery, findAnnotationsInSelection, inlineCommentPluginKey, isBlockNodeAnnotationsSelected, isSelectedAnnotationsChanged } from './utils';
 
 /**
- * Creates a handleDocChanged function with its own deleted annotations cache.
- * This ensures each editor instance has its own cache, avoiding cross-contamination.
+ * Creates a document-sync handler with a deleted annotations cache in its closure.
  */
 var createHandleDocChanged = function createHandleDocChanged() {
   // Cache for preserving deleted annotation resolved states through delete/undo cycles
-  // This lives in closure scope per editor instance to avoid serialization and reduce state size
+  // This stays outside plugin state so the undo cache is not serialized.
   var deletedAnnotationsCache = {};
   return function (tr, prevPluginState) {
     if (tr.getMeta('replaceDocument')) {
@@ -22,16 +23,24 @@ var createHandleDocChanged = function createHandleDocChanged() {
       });
     }
     var updatedState = getSelectionChangedHandler(false)(tr, prevPluginState);
+    var legacyContentExperimentEnabled = isExperimentEnabled('platform_editor_fix_lcm_editor_annotations');
+    var currentDiscovery = legacyContentExperimentEnabled ? getAnnotationDiscovery(tr.doc) : undefined;
+    var previousAnnotationIds = currentDiscovery ? new Set(getAnnotationDiscovery(tr.before).annotationIds) : undefined;
+    var newNestedAnnotationIds = currentDiscovery ? currentDiscovery.nestedAnnotationIds.filter(function (id) {
+      return !(previousAnnotationIds !== null && previousAnnotationIds !== void 0 && previousAnnotationIds.has(id)) && prevPluginState.annotations[id] === undefined && deletedAnnotationsCache[id] === undefined;
+    }) : [];
 
     // Collect annotation IDs currently in the document
-    var annotationIdsInDocument = new Set();
-    tr.doc.descendants(function (node) {
-      node.marks.forEach(function (mark) {
-        if (mark.type.name === 'annotation') {
-          annotationIdsInDocument.add(mark.attrs.id);
-        }
+    var annotationIdsInDocument = currentDiscovery ? new Set([].concat(_toConsumableArray(currentDiscovery.rootAnnotationIds), _toConsumableArray(currentDiscovery.nestedAnnotationIds))) : new Set();
+    if (!currentDiscovery) {
+      tr.doc.descendants(function (node) {
+        node.marks.forEach(function (mark) {
+          if (mark.type.name === 'annotation') {
+            annotationIdsInDocument.add(mark.attrs.id);
+          }
+        });
       });
-    });
+    }
     var annotationIdsInState = Object.keys(prevPluginState.annotations);
 
     // Early return if annotations haven't changed
@@ -39,7 +48,9 @@ var createHandleDocChanged = function createHandleDocChanged() {
       return !annotationIdsInDocument.has(id);
     });
     if (!annotationsHaveChanged) {
-      return updatedState;
+      return newNestedAnnotationIds.length > 0 ? _objectSpread(_objectSpread({}, updatedState), {}, {
+        dirtyAnnotations: true
+      }) : updatedState;
     }
 
     // Cache deleted annotations to be able to restore their resolved states on undo
@@ -62,6 +73,8 @@ var createHandleDocChanged = function createHandleDocChanged() {
     });
     return _objectSpread(_objectSpread({}, updatedState), {}, {
       annotations: updatedAnnotations
+    }, newNestedAnnotationIds.length > 0 && {
+      dirtyAnnotations: true
     });
   };
 };
@@ -189,47 +202,52 @@ var getSelectionChangedHandler = function getSelectionChangedHandler(reopenComme
     getSelectionChangeHandlerOld(reopenCommentView)(tr, pluginState);
   };
 };
+var createAnnotationPluginFactory = function createAnnotationPluginFactory(onDocChanged) {
+  return pluginFactory(inlineCommentPluginKey, reducer, {
+    onSelectionChanged: getSelectionChangedHandler(true),
+    onDocChanged: onDocChanged,
+    mapping: function mapping(tr, pluginState, editorState) {
+      var draftDecorationSet = pluginState.draftDecorationSet,
+        bookmark = pluginState.bookmark;
+      var mappedDecorationSet = DecorationSet.empty,
+        mappedBookmark;
+      var hasMappedDecorations = false;
+      if (draftDecorationSet) {
+        mappedDecorationSet = draftDecorationSet.map(tr.mapping, tr.doc);
+      }
+      hasMappedDecorations = mappedDecorationSet.find(undefined, undefined, function (spec) {
+        return Object.values(decorationKey).includes(spec.key);
+      }).length > 0;
 
-// Create the handler with cache once at module level
-var handleDocChangedWithSync = createHandleDocChanged();
-var dest = pluginFactory(inlineCommentPluginKey, reducer, {
-  onSelectionChanged: getSelectionChangedHandler(true),
-  onDocChanged: handleDocChangedWithSync,
-  mapping: function mapping(tr, pluginState, editorState) {
-    var draftDecorationSet = pluginState.draftDecorationSet,
-      bookmark = pluginState.bookmark;
-    var mappedDecorationSet = DecorationSet.empty,
-      mappedBookmark;
-    var hasMappedDecorations = false;
-    if (draftDecorationSet) {
-      mappedDecorationSet = draftDecorationSet.map(tr.mapping, tr.doc);
-    }
-    hasMappedDecorations = mappedDecorationSet.find(undefined, undefined, function (spec) {
-      return Object.values(decorationKey).includes(spec.key);
-    }).length > 0;
+      // When changes to decoration target make decoration invalid (e.g. delete text, add mark to node),
+      // we need to reset bookmark to hide create component and to avoid invalid draft being published
+      // We only perform this change when document selection has changed.
+      if (!hasMappedDecorations && shouldClearBookMarkCheck(tr, editorState, bookmark)) {
+        return _objectSpread(_objectSpread({}, pluginState), {}, {
+          draftDecorationSet: mappedDecorationSet,
+          bookmark: undefined
+        });
+      }
+      if (bookmark) {
+        mappedBookmark = bookmark.map(tr.mapping);
+      }
 
-    // When changes to decoration target make decoration invalid (e.g. delete text, add mark to node),
-    // we need to reset bookmark to hide create component and to avoid invalid draft being published
-    // We only perform this change when document selection has changed.
-    if (!hasMappedDecorations && shouldClearBookMarkCheck(tr, editorState, bookmark)) {
+      // return same pluginState if mappings did not change
+      if (mappedBookmark === bookmark && mappedDecorationSet === draftDecorationSet) {
+        return pluginState;
+      }
       return _objectSpread(_objectSpread({}, pluginState), {}, {
         draftDecorationSet: mappedDecorationSet,
-        bookmark: undefined
+        bookmark: mappedBookmark
       });
     }
-    if (bookmark) {
-      mappedBookmark = bookmark.map(tr.mapping);
-    }
-
-    // return same pluginState if mappings did not change
-    if (mappedBookmark === bookmark && mappedDecorationSet === draftDecorationSet) {
-      return pluginState;
-    }
-    return _objectSpread(_objectSpread({}, pluginState), {}, {
-      draftDecorationSet: mappedDecorationSet,
-      bookmark: mappedBookmark
-    });
-  }
-});
-export var createPluginState = dest.createPluginState;
-export var createCommand = dest.createCommand;
+  });
+};
+var handleDocChangedWithSync = createHandleDocChanged();
+// Keep the control cohort's existing module-level cache lifetime unchanged.
+var legacyDest = createAnnotationPluginFactory(handleDocChangedWithSync);
+var commandFactory = pluginFactory(inlineCommentPluginKey, reducer);
+export var createPluginState = function createPluginState(dispatch, initialState) {
+  return (isExperimentEnabled('platform_editor_fix_lcm_editor_annotations') ? createAnnotationPluginFactory(createHandleDocChanged()) : legacyDest).createPluginState(dispatch, initialState);
+};
+export var createCommand = commandFactory.createCommand;

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

@@ -1,10 +1,12 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/typeof";
 import { AnnotationTypes } from '@atlaskit/adf-schema/annotation';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics/types/enums';
 import { currentMediaNodeWithPos } from '@atlaskit/editor-common/media-single';
 import { AnnotationSharedClassNames, BlockAnnotationSharedClassNames } from '@atlaskit/editor-common/styles/annotation';
 import { canApplyAnnotationOnRange, getAnnotationIdsFromRange, getRangeInlineNodeNames, hasAnnotationMark, isEmptyTextSelection } from '@atlaskit/editor-common/utils/annotation';
 import { isParagraph, isText } from '@atlaskit/editor-common/utils/nodes';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { AllSelection, NodeSelection, PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
@@ -62,7 +64,111 @@ var reorderAnnotations = function reorderAnnotations(annotations, $from) {
     });
   });
 };
+var legacyContentAnnotationsByDoc = new WeakMap();
+var legacyContentAnnotationIdsByExtension = new WeakMap();
+var readNestedContentNodes = function readNestedContentNodes(parameters) {
+  if (!parameters || _typeof(parameters) !== 'object') {
+    return undefined;
+  }
+  var nestedContent = parameters.nestedContent;
+  if (!nestedContent || _typeof(nestedContent) !== 'object') {
+    return undefined;
+  }
+  var nestedDocument = nestedContent;
+  return nestedDocument.type === 'doc' && Array.isArray(nestedDocument.content) ? nestedDocument.content : undefined;
+};
+var getNestedContentAnnotationIds = function getNestedContentAnnotationIds(extension) {
+  var cachedIds = legacyContentAnnotationIdsByExtension.get(extension);
+  if (cachedIds) {
+    return cachedIds;
+  }
+  var nestedNodes = readNestedContentNodes(extension.attrs.parameters);
+  if (!nestedNodes) {
+    var noIds = Object.freeze([]);
+    legacyContentAnnotationIdsByExtension.set(extension, noIds);
+    return noIds;
+  }
+  var annotationIds = new Set();
+  var visitedAdfNodes = new WeakSet();
+  var pending = _toConsumableArray(nestedNodes).reverse();
+  while (pending.length > 0) {
+    var _adfNode$attrs;
+    var value = pending.pop();
+    if (!value || _typeof(value) !== 'object' || visitedAdfNodes.has(value)) {
+      continue;
+    }
+    visitedAdfNodes.add(value);
+    var adfNode = value;
+    if (Array.isArray(adfNode.marks)) {
+      adfNode.marks.forEach(function (rawMark) {
+        if (!rawMark || _typeof(rawMark) !== 'object') {
+          return;
+        }
+        var annotationMark = rawMark;
+        var attrs = annotationMark.attrs;
+        if (annotationMark.type !== 'annotation' || !validateAnnotationAttributes(attrs)) {
+          return;
+        }
+        annotationIds.add(attrs.id);
+      });
+    }
+    if (adfNode.type === 'extension' && ((_adfNode$attrs = adfNode.attrs) === null || _adfNode$attrs === void 0 ? void 0 : _adfNode$attrs.extensionType) === 'com.atlassian.confluence.migration' && adfNode.attrs.extensionKey === 'legacy-content') {
+      var _nestedNodes = readNestedContentNodes(adfNode.attrs.parameters);
+      if (_nestedNodes) {
+        for (var i = _nestedNodes.length - 1; i >= 0; i--) {
+          pending.push(_nestedNodes[i]);
+        }
+      }
+    }
+    if (Array.isArray(adfNode.content)) {
+      for (var _i = adfNode.content.length - 1; _i >= 0; _i--) {
+        pending.push(adfNode.content[_i]);
+      }
+    }
+  }
+  var ids = Object.freeze(_toConsumableArray(annotationIds));
+  legacyContentAnnotationIdsByExtension.set(extension, ids);
+  return ids;
+};
+
+/** Discover annotation IDs from immutable legacy-content ADF without repeatedly scanning it. */
+export var getAnnotationDiscovery = function getAnnotationDiscovery(doc) {
+  var cachedDiscovery = legacyContentAnnotationsByDoc.get(doc);
+  if (cachedDiscovery) {
+    return cachedDiscovery;
+  }
+  var allAnnotationIds = new Set();
+  var rootAnnotationIds = new Set();
+  var nestedAnnotationIds = new Set();
+  doc.descendants(function (node) {
+    node.marks.filter(function (mark) {
+      return mark.type.name === 'annotation';
+    }).forEach(function (mark) {
+      if (validateAnnotationMark(mark)) {
+        rootAnnotationIds.add(mark.attrs.id);
+        allAnnotationIds.add(mark.attrs.id);
+      }
+    });
+    if (node.type.name === 'extension' && node.attrs.extensionType === 'com.atlassian.confluence.migration' && node.attrs.extensionKey === 'legacy-content') {
+      getNestedContentAnnotationIds(node).forEach(function (id) {
+        nestedAnnotationIds.add(id);
+        allAnnotationIds.add(id);
+      });
+    }
+    return true;
+  });
+  var discovery = {
+    annotationIds: Object.freeze(_toConsumableArray(allAnnotationIds)),
+    rootAnnotationIds: Object.freeze(_toConsumableArray(rootAnnotationIds)),
+    nestedAnnotationIds: Object.freeze(_toConsumableArray(nestedAnnotationIds))
+  };
+  legacyContentAnnotationsByDoc.set(doc, discovery);
+  return discovery;
+};
 export var getAllAnnotations = function getAllAnnotations(doc) {
+  if (isExperimentEnabled('platform_editor_fix_lcm_editor_annotations')) {
+    return _toConsumableArray(getAnnotationDiscovery(doc).annotationIds);
+  }
   var allAnnotationIds = new Set();
   doc.descendants(function (node) {
     node.marks.filter(function (mark) {
@@ -76,29 +182,30 @@ export var getAllAnnotations = function getAllAnnotations(doc) {
   });
   return Array.from(allAnnotationIds);
 };
-
-/*
- * verifies if annotation mark contains valid attributes
- */
-var validateAnnotationMark = function validateAnnotationMark(annotationMark) {
-  var _ref = annotationMark.attrs,
-    id = _ref.id,
-    annotationType = _ref.annotationType;
-  return validateAnnotationId(id) && validateAnnotationType(annotationType);
-  function validateAnnotationId(id) {
-    if (!id || typeof id !== 'string') {
-      return false;
-    }
-    var invalidIds = ['null', 'undefined'];
-    return !invalidIds.includes(id.toLowerCase());
+var validateAnnotationId = function validateAnnotationId(id) {
+  if (!id || typeof id !== 'string') {
+    return false;
   }
-  function validateAnnotationType(type) {
-    if (!type || typeof type !== 'string') {
-      return false;
-    }
-    var allowedTypes = Object.values(AnnotationTypes);
-    return allowedTypes.includes(type);
+  var invalidIds = ['null', 'undefined'];
+  return !invalidIds.includes(id.toLowerCase());
+};
+var validateAnnotationType = function validateAnnotationType(type) {
+  if (!type || typeof type !== 'string') {
+    return false;
   }
+  var allowedTypes = Object.values(AnnotationTypes);
+  return allowedTypes.some(function (allowedType) {
+    return allowedType === type;
+  });
+};
+var validateAnnotationAttributes = function validateAnnotationAttributes(attrs) {
+  if (!attrs || _typeof(attrs) !== 'object') {
+    return false;
+  }
+  return 'id' in attrs && 'annotationType' in attrs && validateAnnotationId(attrs.id) && validateAnnotationType(attrs.annotationType);
+};
+var validateAnnotationMark = function validateAnnotationMark(annotationMark) {
+  return validateAnnotationAttributes(annotationMark.attrs);
 };
 export var decorationKey = {
   block: 'blockCommentDecoration',
@@ -289,8 +396,8 @@ export var getDraftCommandAnalyticsPayload = function getDraftCommandAnalyticsPa
       };
     }
     if (fg('editor_inline_comments_on_inline_nodes')) {
-      var _ref2 = getPluginState(state) || {},
-        bookmark = _ref2.bookmark;
+      var _ref = getPluginState(state) || {},
+        bookmark = _ref.bookmark;
       attributes.inlineNodeNames = getRangeInlineNodeNames({
         doc: state.doc,
         pos: resolveDraftBookmark(state, bookmark)
@@ -311,8 +418,8 @@ export var isSelectionValid = function isSelectionValid(state) {
   var supportedBlockNodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   var isBlockNodeSupported = arguments.length > 2 ? arguments[2] : undefined;
   var selection = state.selection;
-  var _ref3 = getPluginState(state) || {},
-    disallowOnWhitespace = _ref3.disallowOnWhitespace;
+  var _ref2 = getPluginState(state) || {},
+    disallowOnWhitespace = _ref2.disallowOnWhitespace;
   var allowedInlineNodes = ['emoji', 'status', 'date', 'mention', 'inlineCard'];
   var isSelectionEmpty = selection.empty;
   var isTextOrAllSelection = selection instanceof TextSelection || selection instanceof AllSelection;

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

@@ -11,6 +11,13 @@ import type { InlineCommentPluginState } from './types';
  * @param $pos Position to center search around
  */
 export declare const surroundingMarks: ($pos: ResolvedPos) => (readonly Mark[])[];
+type AnnotationDiscovery = {
+    annotationIds: readonly string[];
+    nestedAnnotationIds: readonly string[];
+    rootAnnotationIds: readonly string[];
+};
+/** Discover annotation IDs from immutable legacy-content ADF without repeatedly scanning it. */
+export declare const getAnnotationDiscovery: (doc: Node) => AnnotationDiscovery;
 export declare const getAllAnnotations: (doc: Node) => string[];
 export declare const decorationKey: {
     block: string;
@@ -52,3 +59,4 @@ export declare function isSelectedAnnotationsChanged(oldSelectedAnnotations: Ann
  */
 export declare const isBlockNodeAnnotationsSelected: (selection: Selection, selectedAnnotations?: AnnotationInfo[]) => boolean;
 export declare const hasAnyUnResolvedAnnotationInPage: (state: EditorState) => boolean;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-annotation",
-	"version": "29.0.6",
+	"version": "29.1.0",
 	"description": "Annotation plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -30,6 +30,7 @@
 		"@atlaskit/editor-toolbar": "^2.8.0",
 		"@atlaskit/editor-toolbar-model": "^1.2.0",
 		"@atlaskit/icon": "^38.0.0",
+		"@atlaskit/platform-feature-experiments": "^0.3.0",
 		"@atlaskit/platform-feature-flags": "^2.2.0",
 		"@atlaskit/tmp-editor-statsig": "^246.0.0",
 		"@babel/runtime": "^7.0.0"