@atlaskit/editor-plugin-show-diff 13.0.6 → 13.0.8

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 13.0.8
+
+### Patch Changes
+
+- [`d4fbe7dee465e`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/d4fbe7dee465e) -
+  Consolidate diff decoration scrolling into a single internal helper.
+- Updated dependencies
+
+## 13.0.7
+
+### Patch Changes
+
+- [`2c712e57d3793`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/2c712e57d3793) -
+  Consolidate diffable-attribute rules into a single shared source of truth (`diffableAttrs`) used
+  by both the changeset token encoder (detection) and `getAttrChangeRanges` (rendering), and extend
+  the encoder to fold all mapped node types.
+- Updated dependencies
+
 ## 13.0.6
 
 ### Patch Changes

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

@@ -4,33 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.attrAwareTokenEncoder = void 0;
+var _diffableAttrs = require("../decorations/utils/diffableAttrs");
 /**
- * Attribute-aware token encoder for `prosemirror-changeset`.
- *
- * The library's default encoder reduces a node's open token to `node.type.name`,
- * ignoring attributes. An attribute-only change (e.g. recolouring a table cell's
- * `background`) therefore tokenises identically on both sides and reports no
- * change at all.
- *
- * This encoder folds an allow-listed set of attributes into the open token so
- * such changes register. Everything else encodes exactly as the default. The
- * allow-list is deliberately narrow — folding in ephemeral attrs like `localId`
- * would produce phantom diffs.
+ * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
+ * reduces a node to `node.type.name`, so an attribute-only change (e.g. a table
+ * cell recolour) tokenises identically on both sides and goes undetected. This
+ * folds the diffable attributes (from the shared `diffableAttrs` map) into the
+ * open token so such changes register.
  */
 
-var DIFFED_ATTRS_BY_NODE_TYPE = {
-  tableCell: ['background', 'colspan', 'rowspan'],
-  tableHeader: ['background', 'colspan', 'rowspan']
-};
-
-/**
- * Builds a stable composite token. Iterates the allow-list rather than
- * `Object.keys` so ordering is deterministic for string comparison.
- */
+// 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 : {};
-  // Deterministic order: iterate the allow-list, not `Object.keys(attrs)`.
   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));
@@ -38,18 +24,16 @@ var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
   return "".concat(node.type.name, "|").concat(parts.join('|'));
 };
 
-/**
- * Identical to the library default except that allow-listed node types encode
- * their allow-listed attributes into the open token. Characters and node-end
- * tokens are left as-is, hence the `string | number` token type.
- */
+// Like the library default, but node types with a `diffableAttrs` rule fold their
+// attrs into the open token. Chars/node-end are unchanged, hence `string | number`.
 var attrAwareTokenEncoder = exports.attrAwareTokenEncoder = {
   encodeCharacter: function encodeCharacter(char, _marks) {
     return char;
   },
   encodeNodeStart: function encodeNodeStart(node) {
-    var attrNames = DIFFED_ATTRS_BY_NODE_TYPE[node.type.name];
-    if (attrNames) {
+    var _node$attrs2;
+    var attrNames = (0, _diffableAttrs.getDiffableAttrNames)(node.type.name, (_node$attrs2 = node.attrs) !== null && _node$attrs2 !== void 0 ? _node$attrs2 : {});
+    if (attrNames && attrNames.length > 0) {
       return encodeNodeWithAttrs(node, attrNames);
     }
     return node.type.name;
@@ -62,10 +46,7 @@ var attrAwareTokenEncoder = exports.attrAwareTokenEncoder = {
   }
 };
 
-/**
- * Mirrors the library's private `typeID` so node-end tokens match the default
- * encoding exactly. Reimplemented here because it is not exported.
- */
+// Mirrors the library's private (unexported) `typeID` so node-end tokens match.
 function typeID(type) {
   var cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
   var id = cache[type.name];

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

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDiffableAttr = exports.getRequiredIncludedDiffableAttrs = exports.getIncludedDiffableAttrs = exports.getDiffableAttrNames = exports.DIFFABLE_ATTRS_BY_NODE_TYPE = void 0;
+/**
+ * Single source of truth for which attributes of a node type represent a
+ * meaningful change. Shared by `attrAwareTokenEncoder` (changeset detection)
+ * and `getAttrChangeRanges` (decoration rendering) so the two stages agree.
+ */
+
+// Node types absent from this map have no attribute-level diffing.
+var DIFFABLE_ATTRS_BY_NODE_TYPE = exports.DIFFABLE_ATTRS_BY_NODE_TYPE = {
+  tableCell: {
+    include: ['background', 'colspan', 'rowspan']
+  },
+  tableHeader: {
+    include: ['background', 'colspan', 'rowspan']
+  },
+  // Inline nodes whose identity is their attrs.
+  date: {
+    include: ['timestamp']
+  },
+  emoji: {
+    include: ['shortName', 'id', 'text']
+  },
+  mention: {
+    include: ['id', 'text']
+  },
+  status: {
+    include: ['text', 'color']
+  },
+  taskItem: {
+    include: ['state']
+  },
+  // Media: id/collection/url identify the image.
+  media: {
+    include: ['id', 'collection', 'url']
+  },
+  // Extensions: any attribute change is meaningful except localId.
+  extension: {
+    exclude: ['localId']
+  },
+  inlineExtension: {
+    exclude: ['localId']
+  },
+  bodiedExtension: {
+    exclude: ['localId']
+  }
+};
+
+// Whether `attrName` is a meaningful change for `nodeTypeName`. False if no rule.
+var isDiffableAttr = exports.isDiffableAttr = function isDiffableAttr(nodeTypeName, attrName) {
+  var rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  if (!rule) {
+    return false;
+  }
+  return 'include' in rule ? rule.include.includes(attrName) : !rule.exclude.includes(attrName);
+};
+
+// The fixed include list for a node type, or `undefined` for no/exclude rule.
+// Use where a node-independent attr list is needed (e.g. the inline node map).
+var getIncludedDiffableAttrs = exports.getIncludedDiffableAttrs = function getIncludedDiffableAttrs(nodeTypeName) {
+  var rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  return rule && 'include' in rule ? rule.include : undefined;
+};
+
+// Like `getIncludedDiffableAttrs` but asserts the include rule exists, so a
+// consumer relying on a fixed list fails loudly if the rule is removed or
+// switched to an exclude rule rather than silently drifting.
+var getRequiredIncludedDiffableAttrs = exports.getRequiredIncludedDiffableAttrs = function getRequiredIncludedDiffableAttrs(nodeTypeName) {
+  var attrs = getIncludedDiffableAttrs(nodeTypeName);
+  if (!attrs) {
+    throw new Error("diffableAttrs: expected an include rule for \"".concat(nodeTypeName, "\""));
+  }
+  return attrs;
+};
+
+/**
+ * Concrete attr names to diff for a node instance, honouring include and exclude
+ * rules; `undefined` when the type has no rule. Exclude rules read the node's
+ * attrs and sort them, since key order isn't stable across the two diffed docs.
+ */
+var getDiffableAttrNames = exports.getDiffableAttrNames = function getDiffableAttrNames(nodeTypeName, attrs) {
+  var rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  if (!rule) {
+    return undefined;
+  }
+  if ('include' in rule) {
+    return rule.include;
+  }
+  return Object.keys(attrs).filter(function (name) {
+    return !rule.exclude.includes(name);
+  }).sort();
+};

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

@@ -10,29 +10,20 @@ var _steps = require("@atlaskit/adf-schema/steps");
 var _deprecatedPlatformFeatureExperiments = require("@atlaskit/editor-common/deprecated-platform-feature-experiments");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
+var _diffableAttrs = require("./diffableAttrs");
 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; }
 var filterUndefined = function filterUndefined(x) {
   return !!x;
 };
 
-// Attributes that indicate a change in media image
-var mediaAttrs = ['id', 'collection', 'url'];
-
-// Attribute that indicates a date change
-var dateAttrs = ['timestamp'];
-
-// Attribute that indicates a task item state change
-var taskItemAttrs = ['state'];
-
-// Attributes that indicate an emoji change
-var emojiAttrs = ['shortName', 'id', 'text'];
-
-// Attributes that indicate a mention change (who is mentioned)
-var mentionAttrs = ['id', 'text'];
-
-// Attributes that indicate a status change (label or colour)
-var statusAttrs = ['text', 'color'];
+// Attr lists sourced from the shared `diffableAttrs` map (shared with the encoder).
+var mediaAttrs = (0, _diffableAttrs.getRequiredIncludedDiffableAttrs)('media');
+var dateAttrs = (0, _diffableAttrs.getRequiredIncludedDiffableAttrs)('date');
+var taskItemAttrs = (0, _diffableAttrs.getRequiredIncludedDiffableAttrs)('taskItem');
+var emojiAttrs = (0, _diffableAttrs.getRequiredIncludedDiffableAttrs)('emoji');
+var mentionAttrs = (0, _diffableAttrs.getRequiredIncludedDiffableAttrs)('mention');
+var statusAttrs = (0, _diffableAttrs.getRequiredIncludedDiffableAttrs)('status');
 
 // Map of node type name → the attrs that represent a meaningful content change for that node
 var inlineNodeAttrMap = {
@@ -45,10 +36,8 @@ var isInlineAttrChangeNodeName = function isInlineAttrChangeNodeName(nodeName) {
   return nodeName in inlineNodeAttrMap;
 };
 
-// Attributes excluded from extension change detection (not meaningful content changes)
-var extensionExcludedAttrs = ['localId'];
-
-// Extension node type names
+// Extension node type names. Their "any attr except localId" exclude rule lives
+// in the shared `diffableAttrs` map and is applied via `isDiffableAttr` below.
 var extensionNodeNames = ['extension', 'inlineExtension', 'bodiedExtension'];
 var getStepAttrs = function getStepAttrs(step) {
   if (step instanceof _transform.AttrStep) {
@@ -118,9 +107,9 @@ var getAttrChangeRanges = exports.getAttrChangeRanges = function getAttrChangeRa
       };
     }
 
-    // extension nodes: any attribute change except localId — highlight the node
+    // extension nodes: highlight on any diffable attr change (exclude rule in shared map)
     if (nodeAtPos && extensionNodeNames.includes(nodeAtPos.type.name) && stepAttrs.some(function (v) {
-      return !extensionExcludedAttrs.includes(v);
+      return (0, _diffableAttrs.isDiffableAttr)(nodeAtPos.type.name, v);
     })) {
       var isInline = nodeAtPos.type.name === 'inlineExtension';
       return {

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

@@ -187,7 +187,7 @@ var createPlugin = exports.createPlugin = function createPlugin(config, getIntl,
           if (pluginState !== null && pluginState !== void 0 && pluginState.scrollIntoView && (0, _isExtendedEnabled.isExtendedEnabled)(pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType)) {
             var _cancelPendingScrollT;
             (_cancelPendingScrollT = cancelPendingScrollToDecoration) === null || _cancelPendingScrollT === void 0 || _cancelPendingScrollT();
-            cancelPendingScrollToDecoration = (0, _scrollToDiff.scrollToFirstDecoration)(view, (0, _getScrollableDecorations.getScrollableDecorations)(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType));
+            cancelPendingScrollToDecoration = (0, _scrollToDiff.scrollToDecoration)(view, (0, _getScrollableDecorations.getScrollableDecorations)(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType));
 
             // Reset the flag so we don't scroll again on subsequent updates
             view.dispatch(view.state.tr.setMeta(showDiffPluginKey, {
@@ -208,7 +208,7 @@ var createPlugin = exports.createPlugin = function createPlugin(config, getIntl,
               // avoid a circular dependency; expand picks up the meta if loaded (no-op if not).
               api === null || api === void 0 || api.core.actions.execute((0, _expand.toggleExpandRange)(activeDecoration.from, activeDecoration.to, true));
             }
-            cancelPendingScrollToDecoration = (0, _scrollToDiff.scrollToActiveDecoration)(view, scrollableDecorations, pluginState.activeIndex);
+            cancelPendingScrollToDecoration = (0, _scrollToDiff.scrollToDecoration)(view, scrollableDecorations, pluginState.activeIndex);
           }
         },
         destroy: function destroy() {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.scrollToFirstDecoration = exports.scrollToActiveDecoration = void 0;
+exports.scrollToDecoration = void 0;
 var _decorationKeys = require("./decorations/decorationKeys");
 /**
  * Extra space above the scrolled-to element so it does not sit flush under the
@@ -40,29 +40,13 @@ function scrollToSelection(node) {
 }
 
 /**
- * Schedules scrolling to the first diff decoration after the next frame.
- * Unlike `scrollToActiveDecoration`, this does not require an active index —
- * it simply scrolls to bring the first decoration into view.
- *
- * The caller must pass the list of scrollable decorations as produced by
- * `getScrollableDecorations`, which is filtered (non-scrollable decorations
- * removed) and sorted by document position. This guarantees "first" means the
- * topmost scrollable diff in the document rather than an arbitrary decoration
- * from the raw `DecorationSet` ordering. This is delegated to
- * `scrollToActiveDecoration` at index 0 so both scroll paths behave identically.
- *
- * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
- */
-var scrollToFirstDecoration = exports.scrollToFirstDecoration = function scrollToFirstDecoration(view, scrollableDecorations) {
-  return scrollToActiveDecoration(view, scrollableDecorations, 0);
-};
-
-/**
- * Schedules scrolling to the decoration at the given index after the next frame.
+ * Schedules scrolling to the decoration at the given index after the next frame. Defaults to the
+ * first decoration when no index is provided.
  *
  * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
  */
-var scrollToActiveDecoration = exports.scrollToActiveDecoration = function scrollToActiveDecoration(view, decorations, activeIndex) {
+var scrollToDecoration = exports.scrollToDecoration = function scrollToDecoration(view, decorations) {
+  var activeIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var decoration = decorations[activeIndex];
   if (!decoration) {
     return function () {};

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

@@ -1,30 +1,17 @@
-/**
- * Attribute-aware token encoder for `prosemirror-changeset`.
- *
- * The library's default encoder reduces a node's open token to `node.type.name`,
- * ignoring attributes. An attribute-only change (e.g. recolouring a table cell's
- * `background`) therefore tokenises identically on both sides and reports no
- * change at all.
- *
- * This encoder folds an allow-listed set of attributes into the open token so
- * such changes register. Everything else encodes exactly as the default. The
- * allow-list is deliberately narrow — folding in ephemeral attrs like `localId`
- * would produce phantom diffs.
- */
-
-const DIFFED_ATTRS_BY_NODE_TYPE = {
-  tableCell: ['background', 'colspan', 'rowspan'],
-  tableHeader: ['background', 'colspan', 'rowspan']
-};
+import { getDiffableAttrNames } from '../decorations/utils/diffableAttrs';
 
 /**
- * Builds a stable composite token. Iterates the allow-list rather than
- * `Object.keys` so ordering is deterministic for string comparison.
+ * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
+ * reduces a node to `node.type.name`, so an attribute-only change (e.g. a table
+ * cell recolour) tokenises identically on both sides and goes undetected. This
+ * folds the diffable attributes (from the shared `diffableAttrs` map) into the
+ * open token so such changes register.
  */
+
+// Stable composite token; attr names are pre-ordered by the caller.
 const encodeNodeWithAttrs = (node, attrNames) => {
   var _node$attrs;
   const attrs = (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 ? _node$attrs : {};
-  // Deterministic order: iterate the allow-list, not `Object.keys(attrs)`.
   const parts = attrNames.map(name => {
     var _attrs$name;
     return `${name}=${JSON.stringify((_attrs$name = attrs[name]) !== null && _attrs$name !== void 0 ? _attrs$name : null)}`;
@@ -32,16 +19,14 @@ const encodeNodeWithAttrs = (node, attrNames) => {
   return `${node.type.name}|${parts.join('|')}`;
 };
 
-/**
- * Identical to the library default except that allow-listed node types encode
- * their allow-listed attributes into the open token. Characters and node-end
- * tokens are left as-is, hence the `string | number` token type.
- */
+// Like the library default, but node types with a `diffableAttrs` rule fold their
+// attrs into the open token. Chars/node-end are unchanged, hence `string | number`.
 export const attrAwareTokenEncoder = {
   encodeCharacter: (char, _marks) => char,
   encodeNodeStart: node => {
-    const attrNames = DIFFED_ATTRS_BY_NODE_TYPE[node.type.name];
-    if (attrNames) {
+    var _node$attrs2;
+    const attrNames = getDiffableAttrNames(node.type.name, (_node$attrs2 = node.attrs) !== null && _node$attrs2 !== void 0 ? _node$attrs2 : {});
+    if (attrNames && attrNames.length > 0) {
       return encodeNodeWithAttrs(node, attrNames);
     }
     return node.type.name;
@@ -50,10 +35,7 @@ export const attrAwareTokenEncoder = {
   compareTokens: (a, b) => a === b
 };
 
-/**
- * Mirrors the library's private `typeID` so node-end tokens match the default
- * encoding exactly. Reimplemented here because it is not exported.
- */
+// Mirrors the library's private (unexported) `typeID` so node-end tokens match.
 function typeID(type) {
   const cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
   let id = cache[type.name];

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

@@ -0,0 +1,88 @@
+/**
+ * Single source of truth for which attributes of a node type represent a
+ * meaningful change. Shared by `attrAwareTokenEncoder` (changeset detection)
+ * and `getAttrChangeRanges` (decoration rendering) so the two stages agree.
+ */
+
+// Node types absent from this map have no attribute-level diffing.
+export const DIFFABLE_ATTRS_BY_NODE_TYPE = {
+  tableCell: {
+    include: ['background', 'colspan', 'rowspan']
+  },
+  tableHeader: {
+    include: ['background', 'colspan', 'rowspan']
+  },
+  // Inline nodes whose identity is their attrs.
+  date: {
+    include: ['timestamp']
+  },
+  emoji: {
+    include: ['shortName', 'id', 'text']
+  },
+  mention: {
+    include: ['id', 'text']
+  },
+  status: {
+    include: ['text', 'color']
+  },
+  taskItem: {
+    include: ['state']
+  },
+  // Media: id/collection/url identify the image.
+  media: {
+    include: ['id', 'collection', 'url']
+  },
+  // Extensions: any attribute change is meaningful except localId.
+  extension: {
+    exclude: ['localId']
+  },
+  inlineExtension: {
+    exclude: ['localId']
+  },
+  bodiedExtension: {
+    exclude: ['localId']
+  }
+};
+
+// Whether `attrName` is a meaningful change for `nodeTypeName`. False if no rule.
+export const isDiffableAttr = (nodeTypeName, attrName) => {
+  const rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  if (!rule) {
+    return false;
+  }
+  return 'include' in rule ? rule.include.includes(attrName) : !rule.exclude.includes(attrName);
+};
+
+// The fixed include list for a node type, or `undefined` for no/exclude rule.
+// Use where a node-independent attr list is needed (e.g. the inline node map).
+export const getIncludedDiffableAttrs = nodeTypeName => {
+  const rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  return rule && 'include' in rule ? rule.include : undefined;
+};
+
+// Like `getIncludedDiffableAttrs` but asserts the include rule exists, so a
+// consumer relying on a fixed list fails loudly if the rule is removed or
+// switched to an exclude rule rather than silently drifting.
+export const getRequiredIncludedDiffableAttrs = nodeTypeName => {
+  const attrs = getIncludedDiffableAttrs(nodeTypeName);
+  if (!attrs) {
+    throw new Error(`diffableAttrs: expected an include rule for "${nodeTypeName}"`);
+  }
+  return attrs;
+};
+
+/**
+ * Concrete attr names to diff for a node instance, honouring include and exclude
+ * rules; `undefined` when the type has no rule. Exclude rules read the node's
+ * attrs and sort them, since key order isn't stable across the two diffed docs.
+ */
+export const getDiffableAttrNames = (nodeTypeName, attrs) => {
+  const rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  if (!rule) {
+    return undefined;
+  }
+  if ('include' in rule) {
+    return rule.include;
+  }
+  return Object.keys(attrs).filter(name => !rule.exclude.includes(name)).sort();
+};

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

@@ -2,25 +2,16 @@ import { SetAttrsStep } from '@atlaskit/adf-schema/steps';
 import { isExperimentEnabled } from '@atlaskit/editor-common/deprecated-platform-feature-experiments';
 import { AttrStep } from '@atlaskit/editor-prosemirror/transform';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { getRequiredIncludedDiffableAttrs, isDiffableAttr } from './diffableAttrs';
 const filterUndefined = x => !!x;
 
-// Attributes that indicate a change in media image
-const mediaAttrs = ['id', 'collection', 'url'];
-
-// Attribute that indicates a date change
-const dateAttrs = ['timestamp'];
-
-// Attribute that indicates a task item state change
-const taskItemAttrs = ['state'];
-
-// Attributes that indicate an emoji change
-const emojiAttrs = ['shortName', 'id', 'text'];
-
-// Attributes that indicate a mention change (who is mentioned)
-const mentionAttrs = ['id', 'text'];
-
-// Attributes that indicate a status change (label or colour)
-const statusAttrs = ['text', 'color'];
+// Attr lists sourced from the shared `diffableAttrs` map (shared with the encoder).
+const mediaAttrs = getRequiredIncludedDiffableAttrs('media');
+const dateAttrs = getRequiredIncludedDiffableAttrs('date');
+const taskItemAttrs = getRequiredIncludedDiffableAttrs('taskItem');
+const emojiAttrs = getRequiredIncludedDiffableAttrs('emoji');
+const mentionAttrs = getRequiredIncludedDiffableAttrs('mention');
+const statusAttrs = getRequiredIncludedDiffableAttrs('status');
 
 // Map of node type name → the attrs that represent a meaningful content change for that node
 const inlineNodeAttrMap = {
@@ -31,10 +22,8 @@ const inlineNodeAttrMap = {
 };
 const isInlineAttrChangeNodeName = nodeName => nodeName in inlineNodeAttrMap;
 
-// Attributes excluded from extension change detection (not meaningful content changes)
-const extensionExcludedAttrs = ['localId'];
-
-// Extension node type names
+// Extension node type names. Their "any attr except localId" exclude rule lives
+// in the shared `diffableAttrs` map and is applied via `isDiffableAttr` below.
 const extensionNodeNames = ['extension', 'inlineExtension', 'bodiedExtension'];
 const getStepAttrs = step => {
   if (step instanceof AttrStep) {
@@ -95,8 +84,8 @@ export const getAttrChangeRanges = (doc, steps, originalDoc) => {
       };
     }
 
-    // extension nodes: any attribute change except localId — highlight the node
-    if (nodeAtPos && extensionNodeNames.includes(nodeAtPos.type.name) && stepAttrs.some(v => !extensionExcludedAttrs.includes(v))) {
+    // extension nodes: highlight on any diffable attr change (exclude rule in shared map)
+    if (nodeAtPos && extensionNodeNames.includes(nodeAtPos.type.name) && stepAttrs.some(v => isDiffableAttr(nodeAtPos.type.name, v))) {
       const isInline = nodeAtPos.type.name === 'inlineExtension';
       return {
         fromB: step.pos,

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

@@ -9,7 +9,7 @@ import { enforceCustomStepRegisters } from './enforceCustomStepRegisters';
 import { getScrollableDecorations } from './getScrollableDecorations';
 import { isExtendedEnabled } from './isExtendedEnabled';
 import { NodeViewSerializer } from './NodeViewSerializer';
-import { scrollToActiveDecoration, scrollToFirstDecoration } from './scrollToDiff';
+import { scrollToDecoration } from './scrollToDiff';
 export const showDiffPluginKey = new PluginKey('showDiffPlugin');
 export const createPlugin = (config, getIntl, api, onEditorView) => {
   enforceCustomStepRegisters();
@@ -194,7 +194,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
           if (pluginState !== null && pluginState !== void 0 && pluginState.scrollIntoView && isExtendedEnabled(pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType)) {
             var _cancelPendingScrollT;
             (_cancelPendingScrollT = cancelPendingScrollToDecoration) === null || _cancelPendingScrollT === void 0 ? void 0 : _cancelPendingScrollT();
-            cancelPendingScrollToDecoration = scrollToFirstDecoration(view, getScrollableDecorations(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType));
+            cancelPendingScrollToDecoration = scrollToDecoration(view, getScrollableDecorations(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType));
 
             // Reset the flag so we don't scroll again on subsequent updates
             view.dispatch(view.state.tr.setMeta(showDiffPluginKey, {
@@ -215,7 +215,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
               // avoid a circular dependency; expand picks up the meta if loaded (no-op if not).
               api === null || api === void 0 ? void 0 : api.core.actions.execute(toggleExpandRange(activeDecoration.from, activeDecoration.to, true));
             }
-            cancelPendingScrollToDecoration = scrollToActiveDecoration(view, scrollableDecorations, pluginState.activeIndex);
+            cancelPendingScrollToDecoration = scrollToDecoration(view, scrollableDecorations, pluginState.activeIndex);
           }
         },
         destroy() {

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

@@ -35,27 +35,12 @@ function scrollToSelection(node) {
 }
 
 /**
- * Schedules scrolling to the first diff decoration after the next frame.
- * Unlike `scrollToActiveDecoration`, this does not require an active index —
- * it simply scrolls to bring the first decoration into view.
- *
- * The caller must pass the list of scrollable decorations as produced by
- * `getScrollableDecorations`, which is filtered (non-scrollable decorations
- * removed) and sorted by document position. This guarantees "first" means the
- * topmost scrollable diff in the document rather than an arbitrary decoration
- * from the raw `DecorationSet` ordering. This is delegated to
- * `scrollToActiveDecoration` at index 0 so both scroll paths behave identically.
- *
- * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
- */
-export const scrollToFirstDecoration = (view, scrollableDecorations) => scrollToActiveDecoration(view, scrollableDecorations, 0);
-
-/**
- * Schedules scrolling to the decoration at the given index after the next frame.
+ * Schedules scrolling to the decoration at the given index after the next frame. Defaults to the
+ * first decoration when no index is provided.
  *
  * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
  */
-export const scrollToActiveDecoration = (view, decorations, activeIndex) => {
+export const scrollToDecoration = (view, decorations, activeIndex = 0) => {
   const decoration = decorations[activeIndex];
   if (!decoration) {
     return () => {};

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

@@ -1,30 +1,17 @@
-/**
- * Attribute-aware token encoder for `prosemirror-changeset`.
- *
- * The library's default encoder reduces a node's open token to `node.type.name`,
- * ignoring attributes. An attribute-only change (e.g. recolouring a table cell's
- * `background`) therefore tokenises identically on both sides and reports no
- * change at all.
- *
- * This encoder folds an allow-listed set of attributes into the open token so
- * such changes register. Everything else encodes exactly as the default. The
- * allow-list is deliberately narrow — folding in ephemeral attrs like `localId`
- * would produce phantom diffs.
- */
-
-var DIFFED_ATTRS_BY_NODE_TYPE = {
-  tableCell: ['background', 'colspan', 'rowspan'],
-  tableHeader: ['background', 'colspan', 'rowspan']
-};
+import { getDiffableAttrNames } from '../decorations/utils/diffableAttrs';
 
 /**
- * Builds a stable composite token. Iterates the allow-list rather than
- * `Object.keys` so ordering is deterministic for string comparison.
+ * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
+ * reduces a node to `node.type.name`, so an attribute-only change (e.g. a table
+ * cell recolour) tokenises identically on both sides and goes undetected. This
+ * folds the diffable attributes (from the shared `diffableAttrs` map) into the
+ * open token so such changes register.
  */
+
+// 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 : {};
-  // Deterministic order: iterate the allow-list, not `Object.keys(attrs)`.
   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));
@@ -32,18 +19,16 @@ var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
   return "".concat(node.type.name, "|").concat(parts.join('|'));
 };
 
-/**
- * Identical to the library default except that allow-listed node types encode
- * their allow-listed attributes into the open token. Characters and node-end
- * tokens are left as-is, hence the `string | number` token type.
- */
+// Like the library default, but node types with a `diffableAttrs` rule fold their
+// attrs into the open token. Chars/node-end are unchanged, hence `string | number`.
 export var attrAwareTokenEncoder = {
   encodeCharacter: function encodeCharacter(char, _marks) {
     return char;
   },
   encodeNodeStart: function encodeNodeStart(node) {
-    var attrNames = DIFFED_ATTRS_BY_NODE_TYPE[node.type.name];
-    if (attrNames) {
+    var _node$attrs2;
+    var attrNames = getDiffableAttrNames(node.type.name, (_node$attrs2 = node.attrs) !== null && _node$attrs2 !== void 0 ? _node$attrs2 : {});
+    if (attrNames && attrNames.length > 0) {
       return encodeNodeWithAttrs(node, attrNames);
     }
     return node.type.name;
@@ -56,10 +41,7 @@ export var attrAwareTokenEncoder = {
   }
 };
 
-/**
- * Mirrors the library's private `typeID` so node-end tokens match the default
- * encoding exactly. Reimplemented here because it is not exported.
- */
+// Mirrors the library's private (unexported) `typeID` so node-end tokens match.
 function typeID(type) {
   var cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
   var id = cache[type.name];

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

@@ -0,0 +1,90 @@
+/**
+ * Single source of truth for which attributes of a node type represent a
+ * meaningful change. Shared by `attrAwareTokenEncoder` (changeset detection)
+ * and `getAttrChangeRanges` (decoration rendering) so the two stages agree.
+ */
+
+// Node types absent from this map have no attribute-level diffing.
+export var DIFFABLE_ATTRS_BY_NODE_TYPE = {
+  tableCell: {
+    include: ['background', 'colspan', 'rowspan']
+  },
+  tableHeader: {
+    include: ['background', 'colspan', 'rowspan']
+  },
+  // Inline nodes whose identity is their attrs.
+  date: {
+    include: ['timestamp']
+  },
+  emoji: {
+    include: ['shortName', 'id', 'text']
+  },
+  mention: {
+    include: ['id', 'text']
+  },
+  status: {
+    include: ['text', 'color']
+  },
+  taskItem: {
+    include: ['state']
+  },
+  // Media: id/collection/url identify the image.
+  media: {
+    include: ['id', 'collection', 'url']
+  },
+  // Extensions: any attribute change is meaningful except localId.
+  extension: {
+    exclude: ['localId']
+  },
+  inlineExtension: {
+    exclude: ['localId']
+  },
+  bodiedExtension: {
+    exclude: ['localId']
+  }
+};
+
+// Whether `attrName` is a meaningful change for `nodeTypeName`. False if no rule.
+export var isDiffableAttr = function isDiffableAttr(nodeTypeName, attrName) {
+  var rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  if (!rule) {
+    return false;
+  }
+  return 'include' in rule ? rule.include.includes(attrName) : !rule.exclude.includes(attrName);
+};
+
+// The fixed include list for a node type, or `undefined` for no/exclude rule.
+// Use where a node-independent attr list is needed (e.g. the inline node map).
+export var getIncludedDiffableAttrs = function getIncludedDiffableAttrs(nodeTypeName) {
+  var rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  return rule && 'include' in rule ? rule.include : undefined;
+};
+
+// Like `getIncludedDiffableAttrs` but asserts the include rule exists, so a
+// consumer relying on a fixed list fails loudly if the rule is removed or
+// switched to an exclude rule rather than silently drifting.
+export var getRequiredIncludedDiffableAttrs = function getRequiredIncludedDiffableAttrs(nodeTypeName) {
+  var attrs = getIncludedDiffableAttrs(nodeTypeName);
+  if (!attrs) {
+    throw new Error("diffableAttrs: expected an include rule for \"".concat(nodeTypeName, "\""));
+  }
+  return attrs;
+};
+
+/**
+ * Concrete attr names to diff for a node instance, honouring include and exclude
+ * rules; `undefined` when the type has no rule. Exclude rules read the node's
+ * attrs and sort them, since key order isn't stable across the two diffed docs.
+ */
+export var getDiffableAttrNames = function getDiffableAttrNames(nodeTypeName, attrs) {
+  var rule = DIFFABLE_ATTRS_BY_NODE_TYPE[nodeTypeName];
+  if (!rule) {
+    return undefined;
+  }
+  if ('include' in rule) {
+    return rule.include;
+  }
+  return Object.keys(attrs).filter(function (name) {
+    return !rule.exclude.includes(name);
+  }).sort();
+};

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

@@ -5,27 +5,18 @@ import { SetAttrsStep } from '@atlaskit/adf-schema/steps';
 import { isExperimentEnabled } from '@atlaskit/editor-common/deprecated-platform-feature-experiments';
 import { AttrStep } from '@atlaskit/editor-prosemirror/transform';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { getRequiredIncludedDiffableAttrs, isDiffableAttr } from './diffableAttrs';
 var filterUndefined = function filterUndefined(x) {
   return !!x;
 };
 
-// Attributes that indicate a change in media image
-var mediaAttrs = ['id', 'collection', 'url'];
-
-// Attribute that indicates a date change
-var dateAttrs = ['timestamp'];
-
-// Attribute that indicates a task item state change
-var taskItemAttrs = ['state'];
-
-// Attributes that indicate an emoji change
-var emojiAttrs = ['shortName', 'id', 'text'];
-
-// Attributes that indicate a mention change (who is mentioned)
-var mentionAttrs = ['id', 'text'];
-
-// Attributes that indicate a status change (label or colour)
-var statusAttrs = ['text', 'color'];
+// Attr lists sourced from the shared `diffableAttrs` map (shared with the encoder).
+var mediaAttrs = getRequiredIncludedDiffableAttrs('media');
+var dateAttrs = getRequiredIncludedDiffableAttrs('date');
+var taskItemAttrs = getRequiredIncludedDiffableAttrs('taskItem');
+var emojiAttrs = getRequiredIncludedDiffableAttrs('emoji');
+var mentionAttrs = getRequiredIncludedDiffableAttrs('mention');
+var statusAttrs = getRequiredIncludedDiffableAttrs('status');
 
 // Map of node type name → the attrs that represent a meaningful content change for that node
 var inlineNodeAttrMap = {
@@ -38,10 +29,8 @@ var isInlineAttrChangeNodeName = function isInlineAttrChangeNodeName(nodeName) {
   return nodeName in inlineNodeAttrMap;
 };
 
-// Attributes excluded from extension change detection (not meaningful content changes)
-var extensionExcludedAttrs = ['localId'];
-
-// Extension node type names
+// Extension node type names. Their "any attr except localId" exclude rule lives
+// in the shared `diffableAttrs` map and is applied via `isDiffableAttr` below.
 var extensionNodeNames = ['extension', 'inlineExtension', 'bodiedExtension'];
 var getStepAttrs = function getStepAttrs(step) {
   if (step instanceof AttrStep) {
@@ -111,9 +100,9 @@ export var getAttrChangeRanges = function getAttrChangeRanges(doc, steps, origin
       };
     }
 
-    // extension nodes: any attribute change except localId — highlight the node
+    // extension nodes: highlight on any diffable attr change (exclude rule in shared map)
     if (nodeAtPos && extensionNodeNames.includes(nodeAtPos.type.name) && stepAttrs.some(function (v) {
-      return !extensionExcludedAttrs.includes(v);
+      return isDiffableAttr(nodeAtPos.type.name, v);
     })) {
       var isInline = nodeAtPos.type.name === 'inlineExtension';
       return {

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

@@ -12,7 +12,7 @@ import { enforceCustomStepRegisters } from './enforceCustomStepRegisters';
 import { getScrollableDecorations } from './getScrollableDecorations';
 import { isExtendedEnabled } from './isExtendedEnabled';
 import { NodeViewSerializer } from './NodeViewSerializer';
-import { scrollToActiveDecoration, scrollToFirstDecoration } from './scrollToDiff';
+import { scrollToDecoration } from './scrollToDiff';
 export var showDiffPluginKey = new PluginKey('showDiffPlugin');
 export var createPlugin = function createPlugin(config, getIntl, api, onEditorView) {
   enforceCustomStepRegisters();
@@ -180,7 +180,7 @@ export var createPlugin = function createPlugin(config, getIntl, api, onEditorVi
           if (pluginState !== null && pluginState !== void 0 && pluginState.scrollIntoView && isExtendedEnabled(pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType)) {
             var _cancelPendingScrollT;
             (_cancelPendingScrollT = cancelPendingScrollToDecoration) === null || _cancelPendingScrollT === void 0 || _cancelPendingScrollT();
-            cancelPendingScrollToDecoration = scrollToFirstDecoration(view, getScrollableDecorations(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType));
+            cancelPendingScrollToDecoration = scrollToDecoration(view, getScrollableDecorations(pluginState.decorations, view.state.doc, pluginState === null || pluginState === void 0 ? void 0 : pluginState.diffType));
 
             // Reset the flag so we don't scroll again on subsequent updates
             view.dispatch(view.state.tr.setMeta(showDiffPluginKey, {
@@ -201,7 +201,7 @@ export var createPlugin = function createPlugin(config, getIntl, api, onEditorVi
               // avoid a circular dependency; expand picks up the meta if loaded (no-op if not).
               api === null || api === void 0 || api.core.actions.execute(toggleExpandRange(activeDecoration.from, activeDecoration.to, true));
             }
-            cancelPendingScrollToDecoration = scrollToActiveDecoration(view, scrollableDecorations, pluginState.activeIndex);
+            cancelPendingScrollToDecoration = scrollToDecoration(view, scrollableDecorations, pluginState.activeIndex);
           }
         },
         destroy: function destroy() {

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

@@ -35,29 +35,13 @@ function scrollToSelection(node) {
 }
 
 /**
- * Schedules scrolling to the first diff decoration after the next frame.
- * Unlike `scrollToActiveDecoration`, this does not require an active index —
- * it simply scrolls to bring the first decoration into view.
- *
- * The caller must pass the list of scrollable decorations as produced by
- * `getScrollableDecorations`, which is filtered (non-scrollable decorations
- * removed) and sorted by document position. This guarantees "first" means the
- * topmost scrollable diff in the document rather than an arbitrary decoration
- * from the raw `DecorationSet` ordering. This is delegated to
- * `scrollToActiveDecoration` at index 0 so both scroll paths behave identically.
- *
- * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
- */
-export var scrollToFirstDecoration = function scrollToFirstDecoration(view, scrollableDecorations) {
-  return scrollToActiveDecoration(view, scrollableDecorations, 0);
-};
-
-/**
- * Schedules scrolling to the decoration at the given index after the next frame.
+ * Schedules scrolling to the decoration at the given index after the next frame. Defaults to the
+ * first decoration when no index is provided.
  *
  * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
  */
-export var scrollToActiveDecoration = function scrollToActiveDecoration(view, decorations, activeIndex) {
+export var scrollToDecoration = function scrollToDecoration(view, decorations) {
+  var activeIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var decoration = decorations[activeIndex];
   if (!decoration) {
     return function () {};

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

@@ -1,7 +1,2 @@
 import type { TokenEncoder } from 'prosemirror-changeset';
-/**
- * Identical to the library default except that allow-listed node types encode
- * their allow-listed attributes into the open token. Characters and node-end
- * tokens are left as-is, hence the `string | number` token type.
- */
 export declare const attrAwareTokenEncoder: TokenEncoder<string | number>;

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

@@ -0,0 +1,20 @@
+/**
+ * Single source of truth for which attributes of a node type represent a
+ * meaningful change. Shared by `attrAwareTokenEncoder` (changeset detection)
+ * and `getAttrChangeRanges` (decoration rendering) so the two stages agree.
+ */
+export type DiffableAttrsRule = {
+    include: readonly string[];
+} | {
+    exclude: readonly string[];
+};
+export declare const DIFFABLE_ATTRS_BY_NODE_TYPE: Record<string, DiffableAttrsRule>;
+export declare const isDiffableAttr: (nodeTypeName: string, attrName: string) => boolean;
+export declare const getIncludedDiffableAttrs: (nodeTypeName: string) => readonly string[] | undefined;
+export declare const getRequiredIncludedDiffableAttrs: (nodeTypeName: string) => readonly string[];
+/**
+ * Concrete attr names to diff for a node instance, honouring include and exclude
+ * rules; `undefined` when the type has no rule. Exclude rules read the node's
+ * attrs and sort them, since key order isn't stable across the two diffed docs.
+ */
+export declare const getDiffableAttrNames: (nodeTypeName: string, attrs: Record<string, unknown>) => readonly string[] | undefined;

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

@@ -1,22 +1,8 @@
 import type { EditorView, Decoration } from '@atlaskit/editor-prosemirror/view';
 /**
- * Schedules scrolling to the first diff decoration after the next frame.
- * Unlike `scrollToActiveDecoration`, this does not require an active index —
- * it simply scrolls to bring the first decoration into view.
- *
- * The caller must pass the list of scrollable decorations as produced by
- * `getScrollableDecorations`, which is filtered (non-scrollable decorations
- * removed) and sorted by document position. This guarantees "first" means the
- * topmost scrollable diff in the document rather than an arbitrary decoration
- * from the raw `DecorationSet` ordering. This is delegated to
- * `scrollToActiveDecoration` at index 0 so both scroll paths behave identically.
- *
- * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
- */
-export declare const scrollToFirstDecoration: (view: EditorView, scrollableDecorations: Decoration[]) => (() => void);
-/**
- * Schedules scrolling to the decoration at the given index after the next frame.
+ * Schedules scrolling to the decoration at the given index after the next frame. Defaults to the
+ * first decoration when no index is provided.
  *
  * @returns A function that cancels the scheduled `requestAnimationFrame` if it has not run yet.
  */
-export declare const scrollToActiveDecoration: (view: EditorView, decorations: Decoration[], activeIndex: number) => (() => void);
+export declare const scrollToDecoration: (view: EditorView, decorations: Decoration[], activeIndex?: number) => (() => void);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "13.0.6",
+	"version": "13.0.8",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -27,7 +27,7 @@
 		"@atlaskit/editor-prosemirror": "^8.0.0",
 		"@atlaskit/editor-tables": "^3.0.0",
 		"@atlaskit/platform-feature-flags": "^2.1.0",
-		"@atlaskit/tmp-editor-statsig": "^148.1.0",
+		"@atlaskit/tmp-editor-statsig": "^149.0.0",
 		"@atlaskit/tokens": "^16.7.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^1.0.2",
@@ -37,10 +37,10 @@
 	},
 	"devDependencies": {
 		"@atlaskit/adf-utils": "^20.6.0",
-		"@atlaskit/button": "^25.0.0",
+		"@atlaskit/button": "^25.1.0",
 		"@atlaskit/css": "^1.0.0",
 		"@atlaskit/dropdown-menu": "^18.0.0",
-		"@atlaskit/editor-core": "^224.0.0",
+		"@atlaskit/editor-core": "^224.1.0",
 		"@atlaskit/editor-json-transformer": "^9.4.0",
 		"@atlaskit/form": "^17.0.0",
 		"@atlaskit/primitives": "^22.2.0",
@@ -53,7 +53,7 @@
 		"react-intl": "^7.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^119.6.0",
+		"@atlaskit/editor-common": "^119.8.0",
 		"react": "^18.2.0 || ^19.2.0"
 	},
 	"techstack": {