@atlaskit/prosemirror-collab 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,80 @@
+## 1.3.0 (2022-05-30)
+
+## 0.1.0
+
+### Minor Changes
+
+- [`883590cbe7d`](https://bitbucket.org/atlassian/atlassian-frontend/commits/883590cbe7d) - [ESS-2914] Forked the prosemirror-collab library to create a version that filters out analytics steps
+
+### Patch Changes
+
+- Updated dependencies
+
+### New features
+
+Include TypeScript type declarations.
+
+## 1.2.2 (2019-11-20)
+
+### Bug fixes
+
+Rename ES module files to use a .js extension, since Webpack gets confused by .mjs
+
+## 1.2.1 (2019-11-19)
+
+### Bug fixes
+
+The file referred to in the package's `module` field now is compiled down to ES5.
+
+## 1.2.0 (2019-11-08)
+
+### New features
+
+Add a `module` field to package json file.
+
+## 1.1.2 (2019-05-29)
+
+### Bug fixes
+
+Fix an issue where in `mapSelectionBackward` mode, the plugin flipped the head and anchor of the selection, leading to selection glitches during collaborative editing.
+
+## 1.1.1 (2018-10-09)
+
+### Bug fixes
+
+Fix issue where `mapSelectionBackward` didn't work because of a typo.
+
+## 1.1.0 (2018-08-21)
+
+### New features
+
+[`receiveTransaction`](https://prosemirror.net/docs/ref/#collab.receiveTransaction) now supports a `mapSelectionBackward` option that makes it so that text selections are mapped to stay in place when remote changes insert content at their position.
+
+## 0.19.0 (2017-03-16)
+
+### New features
+
+You can now use strings (as well as numbers) as client IDs (this already worked, but now the documentation reflects this).
+
+## 0.18.0 (2017-02-24)
+
+### New features
+
+[`sendableSteps`](https://prosemirror.net/docs/ref/version/0.18.0.html#collab.sendableSteps) now also returns information about the original transactions that produced the steps.
+
+## 0.11.0 (2016-09-21)
+
+### Breaking changes
+
+Moved into a separate module.
+
+Interface [adjusted](https://prosemirror.net/docs/ref/version/0.11.0.html#collab) to work with the new
+[plugin](https://prosemirror.net/docs/ref/version/0.11.0.html#state.Plugin) system.
+
+### New features
+
+When receiving changes, the module now
+[generates](https://prosemirror.net/docs/ref/version/0.11.0.html#collab.receiveAction) a regular
+[transform action](https://prosemirror.net/docs/ref/version/0.11.0.html#state.TransformAction) instead of hard-setting
+the editor's document. This solves problematic corner cases for code
+keeping track of the document by listening to transform actions.

package/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (C) 2015-2017 by Marijn Haverbeke <marijnh@gmail.com> and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# prosemirror-collab
+
+This is a fork of the ProseMirror Collab module: [GitHub](https://github.com/prosemirror/prosemirror-collab) [NPM](https://www.npmjs.com/package/prosemirror-collab)
+
+[ [**WEBSITE**](https://prosemirror.net) | [**ISSUES**](https://github.com/prosemirror/prosemirror/issues) | [**FORUM**](https://discuss.prosemirror.net) | [**CHANGELOG**](https://github.com/ProseMirror/prosemirror-collab/blob/master/CHANGELOG.md) ]
+
+This is a [core module](https://prosemirror.net/docs/ref/#collab) of [ProseMirror](https://prosemirror.net).
+ProseMirror is a well-behaved rich semantic content editor based on
+contentEditable, with support for collaborative editing and custom
+document schemas.
+
+This [module](https://prosemirror.net/docs/ref/#collab) implements a
+plugin that helps track and merge changes for
+[collaborative editing](https://prosemirror.net/docs/guide/#collab).
+
+The [project page](https://prosemirror.net) has more information, a
+number of [examples](https://prosemirror.net/examples/) and the
+[documentation](https://prosemirror.net/docs/).
+
+This code is released under an
+[MIT license](https://github.com/prosemirror/prosemirror/tree/master/LICENSE).
+There's a [forum](http://discuss.prosemirror.net) for general
+discussion and support requests, and the
+[Github bug tracker](https://github.com/prosemirror/prosemirror/issues)
+is the place to report issues.
+
+We aim to be an inclusive, welcoming community. To make that explicit,
+we have a [code of
+conduct](http://contributor-covenant.org/version/1/1/0/) that applies
+to communication around the project.

package/dist/cjs/collab.js

@@ -0,0 +1,215 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collab = collab;
+exports.getVersion = getVersion;
+exports.rebaseSteps = rebaseSteps;
+exports.receiveTransaction = receiveTransaction;
+exports.sendableSteps = sendableSteps;
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _steps = require("@atlaskit/adf-schema/steps");
+
+var 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);
+  }
+
+  for (var _i = 0; _i < over.length; _i++) {
+    transform.step(over[_i]);
+  }
+
+  var result = [];
+
+  for (var _i2 = 0, mapFrom = steps.length; _i2 < steps.length; _i2++) {
+    var mapped = steps[_i2].step.map(transform.mapping.slice(mapFrom));
+
+    mapFrom--;
+
+    if (mapped && !transform.maybeStep(mapped).failed) {
+      // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
+      // @ts-expect-error
+      transform.mapping.setMirror(mapFrom, transform.steps.length - 1);
+      result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[_i2].origin));
+    }
+  }
+
+  return result;
+} // This state field accumulates changes that have to be sent to the
+// central authority in the collaborating group and makes it possible
+// to integrate changes made by peers into our local document. It is
+// defined by the plugin, and will be available as the `collab` field
+// in the resulting editor state.
+
+
+var CollabState = /*#__PURE__*/(0, _createClass2.default)(function CollabState( // The version number of the last update received from the central
+// authority. Starts at 0 or the value of the `version` property
+// in the option object, for the editor's value when the option
+// was enabled.
+version, // The local steps that havent been successfully sent to the
+// server yet.
+unconfirmed) {
+  (0, _classCallCheck2.default)(this, CollabState);
+  this.version = version;
+  this.unconfirmed = unconfirmed;
+});
+
+function unconfirmedFrom(transform) {
+  var result = [];
+
+  for (var i = 0; i < transform.steps.length; i++) {
+    // Filter out the analytics steps, they don't need to be sent to the collab service
+    if (transform.steps[i] instanceof _steps.AnalyticsStep) {
+      continue;
+    }
+
+    result.push(new Rebaseable(transform.steps[i], transform.steps[i].invert(transform.docs[i]), transform));
+  }
+
+  return result;
+}
+
+var collabKey = new _prosemirrorState.PluginKey('collab');
+
+/// Creates a plugin that enables the collaborative editing framework
+/// for the editor.
+function collab() {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var conf = {
+    version: config.version || 0,
+    clientID: // eslint-disable-next-line eqeqeq
+    config.clientID == null ? Math.floor(Math.random() * 0xffffffff) : config.clientID
+  };
+  return new _prosemirrorState.Plugin({
+    key: collabKey,
+    state: {
+      init: function init() {
+        return new CollabState(conf.version, []);
+      },
+      apply: function apply(tr, collab) {
+        var newState = tr.getMeta(collabKey);
+
+        if (newState) {
+          return newState;
+        }
+
+        if (tr.docChanged) {
+          return new CollabState(collab.version, // @ts-expect-error
+          collab.unconfirmed.concat(unconfirmedFrom(tr)));
+        }
+
+        return collab;
+      }
+    },
+    // @ts-expect-error
+    config: conf,
+    // This is used to notify the history plugin to not merge steps,
+    // so that the history can be rebased.
+    historyPreserveItems: true
+  });
+} /// Create a transaction that represents a set of new steps received from
+/// the authority. Applying this transaction moves the state forward to
+/// adjust to the authority's view of the document.
+
+
+function receiveTransaction(state, steps, clientIDs) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // Pushes a set of steps (received from the central authority) into
+  // the editor state (which should have the collab plugin enabled).
+  // Will recognize its own changes, and confirm unconfirmed steps as
+  // appropriate. Remaining unconfirmed steps will be rebased over
+  // remote steps.
+  var collabState = collabKey.getState(state);
+  var version = collabState.version + steps.length;
+  var ourID = collabKey.get(state).spec.config.clientID; // Find out which prefix of the steps originated with us
+
+  var ours = 0; // eslint-disable-next-line eqeqeq
+
+  while (ours < clientIDs.length && clientIDs[ours] == ourID) {
+    ++ours;
+  }
+
+  var unconfirmed = collabState.unconfirmed.slice(ours);
+  steps = ours ? steps.slice(ours) : steps; // If all steps originated with us, we're done.
+
+  if (!steps.length) {
+    return state.tr.setMeta(collabKey, new CollabState(version, unconfirmed));
+  }
+
+  var nUnconfirmed = unconfirmed.length;
+  var tr = state.tr;
+
+  if (nUnconfirmed) {
+    unconfirmed = rebaseSteps(unconfirmed, steps, tr);
+  } else {
+    for (var i = 0; i < steps.length; i++) {
+      tr.step(steps[i]);
+    }
+
+    unconfirmed = [];
+  }
+
+  var newCollabState = new CollabState(version, unconfirmed);
+
+  if (options && options.mapSelectionBackward && state.selection instanceof _prosemirrorState.TextSelection) {
+    tr.setSelection(_prosemirrorState.TextSelection.between(tr.doc.resolve(tr.mapping.map(state.selection.anchor, -1)), tr.doc.resolve(tr.mapping.map(state.selection.head, -1)), -1));
+    tr.updated &= ~1;
+  }
+
+  return tr.setMeta('rebased', nUnconfirmed).setMeta('addToHistory', false).setMeta(collabKey, newCollabState);
+} /// Provides data describing the editor's unconfirmed steps, which need
+/// to be sent to the central authority. Returns null when there is
+/// nothing to send.
+///
+/// `origins` holds the _original_ transactions that produced each
+/// steps. This can be useful for looking up time stamps and other
+/// metadata for the steps, but note that the steps may have been
+/// rebased, whereas the origin transactions are still the old,
+/// unchanged objects.
+
+
+function sendableSteps(state) {
+  var collabState = collabKey.getState(state); // eslint-disable-next-line eqeqeq
+
+  if (collabState.unconfirmed.length == 0) {
+    return null;
+  }
+
+  return {
+    version: collabState.version,
+    steps: collabState.unconfirmed.map(function (s) {
+      return s.step;
+    }),
+    clientID: collabKey.get(state).spec.config.clientID,
+
+    get origins() {
+      return this._origins || (this._origins = collabState.unconfirmed.map(function (s) {
+        return s.origin;
+      }));
+    }
+
+  };
+} /// Get the version up to which the collab plugin has synced with the
+/// central authority.
+
+
+function getVersion(state) {
+  return collabKey.getState(state).version;
+}

package/dist/cjs/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/prosemirror-collab",
+	"version": "0.1.0",
+	"sideEffects": false
+}

package/dist/es2019/collab.js

@@ -0,0 +1,190 @@
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+
+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);
+  }
+
+  for (let i = 0; i < over.length; i++) {
+    transform.step(over[i]);
+  }
+
+  let result = [];
+
+  for (let i = 0, mapFrom = steps.length; i < steps.length; i++) {
+    let mapped = steps[i].step.map(transform.mapping.slice(mapFrom));
+    mapFrom--;
+
+    if (mapped && !transform.maybeStep(mapped).failed) {
+      // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
+      // @ts-expect-error
+      transform.mapping.setMirror(mapFrom, transform.steps.length - 1);
+      result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[i].origin));
+    }
+  }
+
+  return result;
+} // This state field accumulates changes that have to be sent to the
+// central authority in the collaborating group and makes it possible
+// to integrate changes made by peers into our local document. It is
+// defined by the plugin, and will be available as the `collab` field
+// in the resulting editor state.
+
+class CollabState {
+  constructor( // The version number of the last update received from the central
+  // authority. Starts at 0 or the value of the `version` property
+  // in the option object, for the editor's value when the option
+  // was enabled.
+  version, // The local steps that havent been successfully sent to the
+  // server yet.
+  unconfirmed) {
+    this.version = version;
+    this.unconfirmed = unconfirmed;
+  }
+
+}
+
+function unconfirmedFrom(transform) {
+  let result = [];
+
+  for (let i = 0; i < transform.steps.length; i++) {
+    // Filter out the analytics steps, they don't need to be sent to the collab service
+    if (transform.steps[i] instanceof AnalyticsStep) {
+      continue;
+    }
+
+    result.push(new Rebaseable(transform.steps[i], transform.steps[i].invert(transform.docs[i]), transform));
+  }
+
+  return result;
+}
+
+const collabKey = new PluginKey('collab');
+/// Creates a plugin that enables the collaborative editing framework
+/// for the editor.
+export function collab(config = {}) {
+  let conf = {
+    version: config.version || 0,
+    clientID: // eslint-disable-next-line eqeqeq
+    config.clientID == null ? Math.floor(Math.random() * 0xffffffff) : config.clientID
+  };
+  return new Plugin({
+    key: collabKey,
+    state: {
+      init: () => new CollabState(conf.version, []),
+
+      apply(tr, collab) {
+        let newState = tr.getMeta(collabKey);
+
+        if (newState) {
+          return newState;
+        }
+
+        if (tr.docChanged) {
+          return new CollabState(collab.version, // @ts-expect-error
+          collab.unconfirmed.concat(unconfirmedFrom(tr)));
+        }
+
+        return collab;
+      }
+
+    },
+    // @ts-expect-error
+    config: conf,
+    // This is used to notify the history plugin to not merge steps,
+    // so that the history can be rebased.
+    historyPreserveItems: true
+  });
+} /// Create a transaction that represents a set of new steps received from
+/// the authority. Applying this transaction moves the state forward to
+/// adjust to the authority's view of the document.
+
+export function receiveTransaction(state, steps, clientIDs, options = {}) {
+  // Pushes a set of steps (received from the central authority) into
+  // the editor state (which should have the collab plugin enabled).
+  // Will recognize its own changes, and confirm unconfirmed steps as
+  // appropriate. Remaining unconfirmed steps will be rebased over
+  // remote steps.
+  let collabState = collabKey.getState(state);
+  let version = collabState.version + steps.length;
+  let ourID = collabKey.get(state).spec.config.clientID; // Find out which prefix of the steps originated with us
+
+  let ours = 0; // eslint-disable-next-line eqeqeq
+
+  while (ours < clientIDs.length && clientIDs[ours] == ourID) {
+    ++ours;
+  }
+
+  let unconfirmed = collabState.unconfirmed.slice(ours);
+  steps = ours ? steps.slice(ours) : steps; // If all steps originated with us, we're done.
+
+  if (!steps.length) {
+    return state.tr.setMeta(collabKey, new CollabState(version, unconfirmed));
+  }
+
+  let nUnconfirmed = unconfirmed.length;
+  let tr = state.tr;
+
+  if (nUnconfirmed) {
+    unconfirmed = rebaseSteps(unconfirmed, steps, tr);
+  } else {
+    for (let i = 0; i < steps.length; i++) {
+      tr.step(steps[i]);
+    }
+
+    unconfirmed = [];
+  }
+
+  let newCollabState = new CollabState(version, unconfirmed);
+
+  if (options && options.mapSelectionBackward && state.selection instanceof TextSelection) {
+    tr.setSelection(TextSelection.between(tr.doc.resolve(tr.mapping.map(state.selection.anchor, -1)), tr.doc.resolve(tr.mapping.map(state.selection.head, -1)), -1));
+    tr.updated &= ~1;
+  }
+
+  return tr.setMeta('rebased', nUnconfirmed).setMeta('addToHistory', false).setMeta(collabKey, newCollabState);
+} /// Provides data describing the editor's unconfirmed steps, which need
+/// to be sent to the central authority. Returns null when there is
+/// nothing to send.
+///
+/// `origins` holds the _original_ transactions that produced each
+/// steps. This can be useful for looking up time stamps and other
+/// metadata for the steps, but note that the steps may have been
+/// rebased, whereas the origin transactions are still the old,
+/// unchanged objects.
+
+export function sendableSteps(state) {
+  let collabState = collabKey.getState(state); // eslint-disable-next-line eqeqeq
+
+  if (collabState.unconfirmed.length == 0) {
+    return null;
+  }
+
+  return {
+    version: collabState.version,
+    steps: collabState.unconfirmed.map(s => s.step),
+    clientID: collabKey.get(state).spec.config.clientID,
+
+    get origins() {
+      return this._origins || (this._origins = collabState.unconfirmed.map(s => s.origin));
+    }
+
+  };
+} /// Get the version up to which the collab plugin has synced with the
+/// central authority.
+
+export function getVersion(state) {
+  return collabKey.getState(state).version;
+}

package/dist/es2019/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/prosemirror-collab",
+	"version": "0.1.0",
+	"sideEffects": false
+}

package/dist/esm/collab.js

@@ -0,0 +1,197 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+import { AnalyticsStep } from '@atlaskit/adf-schema/steps';
+
+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);
+  }
+
+  for (var _i = 0; _i < over.length; _i++) {
+    transform.step(over[_i]);
+  }
+
+  var result = [];
+
+  for (var _i2 = 0, mapFrom = steps.length; _i2 < steps.length; _i2++) {
+    var mapped = steps[_i2].step.map(transform.mapping.slice(mapFrom));
+
+    mapFrom--;
+
+    if (mapped && !transform.maybeStep(mapped).failed) {
+      // Open ticket for setMirror https://github.com/ProseMirror/prosemirror/issues/869
+      // @ts-expect-error
+      transform.mapping.setMirror(mapFrom, transform.steps.length - 1);
+      result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[_i2].origin));
+    }
+  }
+
+  return result;
+} // This state field accumulates changes that have to be sent to the
+// central authority in the collaborating group and makes it possible
+// to integrate changes made by peers into our local document. It is
+// defined by the plugin, and will be available as the `collab` field
+// in the resulting editor state.
+
+var CollabState = /*#__PURE__*/_createClass(function CollabState( // The version number of the last update received from the central
+// authority. Starts at 0 or the value of the `version` property
+// in the option object, for the editor's value when the option
+// was enabled.
+version, // The local steps that havent been successfully sent to the
+// server yet.
+unconfirmed) {
+  _classCallCheck(this, CollabState);
+
+  this.version = version;
+  this.unconfirmed = unconfirmed;
+});
+
+function unconfirmedFrom(transform) {
+  var result = [];
+
+  for (var i = 0; i < transform.steps.length; i++) {
+    // Filter out the analytics steps, they don't need to be sent to the collab service
+    if (transform.steps[i] instanceof AnalyticsStep) {
+      continue;
+    }
+
+    result.push(new Rebaseable(transform.steps[i], transform.steps[i].invert(transform.docs[i]), transform));
+  }
+
+  return result;
+}
+
+var collabKey = new PluginKey('collab');
+/// Creates a plugin that enables the collaborative editing framework
+/// for the editor.
+export function collab() {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var conf = {
+    version: config.version || 0,
+    clientID: // eslint-disable-next-line eqeqeq
+    config.clientID == null ? Math.floor(Math.random() * 0xffffffff) : config.clientID
+  };
+  return new Plugin({
+    key: collabKey,
+    state: {
+      init: function init() {
+        return new CollabState(conf.version, []);
+      },
+      apply: function apply(tr, collab) {
+        var newState = tr.getMeta(collabKey);
+
+        if (newState) {
+          return newState;
+        }
+
+        if (tr.docChanged) {
+          return new CollabState(collab.version, // @ts-expect-error
+          collab.unconfirmed.concat(unconfirmedFrom(tr)));
+        }
+
+        return collab;
+      }
+    },
+    // @ts-expect-error
+    config: conf,
+    // This is used to notify the history plugin to not merge steps,
+    // so that the history can be rebased.
+    historyPreserveItems: true
+  });
+} /// Create a transaction that represents a set of new steps received from
+/// the authority. Applying this transaction moves the state forward to
+/// adjust to the authority's view of the document.
+
+export function receiveTransaction(state, steps, clientIDs) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // Pushes a set of steps (received from the central authority) into
+  // the editor state (which should have the collab plugin enabled).
+  // Will recognize its own changes, and confirm unconfirmed steps as
+  // appropriate. Remaining unconfirmed steps will be rebased over
+  // remote steps.
+  var collabState = collabKey.getState(state);
+  var version = collabState.version + steps.length;
+  var ourID = collabKey.get(state).spec.config.clientID; // Find out which prefix of the steps originated with us
+
+  var ours = 0; // eslint-disable-next-line eqeqeq
+
+  while (ours < clientIDs.length && clientIDs[ours] == ourID) {
+    ++ours;
+  }
+
+  var unconfirmed = collabState.unconfirmed.slice(ours);
+  steps = ours ? steps.slice(ours) : steps; // If all steps originated with us, we're done.
+
+  if (!steps.length) {
+    return state.tr.setMeta(collabKey, new CollabState(version, unconfirmed));
+  }
+
+  var nUnconfirmed = unconfirmed.length;
+  var tr = state.tr;
+
+  if (nUnconfirmed) {
+    unconfirmed = rebaseSteps(unconfirmed, steps, tr);
+  } else {
+    for (var i = 0; i < steps.length; i++) {
+      tr.step(steps[i]);
+    }
+
+    unconfirmed = [];
+  }
+
+  var newCollabState = new CollabState(version, unconfirmed);
+
+  if (options && options.mapSelectionBackward && state.selection instanceof TextSelection) {
+    tr.setSelection(TextSelection.between(tr.doc.resolve(tr.mapping.map(state.selection.anchor, -1)), tr.doc.resolve(tr.mapping.map(state.selection.head, -1)), -1));
+    tr.updated &= ~1;
+  }
+
+  return tr.setMeta('rebased', nUnconfirmed).setMeta('addToHistory', false).setMeta(collabKey, newCollabState);
+} /// Provides data describing the editor's unconfirmed steps, which need
+/// to be sent to the central authority. Returns null when there is
+/// nothing to send.
+///
+/// `origins` holds the _original_ transactions that produced each
+/// steps. This can be useful for looking up time stamps and other
+/// metadata for the steps, but note that the steps may have been
+/// rebased, whereas the origin transactions are still the old,
+/// unchanged objects.
+
+export function sendableSteps(state) {
+  var collabState = collabKey.getState(state); // eslint-disable-next-line eqeqeq
+
+  if (collabState.unconfirmed.length == 0) {
+    return null;
+  }
+
+  return {
+    version: collabState.version,
+    steps: collabState.unconfirmed.map(function (s) {
+      return s.step;
+    }),
+    clientID: collabKey.get(state).spec.config.clientID,
+
+    get origins() {
+      return this._origins || (this._origins = collabState.unconfirmed.map(function (s) {
+        return s.origin;
+      }));
+    }
+
+  };
+} /// Get the version up to which the collab plugin has synced with the
+/// central authority.
+
+export function getVersion(state) {
+  return collabKey.getState(state).version;
+}

package/dist/esm/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/prosemirror-collab",
+	"version": "0.1.0",
+	"sideEffects": false
+}

package/dist/types/collab.d.ts

@@ -0,0 +1,25 @@
+import { type EditorState, Plugin, type Transaction } from 'prosemirror-state';
+import type { Step as ProseMirrorStep, Transform as ProseMirrorTransform } from 'prosemirror-transform';
+declare class Rebaseable {
+    readonly step: ProseMirrorStep;
+    readonly inverted: ProseMirrorStep;
+    readonly origin: ProseMirrorTransform;
+    constructor(step: ProseMirrorStep, inverted: ProseMirrorStep, origin: ProseMirrorTransform);
+}
+export declare function rebaseSteps(steps: readonly Rebaseable[], over: readonly ProseMirrorStep[], transform: ProseMirrorTransform): Rebaseable[];
+declare type CollabConfig = {
+    version?: number;
+    clientID?: number | string | null;
+};
+export declare function collab(config?: CollabConfig): Plugin;
+export declare function receiveTransaction(state: EditorState, steps: readonly ProseMirrorStep[], clientIDs: readonly (string | number)[], options?: {
+    mapSelectionBackward?: boolean;
+}): Transaction<any>;
+export declare function sendableSteps(state: EditorState): {
+    version: number;
+    steps: readonly ProseMirrorStep[];
+    clientID: number | string;
+    origins: readonly Transaction[];
+} | null;
+export declare function getVersion(state: EditorState): number;
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@atlaskit/prosemirror-collab",
+  "version": "0.1.0",
+  "description": "Collaborative editing for ProseMirror - Atlassian Fork",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": "https://bitbucket.org/atlassian/atlassian-frontend",
+  "author": "Atlassian Pty Ltd",
+  "license": "MIT",
+  "main": "dist/cjs/collab.js",
+  "module": "dist/esm/collab.js",
+  "module:es2019": "dist/es2019/collab.js",
+  "types": "dist/types/collab.d.ts",
+  "sideEffects": false,
+  "atlaskit:src": "src/collab.ts",
+  "atlassian": {
+    "team": "Editor Services",
+    "inPublicMirror": true,
+    "releaseModel": "scheduled"
+  },
+  "af:exports": {
+    ".": "./src/collab.ts"
+  },
+  "dependencies": {
+    "@atlaskit/adf-schema": "^25.1.0",
+    "@babel/runtime": "^7.0.0",
+    "prosemirror-state": "1.3.4"
+  },
+  "devDependencies": {
+    "@atlaskit/editor-test-helpers": "^18.0.0",
+    "@atlassian/atlassian-frontend-prettier-config-1.0.0": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.0",
+    "@types/prosemirror-history": "^1.0.1",
+    "@types/prosemirror-model": "^1.11.0",
+    "@types/prosemirror-transform": "^1.1.0",
+    "prosemirror-history": "^1.1.3",
+    "prosemirror-model": "1.14.3",
+    "prosemirror-transform": "1.3.2"
+  },
+  "techstack": {
+    "@atlassian/frontend": {
+      "import-structure": [
+        "atlassian-conventions"
+      ],
+      "circular-dependencies": [
+        "file-and-folder-level"
+      ]
+    }
+  },
+  "prettier": "@atlassian/atlassian-frontend-prettier-config-1.0.0"
+}

package/report.api.md

@@ -0,0 +1,85 @@
+<!-- API Report Version: 2.3 -->
+
+## API Report File for "@atlaskit/prosemirror-collab"
+
+> Do not edit this file. This report is auto-generated using [API Extractor](https://api-extractor.com/).
+> [Learn more about API reports](https://hello.atlassian.net/wiki/spaces/UR/pages/1825484529/Package+API+Reports)
+
+### Table of contents
+
+- [Main Entry Types](#main-entry-types)
+- [Peer Dependencies](#peer-dependencies)
+
+### Main Entry Types
+
+<!--SECTION START: Main Entry Types-->
+
+```ts
+import { EditorState } from 'prosemirror-state';
+import { Plugin as Plugin_2 } from 'prosemirror-state';
+import type { Step } from 'prosemirror-transform';
+import { Transaction } from 'prosemirror-state';
+import type { Transform } from 'prosemirror-transform';
+
+// @public (undocumented)
+export function collab(config?: CollabConfig): Plugin_2;
+
+// @public (undocumented)
+type CollabConfig = {
+  version?: number;
+  clientID?: null | number | string;
+};
+
+// @public (undocumented)
+export function getVersion(state: EditorState): number;
+
+// @public (undocumented)
+class Rebaseable {
+  constructor(step: Step, inverted: Step, origin: Transform);
+  // (undocumented)
+  readonly inverted: Step;
+  // (undocumented)
+  readonly origin: Transform;
+  // (undocumented)
+  readonly step: Step;
+}
+
+// @public (undocumented)
+export function rebaseSteps(
+  steps: readonly Rebaseable[],
+  over: readonly Step[],
+  transform: Transform,
+): Rebaseable[];
+
+// @public (undocumented)
+export function receiveTransaction(
+  state: EditorState,
+  steps: readonly Step[],
+  clientIDs: readonly (number | string)[],
+  options?: {
+    mapSelectionBackward?: boolean;
+  },
+): Transaction<any>;
+
+// @public (undocumented)
+export function sendableSteps(state: EditorState): null | {
+  version: number;
+  steps: readonly Step[];
+  clientID: number | string;
+  origins: readonly Transaction[];
+};
+
+// (No @packageDocumentation comment for this package)
+```
+
+<!--SECTION END: Main Entry Types-->
+
+### Peer Dependencies
+
+<!--SECTION START: Peer Dependencies-->
+
+```json
+{}
+```
+
+<!--SECTION END: Peer Dependencies-->