@atlaskit/collab-provider 10.9.2 → 10.9.3

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atlaskit/collab-provider
 
+## 10.9.3
+
+### Patch Changes
+
+- [#122605](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/122605)
+  [`1bf1493f744ce`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/1bf1493f744ce) -
+  [ux] Add conflict metadata on reconnection
+- Updated dependencies
+
 ## 10.9.2
 
 ### Patch Changes

package/dist/cjs/channel.js

@@ -203,7 +203,7 @@ var Channel = exports.Channel = /*#__PURE__*/function (_Emitter) {
           var measure = (0, _performance.stopMeasure)(_performance.MEASURE_NAME.DOCUMENT_INIT, _this.analyticsHelper);
           (_this$initExperience = _this.initExperience) === null || _this$initExperience === void 0 || _this$initExperience.success();
           (_this$analyticsHelper6 = _this.analyticsHelper) === null || _this$analyticsHelper6 === void 0 || _this$analyticsHelper6.sendActionEvent(_const.EVENT_ACTION.DOCUMENT_INIT,
-          // TODO: detect when document init fails and fire corresponding event for it
+          // TODO: ED-26957 - detect when document init fails and fire corresponding event for it
           _const.EVENT_STATUS.SUCCESS, {
             latency: measure === null || measure === void 0 ? void 0 : measure.duration,
             resetReason: data.resetReason,

package/dist/cjs/document/document-service.js

@@ -12,6 +12,7 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _throttle = _interopRequireDefault(require("lodash/throttle"));
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _prosemirrorCollab = require("@atlaskit/prosemirror-collab");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _editorJsonTransformer = require("@atlaskit/editor-json-transformer");
@@ -24,6 +25,7 @@ var _commitStep = require("../provider/commit-step");
 var _customErrors = require("../errors/custom-errors");
 var _catchupv = require("./catchupv2");
 var _stepQueueState = require("./step-queue-state");
+var _getConflictChanges = require("./getConflictChanges");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var CATCHUP_THROTTLE = 1 * 1000; // 1 second
@@ -72,7 +74,7 @@ var DocumentService = exports.DocumentService = /*#__PURE__*/function () {
       return _this.catchupv2(reason, reconnectionMetadata);
     }, CATCHUP_THROTTLE, {
       leading: false,
-      // TODO: why shouldn't this be leading?
+      // TODO: ED-26957 - why shouldn't this be leading?
       trailing: true
     }));
     /**
@@ -772,10 +774,21 @@ var DocumentService = exports.DocumentService = /*#__PURE__*/function () {
       var state = (_this$getState7 = this.getState) === null || _this$getState7 === void 0 ? void 0 : _this$getState7.call(this);
       var unconfirmedSteps = state ? (_getCollabState = (0, _prosemirrorCollab.getCollabState)(state)) === null || _getCollabState === void 0 ? void 0 : _getCollabState.unconfirmed : undefined;
       if (steps.length > 0 && state && unconfirmedSteps && unconfirmedSteps.length > 0) {
-        // In the future we can determine the type of conflict
-        this.providerEmitCallback('data:conflict', {
-          offlineDoc: state.doc
+        var schema = state.schema,
+          tr = state.tr;
+        var remoteSteps = steps.map(function (s) {
+          return _transform.Step.fromJSON(schema, s);
         });
+        var conflicts = (0, _getConflictChanges.getConflictChanges)({
+          localSteps: unconfirmedSteps,
+          remoteSteps: remoteSteps,
+          tr: tr
+        });
+        if (conflicts.deleted.length > 0 || conflicts.inserted.length > 0) {
+          this.providerEmitCallback('data:conflict', _objectSpread({
+            offlineDoc: state.doc
+          }, conflicts));
+        }
       }
     }
   }, {

package/dist/cjs/document/getConflictChanges.js

@@ -0,0 +1,177 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConflictChanges = getConflictChanges;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _prosemirrorChangeset = require("prosemirror-changeset");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var simplifySteps = function simplifySteps(steps) {
+  return steps.reduce(function (acc, step) {
+    var lastStep = acc[acc.length - 1];
+    if (lastStep) {
+      var mergedStep = lastStep.merge(step);
+      if (mergedStep) {
+        acc[acc.length - 1] = mergedStep;
+        return acc;
+      }
+    }
+    return acc.concat(step);
+  }, []);
+};
+function findContentChanges(doc, steps) {
+  var changes = _prosemirrorChangeset.ChangeSet.create(doc);
+  var latestDoc = doc;
+  simplifySteps(steps).forEach(function (step, index) {
+    var stepResult = step.apply(latestDoc);
+    if (stepResult.failed !== null || stepResult.doc === null) {
+      return;
+    }
+    latestDoc = stepResult.doc;
+    changes = changes.addSteps(latestDoc, [step.getMap()], {
+      step: index
+    });
+  });
+  return changes;
+}
+
+/**
+ * Iterate through the changesets to find overlapping regions that indicate conflicting
+ * changes
+ */
+var getConflicts = function getConflicts(_ref) {
+  var localChanges = _ref.localChanges,
+    localDoc = _ref.localDoc,
+    remoteChanges = _ref.remoteChanges,
+    remoteDoc = _ref.remoteDoc;
+  var conflictingChanges = [];
+  localChanges.changes.forEach(function (localChange) {
+    remoteChanges.changes.forEach(function (remoteChange) {
+      if (
+      // Local change is inside remote change
+      localChange.fromA >= remoteChange.fromA && localChange.toA <= remoteChange.toA ||
+      // Remote change is inside local change
+      remoteChange.fromA >= localChange.fromA && remoteChange.toA <= localChange.toA ||
+      // Partial overlap with the end
+      localChange.fromA >= remoteChange.fromA && localChange.fromA < remoteChange.toA && localChange.toA > remoteChange.toA ||
+      // Partial overlap with the start
+      localChange.fromA < remoteChange.fromA && localChange.toA > remoteChange.fromA && localChange.toA <= remoteChange.toA) {
+        conflictingChanges.push({
+          from: Math.min(localChange.fromA, remoteChange.fromA),
+          to: Math.max(localChange.toA, remoteChange.toA),
+          local: localDoc.slice(localChange.fromB, localChange.toB, true),
+          remote: remoteDoc.slice(remoteChange.fromB, remoteChange.toB)
+        });
+      }
+    });
+  });
+  return conflictingChanges;
+};
+
+/**
+ * Almost a copy of the rebaseSteps in the collab algorithm (which gets called
+ * synchronously after this).
+ *
+ * This also tracks the intermediate documents so we can generate the changesets
+ * to use for finding any overlapping regions.
+ * See: `packages/editor/prosemirror-collab/src/index.ts`
+ */
+var rebaseSteps = function rebaseSteps(_ref2) {
+  var _tr$mapping$maps;
+  var localSteps = _ref2.localSteps,
+    remoteSteps = _ref2.remoteSteps,
+    tr = _ref2.tr;
+  for (var i = (localSteps === null || localSteps === void 0 ? void 0 : localSteps.length) - 1; i >= 0; i--) {
+    tr.step(localSteps[i].inverted);
+  }
+  var originalDoc = tr.doc;
+  var mapStart = (_tr$mapping$maps = tr.mapping.maps) === null || _tr$mapping$maps === void 0 ? void 0 : _tr$mapping$maps.length;
+  for (var _i = 0; _i < remoteSteps.length; _i++) {
+    tr.step(remoteSteps[_i]);
+  }
+  var remoteDoc = tr.doc;
+  for (var _i2 = 0, mapFrom = localSteps.length; _i2 < localSteps.length; _i2++) {
+    var mapped = localSteps[_i2].step.map(tr.mapping.slice(mapFrom));
+    mapFrom--;
+    if (mapped && !tr.maybeStep(mapped).failed) {
+      // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
+      // @ts-expect-error
+      tr.mapping.setMirror(mapFrom, tr.steps.length - 1);
+    }
+  }
+  return {
+    mapStart: mapStart,
+    originalDoc: originalDoc,
+    remoteDoc: remoteDoc
+  };
+};
+
+/**
+ * Gets the conflicts between the local document and the remote document based on steps.
+ * It assumes the steps will be rebased using the `prosemirror-collab` algorithm synchronously after this
+ * Therefore the `tr` property is based on the document before rebasing.
+ *
+ * In the future we could possibly use `prosemirror-recreate-steps` (or similar approach)
+ * and tweak this to work for arbitrary diffs between offline and remote documents.
+ *
+ * @param localSteps Local steps applied between now and the server steps
+ * @param remoteSteps Steps retrieved from the server
+ * @param tr Transaction of the current document (expected to happen with local steps applied, before remote are applied)
+ * @returns All the conflicts (inserted + deleted) which can be applied to the current document
+ */
+function getConflictChanges(_ref3) {
+  var localSteps = _ref3.localSteps,
+    remoteSteps = _ref3.remoteSteps,
+    tr = _ref3.tr;
+  var localDoc = tr.doc;
+  var _rebaseSteps = rebaseSteps({
+      localSteps: localSteps,
+      remoteSteps: remoteSteps,
+      tr: tr
+    }),
+    originalDoc = _rebaseSteps.originalDoc,
+    remoteDoc = _rebaseSteps.remoteDoc,
+    mapStart = _rebaseSteps.mapStart;
+  var localChanges = findContentChanges(originalDoc, localSteps.map(function (s) {
+    return s.step;
+  }));
+  var remoteChanges = findContentChanges(originalDoc, remoteSteps);
+
+  // This is the mapping between the original document and our final one which can be used to
+  // map conflict positions (which are based on the original doc)
+  var mapping = tr.mapping.slice(mapStart);
+
+  // Find the overlapping conflicts - these are based on the positions of the original document so are
+  // common to both local and remote documents.
+  // The above mapping allows us to bring these positions to where they are in the current document
+  var conflictingChanges = getConflicts({
+    localChanges: localChanges,
+    localDoc: localDoc,
+    remoteDoc: remoteDoc,
+    remoteChanges: remoteChanges
+  });
+  var isConflictChange = function isConflictChange(value) {
+    return Boolean(value);
+  };
+  return {
+    inserted: conflictingChanges.filter(function (i) {
+      return i.remote.size !== 0;
+    }).map(function (i) {
+      return _objectSpread(_objectSpread({}, i), {}, {
+        from: mapping.map(i.from, -1),
+        to: mapping.map(i.to)
+      });
+    }).filter(isConflictChange),
+    deleted: conflictingChanges.filter(function (d) {
+      return d.remote.size === 0;
+    }).map(function (d) {
+      return _objectSpread(_objectSpread({}, d), {}, {
+        from: mapping.map(d.from),
+        to: mapping.map(d.to)
+      });
+    }).filter(isConflictChange)
+  };
+}

package/dist/cjs/errors/ncs-errors.js

@@ -25,7 +25,7 @@ var NCS_ERROR_CODE = exports.NCS_ERROR_CODE = /*#__PURE__*/function (NCS_ERROR_C
   NCS_ERROR_CODE["RATE_LIMIT_ERROR"] = "RATE_LIMIT_ERROR";
   NCS_ERROR_CODE["PROSEMIRROR_SCHEMA_VALIDATION_ERROR"] = "PROSEMIRROR_SCHEMA_VALIDATION_ERROR";
   return NCS_ERROR_CODE;
-}({}); // TODO: Import emitted error codes from NCS
+}({}); // TODO: ED-26957 - Import emitted error codes from NCS
 // NCS Errors
 // - Step rejection errors
 // - Permission errors

package/dist/cjs/provider/commit-step.js

@@ -16,7 +16,7 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var logger = (0, _utils.createLogger)('commit-step', 'black');
 var readyToCommit = exports.readyToCommit = true;
-var RESET_READYTOCOMMIT_INTERVAL_MS = exports.RESET_READYTOCOMMIT_INTERVAL_MS = 20000;
+var RESET_READYTOCOMMIT_INTERVAL_MS = exports.RESET_READYTOCOMMIT_INTERVAL_MS = 5000;
 var commitStepQueue = exports.commitStepQueue = function commitStepQueue(_ref) {
   var broadcast = _ref.broadcast,
     steps = _ref.steps,

package/dist/cjs/version-wrapper.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.version = exports.nextMajorVersion = exports.name = void 0;
 var name = exports.name = "@atlaskit/collab-provider";
-var version = exports.version = "10.9.2";
+var version = exports.version = "10.9.3";
 var nextMajorVersion = exports.nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/channel.js

@@ -139,7 +139,7 @@ export class Channel extends Emitter {
           const measure = stopMeasure(MEASURE_NAME.DOCUMENT_INIT, this.analyticsHelper);
           (_this$initExperience = this.initExperience) === null || _this$initExperience === void 0 ? void 0 : _this$initExperience.success();
           (_this$analyticsHelper6 = this.analyticsHelper) === null || _this$analyticsHelper6 === void 0 ? void 0 : _this$analyticsHelper6.sendActionEvent(EVENT_ACTION.DOCUMENT_INIT,
-          // TODO: detect when document init fails and fire corresponding event for it
+          // TODO: ED-26957 - detect when document init fails and fire corresponding event for it
           EVENT_STATUS.SUCCESS, {
             latency: measure === null || measure === void 0 ? void 0 : measure.duration,
             resetReason: data.resetReason,

package/dist/es2019/document/document-service.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import throttle from 'lodash/throttle';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
 import { getCollabState, sendableSteps } from '@atlaskit/prosemirror-collab';
 import { Transaction } from '@atlaskit/editor-prosemirror/state';
 import { JSONTransformer } from '@atlaskit/editor-json-transformer';
@@ -13,6 +14,7 @@ import { commitStepQueue } from '../provider/commit-step';
 import { CantSyncUpError, UpdateDocumentError } from '../errors/custom-errors';
 import { catchupv2 } from './catchupv2';
 import { StepQueueState } from './step-queue-state';
+import { getConflictChanges } from './getConflictChanges';
 const CATCHUP_THROTTLE = 1 * 1000; // 1 second
 
 const noop = () => {};
@@ -52,7 +54,7 @@ export class DocumentService {
      */
     _defineProperty(this, "throttledCatchupv2", throttle((reason, reconnectionMetadata) => this.catchupv2(reason, reconnectionMetadata), CATCHUP_THROTTLE, {
       leading: false,
-      // TODO: why shouldn't this be leading?
+      // TODO: ED-26957 - why shouldn't this be leading?
       trailing: true
     }));
     /**
@@ -657,10 +659,22 @@ export class DocumentService {
     const state = (_this$getState7 = this.getState) === null || _this$getState7 === void 0 ? void 0 : _this$getState7.call(this);
     const unconfirmedSteps = state ? (_getCollabState = getCollabState(state)) === null || _getCollabState === void 0 ? void 0 : _getCollabState.unconfirmed : undefined;
     if (steps.length > 0 && state && unconfirmedSteps && unconfirmedSteps.length > 0) {
-      // In the future we can determine the type of conflict
-      this.providerEmitCallback('data:conflict', {
-        offlineDoc: state.doc
+      const {
+        schema,
+        tr
+      } = state;
+      const remoteSteps = steps.map(s => ProseMirrorStep.fromJSON(schema, s));
+      const conflicts = getConflictChanges({
+        localSteps: unconfirmedSteps,
+        remoteSteps,
+        tr
       });
+      if (conflicts.deleted.length > 0 || conflicts.inserted.length > 0) {
+        this.providerEmitCallback('data:conflict', {
+          offlineDoc: state.doc,
+          ...conflicts
+        });
+      }
     }
   }
   processQueue() {

package/dist/es2019/document/getConflictChanges.js

@@ -0,0 +1,161 @@
+import { ChangeSet } from 'prosemirror-changeset';
+const simplifySteps = steps => {
+  return steps.reduce((acc, step) => {
+    const lastStep = acc[acc.length - 1];
+    if (lastStep) {
+      const mergedStep = lastStep.merge(step);
+      if (mergedStep) {
+        acc[acc.length - 1] = mergedStep;
+        return acc;
+      }
+    }
+    return acc.concat(step);
+  }, []);
+};
+function findContentChanges(doc, steps) {
+  let changes = ChangeSet.create(doc);
+  let latestDoc = doc;
+  simplifySteps(steps).forEach((step, index) => {
+    const stepResult = step.apply(latestDoc);
+    if (stepResult.failed !== null || stepResult.doc === null) {
+      return;
+    }
+    latestDoc = stepResult.doc;
+    changes = changes.addSteps(latestDoc, [step.getMap()], {
+      step: index
+    });
+  });
+  return changes;
+}
+
+/**
+ * Iterate through the changesets to find overlapping regions that indicate conflicting
+ * changes
+ */
+const getConflicts = ({
+  localChanges,
+  localDoc,
+  remoteChanges,
+  remoteDoc
+}) => {
+  const conflictingChanges = [];
+  localChanges.changes.forEach(localChange => {
+    remoteChanges.changes.forEach(remoteChange => {
+      if (
+      // Local change is inside remote change
+      localChange.fromA >= remoteChange.fromA && localChange.toA <= remoteChange.toA ||
+      // Remote change is inside local change
+      remoteChange.fromA >= localChange.fromA && remoteChange.toA <= localChange.toA ||
+      // Partial overlap with the end
+      localChange.fromA >= remoteChange.fromA && localChange.fromA < remoteChange.toA && localChange.toA > remoteChange.toA ||
+      // Partial overlap with the start
+      localChange.fromA < remoteChange.fromA && localChange.toA > remoteChange.fromA && localChange.toA <= remoteChange.toA) {
+        conflictingChanges.push({
+          from: Math.min(localChange.fromA, remoteChange.fromA),
+          to: Math.max(localChange.toA, remoteChange.toA),
+          local: localDoc.slice(localChange.fromB, localChange.toB, true),
+          remote: remoteDoc.slice(remoteChange.fromB, remoteChange.toB)
+        });
+      }
+    });
+  });
+  return conflictingChanges;
+};
+
+/**
+ * Almost a copy of the rebaseSteps in the collab algorithm (which gets called
+ * synchronously after this).
+ *
+ * This also tracks the intermediate documents so we can generate the changesets
+ * to use for finding any overlapping regions.
+ * See: `packages/editor/prosemirror-collab/src/index.ts`
+ */
+const rebaseSteps = ({
+  localSteps,
+  remoteSteps,
+  tr
+}) => {
+  var _tr$mapping$maps;
+  for (let i = (localSteps === null || localSteps === void 0 ? void 0 : localSteps.length) - 1; i >= 0; i--) {
+    tr.step(localSteps[i].inverted);
+  }
+  const originalDoc = tr.doc;
+  const mapStart = (_tr$mapping$maps = tr.mapping.maps) === null || _tr$mapping$maps === void 0 ? void 0 : _tr$mapping$maps.length;
+  for (let i = 0; i < remoteSteps.length; i++) {
+    tr.step(remoteSteps[i]);
+  }
+  const remoteDoc = tr.doc;
+  for (let i = 0, mapFrom = localSteps.length; i < localSteps.length; i++) {
+    const mapped = localSteps[i].step.map(tr.mapping.slice(mapFrom));
+    mapFrom--;
+    if (mapped && !tr.maybeStep(mapped).failed) {
+      // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
+      // @ts-expect-error
+      tr.mapping.setMirror(mapFrom, tr.steps.length - 1);
+    }
+  }
+  return {
+    mapStart,
+    originalDoc,
+    remoteDoc
+  };
+};
+
+/**
+ * Gets the conflicts between the local document and the remote document based on steps.
+ * It assumes the steps will be rebased using the `prosemirror-collab` algorithm synchronously after this
+ * Therefore the `tr` property is based on the document before rebasing.
+ *
+ * In the future we could possibly use `prosemirror-recreate-steps` (or similar approach)
+ * and tweak this to work for arbitrary diffs between offline and remote documents.
+ *
+ * @param localSteps Local steps applied between now and the server steps
+ * @param remoteSteps Steps retrieved from the server
+ * @param tr Transaction of the current document (expected to happen with local steps applied, before remote are applied)
+ * @returns All the conflicts (inserted + deleted) which can be applied to the current document
+ */
+export function getConflictChanges({
+  localSteps,
+  remoteSteps,
+  tr
+}) {
+  const localDoc = tr.doc;
+  const {
+    originalDoc,
+    remoteDoc,
+    mapStart
+  } = rebaseSteps({
+    localSteps,
+    remoteSteps,
+    tr
+  });
+  const localChanges = findContentChanges(originalDoc, localSteps.map(s => s.step));
+  const remoteChanges = findContentChanges(originalDoc, remoteSteps);
+
+  // This is the mapping between the original document and our final one which can be used to
+  // map conflict positions (which are based on the original doc)
+  const mapping = tr.mapping.slice(mapStart);
+
+  // Find the overlapping conflicts - these are based on the positions of the original document so are
+  // common to both local and remote documents.
+  // The above mapping allows us to bring these positions to where they are in the current document
+  const conflictingChanges = getConflicts({
+    localChanges,
+    localDoc,
+    remoteDoc,
+    remoteChanges
+  });
+  const isConflictChange = value => Boolean(value);
+  return {
+    inserted: conflictingChanges.filter(i => i.remote.size !== 0).map(i => ({
+      ...i,
+      from: mapping.map(i.from, -1),
+      to: mapping.map(i.to)
+    })).filter(isConflictChange),
+    deleted: conflictingChanges.filter(d => d.remote.size === 0).map(d => ({
+      ...d,
+      from: mapping.map(d.from),
+      to: mapping.map(d.to)
+    })).filter(isConflictChange)
+  };
+}

package/dist/es2019/errors/ncs-errors.js

@@ -21,7 +21,7 @@ export let NCS_ERROR_CODE = /*#__PURE__*/function (NCS_ERROR_CODE) {
   return NCS_ERROR_CODE;
 }({});
 
-// TODO: Import emitted error codes from NCS
+// TODO: ED-26957 - Import emitted error codes from NCS
 
 // NCS Errors
 // - Step rejection errors

package/dist/es2019/provider/commit-step.js

@@ -6,7 +6,7 @@ import { NCS_ERROR_CODE } from '../errors/ncs-errors';
 import { createLogger } from '../helpers/utils';
 const logger = createLogger('commit-step', 'black');
 export let readyToCommit = true;
-export const RESET_READYTOCOMMIT_INTERVAL_MS = 20000;
+export const RESET_READYTOCOMMIT_INTERVAL_MS = 5000;
 export const commitStepQueue = ({
   broadcast,
   steps,

package/dist/es2019/version-wrapper.js

@@ -1,5 +1,5 @@
 export const name = "@atlaskit/collab-provider";
-export const version = "10.9.2";
+export const version = "10.9.3";
 export const nextMajorVersion = () => {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/esm/channel.js

@@ -196,7 +196,7 @@ export var Channel = /*#__PURE__*/function (_Emitter) {
           var measure = stopMeasure(MEASURE_NAME.DOCUMENT_INIT, _this.analyticsHelper);
           (_this$initExperience = _this.initExperience) === null || _this$initExperience === void 0 || _this$initExperience.success();
           (_this$analyticsHelper6 = _this.analyticsHelper) === null || _this$analyticsHelper6 === void 0 || _this$analyticsHelper6.sendActionEvent(EVENT_ACTION.DOCUMENT_INIT,
-          // TODO: detect when document init fails and fire corresponding event for it
+          // TODO: ED-26957 - detect when document init fails and fire corresponding event for it
           EVENT_STATUS.SUCCESS, {
             latency: measure === null || measure === void 0 ? void 0 : measure.duration,
             resetReason: data.resetReason,

package/dist/esm/document/document-service.js

@@ -7,6 +7,7 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import throttle from 'lodash/throttle';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
 import { getCollabState, sendableSteps } from '@atlaskit/prosemirror-collab';
 import { Transaction } from '@atlaskit/editor-prosemirror/state';
 import { JSONTransformer } from '@atlaskit/editor-json-transformer';
@@ -19,6 +20,7 @@ import { commitStepQueue } from '../provider/commit-step';
 import { CantSyncUpError, UpdateDocumentError } from '../errors/custom-errors';
 import { catchupv2 } from './catchupv2';
 import { StepQueueState } from './step-queue-state';
+import { getConflictChanges } from './getConflictChanges';
 var CATCHUP_THROTTLE = 1 * 1000; // 1 second
 
 var noop = function noop() {};
@@ -65,7 +67,7 @@ export var DocumentService = /*#__PURE__*/function () {
       return _this.catchupv2(reason, reconnectionMetadata);
     }, CATCHUP_THROTTLE, {
       leading: false,
-      // TODO: why shouldn't this be leading?
+      // TODO: ED-26957 - why shouldn't this be leading?
       trailing: true
     }));
     /**
@@ -765,10 +767,21 @@ export var DocumentService = /*#__PURE__*/function () {
       var state = (_this$getState7 = this.getState) === null || _this$getState7 === void 0 ? void 0 : _this$getState7.call(this);
       var unconfirmedSteps = state ? (_getCollabState = getCollabState(state)) === null || _getCollabState === void 0 ? void 0 : _getCollabState.unconfirmed : undefined;
       if (steps.length > 0 && state && unconfirmedSteps && unconfirmedSteps.length > 0) {
-        // In the future we can determine the type of conflict
-        this.providerEmitCallback('data:conflict', {
-          offlineDoc: state.doc
+        var schema = state.schema,
+          tr = state.tr;
+        var remoteSteps = steps.map(function (s) {
+          return ProseMirrorStep.fromJSON(schema, s);
         });
+        var conflicts = getConflictChanges({
+          localSteps: unconfirmedSteps,
+          remoteSteps: remoteSteps,
+          tr: tr
+        });
+        if (conflicts.deleted.length > 0 || conflicts.inserted.length > 0) {
+          this.providerEmitCallback('data:conflict', _objectSpread({
+            offlineDoc: state.doc
+          }, conflicts));
+        }
       }
     }
   }, {

package/dist/esm/document/getConflictChanges.js

@@ -0,0 +1,170 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { ChangeSet } from 'prosemirror-changeset';
+var simplifySteps = function simplifySteps(steps) {
+  return steps.reduce(function (acc, step) {
+    var lastStep = acc[acc.length - 1];
+    if (lastStep) {
+      var mergedStep = lastStep.merge(step);
+      if (mergedStep) {
+        acc[acc.length - 1] = mergedStep;
+        return acc;
+      }
+    }
+    return acc.concat(step);
+  }, []);
+};
+function findContentChanges(doc, steps) {
+  var changes = ChangeSet.create(doc);
+  var latestDoc = doc;
+  simplifySteps(steps).forEach(function (step, index) {
+    var stepResult = step.apply(latestDoc);
+    if (stepResult.failed !== null || stepResult.doc === null) {
+      return;
+    }
+    latestDoc = stepResult.doc;
+    changes = changes.addSteps(latestDoc, [step.getMap()], {
+      step: index
+    });
+  });
+  return changes;
+}
+
+/**
+ * Iterate through the changesets to find overlapping regions that indicate conflicting
+ * changes
+ */
+var getConflicts = function getConflicts(_ref) {
+  var localChanges = _ref.localChanges,
+    localDoc = _ref.localDoc,
+    remoteChanges = _ref.remoteChanges,
+    remoteDoc = _ref.remoteDoc;
+  var conflictingChanges = [];
+  localChanges.changes.forEach(function (localChange) {
+    remoteChanges.changes.forEach(function (remoteChange) {
+      if (
+      // Local change is inside remote change
+      localChange.fromA >= remoteChange.fromA && localChange.toA <= remoteChange.toA ||
+      // Remote change is inside local change
+      remoteChange.fromA >= localChange.fromA && remoteChange.toA <= localChange.toA ||
+      // Partial overlap with the end
+      localChange.fromA >= remoteChange.fromA && localChange.fromA < remoteChange.toA && localChange.toA > remoteChange.toA ||
+      // Partial overlap with the start
+      localChange.fromA < remoteChange.fromA && localChange.toA > remoteChange.fromA && localChange.toA <= remoteChange.toA) {
+        conflictingChanges.push({
+          from: Math.min(localChange.fromA, remoteChange.fromA),
+          to: Math.max(localChange.toA, remoteChange.toA),
+          local: localDoc.slice(localChange.fromB, localChange.toB, true),
+          remote: remoteDoc.slice(remoteChange.fromB, remoteChange.toB)
+        });
+      }
+    });
+  });
+  return conflictingChanges;
+};
+
+/**
+ * Almost a copy of the rebaseSteps in the collab algorithm (which gets called
+ * synchronously after this).
+ *
+ * This also tracks the intermediate documents so we can generate the changesets
+ * to use for finding any overlapping regions.
+ * See: `packages/editor/prosemirror-collab/src/index.ts`
+ */
+var rebaseSteps = function rebaseSteps(_ref2) {
+  var _tr$mapping$maps;
+  var localSteps = _ref2.localSteps,
+    remoteSteps = _ref2.remoteSteps,
+    tr = _ref2.tr;
+  for (var i = (localSteps === null || localSteps === void 0 ? void 0 : localSteps.length) - 1; i >= 0; i--) {
+    tr.step(localSteps[i].inverted);
+  }
+  var originalDoc = tr.doc;
+  var mapStart = (_tr$mapping$maps = tr.mapping.maps) === null || _tr$mapping$maps === void 0 ? void 0 : _tr$mapping$maps.length;
+  for (var _i = 0; _i < remoteSteps.length; _i++) {
+    tr.step(remoteSteps[_i]);
+  }
+  var remoteDoc = tr.doc;
+  for (var _i2 = 0, mapFrom = localSteps.length; _i2 < localSteps.length; _i2++) {
+    var mapped = localSteps[_i2].step.map(tr.mapping.slice(mapFrom));
+    mapFrom--;
+    if (mapped && !tr.maybeStep(mapped).failed) {
+      // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
+      // @ts-expect-error
+      tr.mapping.setMirror(mapFrom, tr.steps.length - 1);
+    }
+  }
+  return {
+    mapStart: mapStart,
+    originalDoc: originalDoc,
+    remoteDoc: remoteDoc
+  };
+};
+
+/**
+ * Gets the conflicts between the local document and the remote document based on steps.
+ * It assumes the steps will be rebased using the `prosemirror-collab` algorithm synchronously after this
+ * Therefore the `tr` property is based on the document before rebasing.
+ *
+ * In the future we could possibly use `prosemirror-recreate-steps` (or similar approach)
+ * and tweak this to work for arbitrary diffs between offline and remote documents.
+ *
+ * @param localSteps Local steps applied between now and the server steps
+ * @param remoteSteps Steps retrieved from the server
+ * @param tr Transaction of the current document (expected to happen with local steps applied, before remote are applied)
+ * @returns All the conflicts (inserted + deleted) which can be applied to the current document
+ */
+export function getConflictChanges(_ref3) {
+  var localSteps = _ref3.localSteps,
+    remoteSteps = _ref3.remoteSteps,
+    tr = _ref3.tr;
+  var localDoc = tr.doc;
+  var _rebaseSteps = rebaseSteps({
+      localSteps: localSteps,
+      remoteSteps: remoteSteps,
+      tr: tr
+    }),
+    originalDoc = _rebaseSteps.originalDoc,
+    remoteDoc = _rebaseSteps.remoteDoc,
+    mapStart = _rebaseSteps.mapStart;
+  var localChanges = findContentChanges(originalDoc, localSteps.map(function (s) {
+    return s.step;
+  }));
+  var remoteChanges = findContentChanges(originalDoc, remoteSteps);
+
+  // This is the mapping between the original document and our final one which can be used to
+  // map conflict positions (which are based on the original doc)
+  var mapping = tr.mapping.slice(mapStart);
+
+  // Find the overlapping conflicts - these are based on the positions of the original document so are
+  // common to both local and remote documents.
+  // The above mapping allows us to bring these positions to where they are in the current document
+  var conflictingChanges = getConflicts({
+    localChanges: localChanges,
+    localDoc: localDoc,
+    remoteDoc: remoteDoc,
+    remoteChanges: remoteChanges
+  });
+  var isConflictChange = function isConflictChange(value) {
+    return Boolean(value);
+  };
+  return {
+    inserted: conflictingChanges.filter(function (i) {
+      return i.remote.size !== 0;
+    }).map(function (i) {
+      return _objectSpread(_objectSpread({}, i), {}, {
+        from: mapping.map(i.from, -1),
+        to: mapping.map(i.to)
+      });
+    }).filter(isConflictChange),
+    deleted: conflictingChanges.filter(function (d) {
+      return d.remote.size === 0;
+    }).map(function (d) {
+      return _objectSpread(_objectSpread({}, d), {}, {
+        from: mapping.map(d.from),
+        to: mapping.map(d.to)
+      });
+    }).filter(isConflictChange)
+  };
+}

package/dist/esm/errors/ncs-errors.js

@@ -21,7 +21,7 @@ export var NCS_ERROR_CODE = /*#__PURE__*/function (NCS_ERROR_CODE) {
   return NCS_ERROR_CODE;
 }({});
 
-// TODO: Import emitted error codes from NCS
+// TODO: ED-26957 - Import emitted error codes from NCS
 
 // NCS Errors
 // - Step rejection errors

package/dist/esm/provider/commit-step.js

@@ -9,7 +9,7 @@ import { NCS_ERROR_CODE } from '../errors/ncs-errors';
 import { createLogger } from '../helpers/utils';
 var logger = createLogger('commit-step', 'black');
 export var readyToCommit = true;
-export var RESET_READYTOCOMMIT_INTERVAL_MS = 20000;
+export var RESET_READYTOCOMMIT_INTERVAL_MS = 5000;
 export var commitStepQueue = function commitStepQueue(_ref) {
   var broadcast = _ref.broadcast,
     steps = _ref.steps,

package/dist/esm/version-wrapper.js

@@ -1,5 +1,5 @@
 export var name = "@atlaskit/collab-provider";
-export var version = "10.9.2";
+export var version = "10.9.3";
 export var nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/types/document/getConflictChanges.d.ts

@@ -0,0 +1,26 @@
+import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { ConflictChanges } from '@atlaskit/editor-common/collab';
+interface Options {
+    localSteps: readonly {
+        inverted: ProseMirrorStep;
+        step: ProseMirrorStep;
+    }[];
+    remoteSteps: ProseMirrorStep[];
+    tr: Transaction;
+}
+/**
+ * Gets the conflicts between the local document and the remote document based on steps.
+ * It assumes the steps will be rebased using the `prosemirror-collab` algorithm synchronously after this
+ * Therefore the `tr` property is based on the document before rebasing.
+ *
+ * In the future we could possibly use `prosemirror-recreate-steps` (or similar approach)
+ * and tweak this to work for arbitrary diffs between offline and remote documents.
+ *
+ * @param localSteps Local steps applied between now and the server steps
+ * @param remoteSteps Steps retrieved from the server
+ * @param tr Transaction of the current document (expected to happen with local steps applied, before remote are applied)
+ * @returns All the conflicts (inserted + deleted) which can be applied to the current document
+ */
+export declare function getConflictChanges({ localSteps, remoteSteps, tr }: Options): ConflictChanges;
+export {};

package/dist/types/provider/commit-step.d.ts

@@ -4,7 +4,7 @@ import type { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/trans
 import type AnalyticsHelper from '../analytics/analytics-helper';
 import type { InternalError } from '../errors/internal-errors';
 export declare let readyToCommit: boolean;
-export declare const RESET_READYTOCOMMIT_INTERVAL_MS = 20000;
+export declare const RESET_READYTOCOMMIT_INTERVAL_MS = 5000;
 export declare const commitStepQueue: ({ broadcast, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, emit, __livePage, hasRecovered, collabMode, forcePublish, }: {
     broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void;
     steps: readonly ProseMirrorStep[];

package/dist/types-ts4.5/document/getConflictChanges.d.ts

@@ -0,0 +1,26 @@
+import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform';
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { ConflictChanges } from '@atlaskit/editor-common/collab';
+interface Options {
+    localSteps: readonly {
+        inverted: ProseMirrorStep;
+        step: ProseMirrorStep;
+    }[];
+    remoteSteps: ProseMirrorStep[];
+    tr: Transaction;
+}
+/**
+ * Gets the conflicts between the local document and the remote document based on steps.
+ * It assumes the steps will be rebased using the `prosemirror-collab` algorithm synchronously after this
+ * Therefore the `tr` property is based on the document before rebasing.
+ *
+ * In the future we could possibly use `prosemirror-recreate-steps` (or similar approach)
+ * and tweak this to work for arbitrary diffs between offline and remote documents.
+ *
+ * @param localSteps Local steps applied between now and the server steps
+ * @param remoteSteps Steps retrieved from the server
+ * @param tr Transaction of the current document (expected to happen with local steps applied, before remote are applied)
+ * @returns All the conflicts (inserted + deleted) which can be applied to the current document
+ */
+export declare function getConflictChanges({ localSteps, remoteSteps, tr }: Options): ConflictChanges;
+export {};

package/dist/types-ts4.5/provider/commit-step.d.ts

@@ -4,7 +4,7 @@ import type { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/trans
 import type AnalyticsHelper from '../analytics/analytics-helper';
 import type { InternalError } from '../errors/internal-errors';
 export declare let readyToCommit: boolean;
-export declare const RESET_READYTOCOMMIT_INTERVAL_MS = 20000;
+export declare const RESET_READYTOCOMMIT_INTERVAL_MS = 5000;
 export declare const commitStepQueue: ({ broadcast, steps, version, userId, clientId, onStepsAdded, onErrorHandled, analyticsHelper, emit, __livePage, hasRecovered, collabMode, forcePublish, }: {
     broadcast: <K extends keyof ChannelEvent>(type: K, data: Omit<ChannelEvent[K], 'timestamp'>, callback?: Function) => void;
     steps: readonly ProseMirrorStep[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/collab-provider",
-	"version": "10.9.2",
+	"version": "10.9.3",
 	"description": "A provider for collaborative editing.",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -35,7 +35,7 @@
 		"@atlaskit/adf-utils": "^19.19.0",
 		"@atlaskit/analytics-gas-types": "^5.1.0",
 		"@atlaskit/analytics-listeners": "^9.0.0",
-		"@atlaskit/editor-common": "^102.0.0",
+		"@atlaskit/editor-common": "^102.2.0",
 		"@atlaskit/editor-json-transformer": "^8.24.0",
 		"@atlaskit/editor-prosemirror": "7.0.0",
 		"@atlaskit/feature-gate-js-client": "^4.26.0",
@@ -47,6 +47,7 @@
 		"@babel/runtime": "^7.0.0",
 		"eventemitter2": "^4.1.0",
 		"lodash": "^4.17.21",
+		"prosemirror-changeset": "^2.2.1",
 		"socket.io-client": "^4.7.5",
 		"uuid": "^3.1.0"
 	},