@atlaskit/editor-plugin-collab-edit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @atlaskit/editor-plugin-collab-edit

package/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,30 @@
+# Editor plugin collab-edit
+
+Collab Edit plugin for @atlaskit/editor-core
+
+**Note:** This component is designed for internal Atlassian development.
+External contributors will be able to use this component but will not be able to submit issues.
+
+## Install
+---
+- **Install** - *yarn add @atlaskit/editor-plugin-collab-edit*
+- **npm** - [@atlaskit/editor-plugin-collab-edit](https://www.npmjs.com/package/@atlaskit/editor-plugin-collab-edit)
+- **Source** - [Bitbucket](https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/editor/editor-plugin-collab-edit)
+- **Bundle** - [unpkg.com](https://unpkg.com/@atlaskit/editor-plugin-collab-edit/dist/)
+
+## Usage
+---
+**Internal use only**
+
+@atlaskit/editor-plugin-collab-edit is intended for internal use by the @atlaskit/editor-core and as a plugin dependency of the Editor within your product.
+
+Direct use of this component is not supported.
+
+Please see [Atlaskit - Editor plugin collab edit](https://atlaskit.atlassian.com/packages/editor/editor-plugin-collab-edit) for documentation and examples for this package.
+
+## Support
+---
+For internal Atlassian, visit the slack channel [#help-editor](https://atlassian.slack.com/archives/CFG3PSQ9E) for support or visit [go/editor-help](https://go/editor-help) to submit a bug.
+## License
+---
+ Please see [Atlassian Frontend - License](https://developer.atlassian.com/cloud/framework/atlassian-frontend/#license) for more licensing information.

package/dist/cjs/actions.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleTelePointer = exports.handlePresence = exports.handleInit = exports.handleConnection = exports.getSendableSelection = exports.applyRemoteSteps = exports.applyRemoteData = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _prosemirrorCollab = require("prosemirror-collab");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _utils = require("./utils");
+var handleInit = exports.handleInit = function handleInit(initData, view, options) {
+  var doc = initData.doc,
+    json = initData.json,
+    version = initData.version,
+    reserveCursor = initData.reserveCursor;
+  if (doc) {
+    var state = view.state;
+    var tr = (0, _utils.replaceDocument)(doc, state, version, options, reserveCursor);
+    tr.setMeta('isRemote', true);
+    view.dispatch(tr);
+  } else if (json) {
+    applyRemoteSteps(json, view);
+  }
+};
+var handleConnection = exports.handleConnection = function handleConnection(connectionData, view) {
+  var tr = view.state.tr;
+  view.dispatch(tr.setMeta('sessionId', connectionData));
+};
+var handlePresence = exports.handlePresence = function handlePresence(presenceData, view) {
+  var tr = view.state.tr;
+  view.dispatch(tr.setMeta('presence', presenceData));
+};
+var applyRemoteData = exports.applyRemoteData = function applyRemoteData(remoteData, view, options) {
+  var json = remoteData.json,
+    _remoteData$userIds = remoteData.userIds,
+    userIds = _remoteData$userIds === void 0 ? [] : _remoteData$userIds;
+  if (json) {
+    applyRemoteSteps(json, view, userIds, options);
+  }
+};
+var applyRemoteSteps = exports.applyRemoteSteps = function applyRemoteSteps(json, view, userIds, options) {
+  if (!json || !json.length) {
+    return;
+  }
+  var state = view.state,
+    schema = view.state.schema;
+  var steps = json.map(function (step) {
+    return _transform.Step.fromJSON(schema, step);
+  });
+  var tr;
+  if (options && options.useNativePlugin && userIds) {
+    tr = (0, _prosemirrorCollab.receiveTransaction)(state, steps, userIds);
+  } else {
+    tr = state.tr;
+    steps.forEach(function (step) {
+      return tr.step(step);
+    });
+  }
+  if (tr) {
+    tr.setMeta('addToHistory', false);
+    tr.setMeta('isRemote', true);
+    var _state$selection = state.selection,
+      from = _state$selection.from,
+      to = _state$selection.to;
+    var _json = (0, _slicedToArray2.default)(json, 1),
+      firstStep = _json[0];
+
+    /*
+     * Persist marks across transactions. Fixes an issue where
+     * marks are lost if remote transactions are dispatched
+     * between a user creating the mark and typing.
+     */
+    if (state.tr.storedMarks) {
+      tr.setStoredMarks(state.tr.storedMarks);
+    }
+
+    /**
+     * If the cursor is a the same position as the first step in
+     * the remote data, we need to manually set it back again
+     * in order to prevent the cursor from moving.
+     */
+    if (from === firstStep.from && to === firstStep.to) {
+      tr.setSelection(state.selection.map(tr.doc, tr.mapping));
+    }
+    view.dispatch(tr);
+  }
+};
+var handleTelePointer = exports.handleTelePointer = function handleTelePointer(telepointerData, view) {
+  var tr = view.state.tr;
+  view.dispatch(tr.setMeta('telepointer', telepointerData));
+};
+function isAllSelection(selection) {
+  return selection instanceof _state.AllSelection;
+}
+function isNodeSelection(selection) {
+  return selection instanceof _state.NodeSelection;
+}
+var getSendableSelection = exports.getSendableSelection = function getSendableSelection(selection) {
+  /**
+   * <kbd>CMD + A</kbd> triggers a AllSelection
+   * <kbd>escape</kbd> triggers a NodeSelection
+   */
+  return {
+    type: 'textSelection',
+    anchor: selection.anchor,
+    head: isAllSelection(selection) || isNodeSelection(selection) ? selection.head - 1 : selection.head
+  };
+};

package/dist/cjs/analytics.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addSynchronyErrorAnalytics = exports.addSynchronyEntityAnalytics = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _coreUtils = require("@atlaskit/editor-common/core-utils");
+var _utils = require("@atlaskit/editor-common/utils");
+var addSynchronyErrorAnalytics = exports.addSynchronyErrorAnalytics = function addSynchronyErrorAnalytics(state, tr, featureFlags, editorAnalyticsApi) {
+  return function (error) {
+    var browserExtensions = (0, _utils.sniffUserBrowserExtensions)({
+      extensions: ['grammarly']
+    });
+    var payload = {
+      action: _analytics.ACTION.SYNCHRONY_ERROR,
+      actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+      eventType: _analytics.EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        error: error,
+        browserExtensions: browserExtensions
+      }
+    };
+    if (featureFlags.synchronyErrorDocStructure) {
+      payload.attributes.docStructure = (0, _coreUtils.getDocStructure)(state.doc, {
+        compact: true
+      });
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 || editorAnalyticsApi.attachAnalyticsEvent(payload)(tr);
+    return tr;
+  };
+};
+var addSynchronyEntityAnalytics = exports.addSynchronyEntityAnalytics = function addSynchronyEntityAnalytics(state, tr) {
+  return function (type, editorAnalyticsApi) {
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 || editorAnalyticsApi.attachAnalyticsEvent({
+      action: type === 'error' ? _analytics.ACTION.SYNCHRONY_ENTITY_ERROR : _analytics.ACTION.SYNCHRONY_DISCONNECTED,
+      actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+      eventType: _analytics.EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        // https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine
+        onLine: navigator.onLine,
+        visibilityState: document.visibilityState
+      }
+    })(tr);
+    return tr;
+  };
+};

package/dist/cjs/events/handlers.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribe = void 0;
+var _actions = require("../actions");
+var _analytics = require("../analytics");
+var effect = function effect(fn, eq) {
+  var previousDeps;
+  var cleanup;
+  return function () {
+    for (var _len = arguments.length, currentDeps = new Array(_len), _key = 0; _key < _len; _key++) {
+      currentDeps[_key] = arguments[_key];
+    }
+    if (cleanup && eq(previousDeps, currentDeps)) {
+      return cleanup;
+    }
+    cleanup = fn.apply(void 0, currentDeps);
+    previousDeps = currentDeps;
+    return cleanup;
+  };
+};
+var subscribe = exports.subscribe = effect(function (view, provider, options, featureFlags, _providerFactory, editorAnalyticsApi) {
+  var entityRef;
+  var entityHandlers = {
+    disconnectedHandler: function disconnectedHandler() {
+      (0, _analytics.addSynchronyEntityAnalytics)(view.state, view.state.tr)('disconnected', editorAnalyticsApi);
+    },
+    errorHandler: function errorHandler() {
+      (0, _analytics.addSynchronyEntityAnalytics)(view.state, view.state.tr)('error', editorAnalyticsApi);
+    }
+  };
+  var unsubscribeSynchronyEntity = function unsubscribeSynchronyEntity() {
+    if (entityRef) {
+      entityRef.off('disconnected', entityHandlers.disconnectedHandler);
+      entityRef.off('error', entityHandlers.errorHandler);
+    }
+  };
+  var handlers = {
+    initHandler: function initHandler(data) {
+      view.dispatch(view.state.tr.setMeta('collabInitialised', true));
+      (0, _actions.handleInit)(data, view, options);
+    },
+    connectedHandler: function connectedHandler(data) {
+      return (0, _actions.handleConnection)(data, view);
+    },
+    dataHandler: function dataHandler(data) {
+      return (0, _actions.applyRemoteData)(data, view, options);
+    },
+    presenceHandler: function presenceHandler(data) {
+      return (0, _actions.handlePresence)(data, view);
+    },
+    telepointerHandler: function telepointerHandler(data) {
+      return (0, _actions.handleTelePointer)(data, view);
+    },
+    localStepsHandler: function localStepsHandler(data) {
+      var steps = data.steps;
+      var state = view.state;
+      var tr = state.tr;
+      steps.forEach(function (step) {
+        return tr.step(step);
+      });
+      view.dispatch(tr);
+    },
+    errorHandler: function errorHandler(error) {
+      (0, _analytics.addSynchronyErrorAnalytics)(view.state, view.state.tr, featureFlags, editorAnalyticsApi)(error);
+    },
+    entityHandler: function entityHandler(_ref) {
+      var entity = _ref.entity;
+      unsubscribeSynchronyEntity();
+      if (options.EXPERIMENTAL_allowInternalErrorAnalytics) {
+        entity.on('disconnected', entityHandlers.disconnectedHandler);
+        entity.on('error', entityHandlers.errorHandler);
+        entityRef = entity;
+      }
+    }
+  };
+  provider.on('init', handlers.initHandler).on('connected', handlers.connectedHandler).on('data', handlers.dataHandler).on('presence', handlers.presenceHandler).on('telepointer', handlers.telepointerHandler).on('local-steps', handlers.localStepsHandler).on('error', handlers.errorHandler).on('entity', handlers.entityHandler);
+  return function () {
+    unsubscribeSynchronyEntity();
+    provider.off('init', handlers.initHandler).off('connected', handlers.connectedHandler).off('data', handlers.dataHandler).off('presence', handlers.presenceHandler).off('telepointer', handlers.telepointerHandler).off('local-steps', handlers.localStepsHandler).off('error', handlers.errorHandler).off('entity', handlers.entityHandler);
+  };
+}, function (previousDeps, currentDeps) {
+  return currentDeps && currentDeps.every(function (dep, i) {
+    return dep === previousDeps[i];
+  });
+});

package/dist/cjs/events/initialize.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialize = void 0;
+var _memoizeOne = _interopRequireDefault(require("memoize-one"));
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _pluginKey = require("../plugin-key");
+var _handlers = require("./handlers");
+var initCollab = function initCollab(collabEditProvider, view) {
+  if (collabEditProvider.initialize) {
+    collabEditProvider.initialize(function () {
+      return view.state;
+    }, function (json) {
+      return _transform.Step.fromJSON(view.state.schema, json);
+    });
+  }
+};
+var initNewCollab = function initNewCollab(collabEditProvider, view, onSyncUpError) {
+  collabEditProvider.setup({
+    getState: function getState() {
+      return view.state;
+    },
+    onSyncUpError: onSyncUpError
+  });
+};
+var initCollabMemo = (0, _memoizeOne.default)(initCollab);
+var initialize = exports.initialize = function initialize(_ref) {
+  var options = _ref.options,
+    providerFactory = _ref.providerFactory,
+    view = _ref.view,
+    featureFlags = _ref.featureFlags,
+    editorAnalyticsApi = _ref.editorAnalyticsApi;
+  return function (provider) {
+    var cleanup;
+    var pluginState = _pluginKey.pluginKey.getState(view.state);
+    if (pluginState !== null && pluginState !== void 0 && pluginState.isReady && cleanup) {
+      cleanup();
+    }
+    cleanup = (0, _handlers.subscribe)(view, provider, options, featureFlags, providerFactory, editorAnalyticsApi);
+
+    // Initialize provider
+    if (options.useNativePlugin) {
+      // ED-13912 For NCS we don't want to use memoizeOne because it causes
+      // infinite text while changing page-width
+      initNewCollab(provider, view, options.onSyncUpError);
+    } else {
+      /**
+       * We only want to initialise once, if we reload/reconfigure this plugin
+       * We dont want to re-init collab, it would break existing sessions
+       */
+      initCollabMemo(provider, view);
+    }
+    return cleanup;
+  };
+};

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sendTransaction = void 0;
+var _actions = require("../actions");
+var _pluginKey = require("../plugin-key");
+var sendTransaction = exports.sendTransaction = function sendTransaction(_ref) {
+  var originalTransaction = _ref.originalTransaction,
+    transactions = _ref.transactions,
+    oldEditorState = _ref.oldEditorState,
+    newEditorState = _ref.newEditorState,
+    useNativePlugin = _ref.useNativePlugin;
+  return function (provider) {
+    var docChangedTransaction = transactions.find(function (tr) {
+      return tr.docChanged;
+    });
+    var currentPluginState = _pluginKey.pluginKey.getState(newEditorState);
+    if (!(currentPluginState !== null && currentPluginState !== void 0 && currentPluginState.isReady)) {
+      return;
+    }
+    var shouldSendStepForSynchronyCollabProvider = !originalTransaction.getMeta('isRemote') &&
+    // TODO: ED-8995
+    // We need to do this check to reduce the number of race conditions when working with tables.
+    // This metadata is coming from the scaleTable command in table-resizing plugin
+    !originalTransaction.getMeta('scaleTable') && docChangedTransaction;
+    if (useNativePlugin || shouldSendStepForSynchronyCollabProvider) {
+      provider.send(docChangedTransaction, oldEditorState, newEditorState);
+    }
+    var prevPluginState = _pluginKey.pluginKey.getState(oldEditorState);
+    var _ref2 = prevPluginState || {},
+      prevActiveParticipants = _ref2.activeParticipants;
+    var activeParticipants = currentPluginState.activeParticipants,
+      sessionId = currentPluginState.sessionId;
+    var selectionChanged = !oldEditorState.selection.eq(newEditorState.selection);
+    var participantsChanged = prevActiveParticipants && !prevActiveParticipants.eq(activeParticipants);
+    if (sessionId && selectionChanged && !docChangedTransaction || sessionId && participantsChanged) {
+      var selection = (0, _actions.getSendableSelection)(newEditorState.selection);
+      var message = {
+        type: 'telepointer',
+        selection: selection,
+        sessionId: sessionId
+      };
+      provider.sendMessage(message);
+    }
+  };
+};

package/dist/cjs/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collabEditPlugin = void 0;
+Object.defineProperty(exports, "pluginKey", {
+  enumerable: true,
+  get: function get() {
+    return _plugin.pluginKey;
+  }
+});
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _prosemirrorCollab = require("prosemirror-collab");
+var _analytics = require("./analytics");
+var _sendTransaction = require("./events/send-transaction");
+var _nativeCollabProviderPlugin = require("./native-collab-provider-plugin");
+var _plugin = require("./plugin");
+var _utils = require("./utils");
+var providerBuilder = function providerBuilder(collabEditProviderPromise) {
+  return /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(codeToExecute, onError) {
+      var provider;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return collabEditProviderPromise;
+          case 3:
+            provider = _context.sent;
+            if (!provider) {
+              _context.next = 6;
+              break;
+            }
+            return _context.abrupt("return", codeToExecute(provider));
+          case 6:
+            _context.next = 11;
+            break;
+          case 8:
+            _context.prev = 8;
+            _context.t0 = _context["catch"](0);
+            if (onError) {
+              onError(_context.t0);
+            } else {
+              // eslint-disable-next-line no-console
+              console.error(_context.t0);
+            }
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 8]]);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+var collabEditPlugin = exports.collabEditPlugin = function collabEditPlugin(_ref2) {
+  var _api$featureFlags;
+  var options = _ref2.config,
+    api = _ref2.api;
+  var featureFlags = (api === null || api === void 0 || (_api$featureFlags = api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
+  var providerResolver = function providerResolver() {};
+  var collabEditProviderPromise = new Promise(function (_providerResolver) {
+    providerResolver = _providerResolver;
+  });
+  var executeProviderCode = providerBuilder(collabEditProviderPromise);
+  return {
+    name: 'collabEdit',
+    getSharedState: function getSharedState(state) {
+      if (!state) {
+        return undefined;
+      }
+      var collabPluginState = _plugin.pluginKey.getState(state);
+      return {
+        activeParticipants: collabPluginState === null || collabPluginState === void 0 ? void 0 : collabPluginState.activeParticipants,
+        sessionId: collabPluginState === null || collabPluginState === void 0 ? void 0 : collabPluginState.sessionId
+      };
+    },
+    actions: {
+      getAvatarColor: _utils.getAvatarColor
+    },
+    pmPlugins: function pmPlugins() {
+      var _ref3 = options || {},
+        _ref3$useNativePlugin = _ref3.useNativePlugin,
+        useNativePlugin = _ref3$useNativePlugin === void 0 ? false : _ref3$useNativePlugin,
+        userId = _ref3.userId;
+      return [].concat((0, _toConsumableArray2.default)(useNativePlugin ? [{
+        name: 'pmCollab',
+        plugin: function plugin() {
+          return (0, _prosemirrorCollab.collab)({
+            clientID: userId
+          });
+        }
+      }, {
+        name: 'nativeCollabProviderPlugin',
+        plugin: function plugin() {
+          return (0, _nativeCollabProviderPlugin.nativeCollabProviderPlugin)({
+            providerPromise: collabEditProviderPromise
+          });
+        }
+      }] : []), [{
+        name: 'collab',
+        plugin: function plugin(_ref4) {
+          var dispatch = _ref4.dispatch,
+            providerFactory = _ref4.providerFactory;
+          return (0, _plugin.createPlugin)(dispatch, providerFactory, providerResolver, executeProviderCode, options, featureFlags, api);
+        }
+      }]);
+    },
+    onEditorViewStateUpdated: function onEditorViewStateUpdated(props) {
+      var _api$analytics, _options$useNativePlu;
+      var addErrorAnalytics = (0, _analytics.addSynchronyErrorAnalytics)(props.newEditorState, props.newEditorState.tr, featureFlags, api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions);
+      executeProviderCode((0, _sendTransaction.sendTransaction)({
+        originalTransaction: props.originalTransaction,
+        transactions: props.transactions,
+        oldEditorState: props.oldEditorState,
+        newEditorState: props.newEditorState,
+        useNativePlugin: (_options$useNativePlu = options === null || options === void 0 ? void 0 : options.useNativePlugin) !== null && _options$useNativePlu !== void 0 ? _options$useNativePlu : false
+      }), addErrorAnalytics);
+    }
+  };
+};

package/dist/cjs/native-collab-provider-plugin.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nativeCollabProviderPlugin = exports.getCollabProvider = void 0;
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var nativeCollabProviderPluginKey = new _state.PluginKey('nativeCollabProviderPlugin');
+var nativeCollabProviderPlugin = exports.nativeCollabProviderPlugin = function nativeCollabProviderPlugin(_ref) {
+  var providerPromise = _ref.providerPromise;
+  return new _safePlugin.SafePlugin({
+    key: nativeCollabProviderPluginKey,
+    state: {
+      init: function init() {
+        return null;
+      },
+      apply: function apply(tr, currentPluginState) {
+        var provider = tr.getMeta(nativeCollabProviderPluginKey);
+        return provider ? provider : currentPluginState;
+      }
+    },
+    view: function view(editorView) {
+      providerPromise.then(function (provider) {
+        var dispatch = editorView.dispatch,
+          state = editorView.state;
+        var tr = state.tr;
+        tr.setMeta(nativeCollabProviderPluginKey, provider);
+        dispatch(tr);
+      });
+      return {};
+    }
+  });
+};
+var getCollabProvider = exports.getCollabProvider = function getCollabProvider(editorState) {
+  return nativeCollabProviderPluginKey.getState(editorState);
+};

package/dist/cjs/participants.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Participants = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+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 Participants = exports.Participants = /*#__PURE__*/function () {
+  function Participants() {
+    var participants = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
+    (0, _classCallCheck2.default)(this, Participants);
+    this.participants = participants;
+  }
+  (0, _createClass2.default)(Participants, [{
+    key: "add",
+    value: function add(data) {
+      var newSet = new Map(this.participants);
+      data.forEach(function (participant) {
+        newSet.set(participant.sessionId, participant);
+      });
+      return new Participants(newSet);
+    }
+  }, {
+    key: "remove",
+    value: function remove(sessionIds) {
+      var newSet = new Map(this.participants);
+      sessionIds.forEach(function (sessionId) {
+        newSet.delete(sessionId);
+      });
+      return new Participants(newSet);
+    }
+  }, {
+    key: "update",
+    value: function update(sessionId, lastActive) {
+      var newSet = new Map(this.participants);
+      var data = newSet.get(sessionId);
+      if (!data) {
+        return this;
+      }
+      newSet.set(sessionId, _objectSpread(_objectSpread({}, data), {}, {
+        lastActive: lastActive
+      }));
+      return new Participants(newSet);
+    }
+  }, {
+    key: "updateCursorPos",
+    value: function updateCursorPos(sessionId, cursorPos) {
+      var newSet = new Map(this.participants);
+      var data = newSet.get(sessionId);
+      if (!data) {
+        return this;
+      }
+      newSet.set(sessionId, _objectSpread(_objectSpread({}, data), {}, {
+        cursorPos: cursorPos
+      }));
+      return new Participants(newSet);
+    }
+  }, {
+    key: "toArray",
+    value: function toArray() {
+      return Array.from(this.participants.values());
+    }
+  }, {
+    key: "get",
+    value: function get(sessionId) {
+      return this.participants.get(sessionId);
+    }
+  }, {
+    key: "size",
+    value: function size() {
+      return this.participants.size;
+    }
+  }, {
+    key: "eq",
+    value: function eq(other) {
+      var left = this.toArray().map(function (p) {
+        return p.sessionId;
+      }).sort(function (a, b) {
+        return a > b ? -1 : 1;
+      }).join('');
+      var right = other.toArray().map(function (p) {
+        return p.sessionId;
+      }).sort(function (a, b) {
+        return a > b ? -1 : 1;
+      }).join('');
+      return left === right;
+    }
+  }]);
+  return Participants;
+}();

package/dist/cjs/plugin-key.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginKey = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var pluginKey = exports.pluginKey = new _state.PluginKey('collabEditPlugin');