@atlaskit/editor-plugin-synced-block 10.5.0 → 10.6.1

package/AGENTS.md

@@ -98,8 +98,8 @@ Behind the `editor_synced_block_perf` experiment, `main.ts`:
 2. Calls `editor-commands/createSyncedBlock` → inserts `bodiedSyncBlock` node into document (marked
    as **pending creation** — it is not persisted yet)
 3. `pm-plugins/main.ts` detects new node → `handle-bodied-sync-block-creation.ts` updates
-   `sourceManager` state. Persistence happens later when the product layer calls `flush()`
-   (via `flushBodiedSyncBlocks`), which creates the block in the Block Service and then reconciles
+   `sourceManager` state. Persistence happens later when the product layer calls `flush()` (via
+   `flushBodiedSyncBlocks`), which creates the block in the Block Service and then reconciles
    identifiers via `commitPendingCreation()`
 4. `menu-and-toolbar-experiences.ts` fires the experience event
 

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @atlaskit/editor-plugin-synced-block
 
+## 10.6.1
+
+### Patch Changes
+
+- Updated dependencies
+
+## 10.6.0
+
+### Minor Changes
+
+- [`564443b22eeeb`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/564443b22eeeb) -
+  Fix source synced block unsync deleting the entire block and its content instead of unwrapping it
+  when the cursor is inside the block (behind `platform_editor_blocks_patch_6`).
+
+  This release also adds a new `./types` subpath export so consumers can import the `SyncBlockAttrs`
+  type without reaching into the package internals:
+
+  ```ts
+  import type { SyncBlockAttrs } from '@atlaskit/editor-plugin-synced-block/types';
+  ```
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 10.5.0
 
 ### Minor Changes

package/dist/cjs/editor-commands/index.js

@@ -379,6 +379,12 @@ var unsync = exports.unsync = function unsync(storeManager, isBodiedSyncBlock, v
     return false;
   }
   if (isBodiedSyncBlock) {
+    // Signal the unsync intent. This transaction is intercepted by the plugin's
+    // filterTransaction, which shows the deletion-confirmation modal and, on confirm,
+    // recomputes the actual document change from the live document keyed off the
+    // `deletionReason: 'source-block-unsynced'` meta (see handleBodiedSyncBlockRemoval /
+    // recomputeUnsyncTransaction). The real unwrap-vs-delete decision therefore lives in the
+    // confirm path, not here (EDITOR-8230).
     var content = syncBlock === null || syncBlock === void 0 ? void 0 : syncBlock.node.content;
     var tr = state.tr;
     tr.replaceWith(syncBlock.pos, syncBlock.pos + syncBlock.node.nodeSize, content).setMeta('deletionReason', 'source-block-unsynced');

package/dist/cjs/pm-plugins/utils/handle-bodied-sync-block-removal.js

@@ -56,7 +56,15 @@ var handleBodiedSyncBlockRemoval = exports.handleBodiedSyncBlockRemoval = functi
       // "Invalid content for node bodiedSyncBlock: <>". See EDITOR-7889.
       api === null || api === void 0 || (_api$core2 = api.core) === null || _api$core2 === void 0 || _api$core2.actions.execute(function (_ref2) {
         var tr = _ref2.tr;
-        var recomputedTr = (0, _recomputeDeleteTransaction.recomputeDeleteTransaction)(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(function (node) {
+        // EDITOR-8230: unsync must remove only the sync wrapper and keep the block's
+        // content inline, whereas delete removes the whole block. Before this branch,
+        // the confirm path always recomputed a full delete, so unsyncing a source block
+        // silently deleted its content. When the deletion was actually triggered by
+        // unsync, recompute an unwrap (replaceWith content) instead of a delete.
+        var isUnsync = (0, _platformFeatureFlags.fg)('platform_editor_blocks_patch_6') && deletionReason === 'source-block-unsynced';
+        var recomputedTr = isUnsync ? (0, _recomputeDeleteTransaction.recomputeUnsyncTransaction)(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(function (node) {
+          return node.attrs;
+        })) : (0, _recomputeDeleteTransaction.recomputeDeleteTransaction)(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(function (node) {
           return node.attrs;
         }));
 

package/dist/cjs/pm-plugins/utils/recompute-delete-transaction.js

@@ -3,7 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.recomputeDeleteTransaction = void 0;
+exports.recomputeUnsyncTransaction = exports.recomputeDeleteTransaction = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /**
  * Whether `node` is the source block requested by `wanted`.
  *
@@ -95,4 +99,65 @@ var recomputeDeleteTransaction = exports.recomputeDeleteTransaction = function r
     tr.delete(pos, pos + node.nodeSize);
   });
   return tr;
+};
+
+/**
+ * Recompute a source `bodiedSyncBlock` *unsync* from the live document.
+ *
+ * Unsync differs from delete: the sync wrapper must be removed while its content
+ * is preserved inline in the document. Instead of `tr.delete(pos, pos +
+ * nodeSize)` (which drops the content too — EDITOR-8230), this replaces each
+ * matched source block with its own content.
+ *
+ * The replacement uses a raw `tr.replace(pos, pos + nodeSize, new Slice(content,
+ * 0, 0))` — an explicit zero-open slice inserted verbatim — rather than
+ * `tr.replaceWith(...)`. `replaceWith` routes through ProseMirror's
+ * `replaceRange`, whose range-fitting heuristics can collapse or drop a trailing
+ * block (e.g. the block's final panel/empty paragraph) when the unwrapped
+ * content meets a document boundary, silently losing content (EDITOR-8230). A
+ * zero-open `replace` drops the wrapper's own open ends while keeping every child
+ * of the fragment as its own top-level node.
+ *
+ * Like `recomputeDeleteTransaction`, targets are located in the *current*
+ * document (`tr.doc`) so the operation is robust to intervening local edits and
+ * remote collab changes while the confirmation modal is open, and it handles
+ * partial matches gracefully (missing blocks are skipped).
+ *
+ * Replacements are applied in reverse document order so earlier replacements do
+ * not invalidate the positions of later ones.
+ *
+ * @returns the mutated transaction when at least one target node was found and
+ * unwrapped, otherwise `undefined` when none of the targets exist any more.
+ */
+var recomputeUnsyncTransaction = exports.recomputeUnsyncTransaction = function recomputeUnsyncTransaction(tr, isSourceBlock, syncBlockIds) {
+  var matches = findSourceBlocks(tr, isSourceBlock, syncBlockIds);
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  // Unwrap in reverse document order so positions remain valid across edits.
+  // Use a raw zero-open Slice replace (not `replaceWith`) so the block's content
+  // is inserted verbatim as top-level nodes without ProseMirror's replaceRange
+  // heuristics collapsing a trailing block (EDITOR-8230).
+  var orderedMatches = matches.sort(function (a, b) {
+    return b.pos - a.pos;
+  });
+  var _iterator = _createForOfIteratorHelper(orderedMatches),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+        node = _step$value.node,
+        pos = _step$value.pos;
+      // This is ProseMirror's Transaction.replace (a document edit), not String.replace — the
+      // perf rule misfires on the method name, and there is nothing to hoist.
+      // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace
+      tr.replace(pos, pos + node.nodeSize, new _model.Slice(node.content, 0, 0));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return tr;
 };

package/dist/es2019/editor-commands/index.js

@@ -381,6 +381,12 @@ export const unsync = (storeManager, isBodiedSyncBlock, view) => {
     return false;
   }
   if (isBodiedSyncBlock) {
+    // Signal the unsync intent. This transaction is intercepted by the plugin's
+    // filterTransaction, which shows the deletion-confirmation modal and, on confirm,
+    // recomputes the actual document change from the live document keyed off the
+    // `deletionReason: 'source-block-unsynced'` meta (see handleBodiedSyncBlockRemoval /
+    // recomputeUnsyncTransaction). The real unwrap-vs-delete decision therefore lives in the
+    // confirm path, not here (EDITOR-8230).
     const content = syncBlock === null || syncBlock === void 0 ? void 0 : syncBlock.node.content;
     const {
       tr

package/dist/es2019/pm-plugins/utils/handle-bodied-sync-block-removal.js

@@ -2,7 +2,7 @@ import { pmHistoryPluginKey } from '@atlaskit/editor-common/utils';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { FLAG_ID } from '../../types';
 import { syncedBlockPluginKey } from '../main';
-import { recomputeDeleteTransaction } from './recompute-delete-transaction';
+import { recomputeDeleteTransaction, recomputeUnsyncTransaction } from './recompute-delete-transaction';
 const onRetry = (api, syncBlockStore) => () => {
   var _api$core;
   api === null || api === void 0 ? void 0 : (_api$core = api.core) === null || _api$core === void 0 ? void 0 : _api$core.actions.execute(({
@@ -42,7 +42,13 @@ export const handleBodiedSyncBlockRemoval = (bodiedSyncBlockRemoved, syncBlockSt
       api === null || api === void 0 ? void 0 : (_api$core2 = api.core) === null || _api$core2 === void 0 ? void 0 : _api$core2.actions.execute(({
         tr
       }) => {
-        const recomputedTr = recomputeDeleteTransaction(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(node => node.attrs));
+        // EDITOR-8230: unsync must remove only the sync wrapper and keep the block's
+        // content inline, whereas delete removes the whole block. Before this branch,
+        // the confirm path always recomputed a full delete, so unsyncing a source block
+        // silently deleted its content. When the deletion was actually triggered by
+        // unsync, recompute an unwrap (replaceWith content) instead of a delete.
+        const isUnsync = fg('platform_editor_blocks_patch_6') && deletionReason === 'source-block-unsynced';
+        const recomputedTr = isUnsync ? recomputeUnsyncTransaction(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(node => node.attrs)) : recomputeDeleteTransaction(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(node => node.attrs));
 
         // The target node(s) no longer exist in the live document (e.g.
         // a remote collaborator already removed them). There is nothing

package/dist/es2019/pm-plugins/utils/recompute-delete-transaction.js

@@ -1,3 +1,4 @@
+import { Slice } from '@atlaskit/editor-prosemirror/model';
 /**
  * Whether `node` is the source block requested by `wanted`.
  *
@@ -87,4 +88,55 @@ export const recomputeDeleteTransaction = (tr, isSourceBlock, syncBlockIds) => {
     tr.delete(pos, pos + node.nodeSize);
   });
   return tr;
+};
+
+/**
+ * Recompute a source `bodiedSyncBlock` *unsync* from the live document.
+ *
+ * Unsync differs from delete: the sync wrapper must be removed while its content
+ * is preserved inline in the document. Instead of `tr.delete(pos, pos +
+ * nodeSize)` (which drops the content too — EDITOR-8230), this replaces each
+ * matched source block with its own content.
+ *
+ * The replacement uses a raw `tr.replace(pos, pos + nodeSize, new Slice(content,
+ * 0, 0))` — an explicit zero-open slice inserted verbatim — rather than
+ * `tr.replaceWith(...)`. `replaceWith` routes through ProseMirror's
+ * `replaceRange`, whose range-fitting heuristics can collapse or drop a trailing
+ * block (e.g. the block's final panel/empty paragraph) when the unwrapped
+ * content meets a document boundary, silently losing content (EDITOR-8230). A
+ * zero-open `replace` drops the wrapper's own open ends while keeping every child
+ * of the fragment as its own top-level node.
+ *
+ * Like `recomputeDeleteTransaction`, targets are located in the *current*
+ * document (`tr.doc`) so the operation is robust to intervening local edits and
+ * remote collab changes while the confirmation modal is open, and it handles
+ * partial matches gracefully (missing blocks are skipped).
+ *
+ * Replacements are applied in reverse document order so earlier replacements do
+ * not invalidate the positions of later ones.
+ *
+ * @returns the mutated transaction when at least one target node was found and
+ * unwrapped, otherwise `undefined` when none of the targets exist any more.
+ */
+export const recomputeUnsyncTransaction = (tr, isSourceBlock, syncBlockIds) => {
+  const matches = findSourceBlocks(tr, isSourceBlock, syncBlockIds);
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  // Unwrap in reverse document order so positions remain valid across edits.
+  // Use a raw zero-open Slice replace (not `replaceWith`) so the block's content
+  // is inserted verbatim as top-level nodes without ProseMirror's replaceRange
+  // heuristics collapsing a trailing block (EDITOR-8230).
+  const orderedMatches = matches.sort((a, b) => b.pos - a.pos);
+  for (const {
+    node,
+    pos
+  } of orderedMatches) {
+    // This is ProseMirror's Transaction.replace (a document edit), not String.replace — the
+    // perf rule misfires on the method name, and there is nothing to hoist.
+    // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace
+    tr.replace(pos, pos + node.nodeSize, new Slice(node.content, 0, 0));
+  }
+  return tr;
 };

package/dist/esm/editor-commands/index.js

@@ -372,6 +372,12 @@ export var unsync = function unsync(storeManager, isBodiedSyncBlock, view) {
     return false;
   }
   if (isBodiedSyncBlock) {
+    // Signal the unsync intent. This transaction is intercepted by the plugin's
+    // filterTransaction, which shows the deletion-confirmation modal and, on confirm,
+    // recomputes the actual document change from the live document keyed off the
+    // `deletionReason: 'source-block-unsynced'` meta (see handleBodiedSyncBlockRemoval /
+    // recomputeUnsyncTransaction). The real unwrap-vs-delete decision therefore lives in the
+    // confirm path, not here (EDITOR-8230).
     var content = syncBlock === null || syncBlock === void 0 ? void 0 : syncBlock.node.content;
     var tr = state.tr;
     tr.replaceWith(syncBlock.pos, syncBlock.pos + syncBlock.node.nodeSize, content).setMeta('deletionReason', 'source-block-unsynced');

package/dist/esm/pm-plugins/utils/handle-bodied-sync-block-removal.js

@@ -5,7 +5,7 @@ import { pmHistoryPluginKey } from '@atlaskit/editor-common/utils';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { FLAG_ID } from '../../types';
 import { syncedBlockPluginKey } from '../main';
-import { recomputeDeleteTransaction } from './recompute-delete-transaction';
+import { recomputeDeleteTransaction, recomputeUnsyncTransaction } from './recompute-delete-transaction';
 var onRetry = function onRetry(api, syncBlockStore) {
   return function () {
     var _api$core;
@@ -49,7 +49,15 @@ export var handleBodiedSyncBlockRemoval = function handleBodiedSyncBlockRemoval(
       // "Invalid content for node bodiedSyncBlock: <>". See EDITOR-7889.
       api === null || api === void 0 || (_api$core2 = api.core) === null || _api$core2 === void 0 || _api$core2.actions.execute(function (_ref2) {
         var tr = _ref2.tr;
-        var recomputedTr = recomputeDeleteTransaction(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(function (node) {
+        // EDITOR-8230: unsync must remove only the sync wrapper and keep the block's
+        // content inline, whereas delete removes the whole block. Before this branch,
+        // the confirm path always recomputed a full delete, so unsyncing a source block
+        // silently deleted its content. When the deletion was actually triggered by
+        // unsync, recompute an unwrap (replaceWith content) instead of a delete.
+        var isUnsync = fg('platform_editor_blocks_patch_6') && deletionReason === 'source-block-unsynced';
+        var recomputedTr = isUnsync ? recomputeUnsyncTransaction(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(function (node) {
+          return node.attrs;
+        })) : recomputeDeleteTransaction(tr, syncBlockStore.sourceManager.isSourceBlock, bodiedSyncBlockRemoved.map(function (node) {
           return node.attrs;
         }));
 

package/dist/esm/pm-plugins/utils/recompute-delete-transaction.js

@@ -1,3 +1,7 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { Slice } from '@atlaskit/editor-prosemirror/model';
 /**
  * Whether `node` is the source block requested by `wanted`.
  *
@@ -89,4 +93,65 @@ export var recomputeDeleteTransaction = function recomputeDeleteTransaction(tr,
     tr.delete(pos, pos + node.nodeSize);
   });
   return tr;
+};
+
+/**
+ * Recompute a source `bodiedSyncBlock` *unsync* from the live document.
+ *
+ * Unsync differs from delete: the sync wrapper must be removed while its content
+ * is preserved inline in the document. Instead of `tr.delete(pos, pos +
+ * nodeSize)` (which drops the content too — EDITOR-8230), this replaces each
+ * matched source block with its own content.
+ *
+ * The replacement uses a raw `tr.replace(pos, pos + nodeSize, new Slice(content,
+ * 0, 0))` — an explicit zero-open slice inserted verbatim — rather than
+ * `tr.replaceWith(...)`. `replaceWith` routes through ProseMirror's
+ * `replaceRange`, whose range-fitting heuristics can collapse or drop a trailing
+ * block (e.g. the block's final panel/empty paragraph) when the unwrapped
+ * content meets a document boundary, silently losing content (EDITOR-8230). A
+ * zero-open `replace` drops the wrapper's own open ends while keeping every child
+ * of the fragment as its own top-level node.
+ *
+ * Like `recomputeDeleteTransaction`, targets are located in the *current*
+ * document (`tr.doc`) so the operation is robust to intervening local edits and
+ * remote collab changes while the confirmation modal is open, and it handles
+ * partial matches gracefully (missing blocks are skipped).
+ *
+ * Replacements are applied in reverse document order so earlier replacements do
+ * not invalidate the positions of later ones.
+ *
+ * @returns the mutated transaction when at least one target node was found and
+ * unwrapped, otherwise `undefined` when none of the targets exist any more.
+ */
+export var recomputeUnsyncTransaction = function recomputeUnsyncTransaction(tr, isSourceBlock, syncBlockIds) {
+  var matches = findSourceBlocks(tr, isSourceBlock, syncBlockIds);
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  // Unwrap in reverse document order so positions remain valid across edits.
+  // Use a raw zero-open Slice replace (not `replaceWith`) so the block's content
+  // is inserted verbatim as top-level nodes without ProseMirror's replaceRange
+  // heuristics collapsing a trailing block (EDITOR-8230).
+  var orderedMatches = matches.sort(function (a, b) {
+    return b.pos - a.pos;
+  });
+  var _iterator = _createForOfIteratorHelper(orderedMatches),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+        node = _step$value.node,
+        pos = _step$value.pos;
+      // This is ProseMirror's Transaction.replace (a document edit), not String.replace — the
+      // perf rule misfires on the method name, and there is nothing to hoist.
+      // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace
+      tr.replace(pos, pos + node.nodeSize, new Slice(node.content, 0, 0));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return tr;
 };

package/dist/types/pm-plugins/utils/recompute-delete-transaction.d.ts

@@ -27,3 +27,32 @@ import type { SyncBlockAttrs } from '../../types';
  * collaborator already removed them all — so there is nothing to delete.
  */
 export declare const recomputeDeleteTransaction: (tr: Transaction, isSourceBlock: (node: PMNode) => boolean, syncBlockIds: SyncBlockAttrs[]) => Transaction | undefined;
+/**
+ * Recompute a source `bodiedSyncBlock` *unsync* from the live document.
+ *
+ * Unsync differs from delete: the sync wrapper must be removed while its content
+ * is preserved inline in the document. Instead of `tr.delete(pos, pos +
+ * nodeSize)` (which drops the content too — EDITOR-8230), this replaces each
+ * matched source block with its own content.
+ *
+ * The replacement uses a raw `tr.replace(pos, pos + nodeSize, new Slice(content,
+ * 0, 0))` — an explicit zero-open slice inserted verbatim — rather than
+ * `tr.replaceWith(...)`. `replaceWith` routes through ProseMirror's
+ * `replaceRange`, whose range-fitting heuristics can collapse or drop a trailing
+ * block (e.g. the block's final panel/empty paragraph) when the unwrapped
+ * content meets a document boundary, silently losing content (EDITOR-8230). A
+ * zero-open `replace` drops the wrapper's own open ends while keeping every child
+ * of the fragment as its own top-level node.
+ *
+ * Like `recomputeDeleteTransaction`, targets are located in the *current*
+ * document (`tr.doc`) so the operation is robust to intervening local edits and
+ * remote collab changes while the confirmation modal is open, and it handles
+ * partial matches gracefully (missing blocks are skipped).
+ *
+ * Replacements are applied in reverse document order so earlier replacements do
+ * not invalidate the positions of later ones.
+ *
+ * @returns the mutated transaction when at least one target node was found and
+ * unwrapped, otherwise `undefined` when none of the targets exist any more.
+ */
+export declare const recomputeUnsyncTransaction: (tr: Transaction, isSourceBlock: (node: PMNode) => boolean, syncBlockIds: SyncBlockAttrs[]) => Transaction | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-synced-block",
-	"version": "10.5.0",
+	"version": "10.6.1",
 	"description": "SyncedBlock plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -21,7 +21,7 @@
 	"atlaskit:src": "src/index.ts",
 	"dependencies": {
 		"@atlaskit/adf-schema": "^56.1.0",
-		"@atlaskit/button": "24.3.7",
+		"@atlaskit/button": "24.3.8",
 		"@atlaskit/dropdown-menu": "17.2.0",
 		"@atlaskit/editor-json-transformer": "^9.1.0",
 		"@atlaskit/editor-plugin-analytics": "^12.0.0",
@@ -46,9 +46,9 @@
 		"@atlaskit/platform-feature-flags": "^2.1.0",
 		"@atlaskit/primitives": "^22.2.0",
 		"@atlaskit/spinner": "20.1.1",
-		"@atlaskit/tmp-editor-statsig": "^135.3.0",
+		"@atlaskit/tmp-editor-statsig": "^135.6.0",
 		"@atlaskit/tokens": "16.3.0",
-		"@atlaskit/tooltip": "^23.2.0",
+		"@atlaskit/tooltip": "^24.0.0",
 		"@atlaskit/visually-hidden": "^4.2.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^1.0.0",
@@ -110,6 +110,9 @@
 		"platform_editor_blocks_patch_4": {
 			"type": "boolean"
 		},
+		"platform_editor_blocks_patch_6": {
+			"type": "boolean"
+		},
 		"platform_synced_block_patch_13": {
 			"type": "boolean"
 		},

package/types/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@atlaskit/editor-plugin-synced-block/types",
+  "main": "../dist/cjs/types/index.js",
+  "module": "../dist/esm/types/index.js",
+  "module:es2019": "../dist/es2019/types/index.js",
+  "sideEffects": false,
+  "types": "../dist/types/types/index.d.ts"
+}