@atlaskit/prosemirror-collab 0.16.2 → 0.16.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/prosemirror-collab
 
+## 0.16.4
+
+### Patch Changes
+
+- Updated dependencies
+
+## 0.16.3
+
+### Patch Changes
+
+- [#144227](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/144227)
+  [`6da190d8e3a24`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/6da190d8e3a24) -
+  Add ability to rebase drag and drop content
+- Updated dependencies
+
 ## 0.16.2
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -4,6 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.Rebaseable = void 0;
 exports.collab = collab;
 exports.getCollabState = getCollabState;
 exports.getDocBeforeUnconfirmedSteps = getDocBeforeUnconfirmedSteps;
@@ -16,13 +17,13 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 var _uuid = require("uuid");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _experiments = require("@atlaskit/tmp-editor-statsig/experiments");
-var Rebaseable = /*#__PURE__*/(0, _createClass2.default)(function Rebaseable(step, inverted, origin) {
+var _movedContent = require("./movedContent");
+var Rebaseable = exports.Rebaseable = /*#__PURE__*/(0, _createClass2.default)(function Rebaseable(step, inverted, origin) {
   (0, _classCallCheck2.default)(this, Rebaseable);
   this.step = step;
   this.inverted = inverted;
   this.origin = origin;
-}); /// Undo a given set of steps, apply a set of other steps, and then
-/// redo them @internal
+});
 function rebaseSteps(steps, over, transform) {
   for (var i = steps.length - 1; i >= 0; i--) {
     transform.step(steps[i].inverted);
@@ -33,6 +34,7 @@ function rebaseSteps(steps, over, transform) {
   var result = [];
   for (var _i2 = 0, mapFrom = steps.length; _i2 < steps.length; _i2++) {
     var mapped = steps[_i2].step.map(transform.mapping.slice(mapFrom));
+    var movedStep = (0, _experiments.editorExperiment)('platform_editor_offline_editing_web', true) ? (0, _movedContent.mapStep)(steps, transform, _i2, mapped) : undefined;
     mapFrom--;
     if (mapped && !transform.maybeStep(mapped).failed) {
       // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
@@ -40,6 +42,13 @@ function rebaseSteps(steps, over, transform) {
       transform.mapping.setMirror(mapFrom, transform.steps.length - 1);
       result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[_i2].origin));
     }
+
+    // If the step is a "move" step - apply the additional step
+    if ((0, _experiments.editorExperiment)('platform_editor_offline_editing_web', true)) {
+      if (movedStep && !transform.maybeStep(movedStep).failed) {
+        result.push(new Rebaseable(movedStep, movedStep.invert(transform.docs[transform.docs.length - 1]), transform));
+      }
+    }
   }
   return result;
 }

package/dist/cjs/movedContent.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mapStep = exports.isMoveSequence = exports.createMoveMapStep = void 0;
+var _steps = require("@atlaskit/adf-schema/steps");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+// Iterate from the specified starting index down to 0
+var findPreviousStepInverseIndex = function findPreviousStepInverseIndex(steps) {
+  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : steps.length - 1;
+  for (var i = startIndex; i >= 0; i--) {
+    if (!(steps[i] instanceof _steps.AnalyticsStep)) {
+      return i;
+    }
+  }
+};
+var mapStep = exports.mapStep = function mapStep(steps, transform, index, mapped) {
+  if (index < 1) {
+    return undefined;
+  }
+  var previousRebaseableStepIndex = findPreviousStepInverseIndex(steps.map(function (s) {
+    return s.step;
+  }), index - 1);
+
+  // This checks the local steps are a "move" sequence
+  if (previousRebaseableStepIndex !== undefined && isMoveSequence(steps[previousRebaseableStepIndex], steps[index].step)) {
+    var previousStepInverseIndex = findPreviousStepInverseIndex(transform.steps);
+
+    // Creates a new step based on the "current" steps (partially through the rebase)
+    if (previousStepInverseIndex !== undefined) {
+      return createMoveMapStep(mapped, transform.steps[previousStepInverseIndex], transform, previousStepInverseIndex);
+    }
+  }
+};
+
+// Only consider ReplaceStep (ReplaceAroundStep do not occur for moves)
+var isReplaceTypeStep = function isReplaceTypeStep(step) {
+  return step instanceof _transform.ReplaceStep;
+};
+
+/**
+ * Determines if a step pairing is a move sequence (ie. drag + drop or cut + paste).
+ *
+ * We determine this if we have a deletion followed by insertion and their content matches
+ *
+ * @param previousStep
+ * @param currentStep
+ * @param previousRebaseable
+ */
+var isMoveSequence = exports.isMoveSequence = function isMoveSequence(previousRebaseableStep, currentStep) {
+  if (
+  // The both steps are replace
+  isReplaceTypeStep(previousRebaseableStep.step) && isReplaceTypeStep(currentStep) &&
+  // The current step is a deletion
+  previousRebaseableStep.step.slice.size === 0 &&
+  // The following step is an insertion with the same length that was deleted by the current step
+  Math.abs(previousRebaseableStep.step.to - previousRebaseableStep.step.from) === currentStep.slice.size) {
+    // Ensure we're getting the doc before our step changes so we can compare node contents
+    var originStepIndex = previousRebaseableStep.origin.steps.findIndex(function (s) {
+      return s === previousRebaseableStep.step;
+    });
+    var originalDoc = previousRebaseableStep.origin.docs[originStepIndex];
+    var currentSlice = originalDoc.slice(previousRebaseableStep.step.from, previousRebaseableStep.step.to);
+    // The content from the deleted + inserted slice is exactly the same (cut + paste or drag + drop)
+    if (currentSlice.eq(currentStep.slice)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Update the replace step slice of the insert part of a move
+ * to contain the slice of the current document rather than what was sliced originally.
+ *
+ * @param mapped
+ * @param previousStep
+ * @param transform
+ * @returns Step to apply missing changes
+ */
+var createMoveMapStep = exports.createMoveMapStep = function createMoveMapStep(mapped, previousStep, transform, previousStepIndex) {
+  if (!isReplaceTypeStep(previousStep) || mapped && !isReplaceTypeStep(mapped) || !mapped) {
+    return undefined;
+  }
+  var newSlice = transform.docs[previousStepIndex].slice(previousStep === null || previousStep === void 0 ? void 0 : previousStep.from, previousStep === null || previousStep === void 0 ? void 0 : previousStep.to);
+  var diff = getDiffRange(mapped.slice.content, newSlice.content);
+  if (diff === undefined) {
+    return undefined;
+  }
+  var start = mapped.from + diff.start;
+  var offset = newSlice.content.size - mapped.slice.content.size === 0 ? diff.end - diff.start : 0;
+
+  // If the new slice is smaller then we're doing a deletion of content - this needs
+  // to be a replace step with empty content to delete content
+  if (newSlice.content.size - mapped.slice.content.size < 0) {
+    return new _transform.ReplaceStep(start, start + mapped.slice.content.size - newSlice.content.size, _model.Slice.empty);
+  }
+
+  // Replace the diff range with the latest content in the document (at the old position)
+  return new _transform.ReplaceStep(start, start + offset, transform.docs[previousStepIndex].slice((previousStep === null || previousStep === void 0 ? void 0 : previousStep.from) + diff.start, (previousStep === null || previousStep === void 0 ? void 0 : previousStep.from) + diff.end));
+};
+
+/**
+ * Get start and end diff position values for two fragments (old, new).
+ * @param {Fragment} before - content that is planned to move
+ * @param {Fragment} after - content that was in paragraph being deleted (updated content)
+ * @returns {object} - { start, end }
+ */
+function getDiffRange(before, after) {
+  // https://prosemirror.net/docs/ref/#model.Fragment.findDiffStart
+  var start = before.findDiffStart(after);
+  // Important: diffEnd value is {a,b} object since end pos will differ.
+  // https://prosemirror.net/docs/ref/#model.Fragment.findDiffEnd
+  var diffEnd = before.findDiffEnd(after);
+  if (start === null || diffEnd === null) {
+    return undefined;
+  }
+  // WARNING: diffEnd may be lower than diffStart.
+  // If so, add overlap to get correct range.
+  // https://discuss.prosemirror.net/t/overlap-handling-of-finddiffstart-and-finddiffend/2856
+  var overlap = start - Math.min(diffEnd.a, diffEnd.b);
+  var end = diffEnd.b;
+  if (overlap > 0) {
+    end += overlap;
+  }
+  return {
+    start: start,
+    end: end
+  };
+}

package/dist/es2019/index.js

@@ -1,16 +1,14 @@
 import { v4 as uuidv4 } from 'uuid';
 import { Plugin, PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
-class Rebaseable {
+import { mapStep } from './movedContent';
+export class Rebaseable {
   constructor(step, inverted, origin) {
     this.step = step;
     this.inverted = inverted;
     this.origin = origin;
   }
 }
-
-/// Undo a given set of steps, apply a set of other steps, and then
-/// redo them @internal
 export function rebaseSteps(steps, over, transform) {
   for (let i = steps.length - 1; i >= 0; i--) {
     transform.step(steps[i].inverted);
@@ -21,6 +19,7 @@ export function rebaseSteps(steps, over, transform) {
   const result = [];
   for (let i = 0, mapFrom = steps.length; i < steps.length; i++) {
     const mapped = steps[i].step.map(transform.mapping.slice(mapFrom));
+    const movedStep = editorExperiment('platform_editor_offline_editing_web', true) ? mapStep(steps, transform, i, mapped) : undefined;
     mapFrom--;
     if (mapped && !transform.maybeStep(mapped).failed) {
       // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
@@ -28,6 +27,13 @@ export function rebaseSteps(steps, over, transform) {
       transform.mapping.setMirror(mapFrom, transform.steps.length - 1);
       result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[i].origin));
     }
+
+    // If the step is a "move" step - apply the additional step
+    if (editorExperiment('platform_editor_offline_editing_web', true)) {
+      if (movedStep && !transform.maybeStep(movedStep).failed) {
+        result.push(new Rebaseable(movedStep, movedStep.invert(transform.docs[transform.docs.length - 1]), transform));
+      }
+    }
   }
   return result;
 }

package/dist/es2019/movedContent.js

@@ -0,0 +1,119 @@
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+// Iterate from the specified starting index down to 0
+const findPreviousStepInverseIndex = (steps, startIndex = steps.length - 1) => {
+  for (let i = startIndex; i >= 0; i--) {
+    if (!(steps[i] instanceof AnalyticsStep)) {
+      return i;
+    }
+  }
+};
+export const mapStep = (steps, transform, index, mapped) => {
+  if (index < 1) {
+    return undefined;
+  }
+  const previousRebaseableStepIndex = findPreviousStepInverseIndex(steps.map(s => s.step), index - 1);
+
+  // This checks the local steps are a "move" sequence
+  if (previousRebaseableStepIndex !== undefined && isMoveSequence(steps[previousRebaseableStepIndex], steps[index].step)) {
+    const previousStepInverseIndex = findPreviousStepInverseIndex(transform.steps);
+
+    // Creates a new step based on the "current" steps (partially through the rebase)
+    if (previousStepInverseIndex !== undefined) {
+      return createMoveMapStep(mapped, transform.steps[previousStepInverseIndex], transform, previousStepInverseIndex);
+    }
+  }
+};
+
+// Only consider ReplaceStep (ReplaceAroundStep do not occur for moves)
+const isReplaceTypeStep = step => step instanceof ReplaceStep;
+
+/**
+ * Determines if a step pairing is a move sequence (ie. drag + drop or cut + paste).
+ *
+ * We determine this if we have a deletion followed by insertion and their content matches
+ *
+ * @param previousStep
+ * @param currentStep
+ * @param previousRebaseable
+ */
+export const isMoveSequence = (previousRebaseableStep, currentStep) => {
+  if (
+  // The both steps are replace
+  isReplaceTypeStep(previousRebaseableStep.step) && isReplaceTypeStep(currentStep) &&
+  // The current step is a deletion
+  previousRebaseableStep.step.slice.size === 0 &&
+  // The following step is an insertion with the same length that was deleted by the current step
+  Math.abs(previousRebaseableStep.step.to - previousRebaseableStep.step.from) === currentStep.slice.size) {
+    // Ensure we're getting the doc before our step changes so we can compare node contents
+    const originStepIndex = previousRebaseableStep.origin.steps.findIndex(s => s === previousRebaseableStep.step);
+    const originalDoc = previousRebaseableStep.origin.docs[originStepIndex];
+    const currentSlice = originalDoc.slice(previousRebaseableStep.step.from, previousRebaseableStep.step.to);
+    // The content from the deleted + inserted slice is exactly the same (cut + paste or drag + drop)
+    if (currentSlice.eq(currentStep.slice)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Update the replace step slice of the insert part of a move
+ * to contain the slice of the current document rather than what was sliced originally.
+ *
+ * @param mapped
+ * @param previousStep
+ * @param transform
+ * @returns Step to apply missing changes
+ */
+export const createMoveMapStep = (mapped, previousStep, transform, previousStepIndex) => {
+  if (!isReplaceTypeStep(previousStep) || mapped && !isReplaceTypeStep(mapped) || !mapped) {
+    return undefined;
+  }
+  const newSlice = transform.docs[previousStepIndex].slice(previousStep === null || previousStep === void 0 ? void 0 : previousStep.from, previousStep === null || previousStep === void 0 ? void 0 : previousStep.to);
+  const diff = getDiffRange(mapped.slice.content, newSlice.content);
+  if (diff === undefined) {
+    return undefined;
+  }
+  const start = mapped.from + diff.start;
+  const offset = newSlice.content.size - mapped.slice.content.size === 0 ? diff.end - diff.start : 0;
+
+  // If the new slice is smaller then we're doing a deletion of content - this needs
+  // to be a replace step with empty content to delete content
+  if (newSlice.content.size - mapped.slice.content.size < 0) {
+    return new ReplaceStep(start, start + mapped.slice.content.size - newSlice.content.size, Slice.empty);
+  }
+
+  // Replace the diff range with the latest content in the document (at the old position)
+  return new ReplaceStep(start, start + offset, transform.docs[previousStepIndex].slice((previousStep === null || previousStep === void 0 ? void 0 : previousStep.from) + diff.start, (previousStep === null || previousStep === void 0 ? void 0 : previousStep.from) + diff.end));
+};
+
+/**
+ * Get start and end diff position values for two fragments (old, new).
+ * @param {Fragment} before - content that is planned to move
+ * @param {Fragment} after - content that was in paragraph being deleted (updated content)
+ * @returns {object} - { start, end }
+ */
+function getDiffRange(before, after) {
+  // https://prosemirror.net/docs/ref/#model.Fragment.findDiffStart
+  const start = before.findDiffStart(after);
+  // Important: diffEnd value is {a,b} object since end pos will differ.
+  // https://prosemirror.net/docs/ref/#model.Fragment.findDiffEnd
+  const diffEnd = before.findDiffEnd(after);
+  if (start === null || diffEnd === null) {
+    return undefined;
+  }
+  // WARNING: diffEnd may be lower than diffStart.
+  // If so, add overlap to get correct range.
+  // https://discuss.prosemirror.net/t/overlap-handling-of-finddiffstart-and-finddiffend/2856
+  const overlap = start - Math.min(diffEnd.a, diffEnd.b);
+  let end = diffEnd.b;
+  if (overlap > 0) {
+    end += overlap;
+  }
+  return {
+    start,
+    end
+  };
+}

package/dist/esm/index.js

@@ -3,13 +3,13 @@ import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import { v4 as uuidv4 } from 'uuid';
 import { Plugin, PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
-var Rebaseable = /*#__PURE__*/_createClass(function Rebaseable(step, inverted, origin) {
+import { mapStep } from './movedContent';
+export var Rebaseable = /*#__PURE__*/_createClass(function Rebaseable(step, inverted, origin) {
   _classCallCheck(this, Rebaseable);
   this.step = step;
   this.inverted = inverted;
   this.origin = origin;
-}); /// Undo a given set of steps, apply a set of other steps, and then
-/// redo them @internal
+});
 export function rebaseSteps(steps, over, transform) {
   for (var i = steps.length - 1; i >= 0; i--) {
     transform.step(steps[i].inverted);
@@ -20,6 +20,7 @@ export function rebaseSteps(steps, over, transform) {
   var result = [];
   for (var _i2 = 0, mapFrom = steps.length; _i2 < steps.length; _i2++) {
     var mapped = steps[_i2].step.map(transform.mapping.slice(mapFrom));
+    var movedStep = editorExperiment('platform_editor_offline_editing_web', true) ? mapStep(steps, transform, _i2, mapped) : undefined;
     mapFrom--;
     if (mapped && !transform.maybeStep(mapped).failed) {
       // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
@@ -27,6 +28,13 @@ export function rebaseSteps(steps, over, transform) {
       transform.mapping.setMirror(mapFrom, transform.steps.length - 1);
       result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[_i2].origin));
     }
+
+    // If the step is a "move" step - apply the additional step
+    if (editorExperiment('platform_editor_offline_editing_web', true)) {
+      if (movedStep && !transform.maybeStep(movedStep).failed) {
+        result.push(new Rebaseable(movedStep, movedStep.invert(transform.docs[transform.docs.length - 1]), transform));
+      }
+    }
   }
   return result;
 }

package/dist/esm/movedContent.js

@@ -0,0 +1,126 @@
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+// Iterate from the specified starting index down to 0
+var findPreviousStepInverseIndex = function findPreviousStepInverseIndex(steps) {
+  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : steps.length - 1;
+  for (var i = startIndex; i >= 0; i--) {
+    if (!(steps[i] instanceof AnalyticsStep)) {
+      return i;
+    }
+  }
+};
+export var mapStep = function mapStep(steps, transform, index, mapped) {
+  if (index < 1) {
+    return undefined;
+  }
+  var previousRebaseableStepIndex = findPreviousStepInverseIndex(steps.map(function (s) {
+    return s.step;
+  }), index - 1);
+
+  // This checks the local steps are a "move" sequence
+  if (previousRebaseableStepIndex !== undefined && isMoveSequence(steps[previousRebaseableStepIndex], steps[index].step)) {
+    var previousStepInverseIndex = findPreviousStepInverseIndex(transform.steps);
+
+    // Creates a new step based on the "current" steps (partially through the rebase)
+    if (previousStepInverseIndex !== undefined) {
+      return createMoveMapStep(mapped, transform.steps[previousStepInverseIndex], transform, previousStepInverseIndex);
+    }
+  }
+};
+
+// Only consider ReplaceStep (ReplaceAroundStep do not occur for moves)
+var isReplaceTypeStep = function isReplaceTypeStep(step) {
+  return step instanceof ReplaceStep;
+};
+
+/**
+ * Determines if a step pairing is a move sequence (ie. drag + drop or cut + paste).
+ *
+ * We determine this if we have a deletion followed by insertion and their content matches
+ *
+ * @param previousStep
+ * @param currentStep
+ * @param previousRebaseable
+ */
+export var isMoveSequence = function isMoveSequence(previousRebaseableStep, currentStep) {
+  if (
+  // The both steps are replace
+  isReplaceTypeStep(previousRebaseableStep.step) && isReplaceTypeStep(currentStep) &&
+  // The current step is a deletion
+  previousRebaseableStep.step.slice.size === 0 &&
+  // The following step is an insertion with the same length that was deleted by the current step
+  Math.abs(previousRebaseableStep.step.to - previousRebaseableStep.step.from) === currentStep.slice.size) {
+    // Ensure we're getting the doc before our step changes so we can compare node contents
+    var originStepIndex = previousRebaseableStep.origin.steps.findIndex(function (s) {
+      return s === previousRebaseableStep.step;
+    });
+    var originalDoc = previousRebaseableStep.origin.docs[originStepIndex];
+    var currentSlice = originalDoc.slice(previousRebaseableStep.step.from, previousRebaseableStep.step.to);
+    // The content from the deleted + inserted slice is exactly the same (cut + paste or drag + drop)
+    if (currentSlice.eq(currentStep.slice)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Update the replace step slice of the insert part of a move
+ * to contain the slice of the current document rather than what was sliced originally.
+ *
+ * @param mapped
+ * @param previousStep
+ * @param transform
+ * @returns Step to apply missing changes
+ */
+export var createMoveMapStep = function createMoveMapStep(mapped, previousStep, transform, previousStepIndex) {
+  if (!isReplaceTypeStep(previousStep) || mapped && !isReplaceTypeStep(mapped) || !mapped) {
+    return undefined;
+  }
+  var newSlice = transform.docs[previousStepIndex].slice(previousStep === null || previousStep === void 0 ? void 0 : previousStep.from, previousStep === null || previousStep === void 0 ? void 0 : previousStep.to);
+  var diff = getDiffRange(mapped.slice.content, newSlice.content);
+  if (diff === undefined) {
+    return undefined;
+  }
+  var start = mapped.from + diff.start;
+  var offset = newSlice.content.size - mapped.slice.content.size === 0 ? diff.end - diff.start : 0;
+
+  // If the new slice is smaller then we're doing a deletion of content - this needs
+  // to be a replace step with empty content to delete content
+  if (newSlice.content.size - mapped.slice.content.size < 0) {
+    return new ReplaceStep(start, start + mapped.slice.content.size - newSlice.content.size, Slice.empty);
+  }
+
+  // Replace the diff range with the latest content in the document (at the old position)
+  return new ReplaceStep(start, start + offset, transform.docs[previousStepIndex].slice((previousStep === null || previousStep === void 0 ? void 0 : previousStep.from) + diff.start, (previousStep === null || previousStep === void 0 ? void 0 : previousStep.from) + diff.end));
+};
+
+/**
+ * Get start and end diff position values for two fragments (old, new).
+ * @param {Fragment} before - content that is planned to move
+ * @param {Fragment} after - content that was in paragraph being deleted (updated content)
+ * @returns {object} - { start, end }
+ */
+function getDiffRange(before, after) {
+  // https://prosemirror.net/docs/ref/#model.Fragment.findDiffStart
+  var start = before.findDiffStart(after);
+  // Important: diffEnd value is {a,b} object since end pos will differ.
+  // https://prosemirror.net/docs/ref/#model.Fragment.findDiffEnd
+  var diffEnd = before.findDiffEnd(after);
+  if (start === null || diffEnd === null) {
+    return undefined;
+  }
+  // WARNING: diffEnd may be lower than diffStart.
+  // If so, add overlap to get correct range.
+  // https://discuss.prosemirror.net/t/overlap-handling-of-finddiffstart-and-finddiffend/2856
+  var overlap = start - Math.min(diffEnd.a, diffEnd.b);
+  var end = diffEnd.b;
+  if (overlap > 0) {
+    end += overlap;
+  }
+  return {
+    start: start,
+    end: end
+  };
+}

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
 import { Plugin } from '@atlaskit/editor-prosemirror/state';
 import type { Step as ProseMirrorStep, Transform as ProseMirrorTransform } from '@atlaskit/editor-prosemirror/transform';
-declare class Rebaseable {
+export declare class Rebaseable {
     readonly step: ProseMirrorStep;
     readonly inverted: ProseMirrorStep;
     readonly origin: ProseMirrorTransform;

package/dist/types/movedContent.d.ts

@@ -0,0 +1,24 @@
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import type { Step as ProseMirrorStep, Transform as ProseMirrorTransform } from '@atlaskit/editor-prosemirror/transform';
+import type { Rebaseable } from './index';
+export declare const mapStep: (steps: readonly Rebaseable[], transform: ProseMirrorTransform, index: number, mapped: ProseMirrorStep | null) => ReplaceStep | undefined;
+/**
+ * Determines if a step pairing is a move sequence (ie. drag + drop or cut + paste).
+ *
+ * We determine this if we have a deletion followed by insertion and their content matches
+ *
+ * @param previousStep
+ * @param currentStep
+ * @param previousRebaseable
+ */
+export declare const isMoveSequence: (previousRebaseableStep: Rebaseable, currentStep: ProseMirrorStep) => boolean;
+/**
+ * Update the replace step slice of the insert part of a move
+ * to contain the slice of the current document rather than what was sliced originally.
+ *
+ * @param mapped
+ * @param previousStep
+ * @param transform
+ * @returns Step to apply missing changes
+ */
+export declare const createMoveMapStep: (mapped: ProseMirrorStep | null, previousStep: ProseMirrorStep, transform: ProseMirrorTransform, previousStepIndex: number) => ReplaceStep | undefined;

package/dist/types-ts4.5/index.d.ts

@@ -1,7 +1,7 @@
 import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
 import { Plugin } from '@atlaskit/editor-prosemirror/state';
 import type { Step as ProseMirrorStep, Transform as ProseMirrorTransform } from '@atlaskit/editor-prosemirror/transform';
-declare class Rebaseable {
+export declare class Rebaseable {
     readonly step: ProseMirrorStep;
     readonly inverted: ProseMirrorStep;
     readonly origin: ProseMirrorTransform;

package/dist/types-ts4.5/movedContent.d.ts

@@ -0,0 +1,24 @@
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import type { Step as ProseMirrorStep, Transform as ProseMirrorTransform } from '@atlaskit/editor-prosemirror/transform';
+import type { Rebaseable } from './index';
+export declare const mapStep: (steps: readonly Rebaseable[], transform: ProseMirrorTransform, index: number, mapped: ProseMirrorStep | null) => ReplaceStep | undefined;
+/**
+ * Determines if a step pairing is a move sequence (ie. drag + drop or cut + paste).
+ *
+ * We determine this if we have a deletion followed by insertion and their content matches
+ *
+ * @param previousStep
+ * @param currentStep
+ * @param previousRebaseable
+ */
+export declare const isMoveSequence: (previousRebaseableStep: Rebaseable, currentStep: ProseMirrorStep) => boolean;
+/**
+ * Update the replace step slice of the insert part of a move
+ * to contain the slice of the current document rather than what was sliced originally.
+ *
+ * @param mapped
+ * @param previousStep
+ * @param transform
+ * @returns Step to apply missing changes
+ */
+export declare const createMoveMapStep: (mapped: ProseMirrorStep | null, previousStep: ProseMirrorStep, transform: ProseMirrorTransform, previousStepIndex: number) => ReplaceStep | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/prosemirror-collab",
-	"version": "0.16.2",
+	"version": "0.16.4",
 	"description": "Collaborative editing for ProseMirror - Atlassian Fork",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -30,14 +30,12 @@
 		".": "./src/index.ts"
 	},
 	"dependencies": {
+		"@atlaskit/adf-schema": "^47.6.0",
 		"@atlaskit/editor-prosemirror": "7.0.0",
-		"@atlaskit/tmp-editor-statsig": "^4.8.0",
+		"@atlaskit/tmp-editor-statsig": "^5.0.0",
 		"@babel/runtime": "^7.0.0",
 		"uuid": "^3.1.0"
 	},
-	"devDependencies": {
-		"@atlaskit/adf-schema": "^47.6.0"
-	},
 	"techstack": {
 		"@atlassian/frontend": {
 			"import-structure": [