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

package/dist/es2019/collabEditPlugin.js

@@ -4,8 +4,9 @@ import { JSONTransformer } from '@atlaskit/editor-json-transformer/JSONTransform
 import { AddMarkStep, AddNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { collab, getCollabState, sendableSteps } from '@atlaskit/prosemirror-collab';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { addSynchronyErrorAnalytics } from './pm-plugins/analytics';
+import { createCollabSendHold } from './pm-plugins/collabSendHold';
+import { collapseStreamingSteps } from './pm-plugins/collapseStreamingSteps';
 import { sendTransaction } from './pm-plugins/events/send-transaction';
 import { filterAnalyticsSteps } from './pm-plugins/filterAnalytics';
 import { createPlugin } from './pm-plugins/main';
@@ -17,7 +18,6 @@ import { sanitizeFilteredStep, createPlugin as trackSpammingStepsPlugin } from '
 import { createPlugin as createLastOrganicChangePlugin, trackLastOrganicChangePluginKey } from './pm-plugins/track-last-organic-change';
 import { createPlugin as createTrackNCSInitializationPlugin, trackNCSInitializationPluginKey } from './pm-plugins/track-ncs-initialization';
 import { createPlugin as createTrackReconnectionConflictPlugin, trackLastRemoteConflictPluginKey } from './pm-plugins/track-reconnection-conflict';
-import { track } from './pm-plugins/track-steps';
 import { getAvatarColor } from './pm-plugins/utils';
 const providerBuilder = collabEditProviderPromise => async (codeToExecute, onError) => {
   try {
@@ -75,6 +75,9 @@ export const collabEditPlugin = ({
     providerResolver = _providerResolver;
   });
   const executeProviderCode = providerBuilder(collabEditProviderPromise);
+  // Spans transactions: a streaming producer holds the flush across many state updates, not just
+  // the ones it dispatches itself. See `createCollabSendHold`.
+  const sendHold = createCollabSendHold();
   return {
     name: 'collabEdit',
     getSharedState(state) {
@@ -160,7 +163,10 @@ export const collabEditPlugin = ({
         userId = null
       } = options || {};
       const transformUnconfirmed = steps => {
-        const transformed = filterAnalyticsSteps(steps);
+        // Analytics steps are filtered first so they cannot break up an otherwise adjacent
+        // run of streaming frames.
+        const filtered = filterAnalyticsSteps(steps);
+        const transformed = fg('platform_editor_ai_collapse_streaming_steps') ? collapseStreamingSteps(filtered) : filtered;
         return mergeUnconfirmedSteps(transformed, api);
       };
       const plugins = [...(useNativePlugin ? [{
@@ -213,6 +219,16 @@ export const collabEditPlugin = ({
     },
     onEditorViewStateUpdated(props) {
       var _api$analytics2, _api$editorViewMode, _api$editorViewMode$s, _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.
+      const collapseStreamingStepsEnabled = fg('platform_editor_ai_collapse_streaming_steps');
+      if (collapseStreamingStepsEnabled) {
+        props.transactions.forEach(transaction => sendHold.observe(transaction));
+      }
       const addErrorAnalytics = addSynchronyErrorAnalytics(props.newEditorState, props.newEditorState.tr, featureFlags, api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions);
       const isEmptyDoc = isEmptyDocument(props.newEditorState.doc);
       const viewMode = api === null || api === void 0 ? void 0 : (_api$editorViewMode = api.editorViewMode) === null || _api$editorViewMode === void 0 ? void 0 : (_api$editorViewMode$s = _api$editorViewMode.sharedState.currentState()) === null || _api$editorViewMode$s === void 0 ? void 0 : _api$editorViewMode$s.mode;
@@ -223,32 +239,16 @@ export const collabEditPlugin = ({
         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,
+        isSendHeld: collapseStreamingStepsEnabled && sendHold.isHeld()
       }), addErrorAnalytics);
-      if (!expValEquals('platform_editor_remove_collab_step_metrics', 'isEnabled', true)) {
-        track({
-          api,
-          ...props,
-          onTrackDataProcessed: steps => {
-            var _api$analytics3, _api$analytics3$actio;
-            api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : (_api$analytics3$actio = _api$analytics3.actions) === null || _api$analytics3$actio === void 0 ? void 0 : _api$analytics3$actio.fireAnalyticsEvent({
-              action: ACTION.STEPS_TRACKED,
-              actionSubject: ACTION_SUBJECT.COLLAB,
-              attributes: {
-                steps
-              },
-              eventType: EVENT_TYPE.OPERATIONAL
-            });
-          }
-        });
-      }
       if (fg('platform_editor_collab_organic_change_reporting')) {
         monitorOrganic({
           api,
           ...props,
           onDataProcessed: data => {
-            var _api$analytics4, _api$analytics4$actio;
-            api === null || api === void 0 ? void 0 : (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : (_api$analytics4$actio = _api$analytics4.actions) === null || _api$analytics4$actio === void 0 ? void 0 : _api$analytics4$actio.fireAnalyticsEvent({
+            var _api$analytics3, _api$analytics3$actio;
+            api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : (_api$analytics3$actio = _api$analytics3.actions) === null || _api$analytics3$actio === void 0 ? void 0 : _api$analytics3$actio.fireAnalyticsEvent({
               action: ACTION.ORGANIC_CHANGES_TRACKED,
               actionSubject: ACTION_SUBJECT.COLLAB,
               attributes: {

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

@@ -0,0 +1,68 @@
+import { DEFER_COLLAB_SEND } from '@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.
+ */
+export const 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.
+ */
+export const createCollabSendHold = () => {
+  let heldSince;
+  return {
+    observe: (transaction, now = Date.now()) => {
+      const meta = transaction.getMeta(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: (now = 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/es2019/pm-plugins/collapseStreamingSteps.js

@@ -0,0 +1,114 @@
+import { STREAMING_COLLAPSIBLE_STEPS } from '@atlaskit/editor-common/collab-streaming-step-collapse';
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Rebaseable } from '@atlaskit/prosemirror-collab';
+import { mergeOverlappingSteps } from './mergeOverlappingSteps';
+
+/**
+ * Is this step an intermediate frame that its producer has marked as collapsible, and is it still
+ * free to be composed?
+ */
+const isCollapsibleFrame = rebaseable => {
+  const {
+    origin
+  } = rebaseable;
+  if (!(origin instanceof Transaction) || origin.getMeta(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.
+ */
+const 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.
+ */
+const docBeforeStep = rebaseable => {
+  const {
+    origin,
+    step
+  } = rebaseable;
+  const composed = composedStepDocs.get(step);
+  if (composed) {
+    return composed;
+  }
+  const 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
+ */
+export function collapseStreamingSteps(steps) {
+  // Fast path: nothing to do unless at least two frames could possibly compose.
+  if (steps.length < 2) {
+    return steps;
+  }
+  const 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.
+  let runDocBefore;
+  for (const rebaseable of steps) {
+    const previous = collapsed[collapsed.length - 1];
+    if (!previous || !isCollapsibleFrame(previous) || !isCollapsibleFrame(rebaseable)) {
+      collapsed.push(rebaseable);
+      runDocBefore = docBeforeStep(rebaseable);
+      continue;
+    }
+    const merged = 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.
+    const composed = new Rebaseable(merged.step, merged.inverted, previous.origin);
+    if (runDocBefore) {
+      composedStepDocs.set(composed.step, runDocBefore);
+    }
+    collapsed[collapsed.length - 1] = composed;
+  }
+  return collapsed;
+}

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

@@ -8,7 +8,8 @@ export const sendTransaction = ({
   newEditorState,
   useNativePlugin,
   viewMode,
-  hideTelecursorOnLoad
+  hideTelecursorOnLoad,
+  isSendHeld = false
 }) => provider => {
   const docChangedTransaction = transactions.find(tr => tr.docChanged);
   const currentPluginState = pluginKey.getState(newEditorState);
@@ -25,7 +26,16 @@ export const sendTransaction = ({
   // 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);
   }
   const prevPluginState = pluginKey.getState(oldEditorState);

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

@@ -0,0 +1,144 @@
+import { ReplaceStep, Transform } from '@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.
+ */
+const isStructural = step => step.toJSON().structure === true;
+const asPlainReplaceStep = step =>
+// Deliberately excludes ReplaceAroundStep — the position arithmetic below is only sound for a
+// plain range replace.
+step instanceof 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]`.
+ */
+const overlaps = (first, second) => {
+  const 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.
+ */
+const mergeNatively = (first, second) => {
+  const step = first.step.merge(second.step);
+  if (!step) {
+    return null;
+  }
+  const inverted = second.inverted.merge(first.inverted);
+  if (!inverted) {
+    return null;
+  }
+  return {
+    step,
+    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.
+ */
+const mergeViaDocument = (first, second, docBefore) => {
+  let docAfter;
+  try {
+    const transform = new Transform(docBefore);
+    transform.step(first.step);
+    transform.step(second.step);
+    docAfter = transform.doc;
+  } catch {
+    // `docBefore` did not match the steps (for example the steps have since been rebased).
+    return null;
+  }
+  const 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;
+  }
+  const 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.
+  let {
+    a: endBefore,
+    b: endAfter
+  } = diffEnd;
+  const overshoot = start - Math.min(endBefore, endAfter);
+  if (overshoot > 0) {
+    endBefore += overshoot;
+    endAfter += overshoot;
+  }
+  const step = new ReplaceStep(start, endBefore, docAfter.slice(start, endAfter));
+
+  // Cheap guarantee that the composition is exact. If it is not, keep the original pair.
+  const applied = step.apply(docBefore);
+  if (applied.failed !== null || !applied.doc || !applied.doc.eq(docAfter)) {
+    return null;
+  }
+  return {
+    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.
+ */
+export function mergeOverlappingSteps(first, second, docBefore) {
+  const firstStep = asPlainReplaceStep(first.step);
+  const 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.
+  const 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/es2019/pm-plugins/track-steps.js

@@ -1,10 +1,6 @@
-// delete this file when cleaning up platform_editor_remove_collab_step_metrics
-import { AnalyticsStep } from '@atlaskit/adf-schema/steps/analytics';
 import { BatchAttrsStep } from '@atlaskit/adf-schema/steps/batch-attrs-step';
 import { SetAttrsStep } from '@atlaskit/adf-schema/steps/set-attrs';
 import { AddMarkStep, AddNodeMarkStep, AttrStep, DocAttrStep, RemoveMarkStep, RemoveNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
-import { sendableSteps } from '@atlaskit/prosemirror-collab';
-import { updateNcsSessionStepMetrics } from './track-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') {
@@ -82,93 +78,4 @@ export const 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.
- */
-export const task = (cache, onTrackDataProcessed) => {
-  const stepsMetadata = [];
-  for (const entry of cache.values()) {
-    const {
-      startedAt,
-      endedAt,
-      steps
-    } = entry;
-    const stepTypesAmount = groupSteps(steps.map(sanitizeStep));
-    stepsMetadata.push({
-      startedAt,
-      endedAt,
-      stepTypesAmount
-    });
-  }
-  cache.clear();
-  if (stepsMetadata.length > 0) {
-    onTrackDataProcessed(stepsMetadata);
-  }
-};
-const stepsSentCache = new Map();
-// Every ten seconds we will try to process the step data.
-const LOW_PRIORITY_DELAY = 10000;
-
-// See https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/
-
-const 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.
- */
-export const track = ({
-  api,
-  newEditorState,
-  transactions,
-  onTrackDataProcessed
-}) => {
-  const newSteps = transactions.flatMap(t => t.steps);
-  const collabState = sendableSteps(newEditorState);
-  const scheduler = getScheduler(window);
-  if (!newSteps.length || !scheduler || !collabState) {
-    return;
-  }
-  const {
-    version
-  } = collabState;
-  const buffer = stepsSentCache.get(version);
-  const startedAt = (buffer === null || buffer === void 0 ? void 0 : buffer.startedAt) || Date.now();
-  const endedAt = Date.now();
-  const steps = ((buffer === null || buffer === void 0 ? void 0 : buffer.steps) || []).concat(newSteps);
-  stepsSentCache.set(version, {
-    startedAt,
-    endedAt,
-    steps
-  });
-  updateNcsSessionStepMetrics({
-    api,
-    steps: newSteps.filter(step => !(step instanceof AnalyticsStep))
-  });
-  scheduler.postTask(() => {
-    task(stepsSentCache, onTrackDataProcessed);
-  }, {
-    priority: 'background',
-    delay: LOW_PRIORITY_DELAY
-  });
 };

package/dist/esm/collabEditPlugin.js

@@ -10,8 +10,9 @@ import { JSONTransformer } from '@atlaskit/editor-json-transformer/JSONTransform
 import { AddMarkStep, AddNodeMarkStep } from '@atlaskit/editor-prosemirror/transform';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { collab, getCollabState, sendableSteps } from '@atlaskit/prosemirror-collab';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { addSynchronyErrorAnalytics } from './pm-plugins/analytics';
+import { createCollabSendHold } from './pm-plugins/collabSendHold';
+import { collapseStreamingSteps } from './pm-plugins/collapseStreamingSteps';
 import { sendTransaction } from './pm-plugins/events/send-transaction';
 import { filterAnalyticsSteps } from './pm-plugins/filterAnalytics';
 import { createPlugin } from './pm-plugins/main';
@@ -23,7 +24,6 @@ import { sanitizeFilteredStep, createPlugin as trackSpammingStepsPlugin } from '
 import { createPlugin as createLastOrganicChangePlugin, trackLastOrganicChangePluginKey } from './pm-plugins/track-last-organic-change';
 import { createPlugin as createTrackNCSInitializationPlugin, trackNCSInitializationPluginKey } from './pm-plugins/track-ncs-initialization';
 import { createPlugin as createTrackReconnectionConflictPlugin, trackLastRemoteConflictPluginKey } from './pm-plugins/track-reconnection-conflict';
-import { track } from './pm-plugins/track-steps';
 import { getAvatarColor } from './pm-plugins/utils';
 var providerBuilder = function providerBuilder(collabEditProviderPromise) {
   return /*#__PURE__*/function () {
@@ -107,6 +107,9 @@ export var collabEditPlugin = function collabEditPlugin(_ref4) {
     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 = createCollabSendHold();
   return {
     name: 'collabEdit',
     getSharedState: function getSharedState(state) {
@@ -198,7 +201,10 @@ export var collabEditPlugin = function collabEditPlugin(_ref4) {
         _ref5$userId = _ref5.userId,
         userId = _ref5$userId === void 0 ? null : _ref5$userId;
       var transformUnconfirmed = function transformUnconfirmed(steps) {
-        var transformed = filterAnalyticsSteps(steps);
+        // Analytics steps are filtered first so they cannot break up an otherwise adjacent
+        // run of streaming frames.
+        var filtered = filterAnalyticsSteps(steps);
+        var transformed = fg('platform_editor_ai_collapse_streaming_steps') ? collapseStreamingSteps(filtered) : filtered;
         return mergeUnconfirmedSteps(transformed, api);
       };
       var plugins = [].concat(_toConsumableArray(useNativePlugin ? [{
@@ -258,6 +264,18 @@ export var collabEditPlugin = function collabEditPlugin(_ref4) {
     },
     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 = fg('platform_editor_ai_collapse_streaming_steps');
+      if (collapseStreamingStepsEnabled) {
+        props.transactions.forEach(function (transaction) {
+          return sendHold.observe(transaction);
+        });
+      }
       var addErrorAnalytics = 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 = 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;
@@ -268,32 +286,16 @@ export var collabEditPlugin = function collabEditPlugin(_ref4) {
         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 (!expValEquals('platform_editor_remove_collab_step_metrics', 'isEnabled', true)) {
-        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: ACTION.STEPS_TRACKED,
-              actionSubject: ACTION_SUBJECT.COLLAB,
-              attributes: {
-                steps: steps
-              },
-              eventType: EVENT_TYPE.OPERATIONAL
-            });
-          }
-        }));
-      }
       if (fg('platform_editor_collab_organic_change_reporting')) {
         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: ACTION.ORGANIC_CHANGES_TRACKED,
               actionSubject: ACTION_SUBJECT.COLLAB,
               attributes: {