@atlaskit/editor-plugin-collab-edit 23.0.0 → 23.0.1

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @atlaskit/editor-plugin-collab-edit
 
+## 23.0.1
+
+### Patch Changes
+
+- [`5b30c74e8080f`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/5b30c74e8080f) -
+  Compose the intermediate steps of an AI streaming response into a single collab step, so a
+  streamed edit costs the collab service roughly one step per block instead of one per chunk.
+
+  Each streaming frame replaces the whole AI region with the cumulative content so far, so the
+  frames are individually large and grow as the response does. They are also thrown away at the end
+  — `buildCommitTransaction` rebuilds the final document from the response rather than from what was
+  streamed — which is what makes composing them safe.
+
+  `mergeOverlappingSteps` merges two consecutive overlapping steps into the single step they are
+  collectively equivalent to, and `collapseStreamingSteps` folds it across the steps in the collab
+  unconfirmed queue. Composition is exact in both directions: the forward step is verified against
+  the document, and the inverse is composed alongside it because `rebaseSteps` applies inverses to
+  the live document whenever a remote step arrives.
+
+  Composing only helps while the steps are still unsent, because `lockStepOrigins` marks everything
+  a flush sends and a locked step can never be merged. `createCollabSendHold` therefore holds the
+  send back across transactions — not per transaction, since acks, remote steps and the user's own
+  typing all trigger sends that would otherwise lock the queue. Producers drive it with the
+  `DEFER_COLLAB_SEND` meta: `true` starts the hold, `false` releases it, anything else leaves it
+  untouched. `true` does not extend a hold already in progress, so a continuous stream of held
+  frames still reaches the bound.
+
+  `editor-common` gains two new entrypoints for the metadata keys shared between the producer and
+  the collab layer: `./collab-streaming-step-collapse` and `./collab-defer-collab-send`. The changes
+  in `editor-plugin-collab-edit` and `editor-plugin-ai` are internal — neither package's exports map
+  changes.
+
+  While the send is held nothing is sent, including the user's own edits, up to the hold's time
+  bound. `sendableSteps` returns the queue in version order, so a later step cannot be sent ahead of
+  held ones. Peers also do not see in-progress content until a flush, and content in a held queue
+  exists only on the client until then.
+
+  All of this is behind the `platform_editor_ai_collapse_streaming_steps` feature gate. With the
+  gate off, streaming frames are not stamped, the send is never held, and the unconfirmed queue is
+  left exactly as it is today.
+
+- [`5f61320693517`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/5f61320693517) -
+  Clean up experiment `platform_editor_remove_collab_step_metrics`
+- Updated dependencies
+
 ## 23.0.0
 
 ### Patch Changes

package/dist/cjs/collabEditPlugin.js

@@ -15,8 +15,9 @@ var _JSONTransformer = require("@atlaskit/editor-json-transformer/JSONTransforme
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _prosemirrorCollab = require("@atlaskit/prosemirror-collab");
-var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _analytics2 = require("./pm-plugins/analytics");
+var _collabSendHold = require("./pm-plugins/collabSendHold");
+var _collapseStreamingSteps = require("./pm-plugins/collapseStreamingSteps");
 var _sendTransaction = require("./pm-plugins/events/send-transaction");
 var _filterAnalytics = require("./pm-plugins/filterAnalytics");
 var _main = require("./pm-plugins/main");
@@ -28,7 +29,6 @@ var _trackAndFilterSpammingSteps = require("./pm-plugins/track-and-filter-spammi
 var _trackLastOrganicChange = require("./pm-plugins/track-last-organic-change");
 var _trackNcsInitialization = require("./pm-plugins/track-ncs-initialization");
 var _trackReconnectionConflict = require("./pm-plugins/track-reconnection-conflict");
-var _trackSteps = require("./pm-plugins/track-steps");
 var _utils2 = require("./pm-plugins/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; }
@@ -114,6 +114,9 @@ var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref
     providerResolver = _providerResolver;
   });
   var executeProviderCode = providerBuilder(collabEditProviderPromise);
+  // Spans transactions: a streaming producer holds the flush across many state updates, not just
+  // the ones it dispatches itself. See `createCollabSendHold`.
+  var sendHold = (0, _collabSendHold.createCollabSendHold)();
   return {
     name: 'collabEdit',
     getSharedState: function getSharedState(state) {
@@ -205,7 +208,10 @@ var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref
         _ref5$userId = _ref5.userId,
         userId = _ref5$userId === void 0 ? null : _ref5$userId;
       var transformUnconfirmed = function transformUnconfirmed(steps) {
-        var transformed = (0, _filterAnalytics.filterAnalyticsSteps)(steps);
+        // Analytics steps are filtered first so they cannot break up an otherwise adjacent
+        // run of streaming frames.
+        var filtered = (0, _filterAnalytics.filterAnalyticsSteps)(steps);
+        var transformed = (0, _fg.fg)('platform_editor_ai_collapse_streaming_steps') ? (0, _collapseStreamingSteps.collapseStreamingSteps)(filtered) : filtered;
         return (0, _mergeUnconfirmed.mergeUnconfirmedSteps)(transformed, api);
       };
       var plugins = [].concat((0, _toConsumableArray2.default)(useNativePlugin ? [{
@@ -265,6 +271,18 @@ var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref
     },
     onEditorViewStateUpdated: function onEditorViewStateUpdated(props) {
       var _api$analytics2, _api$editorViewMode, _options$useNativePlu, _options$hideTelecurs;
+      // `props.transactions` is what `applyTransaction` produced: the dispatched transaction
+      // followed by everything `appendTransaction` added. Streaming frames are built in an
+      // appendTransaction, so their hold metadata is never on `originalTransaction`.
+      // Evaluated once and used for both the observation and the send decision. If the gate
+      // is turned off mid-stream, an already-active hold must stop applying immediately
+      // rather than persisting until the backstop expires and blocking every send.
+      var collapseStreamingStepsEnabled = (0, _fg.fg)('platform_editor_ai_collapse_streaming_steps');
+      if (collapseStreamingStepsEnabled) {
+        props.transactions.forEach(function (transaction) {
+          return sendHold.observe(transaction);
+        });
+      }
       var addErrorAnalytics = (0, _analytics2.addSynchronyErrorAnalytics)(props.newEditorState, props.newEditorState.tr, featureFlags, api === null || api === void 0 || (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions);
       var isEmptyDoc = (0, _utils.isEmptyDocument)(props.newEditorState.doc);
       var viewMode = api === null || api === void 0 || (_api$editorViewMode = api.editorViewMode) === null || _api$editorViewMode === void 0 || (_api$editorViewMode = _api$editorViewMode.sharedState.currentState()) === null || _api$editorViewMode === void 0 ? void 0 : _api$editorViewMode.mode;
@@ -275,32 +293,16 @@ var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref
         newEditorState: props.newEditorState,
         useNativePlugin: (_options$useNativePlu = options.useNativePlugin) !== null && _options$useNativePlu !== void 0 ? _options$useNativePlu : false,
         hideTelecursorOnLoad: !isEmptyDoc && ((_options$hideTelecurs = options.hideTelecursorOnLoad) !== null && _options$hideTelecurs !== void 0 ? _options$hideTelecurs : false),
-        viewMode: viewMode
+        viewMode: viewMode,
+        isSendHeld: collapseStreamingStepsEnabled && sendHold.isHeld()
       }), addErrorAnalytics);
-      if (!(0, _expValEquals.expValEquals)('platform_editor_remove_collab_step_metrics', 'isEnabled', true)) {
-        (0, _trackSteps.track)(_objectSpread(_objectSpread({
-          api: api
-        }, props), {}, {
-          onTrackDataProcessed: function onTrackDataProcessed(steps) {
-            var _api$analytics3;
-            api === null || api === void 0 || (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 || (_api$analytics3 = _api$analytics3.actions) === null || _api$analytics3 === void 0 || _api$analytics3.fireAnalyticsEvent({
-              action: _analytics.ACTION.STEPS_TRACKED,
-              actionSubject: _analytics.ACTION_SUBJECT.COLLAB,
-              attributes: {
-                steps: steps
-              },
-              eventType: _analytics.EVENT_TYPE.OPERATIONAL
-            });
-          }
-        }));
-      }
       if ((0, _fg.fg)('platform_editor_collab_organic_change_reporting')) {
         (0, _monitorOrganicChanges.monitorOrganic)(_objectSpread(_objectSpread({
           api: api
         }, props), {}, {
           onDataProcessed: function onDataProcessed(data) {
-            var _api$analytics4;
-            api === null || api === void 0 || (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 || (_api$analytics4 = _api$analytics4.actions) === null || _api$analytics4 === void 0 || _api$analytics4.fireAnalyticsEvent({
+            var _api$analytics3;
+            api === null || api === void 0 || (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 || (_api$analytics3 = _api$analytics3.actions) === null || _api$analytics3 === void 0 || _api$analytics3.fireAnalyticsEvent({
               action: _analytics.ACTION.ORGANIC_CHANGES_TRACKED,
               actionSubject: _analytics.ACTION_SUBJECT.COLLAB,
               attributes: {

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCollabSendHold = exports.MAX_SEND_HOLD_MS = void 0;
+var _collabDeferCollabSend = require("@atlaskit/editor-common/collab-defer-collab-send");
+/**
+ * Upper bound on how long the send may stay held, measured from the transaction that *started* the
+ * hold rather than the most recent one.
+ *
+ * This is the only time bound on the hold. Producers decide when to release on semantic grounds —
+ * a completed block, the end of a stream — and this bounds how long that can take. It therefore
+ * doubles as the guarantee that a producer which never releases, because it aborted or threw
+ * between hold and release, cannot stop the editor sending for the rest of the session.
+ */
+var MAX_SEND_HOLD_MS = exports.MAX_SEND_HOLD_MS = 2000;
+/**
+ * Tracks whether sending to the collab service is currently held back.
+ *
+ * A producer that streams into the document needs several of its transactions to accumulate in the
+ * unconfirmed queue before anything is sent, so they can be composed into one step. Marking only
+ * the producer's own transactions is not enough: `sendTransaction` runs for *every* state update,
+ * and `provider.send` flushes and locks the entire queue regardless of which transaction triggered
+ * it. Acknowledgements from previous commits, remote steps, selection changes and the user's own
+ * typing all trigger it.
+ *
+ * So the hold has to be a state that spans transactions rather than a flag on one:
+ *
+ * - `tr.setMeta(DEFER_COLLAB_SEND, true)` starts the hold, and does *not* extend one already in
+ *   progress
+ * - `tr.setMeta(DEFER_COLLAB_SEND, false)` releases it
+ * - anything else leaves it as it is
+ *
+ * Not extending matters. A producer marks every frame it wants held, so re-arming on each one
+ * would push the deadline back indefinitely and the bound would never be reached during an active
+ * stream. Measuring from the first held transaction instead makes the hold flush at least every
+ * {@link MAX_SEND_HOLD_MS}, with the next held frame starting a fresh window.
+ *
+ * While held, nothing is sent. Note this includes the local user's own edits: `sendableSteps`
+ * returns the queue in version order, so there is no way to send a step that sits behind held
+ * steps. Producers should keep hold windows short for that reason.
+ */
+var createCollabSendHold = exports.createCollabSendHold = function createCollabSendHold() {
+  var heldSince;
+  return {
+    observe: function observe(transaction) {
+      var now = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Date.now();
+      var meta = transaction.getMeta(_collabDeferCollabSend.DEFER_COLLAB_SEND);
+      if (meta === true) {
+        // Only start a window, never extend one, so a continuous stream of held frames
+        // still reaches the bound. See the note on this type about why.
+        if (heldSince === undefined) {
+          heldSince = now;
+        }
+        return;
+      }
+      if (meta === false) {
+        heldSince = undefined;
+      }
+    },
+    isHeld: function isHeld() {
+      var now = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Date.now();
+      if (heldSince === undefined) {
+        return false;
+      }
+      if (now - heldSince >= MAX_SEND_HOLD_MS) {
+        // Clear as well as report, so the next held frame opens a fresh window instead of
+        // being judged against the expired one.
+        heldSince = undefined;
+        return false;
+      }
+      return true;
+    }
+  };
+};

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

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collapseStreamingSteps = collapseStreamingSteps;
+var _collabStreamingStepCollapse = require("@atlaskit/editor-common/collab-streaming-step-collapse");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _prosemirrorCollab = require("@atlaskit/prosemirror-collab");
+var _mergeOverlappingSteps = require("./mergeOverlappingSteps");
+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; }
+/**
+ * Is this step an intermediate frame that its producer has marked as collapsible, and is it still
+ * free to be composed?
+ */
+var isCollapsibleFrame = function isCollapsibleFrame(rebaseable) {
+  var origin = rebaseable.origin;
+  if (!(origin instanceof _state.Transaction) || origin.getMeta(_collabStreamingStepCollapse.STREAMING_COLLAPSIBLE_STEPS) !== true) {
+    return false;
+  }
+
+  // Already sent to (or queued for) the collab service — composing it now would change a step the
+  // backend has already seen. Mirrors the `mergeIsLocked` contract in `mergeUnconfirmedSteps`.
+  return !origin.getMeta('mergeIsLocked');
+};
+
+/**
+ * Starting document of each composed step this module has produced.
+ *
+ * A composed step is synthesised rather than taken from a transaction, so it cannot be found in
+ * `origin.steps` and its starting document cannot be recovered the way an original frame's can.
+ * `transformUnconfirmed` runs once per transaction and is handed back the steps it returned last
+ * time, so the composed step needs to carry its document forward to keep composing against later
+ * frames.
+ *
+ * Keyed on the step rather than its Rebaseable wrapper. `mergeUnconfirmedSteps` runs immediately
+ * after this module in `transformUnconfirmed` and rebuilds every wrapper it is given — merging
+ * enabled or not — so a wrapper-keyed entry would be unreachable by the very next pass. The step
+ * survives that rebuild untouched, and is still replaced whenever the association genuinely
+ * becomes stale: `rebaseSteps` maps steps into new objects, and a real merge composes a new one.
+ */
+var composedStepDocs = new WeakMap();
+
+/**
+ * The document this step was applied to.
+ *
+ * `transformUnconfirmed` is handed steps and nothing else, but a Rebaseable keeps a reference to
+ * the transaction that produced it, and a transaction records the document before each of its
+ * steps. That is enough for `mergeOverlappingSteps` to resolve merges it cannot derive from the
+ * steps alone — notably a frame that replaces more than just what the previous frame inserted.
+ *
+ * Rebasing maps a step into a new object while keeping the original transaction, so a rebased step
+ * is not found in `origin.steps` and correctly yields no document. `mergeOverlappingSteps` then
+ * falls back to the merges it can prove without one.
+ */
+var docBeforeStep = function docBeforeStep(rebaseable) {
+  var origin = rebaseable.origin,
+    step = rebaseable.step;
+  var composed = composedStepDocs.get(step);
+  if (composed) {
+    return composed;
+  }
+  var index = origin.steps.indexOf(step);
+  return index >= 0 ? origin.docs[index] : undefined;
+};
+
+/**
+ * Compose adjacent streaming frames in the unconfirmed queue so the collab service receives one
+ * step per flush instead of one step per rendered chunk.
+ *
+ * This runs in the collab plugin's `transformUnconfirmed` hook, which fires *after* each frame has
+ * already been applied to the document. Collapsing therefore has no effect on what the local user
+ * sees, on undo history, or on any other plugin state — it only changes what is sent to the collab
+ * service, and what is used as the rebase buffer when remote steps arrive.
+ *
+ * Because the unconfirmed steps double as the rebase buffer (`rebaseSteps` applies their inverses
+ * to the live document), the composition must be exact. `mergeOverlappingSteps` only returns a
+ * merge it can prove exact, and this function degrades to a no-op whenever it declines.
+ *
+ * @param steps Rebaseable steps
+ * @returns Rebaseable steps, with adjacent streaming frames composed
+ */
+function collapseStreamingSteps(steps) {
+  // Fast path: nothing to do unless at least two frames could possibly compose.
+  if (steps.length < 2) {
+    return steps;
+  }
+  var collapsed = [];
+  // The document the run currently at the tail of `collapsed` started from. A composed step
+  // still applies to the document its first frame applied to, so this survives each merge.
+  var runDocBefore;
+  var _iterator = _createForOfIteratorHelper(steps),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var rebaseable = _step.value;
+      var previous = collapsed[collapsed.length - 1];
+      if (!previous || !isCollapsibleFrame(previous) || !isCollapsibleFrame(rebaseable)) {
+        collapsed.push(rebaseable);
+        runDocBefore = docBeforeStep(rebaseable);
+        continue;
+      }
+      var merged = (0, _mergeOverlappingSteps.mergeOverlappingSteps)(previous, rebaseable, runDocBefore);
+      if (!merged) {
+        collapsed.push(rebaseable);
+        runDocBefore = docBeforeStep(rebaseable);
+        continue;
+      }
+
+      // Keep the earliest origin, matching `mergeUnconfirmedSteps`. `commitUnconfirmedSteps` in
+      // the collab provider tracks completion by origin identity, so keeping the earliest means
+      // the composed step is not considered confirmed until the whole run has been acknowledged.
+      var composed = new _prosemirrorCollab.Rebaseable(merged.step, merged.inverted, previous.origin);
+      if (runDocBefore) {
+        composedStepDocs.set(composed.step, runDocBefore);
+      }
+      collapsed[collapsed.length - 1] = composed;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return collapsed;
+}

package/dist/cjs/pm-plugins/events/send-transaction.js

@@ -14,7 +14,9 @@ var sendTransaction = exports.sendTransaction = function sendTransaction(_ref) {
     newEditorState = _ref.newEditorState,
     useNativePlugin = _ref.useNativePlugin,
     viewMode = _ref.viewMode,
-    hideTelecursorOnLoad = _ref.hideTelecursorOnLoad;
+    hideTelecursorOnLoad = _ref.hideTelecursorOnLoad,
+    _ref$isSendHeld = _ref.isSendHeld,
+    isSendHeld = _ref$isSendHeld === void 0 ? false : _ref$isSendHeld;
   return function (provider) {
     var docChangedTransaction = transactions.find(function (tr) {
       return tr.docChanged;
@@ -33,7 +35,16 @@ var sendTransaction = exports.sendTransaction = function sendTransaction(_ref) {
     // TODO: ED-8995 - We need to do this check to reduce the number of race conditions when working with tables.
     // This metadata is coming from the scaleTable command in table-resizing plugin
     !originalTransaction.getMeta('scaleTable') && trNoAnalytics.docChanged;
-    if (useNativePlugin || shouldSendStepForSynchronyCollabProvider) {
+
+    // A streaming producer can hold the flush back so several of its frames accumulate in the
+    // unconfirmed queue and collapse into one step before being sent. The steps are not
+    // dropped: `sendableSteps` returns the whole queue, so the first unheld state update sends
+    // everything that accumulated. Skipping `send` also skips `lockStepOrigins`, which is what
+    // keeps the accumulated frames composable.
+    //
+    // Telepointer messages below are intentionally left alone — holding them would freeze
+    // other participants' cursors for the length of the hold, and they carry no steps.
+    if (!isSendHeld && (useNativePlugin || shouldSendStepForSynchronyCollabProvider)) {
       provider.send(trNoAnalytics, oldEditorState, newEditorState);
     }
     var prevPluginState = _pluginKey.pluginKey.getState(oldEditorState);

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

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeOverlappingSteps = mergeOverlappingSteps;
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+/**
+ * A step paired with its inverse, as stored in the collab unconfirmed queue.
+ */
+
+/**
+ * `structure` is `@internal` on ReplaceStep but is part of the serialised form, so this is the
+ * supported way to read it. Structural replaces exist to stop rebased steps from overwriting
+ * content they should not, so they are never merged.
+ */
+var isStructural = function isStructural(step) {
+  return step.toJSON().structure === true;
+};
+var asPlainReplaceStep = function asPlainReplaceStep(step) {
+  return (
+    // Deliberately excludes ReplaceAroundStep — the position arithmetic below is only sound for a
+    // plain range replace.
+    step instanceof _transform.ReplaceStep && !isStructural(step) ? step : undefined
+  );
+};
+
+/**
+ * Do the two steps touch the same region of the document?
+ *
+ * `second` is expressed in the coordinate space *after* `first` has been applied, so `first`'s
+ * footprint there is the range its slice occupies: `[from, from + slice.size]`.
+ */
+var overlaps = function overlaps(first, second) {
+  var firstInsertedEnd = first.from + first.slice.size;
+  return second.from <= firstInsertedEnd && second.to >= first.from;
+};
+
+/**
+ * Merge using ProseMirror's own step merging, which handles adjacent insertions and adjacent
+ * deletions. Both the steps and their inverses have to merge for the result to be usable as a
+ * rebase buffer entry — inverses compose in reverse order.
+ */
+var mergeNatively = function mergeNatively(first, second) {
+  var step = first.step.merge(second.step);
+  if (!step) {
+    return null;
+  }
+  var inverted = second.inverted.merge(first.inverted);
+  if (!inverted) {
+    return null;
+  }
+  return {
+    step: step,
+    inverted: inverted
+  };
+};
+
+/**
+ * Merge any two overlapping steps by applying both to the document and describing the net change
+ * as a single minimal replacement.
+ *
+ * This is the general case: it copes with `second` reaching past `first` on either side, with
+ * partial overlaps, and with slices whose open depths differ — none of which can be resolved from
+ * the steps alone, because the composed slice has to be cut out of a real document.
+ */
+var mergeViaDocument = function mergeViaDocument(first, second, docBefore) {
+  var docAfter;
+  try {
+    var transform = new _transform.Transform(docBefore);
+    transform.step(first.step);
+    transform.step(second.step);
+    docAfter = transform.doc;
+  } catch (_unused) {
+    // `docBefore` did not match the steps (for example the steps have since been rebased).
+    return null;
+  }
+  var start = docBefore.content.findDiffStart(docAfter.content);
+  if (start === null) {
+    // The steps cancel each other out. There is no single step representing "no change", so
+    // leave the pair alone rather than inventing one.
+    return null;
+  }
+  var diffEnd = docBefore.content.findDiffEnd(docAfter.content);
+  if (!diffEnd) {
+    return null;
+  }
+
+  // findDiffStart and findDiffEnd can overshoot each other when the same text appears on both
+  // sides of the change; push the end out so the range stays well formed.
+  var endBefore = diffEnd.a,
+    endAfter = diffEnd.b;
+  var overshoot = start - Math.min(endBefore, endAfter);
+  if (overshoot > 0) {
+    endBefore += overshoot;
+    endAfter += overshoot;
+  }
+  var step = new _transform.ReplaceStep(start, endBefore, docAfter.slice(start, endAfter));
+
+  // Cheap guarantee that the composition is exact. If it is not, keep the original pair.
+  var applied = step.apply(docBefore);
+  if (applied.failed !== null || !applied.doc || !applied.doc.eq(docAfter)) {
+    return null;
+  }
+  return {
+    step: step,
+    inverted: step.invert(docBefore)
+  };
+};
+
+/**
+ * Merge two consecutive steps into the single step they are collectively equivalent to.
+ *
+ * `second` must be expressed in the coordinate space produced by `first` — that is, the two must be
+ * consecutive steps of the same document. The returned step maps the document from before `first`
+ * to after `second`, and the returned inverse maps it back, so the result is safe to use both on
+ * the wire and as a rebase buffer entry.
+ *
+ * Returns `null` whenever the steps do not overlap, or when the merge cannot be proven exact. A
+ * `null` result always means "keep the two steps as they are", never "the steps are equivalent to
+ * nothing".
+ *
+ * @param first The earlier step and its inverse.
+ * @param second The later step and its inverse.
+ * @param docBefore The document `first` applies to. Optional, but without it only ProseMirror's own
+ * adjacent-step merges can be resolved, because the composed slice otherwise has to be cut out of a
+ * real document. Callers lose it when the queue has been rebased over a remote step.
+ */
+function mergeOverlappingSteps(first, second, docBefore) {
+  var firstStep = asPlainReplaceStep(first.step);
+  var secondStep = asPlainReplaceStep(second.step);
+
+  // Non-plain replaces are only ever merged by ProseMirror itself, which knows the rules for them.
+  if (!firstStep || !secondStep) {
+    return mergeNatively(first, second);
+  }
+  if (!overlaps(firstStep, secondStep)) {
+    return null;
+  }
+
+  // Try the O(1) strategy before the one that has to replay both steps against a document.
+  // `transformUnconfirmed` runs on every transaction, and adjacent insertions — which is what
+  // consecutive streaming frames often are — are exactly what ProseMirror merges natively.
+  var natively = mergeNatively(first, second);
+  if (natively) {
+    return natively;
+  }
+
+  // Anything else needs the document to cut the composed slice out of, so without one there is
+  // no merge that can be proven exact.
+  return docBefore ? mergeViaDocument(first, second, docBefore) : null;
+}

package/dist/cjs/pm-plugins/track-steps.js

@@ -4,17 +4,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.track = exports.task = exports.sanitizeStep = exports.groupSteps = void 0;
+exports.sanitizeStep = exports.groupSteps = void 0;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _analytics = require("@atlaskit/adf-schema/steps/analytics");
 var _batchAttrsStep = require("@atlaskit/adf-schema/steps/batch-attrs-step");
 var _setAttrs = require("@atlaskit/adf-schema/steps/set-attrs");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
-var _prosemirrorCollab = require("@atlaskit/prosemirror-collab");
-var _trackStepMetrics = require("./track-step-metrics");
-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; } // delete this file when cleaning up platform_editor_remove_collab_step_metrics
 function groupBy(array, keyGetter) {
   // Check group by exists, and that it's a function. If so, use the native browser code
   if ('groupBy' in Object && typeof Object.groupBy === 'function') {
@@ -98,101 +92,4 @@ var groupSteps = exports.groupSteps = function groupSteps(sanitizedSteps) {
     acc[key] = Array.isArray(value) ? value.length : 0;
     return acc;
   }, {});
-};
-
-/**
- * Processes the steps metadata from the cache and calls the callback function with the processed data.
- *
- * @param {CacheType} cache - A cache containing steps metadata.
- * @param {(data: StepMetadataAnalytics[]) => void} onTrackDataProcessed - Callback function to be called with the processed data.
- */
-var task = exports.task = function task(cache, onTrackDataProcessed) {
-  var stepsMetadata = [];
-  var _iterator = _createForOfIteratorHelper(cache.values()),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var entry = _step.value;
-      var startedAt = entry.startedAt,
-        endedAt = entry.endedAt,
-        steps = entry.steps;
-      var stepTypesAmount = groupSteps(steps.map(sanitizeStep));
-      stepsMetadata.push({
-        startedAt: startedAt,
-        endedAt: endedAt,
-        stepTypesAmount: stepTypesAmount
-      });
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  cache.clear();
-  if (stepsMetadata.length > 0) {
-    onTrackDataProcessed(stepsMetadata);
-  }
-};
-var stepsSentCache = new Map();
-// Every ten seconds we will try to process the step data.
-var LOW_PRIORITY_DELAY = 10000;
-
-// See https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
-
-var getScheduler = function getScheduler(obj) {
-  if (!obj) {
-    return null;
-  }
-  if ('scheduler' in obj) {
-    return obj.scheduler;
-  }
-  return null;
-};
-
-/**
- * Tracks the steps sent by the client by storing them in a cache and scheduling a task to process them. Once the steps are processed, the onTrackDataProcessed callabck will be called.
- *
- * This is a non-critical code. If the browser doesn't support the Scheduler API https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
- *
- * @param {TrackProps} props - The properties required for tracking steps.
- * @param {ExtractInjectionAPI<CollabEditPlugin> | undefined} props.api - The API for the CollabEdit plugin.
- * @param {EditorState} props.newEditorState - The new editor state.
- * @param {Readonly<Transaction[]>} props.transactions - The transactions that contain the steps.
- * @param {(data: StepMetadataAnalytics[]) => void} props.onTrackDataProcessed - Callback function to be called with the processed data.
- */
-var track = exports.track = function track(_ref4) {
-  var api = _ref4.api,
-    newEditorState = _ref4.newEditorState,
-    transactions = _ref4.transactions,
-    onTrackDataProcessed = _ref4.onTrackDataProcessed;
-  var newSteps = transactions.flatMap(function (t) {
-    return t.steps;
-  });
-  var collabState = (0, _prosemirrorCollab.sendableSteps)(newEditorState);
-  var scheduler = getScheduler(window);
-  if (!newSteps.length || !scheduler || !collabState) {
-    return;
-  }
-  var version = collabState.version;
-  var buffer = stepsSentCache.get(version);
-  var startedAt = (buffer === null || buffer === void 0 ? void 0 : buffer.startedAt) || Date.now();
-  var endedAt = Date.now();
-  var steps = ((buffer === null || buffer === void 0 ? void 0 : buffer.steps) || []).concat(newSteps);
-  stepsSentCache.set(version, {
-    startedAt: startedAt,
-    endedAt: endedAt,
-    steps: steps
-  });
-  (0, _trackStepMetrics.updateNcsSessionStepMetrics)({
-    api: api,
-    steps: newSteps.filter(function (step) {
-      return !(step instanceof _analytics.AnalyticsStep);
-    })
-  });
-  scheduler.postTask(function () {
-    task(stepsSentCache, onTrackDataProcessed);
-  }, {
-    priority: 'background',
-    delay: LOW_PRIORITY_DELAY
-  });
 };