@atlaskit/editor-plugin-collab-edit 0.1.0

package/dist/es2019/events/handlers.js

@@ -0,0 +1,72 @@
+import { applyRemoteData, handleConnection, handleInit, handlePresence, handleTelePointer } from '../actions';
+import { addSynchronyEntityAnalytics, addSynchronyErrorAnalytics } from '../analytics';
+const effect = (fn, eq) => {
+  let previousDeps;
+  let cleanup;
+  return (...currentDeps) => {
+    if (cleanup && eq(previousDeps, currentDeps)) {
+      return cleanup;
+    }
+    cleanup = fn(...currentDeps);
+    previousDeps = currentDeps;
+    return cleanup;
+  };
+};
+export const subscribe = effect((view, provider, options, featureFlags, _providerFactory, editorAnalyticsApi) => {
+  let entityRef;
+  const entityHandlers = {
+    disconnectedHandler: () => {
+      addSynchronyEntityAnalytics(view.state, view.state.tr)('disconnected', editorAnalyticsApi);
+    },
+    errorHandler: () => {
+      addSynchronyEntityAnalytics(view.state, view.state.tr)('error', editorAnalyticsApi);
+    }
+  };
+  const unsubscribeSynchronyEntity = () => {
+    if (entityRef) {
+      entityRef.off('disconnected', entityHandlers.disconnectedHandler);
+      entityRef.off('error', entityHandlers.errorHandler);
+    }
+  };
+  const handlers = {
+    initHandler: data => {
+      view.dispatch(view.state.tr.setMeta('collabInitialised', true));
+      handleInit(data, view, options);
+    },
+    connectedHandler: data => handleConnection(data, view),
+    dataHandler: data => applyRemoteData(data, view, options),
+    presenceHandler: data => handlePresence(data, view),
+    telepointerHandler: data => handleTelePointer(data, view),
+    localStepsHandler: data => {
+      const {
+        steps
+      } = data;
+      const {
+        state
+      } = view;
+      const {
+        tr
+      } = state;
+      steps.forEach(step => tr.step(step));
+      view.dispatch(tr);
+    },
+    errorHandler: error => {
+      addSynchronyErrorAnalytics(view.state, view.state.tr, featureFlags, editorAnalyticsApi)(error);
+    },
+    entityHandler: ({
+      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 () => {
+    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);
+  };
+}, (previousDeps, currentDeps) => currentDeps && currentDeps.every((dep, i) => dep === previousDeps[i]));

package/dist/es2019/events/initialize.js

@@ -0,0 +1,44 @@
+import memoizeOne from 'memoize-one';
+import { Step } from '@atlaskit/editor-prosemirror/transform';
+import { pluginKey } from '../plugin-key';
+import { subscribe } from './handlers';
+const initCollab = (collabEditProvider, view) => {
+  if (collabEditProvider.initialize) {
+    collabEditProvider.initialize(() => view.state, json => Step.fromJSON(view.state.schema, json));
+  }
+};
+const initNewCollab = (collabEditProvider, view, onSyncUpError) => {
+  collabEditProvider.setup({
+    getState: () => view.state,
+    onSyncUpError
+  });
+};
+const initCollabMemo = memoizeOne(initCollab);
+export const initialize = ({
+  options,
+  providerFactory,
+  view,
+  featureFlags,
+  editorAnalyticsApi
+}) => provider => {
+  let cleanup;
+  const 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/es2019/events/send-transaction.js

@@ -0,0 +1,42 @@
+import { getSendableSelection } from '../actions';
+import { pluginKey } from '../plugin-key';
+export const sendTransaction = ({
+  originalTransaction,
+  transactions,
+  oldEditorState,
+  newEditorState,
+  useNativePlugin
+}) => provider => {
+  const docChangedTransaction = transactions.find(tr => tr.docChanged);
+  const currentPluginState = pluginKey.getState(newEditorState);
+  if (!(currentPluginState !== null && currentPluginState !== void 0 && currentPluginState.isReady)) {
+    return;
+  }
+  const 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);
+  }
+  const prevPluginState = pluginKey.getState(oldEditorState);
+  const {
+    activeParticipants: prevActiveParticipants
+  } = prevPluginState || {};
+  const {
+    activeParticipants,
+    sessionId
+  } = currentPluginState;
+  const selectionChanged = !oldEditorState.selection.eq(newEditorState.selection);
+  const participantsChanged = prevActiveParticipants && !prevActiveParticipants.eq(activeParticipants);
+  if (sessionId && selectionChanged && !docChangedTransaction || sessionId && participantsChanged) {
+    const selection = getSendableSelection(newEditorState.selection);
+    const message = {
+      type: 'telepointer',
+      selection,
+      sessionId
+    };
+    provider.sendMessage(message);
+  }
+};

package/dist/es2019/index.js

@@ -0,0 +1,86 @@
+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';
+const providerBuilder = collabEditProviderPromise => async (codeToExecute, onError) => {
+  try {
+    const provider = await collabEditProviderPromise;
+    if (provider) {
+      return codeToExecute(provider);
+    }
+  } catch (err) {
+    if (onError) {
+      onError(err);
+    } else {
+      // eslint-disable-next-line no-console
+      console.error(err);
+    }
+  }
+};
+export const collabEditPlugin = ({
+  config: options,
+  api
+}) => {
+  var _api$featureFlags;
+  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$featureFlags = api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
+  let providerResolver = () => {};
+  const collabEditProviderPromise = new Promise(_providerResolver => {
+    providerResolver = _providerResolver;
+  });
+  const executeProviderCode = providerBuilder(collabEditProviderPromise);
+  return {
+    name: 'collabEdit',
+    getSharedState(state) {
+      if (!state) {
+        return undefined;
+      }
+      const 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
+    },
+    pmPlugins() {
+      const {
+        useNativePlugin = false,
+        userId
+      } = options || {};
+      return [...(useNativePlugin ? [{
+        name: 'pmCollab',
+        plugin: () => collab({
+          clientID: userId
+        })
+      }, {
+        name: 'nativeCollabProviderPlugin',
+        plugin: () => nativeCollabProviderPlugin({
+          providerPromise: collabEditProviderPromise
+        })
+      }] : []), {
+        name: 'collab',
+        plugin: ({
+          dispatch,
+          providerFactory
+        }) => {
+          return createPlugin(dispatch, providerFactory, providerResolver, executeProviderCode, options, featureFlags, api);
+        }
+      }];
+    },
+    onEditorViewStateUpdated(props) {
+      var _api$analytics, _options$useNativePlu;
+      const addErrorAnalytics = addSynchronyErrorAnalytics(props.newEditorState, props.newEditorState.tr, featureFlags, api === null || api === void 0 ? 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/es2019/native-collab-provider-plugin.js

@@ -0,0 +1,32 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+const nativeCollabProviderPluginKey = new PluginKey('nativeCollabProviderPlugin');
+export const nativeCollabProviderPlugin = ({
+  providerPromise
+}) => {
+  return new SafePlugin({
+    key: nativeCollabProviderPluginKey,
+    state: {
+      init: () => null,
+      apply: (tr, currentPluginState) => {
+        const provider = tr.getMeta(nativeCollabProviderPluginKey);
+        return provider ? provider : currentPluginState;
+      }
+    },
+    view: editorView => {
+      providerPromise.then(provider => {
+        const {
+          dispatch,
+          state
+        } = editorView;
+        const tr = state.tr;
+        tr.setMeta(nativeCollabProviderPluginKey, provider);
+        dispatch(tr);
+      });
+      return {};
+    }
+  });
+};
+export const getCollabProvider = editorState => {
+  return nativeCollabProviderPluginKey.getState(editorState);
+};

package/dist/es2019/participants.js

@@ -0,0 +1,57 @@
+export class Participants {
+  constructor(participants = new Map()) {
+    this.participants = participants;
+  }
+  add(data) {
+    const newSet = new Map(this.participants);
+    data.forEach(participant => {
+      newSet.set(participant.sessionId, participant);
+    });
+    return new Participants(newSet);
+  }
+  remove(sessionIds) {
+    const newSet = new Map(this.participants);
+    sessionIds.forEach(sessionId => {
+      newSet.delete(sessionId);
+    });
+    return new Participants(newSet);
+  }
+  update(sessionId, lastActive) {
+    const newSet = new Map(this.participants);
+    const data = newSet.get(sessionId);
+    if (!data) {
+      return this;
+    }
+    newSet.set(sessionId, {
+      ...data,
+      lastActive
+    });
+    return new Participants(newSet);
+  }
+  updateCursorPos(sessionId, cursorPos) {
+    const newSet = new Map(this.participants);
+    const data = newSet.get(sessionId);
+    if (!data) {
+      return this;
+    }
+    newSet.set(sessionId, {
+      ...data,
+      cursorPos
+    });
+    return new Participants(newSet);
+  }
+  toArray() {
+    return Array.from(this.participants.values());
+  }
+  get(sessionId) {
+    return this.participants.get(sessionId);
+  }
+  size() {
+    return this.participants.size;
+  }
+  eq(other) {
+    const left = this.toArray().map(p => p.sessionId).sort((a, b) => a > b ? -1 : 1).join('');
+    const right = other.toArray().map(p => p.sessionId).sort((a, b) => a > b ? -1 : 1).join('');
+    return left === right;
+  }
+}

package/dist/es2019/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export const pluginKey = new PluginKey('collabEditPlugin');

package/dist/es2019/plugin-state.js

@@ -0,0 +1,219 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { TELEPOINTER_DIM_CLASS } from '@atlaskit/editor-common/collab';
+import { browser } from '@atlaskit/editor-common/utils';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { Participants } from './participants';
+import { createTelepointers, findPointers, getPositionOfTelepointer } from './utils';
+const isReplaceStep = step => step instanceof ReplaceStep;
+export { TELEPOINTER_DIM_CLASS };
+
+/**
+ * Returns position where it's possible to place a decoration.
+ */
+export const getValidPos = (tr, pos) => {
+  const endOfDocPos = tr.doc.nodeSize - 2;
+  if (pos <= endOfDocPos) {
+    const resolvedPos = tr.doc.resolve(pos);
+    const backwardSelection = Selection.findFrom(resolvedPos, -1, true);
+    // if there's no correct cursor position before the `pos`, we try to find it after the `pos`
+    const forwardSelection = Selection.findFrom(resolvedPos, 1, true);
+    return backwardSelection ? backwardSelection.from : forwardSelection ? forwardSelection.from : pos;
+  }
+  return endOfDocPos;
+};
+export class PluginState {
+  get decorations() {
+    return this.decorationSet;
+  }
+  get activeParticipants() {
+    return this.participants;
+  }
+  get sessionId() {
+    return this.sid;
+  }
+  constructor(decorations, participants, sessionId, collabInitalised = false, onError) {
+    // eslint-disable-next-line no-console
+    _defineProperty(this, "onError", error => console.error(error));
+    this.decorationSet = decorations;
+    this.participants = participants;
+    this.sid = sessionId;
+    this.isReady = collabInitalised;
+    this.onError = onError || this.onError;
+  }
+  getInitial(sessionId) {
+    const participant = this.participants.get(sessionId);
+    return participant ? participant.name.substring(0, 1).toUpperCase() : 'X';
+  }
+  apply(tr) {
+    let {
+      participants,
+      sid,
+      isReady
+    } = this;
+    const presenceData = tr.getMeta('presence');
+    const telepointerData = tr.getMeta('telepointer');
+    const sessionIdData = tr.getMeta('sessionId');
+    let collabInitialised = tr.getMeta('collabInitialised');
+    if (typeof collabInitialised !== 'boolean') {
+      collabInitialised = isReady;
+    }
+    if (sessionIdData) {
+      sid = sessionIdData.sid;
+    }
+    let add = [];
+    let remove = [];
+    if (presenceData) {
+      const {
+        joined = [],
+        left = []
+      } = presenceData;
+      participants = participants.remove(left.map(i => i.sessionId));
+      participants = participants.add(joined);
+
+      // Remove telepointers for users that left
+      left.forEach(i => {
+        const pointers = findPointers(i.sessionId, this.decorationSet);
+        if (pointers) {
+          remove = remove.concat(pointers);
+        }
+      });
+    }
+    if (telepointerData) {
+      const {
+        sessionId
+      } = telepointerData;
+      if (participants.get(sessionId) && sessionId !== sid) {
+        const oldPointers = findPointers(telepointerData.sessionId, this.decorationSet);
+        if (oldPointers) {
+          remove = remove.concat(oldPointers);
+        }
+        const endOfDocPos = tr.doc.nodeSize - 2;
+        const anchor = telepointerData.selection.anchor;
+        const head = telepointerData.selection.head;
+        let rawFrom = anchor < head ? anchor : head;
+        let rawTo = anchor >= head ? anchor : head;
+        if (rawFrom > endOfDocPos) {
+          rawFrom = endOfDocPos;
+        }
+        if (rawTo > endOfDocPos) {
+          rawTo = endOfDocPos;
+        }
+        const isSelection = rawTo - rawFrom > 0;
+        let from = 1;
+        let to = 1;
+        try {
+          from = getValidPos(tr, isSelection ? Math.max(rawFrom - 1, 0) : rawFrom);
+          to = isSelection ? getValidPos(tr, rawTo) : from;
+        } catch (err) {
+          this.onError(err);
+        }
+        add = add.concat(createTelepointers(from, to, sessionId, isSelection, this.getInitial(sessionId)));
+      }
+    }
+    if (tr.docChanged) {
+      // Adjust decoration positions to changes made by the transaction
+      try {
+        this.decorationSet = this.decorationSet.map(tr.mapping, tr.doc, {
+          // Reapplies decorators those got removed by the state change
+          onRemove: spec => {
+            if (spec.pointer && spec.pointer.sessionId && spec.key === `telepointer-${spec.pointer.sessionId}`) {
+              const step = tr.steps.filter(isReplaceStep)[0];
+              if (step) {
+                const {
+                  sessionId
+                } = spec.pointer;
+                const {
+                  slice: {
+                    content: {
+                      size
+                    }
+                  },
+                  from
+                } = step;
+                const pos = getValidPos(tr, size ? Math.min(from + size, tr.doc.nodeSize - 3) : Math.max(from, 1));
+                add = add.concat(createTelepointers(pos, pos, sessionId, false, this.getInitial(sessionId)));
+              }
+            }
+          }
+        });
+      } catch (err) {
+        this.onError(err);
+      }
+
+      // Remove any selection decoration within the change range,
+      // takes care of the issue when after pasting we end up with a dead selection
+      tr.steps.filter(isReplaceStep).forEach(s => {
+        const {
+          from,
+          to
+        } = s;
+        this.decorationSet.find(from, to).forEach(deco => {
+          // `type` is private, `from` and `to` are public in latest version
+          // `from` != `to` means it's a selection
+          if (deco.from !== deco.to) {
+            remove.push(deco);
+          }
+        });
+      });
+    }
+    const {
+      selection
+    } = tr;
+    this.decorationSet.find().forEach(deco => {
+      if (deco.type.toDOM) {
+        const hasTelepointerDimClass = deco.type.toDOM.classList.contains(TELEPOINTER_DIM_CLASS);
+        if (deco.from === selection.from && deco.to === selection.to) {
+          if (!hasTelepointerDimClass) {
+            deco.type.toDOM.classList.add(TELEPOINTER_DIM_CLASS);
+          }
+
+          // Browser condition here to fix ED-14722 where telepointer
+          // decorations with side -1 in Firefox causes backspace issues.
+          // This is likely caused by contenteditable quirks in Firefox
+          if (!browser.gecko) {
+            deco.type.side = -1;
+          }
+        } else {
+          if (hasTelepointerDimClass) {
+            deco.type.toDOM.classList.remove(TELEPOINTER_DIM_CLASS);
+          }
+          deco.type.side = 0;
+        }
+      }
+    });
+    if (remove.length) {
+      this.decorationSet = this.decorationSet.remove(remove);
+    }
+    if (add.length) {
+      this.decorationSet = this.decorationSet.add(tr.doc, add);
+    }
+
+    // This piece needs to be after the decorationSet adjustments,
+    // otherwise it's always one step behind where the cursor is
+    if (telepointerData) {
+      const {
+        sessionId
+      } = telepointerData;
+      if (participants.get(sessionId)) {
+        const positionForScroll = getPositionOfTelepointer(sessionId, this.decorationSet);
+        if (positionForScroll) {
+          participants = participants.updateCursorPos(sessionId, positionForScroll);
+        }
+      }
+    }
+    const nextState = new PluginState(this.decorationSet, participants, sid, collabInitialised);
+    return PluginState.eq(nextState, this) ? this : nextState;
+  }
+  static eq(a, b) {
+    return a.participants === b.participants && a.sessionId === b.sessionId && a.isReady === b.isReady;
+  }
+  static init(config) {
+    const {
+      doc,
+      onError
+    } = config;
+    return new PluginState(DecorationSet.create(doc, []), new Participants(), undefined, undefined, onError);
+  }
+}

package/dist/es2019/plugin.js

@@ -0,0 +1,83 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, fireAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { addSynchronyErrorAnalytics } from './analytics';
+import { initialize } from './events/initialize';
+import { pluginKey } from './plugin-key';
+import { PluginState } from './plugin-state';
+export { PluginState, pluginKey };
+export const createPlugin = (dispatch, providerFactory, providerResolver, collabProviderCallback, options, featureFlags, pluginInjectionApi) => {
+  return new SafePlugin({
+    key: pluginKey,
+    state: {
+      init(config) {
+        return PluginState.init(config);
+      },
+      apply(transaction, prevPluginState, _oldEditorState, _newEditorState) {
+        const pluginState = prevPluginState.apply(transaction);
+        dispatch(pluginKey, pluginState);
+        return pluginState;
+      }
+    },
+    props: {
+      decorations(state) {
+        var _pluginKey$getState;
+        return (_pluginKey$getState = pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.decorations;
+      }
+    },
+    filterTransaction(tr, state) {
+      const pluginState = pluginKey.getState(state);
+      const collabInitialiseTr = tr.getMeta('collabInitialised');
+
+      // Don't allow transactions that modifies the document before
+      // collab-plugin is ready.
+      if (collabInitialiseTr) {
+        return true;
+      }
+      if (!(pluginState !== null && pluginState !== void 0 && pluginState.isReady) && tr.docChanged) {
+        return false;
+      }
+      return true;
+    },
+    view(view) {
+      var _pluginInjectionApi$a, _pluginInjectionApi$a5;
+      const addErrorAnalytics = addSynchronyErrorAnalytics(view.state, view.state.tr, featureFlags, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : _pluginInjectionApi$a.actions);
+      const onSyncUpError = attributes => {
+        var _pluginInjectionApi$a2, _pluginInjectionApi$a3, _pluginInjectionApi$a4;
+        const fireAnalyticsCallback = fireAnalyticsEvent((_pluginInjectionApi$a2 = pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a3 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a3 === void 0 ? void 0 : (_pluginInjectionApi$a4 = _pluginInjectionApi$a3.sharedState.currentState()) === null || _pluginInjectionApi$a4 === void 0 ? void 0 : _pluginInjectionApi$a4.createAnalyticsEvent) !== null && _pluginInjectionApi$a2 !== void 0 ? _pluginInjectionApi$a2 : undefined);
+        fireAnalyticsCallback({
+          payload: {
+            action: ACTION.NEW_COLLAB_SYNC_UP_ERROR_NO_STEPS,
+            actionSubject: ACTION_SUBJECT.EDITOR,
+            eventType: EVENT_TYPE.OPERATIONAL,
+            attributes
+          }
+        });
+      };
+      options.onSyncUpError = onSyncUpError;
+      const cleanup = collabProviderCallback(initialize({
+        view,
+        options,
+        providerFactory,
+        featureFlags,
+        editorAnalyticsApi: pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a5 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a5 === void 0 ? void 0 : _pluginInjectionApi$a5.actions
+      }), addErrorAnalytics);
+      providerFactory && providerFactory.subscribe('collabEditProvider', (_name, providerPromise) => {
+        if (providerPromise) {
+          providerPromise.then(provider => providerResolver(provider));
+        }
+      });
+      return {
+        destroy() {
+          providerFactory.unsubscribeAll('collabEditProvider');
+          if (cleanup) {
+            cleanup.then(unsubscribe => {
+              if (unsubscribe) {
+                unsubscribe();
+              }
+            });
+          }
+        }
+      };
+    }
+  });
+};

package/dist/es2019/types.js

@@ -0,0 +1 @@
+export {};