@atlaskit/editor-plugin-collab-edit 0.1.0

package/dist/es2019/utils.js

@@ -0,0 +1,133 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { colors } from '@atlaskit/editor-common/collab';
+import { ZERO_WIDTH_JOINER } from '@atlaskit/editor-common/utils';
+import { Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+export { colors };
+export const findPointers = (id, decorations) => decorations.find().reduce((arr, deco) => deco.spec.pointer.sessionId === id ? arr.concat(deco) : arr, []);
+function style(options) {
+  const color = options && options.color || 'black';
+  return `border-left: 1px solid ${color}; border-right: 1px solid ${color}; margin-right: -2px;`;
+}
+export function getAvatarColor(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    /* eslint-disable no-bitwise */
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash = hash & hash;
+    /* eslint-enable no-bitwise */
+  }
+
+  const index = Math.abs(hash) % colors.length;
+  return {
+    index,
+    color: colors[index]
+  };
+}
+export const createTelepointers = (from, to, sessionId, isSelection, initial) => {
+  let decorations = [];
+  const avatarColor = getAvatarColor(sessionId);
+  const color = avatarColor.index.toString();
+  if (isSelection) {
+    const className = `telepointer color-${color} telepointer-selection`;
+    decorations.push(Decoration.inline(from, to, {
+      class: className,
+      'data-initial': initial
+    }, {
+      pointer: {
+        sessionId
+      }
+    }));
+  }
+  const spaceJoinerBefore = document.createElement('span');
+  spaceJoinerBefore.textContent = ZERO_WIDTH_JOINER;
+  const spaceJoinerAfter = document.createElement('span');
+  spaceJoinerAfter.textContent = ZERO_WIDTH_JOINER;
+  const cursor = document.createElement('span');
+  cursor.textContent = ZERO_WIDTH_JOINER;
+  cursor.className = `telepointer color-${color} telepointer-selection-badge`;
+  cursor.style.cssText = `${style({
+    color: avatarColor.color.solid
+  })};`;
+  cursor.setAttribute('data-initial', initial);
+  return decorations.concat(Decoration.widget(to, spaceJoinerAfter, {
+    pointer: {
+      sessionId
+    },
+    key: `telepointer-${sessionId}-zero`
+  })).concat(Decoration.widget(to, cursor, {
+    pointer: {
+      sessionId
+    },
+    key: `telepointer-${sessionId}`
+  })).concat(Decoration.widget(to, spaceJoinerBefore, {
+    pointer: {
+      sessionId
+    },
+    key: `telepointer-${sessionId}-zero`
+  }));
+};
+export const replaceDocument = (doc, state, version, options, reserveCursor) => {
+  const {
+    schema,
+    tr
+  } = state;
+  let content = (doc.content || []).map(child => schema.nodeFromJSON(child));
+  let hasContent = !!content.length;
+  if (hasContent) {
+    tr.setMeta('addToHistory', false);
+    tr.replaceWith(0, state.doc.nodeSize - 2, content);
+    const selection = state.selection;
+    if (reserveCursor) {
+      // If the cursor is still in the range of the new document,
+      // keep where it was.
+      if (selection.to < tr.doc.content.size - 2) {
+        const $from = tr.doc.resolve(selection.from);
+        const $to = tr.doc.resolve(selection.to);
+        const newselection = new TextSelection($from, $to);
+        tr.setSelection(newselection);
+      }
+    } else {
+      tr.setSelection(Selection.atStart(tr.doc));
+    }
+    tr.setMeta('replaceDocument', true);
+    if (typeof version !== undefined && options && options.useNativePlugin) {
+      const collabState = {
+        version,
+        unconfirmed: []
+      };
+      tr.setMeta('collab$', collabState);
+    }
+  }
+  return tr;
+};
+export const scrollToCollabCursor = (editorView, participants, sessionId, index, editorAnalyticsAPI) => {
+  const selectedUser = participants[index];
+  if (selectedUser && selectedUser.cursorPos !== undefined && selectedUser.sessionId !== sessionId) {
+    const {
+      state
+    } = editorView;
+    let tr = state.tr;
+    const analyticsPayload = {
+      action: ACTION.MATCHED,
+      actionSubject: ACTION_SUBJECT.SELECTION,
+      eventType: EVENT_TYPE.TRACK
+    };
+    tr.setSelection(Selection.near(tr.doc.resolve(selectedUser.cursorPos)));
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(analyticsPayload)(tr);
+    tr.scrollIntoView();
+    editorView.dispatch(tr);
+    if (!editorView.hasFocus()) {
+      editorView.focus();
+    }
+  }
+};
+export const getPositionOfTelepointer = (sessionId, decorationSet) => {
+  let scrollPosition;
+  decorationSet.find().forEach(deco => {
+    if (deco.type.spec.pointer.sessionId === sessionId) {
+      scrollPosition = deco.from;
+    }
+  });
+  return scrollPosition;
+};

package/dist/esm/actions.js

@@ -0,0 +1,103 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { receiveTransaction } from 'prosemirror-collab';
+import { AllSelection, NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { Step } from '@atlaskit/editor-prosemirror/transform';
+import { replaceDocument } from './utils';
+export var 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 = replaceDocument(doc, state, version, options, reserveCursor);
+    tr.setMeta('isRemote', true);
+    view.dispatch(tr);
+  } else if (json) {
+    applyRemoteSteps(json, view);
+  }
+};
+export var handleConnection = function handleConnection(connectionData, view) {
+  var tr = view.state.tr;
+  view.dispatch(tr.setMeta('sessionId', connectionData));
+};
+export var handlePresence = function handlePresence(presenceData, view) {
+  var tr = view.state.tr;
+  view.dispatch(tr.setMeta('presence', presenceData));
+};
+export var 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);
+  }
+};
+export var 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 Step.fromJSON(schema, step);
+  });
+  var tr;
+  if (options && options.useNativePlugin && userIds) {
+    tr = 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 = _slicedToArray(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);
+  }
+};
+export var handleTelePointer = function handleTelePointer(telepointerData, view) {
+  var tr = view.state.tr;
+  view.dispatch(tr.setMeta('telepointer', telepointerData));
+};
+function isAllSelection(selection) {
+  return selection instanceof AllSelection;
+}
+function isNodeSelection(selection) {
+  return selection instanceof NodeSelection;
+}
+export var 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/esm/analytics.js

@@ -0,0 +1,41 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { getDocStructure } from '@atlaskit/editor-common/core-utils';
+import { sniffUserBrowserExtensions } from '@atlaskit/editor-common/utils';
+export var addSynchronyErrorAnalytics = function addSynchronyErrorAnalytics(state, tr, featureFlags, editorAnalyticsApi) {
+  return function (error) {
+    var browserExtensions = sniffUserBrowserExtensions({
+      extensions: ['grammarly']
+    });
+    var payload = {
+      action: ACTION.SYNCHRONY_ERROR,
+      actionSubject: ACTION_SUBJECT.EDITOR,
+      eventType: EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        error: error,
+        browserExtensions: browserExtensions
+      }
+    };
+    if (featureFlags.synchronyErrorDocStructure) {
+      payload.attributes.docStructure = getDocStructure(state.doc, {
+        compact: true
+      });
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 || editorAnalyticsApi.attachAnalyticsEvent(payload)(tr);
+    return tr;
+  };
+};
+export var addSynchronyEntityAnalytics = function addSynchronyEntityAnalytics(state, tr) {
+  return function (type, editorAnalyticsApi) {
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 || editorAnalyticsApi.attachAnalyticsEvent({
+      action: type === 'error' ? ACTION.SYNCHRONY_ENTITY_ERROR : ACTION.SYNCHRONY_DISCONNECTED,
+      actionSubject: ACTION_SUBJECT.EDITOR,
+      eventType: 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/esm/events/handlers.js

@@ -0,0 +1,82 @@
+import { applyRemoteData, handleConnection, handleInit, handlePresence, handleTelePointer } from '../actions';
+import { addSynchronyEntityAnalytics, addSynchronyErrorAnalytics } from '../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;
+  };
+};
+export var subscribe = effect(function (view, provider, options, featureFlags, _providerFactory, editorAnalyticsApi) {
+  var entityRef;
+  var entityHandlers = {
+    disconnectedHandler: function disconnectedHandler() {
+      addSynchronyEntityAnalytics(view.state, view.state.tr)('disconnected', editorAnalyticsApi);
+    },
+    errorHandler: function errorHandler() {
+      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));
+      handleInit(data, view, options);
+    },
+    connectedHandler: function connectedHandler(data) {
+      return handleConnection(data, view);
+    },
+    dataHandler: function dataHandler(data) {
+      return applyRemoteData(data, view, options);
+    },
+    presenceHandler: function presenceHandler(data) {
+      return handlePresence(data, view);
+    },
+    telepointerHandler: function telepointerHandler(data) {
+      return 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) {
+      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/esm/events/initialize.js

@@ -0,0 +1,51 @@
+import memoizeOne from 'memoize-one';
+import { Step } from '@atlaskit/editor-prosemirror/transform';
+import { pluginKey } from '../plugin-key';
+import { subscribe } from './handlers';
+var initCollab = function initCollab(collabEditProvider, view) {
+  if (collabEditProvider.initialize) {
+    collabEditProvider.initialize(function () {
+      return view.state;
+    }, function (json) {
+      return 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 = memoizeOne(initCollab);
+export var 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.getState(view.state);
+    if (pluginState !== null && pluginState !== void 0 && pluginState.isReady && cleanup) {
+      cleanup();
+    }
+    cleanup = 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/esm/events/send-transaction.js

@@ -0,0 +1,42 @@
+import { getSendableSelection } from '../actions';
+import { pluginKey } from '../plugin-key';
+export var 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.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.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 = getSendableSelection(newEditorState.selection);
+      var message = {
+        type: 'telepointer',
+        selection: selection,
+        sessionId: sessionId
+      };
+      provider.sendMessage(message);
+    }
+  };
+};

package/dist/esm/index.js

@@ -0,0 +1,116 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { collab } from 'prosemirror-collab';
+import { addSynchronyErrorAnalytics } from './analytics';
+import { sendTransaction } from './events/send-transaction';
+import { nativeCollabProviderPlugin } from './native-collab-provider-plugin';
+import { createPlugin, pluginKey } from './plugin';
+export { pluginKey };
+import { getAvatarColor } from './utils';
+var providerBuilder = function providerBuilder(collabEditProviderPromise) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(codeToExecute, onError) {
+      var provider;
+      return _regeneratorRuntime.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);
+    };
+  }();
+};
+export var 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 = 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: getAvatarColor
+    },
+    pmPlugins: function pmPlugins() {
+      var _ref3 = options || {},
+        _ref3$useNativePlugin = _ref3.useNativePlugin,
+        useNativePlugin = _ref3$useNativePlugin === void 0 ? false : _ref3$useNativePlugin,
+        userId = _ref3.userId;
+      return [].concat(_toConsumableArray(useNativePlugin ? [{
+        name: 'pmCollab',
+        plugin: function plugin() {
+          return collab({
+            clientID: userId
+          });
+        }
+      }, {
+        name: 'nativeCollabProviderPlugin',
+        plugin: function plugin() {
+          return nativeCollabProviderPlugin({
+            providerPromise: collabEditProviderPromise
+          });
+        }
+      }] : []), [{
+        name: 'collab',
+        plugin: function plugin(_ref4) {
+          var dispatch = _ref4.dispatch,
+            providerFactory = _ref4.providerFactory;
+          return createPlugin(dispatch, providerFactory, providerResolver, executeProviderCode, options, featureFlags, api);
+        }
+      }]);
+    },
+    onEditorViewStateUpdated: function onEditorViewStateUpdated(props) {
+      var _api$analytics, _options$useNativePlu;
+      var addErrorAnalytics = 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(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/esm/native-collab-provider-plugin.js

@@ -0,0 +1,31 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+var nativeCollabProviderPluginKey = new PluginKey('nativeCollabProviderPlugin');
+export var nativeCollabProviderPlugin = function nativeCollabProviderPlugin(_ref) {
+  var providerPromise = _ref.providerPromise;
+  return new 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 {};
+    }
+  });
+};
+export var getCollabProvider = function getCollabProvider(editorState) {
+  return nativeCollabProviderPluginKey.getState(editorState);
+};