@atlaskit/editor-core 190.2.3 → 191.0.0

package/dist/es2019/plugins/collab-edit/actions.js

@@ -1,119 +0,0 @@
-import { AllSelection, NodeSelection } from '@atlaskit/editor-prosemirror/state';
-import { Step } from '@atlaskit/editor-prosemirror/transform';
-import { receiveTransaction } from 'prosemirror-collab';
-import { replaceDocument } from './utils';
-export const handleInit = (initData, view, options) => {
-  const {
-    doc,
-    json,
-    version,
-    reserveCursor
-  } = initData;
-  if (doc) {
-    const {
-      state
-    } = view;
-    const tr = replaceDocument(doc, state, version, options, reserveCursor);
-    tr.setMeta('isRemote', true);
-    view.dispatch(tr);
-  } else if (json) {
-    applyRemoteSteps(json, view);
-  }
-};
-export const handleConnection = (connectionData, view) => {
-  const {
-    state: {
-      tr
-    }
-  } = view;
-  view.dispatch(tr.setMeta('sessionId', connectionData));
-};
-export const handlePresence = (presenceData, view) => {
-  const {
-    state: {
-      tr
-    }
-  } = view;
-  view.dispatch(tr.setMeta('presence', presenceData));
-};
-export const applyRemoteData = (remoteData, view, options) => {
-  const {
-    json,
-    userIds = []
-  } = remoteData;
-  if (json) {
-    applyRemoteSteps(json, view, userIds, options);
-  }
-};
-export const applyRemoteSteps = (json, view, userIds, options) => {
-  if (!json || !json.length) {
-    return;
-  }
-  const {
-    state,
-    state: {
-      schema
-    }
-  } = view;
-  const steps = json.map(step => Step.fromJSON(schema, step));
-  let tr;
-  if (options && options.useNativePlugin && userIds) {
-    tr = receiveTransaction(state, steps, userIds);
-  } else {
-    tr = state.tr;
-    steps.forEach(step => tr.step(step));
-  }
-  if (tr) {
-    tr.setMeta('addToHistory', false);
-    tr.setMeta('isRemote', true);
-    const {
-      from,
-      to
-    } = state.selection;
-    const [firstStep] = json;
-
-    /*
-     * 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 const handleTelePointer = (telepointerData, view) => {
-  const {
-    state: {
-      tr
-    }
-  } = view;
-  view.dispatch(tr.setMeta('telepointer', telepointerData));
-};
-function isAllSelection(selection) {
-  return selection instanceof AllSelection;
-}
-function isNodeSelection(selection) {
-  return selection instanceof NodeSelection;
-}
-export const 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/es2019/plugins/collab-edit/analytics.js

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

@@ -1,72 +0,0 @@
-import { handleInit, handleConnection, handlePresence, handleTelePointer, applyRemoteData } 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/plugins/collab-edit/events/initialize.js

@@ -1,44 +0,0 @@
-import { Step } from '@atlaskit/editor-prosemirror/transform';
-import memoizeOne from 'memoize-one';
-import { subscribe } from './handlers';
-import { pluginKey } from '../plugin-key';
-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/plugins/collab-edit/events/send-transaction.js

@@ -1,42 +0,0 @@
-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/plugins/collab-edit/get-participants-count.js

@@ -1,11 +0,0 @@
-import { pluginKey } from './plugin-key';
-export function getParticipantsCount(state) {
-  if (!state) {
-    return 1;
-  }
-  const pluginState = pluginKey.getState(state);
-  // @ts-ignore accessing private property
-  return pluginState && pluginState.participants ?
-  // @ts-ignore accessing private property
-  pluginState.participants.size() : 1;
-}

package/dist/es2019/plugins/collab-edit/index.js

@@ -1,73 +0,0 @@
-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 };
-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);
-    }
-  }
-};
-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',
-    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);
-    }
-  };
-};
-export default collabEditPlugin;

package/dist/es2019/plugins/collab-edit/native-collab-provider-plugin.js

@@ -1,32 +0,0 @@
-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/plugins/collab-edit/participants.js

@@ -1,57 +0,0 @@
-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/plugins/collab-edit/plugin-key.js

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