@atlaskit/editor-plugin-synced-block/dist/esm/editor-commands/index.js

SyncedBlock plugin for @atlaskit/editor-core

import { defaultSchema } from '@atlaskit/adf-schema/schema-default';
import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
import { copyDomNode, toDOM } from '@atlaskit/editor-common/copy-button';
import { DOMSerializer, Fragment } from '@atlaskit/editor-prosemirror/model';
import { TextSelection } from '@atlaskit/editor-prosemirror/state';
import { findSelectedNodeOfType, removeParentNodeOfType, removeSelectedNode, safeInsert } from '@atlaskit/editor-prosemirror/utils';
import { syncedBlockPluginKey } from '../pm-plugins/main';
import { canBeConvertedToSyncBlock, deferDispatch, findSyncBlock, findSyncBlockOrBodiedSyncBlock, isBodiedSyncBlockNode } from '../pm-plugins/utils/utils';
import { FLAG_ID } from '../types';
import { pasteSyncBlockHTMLContent } from './utils';
export var createSyncedBlock = function createSyncedBlock(_ref) {
  var tr = _ref.tr,
    syncBlockStore = _ref.syncBlockStore,
    typeAheadInsert = _ref.typeAheadInsert,
    fireAnalyticsEvent = _ref.fireAnalyticsEvent;
  var _tr$doc$type$schema$n = tr.doc.type.schema.nodes,
    bodiedSyncBlock = _tr$doc$type$schema$n.bodiedSyncBlock,
    paragraph = _tr$doc$type$schema$n.paragraph;

  // If the selection is empty, we want to insert the sync block on a new line
  if (tr.selection.empty) {
    var attrs = syncBlockStore.sourceManager.generateBodiedSyncBlockAttrs();
    var paragraphNode = paragraph.createAndFill({});
    var newBodiedSyncBlockNode = bodiedSyncBlock.createAndFill(attrs, paragraphNode ? [paragraphNode] : []);
    if (!newBodiedSyncBlockNode) {
      fireAnalyticsEvent === null || fireAnalyticsEvent === void 0 || fireAnalyticsEvent({
        action: ACTION.ERROR,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_CREATE,
        attributes: {
          error: 'Create and fill for empty content failed'
        },
        eventType: EVENT_TYPE.OPERATIONAL
      });
      return false;
    }
    if (typeAheadInsert) {
      tr = typeAheadInsert(newBodiedSyncBlockNode);
    } else {
      tr = safeInsert(newBodiedSyncBlockNode)(tr).scrollIntoView();
    }
  } else {
    var conversionInfo = canBeConvertedToSyncBlock(tr.selection);
    if (!conversionInfo) {
      fireAnalyticsEvent === null || fireAnalyticsEvent === void 0 || fireAnalyticsEvent({
        action: ACTION.ERROR,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_CREATE,
        attributes: {
          error: 'Content cannot be converted to sync block'
        },
        eventType: EVENT_TYPE.OPERATIONAL
      });
      return false;
    }
    var _attrs = syncBlockStore.sourceManager.generateBodiedSyncBlockAttrs();
    var _newBodiedSyncBlockNode = bodiedSyncBlock.createAndFill(_attrs, conversionInfo.contentToInclude);
    if (!_newBodiedSyncBlockNode) {
      fireAnalyticsEvent === null || fireAnalyticsEvent === void 0 || fireAnalyticsEvent({
        action: ACTION.ERROR,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_CREATE,
        attributes: {
          error: 'Create and fill for content failed'
        },
        eventType: EVENT_TYPE.OPERATIONAL
      });
      return false;
    }
    tr.replaceWith(conversionInfo.from, conversionInfo.to, _newBodiedSyncBlockNode).scrollIntoView();

    // set selection to the start of the previous selection for the position taken up by the start of the new synced block
    tr.setSelection(TextSelection.create(tr.doc, conversionInfo.from));
  }
  return tr;
};
export var copySyncedBlockReferenceToClipboardEditorCommand = function copySyncedBlockReferenceToClipboardEditorCommand(syncBlockStore, inputMethod, api) {
  return function (_ref2) {
    var tr = _ref2.tr;
    if (copySyncedBlockReferenceToClipboardInternal(tr.doc.type.schema, tr.selection, syncBlockStore, inputMethod, api)) {
      return tr;
    }
    return null;
  };
};
export var copySyncedBlockReferenceToClipboard = function copySyncedBlockReferenceToClipboard(syncBlockStore, inputMethod, api) {
  return function (state, _dispatch, _view) {
    return copySyncedBlockReferenceToClipboardInternal(state.tr.doc.type.schema, state.tr.selection, syncBlockStore, inputMethod, api);
  };
};
var copySyncedBlockReferenceToClipboardInternal = function copySyncedBlockReferenceToClipboardInternal(schema, selection, syncBlockStore, inputMethod, api) {
  var syncBlockFindResult = findSyncBlockOrBodiedSyncBlock(schema, selection);
  if (!syncBlockFindResult) {
    var _api$analytics;
    api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || (_api$analytics = _api$analytics.actions) === null || _api$analytics === void 0 || _api$analytics.fireAnalyticsEvent({
      eventType: EVENT_TYPE.OPERATIONAL,
      action: ACTION.ERROR,
      actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
      actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_COPY,
      attributes: {
        error: 'No sync block found in selection',
        inputMethod: inputMethod
      }
    });
    return false;
  }
  var isBodiedSyncBlock = isBodiedSyncBlockNode(syncBlockFindResult.node, schema.nodes.bodiedSyncBlock);
  var referenceSyncBlockNode = null;
  if (isBodiedSyncBlock) {
    var syncBlock = schema.nodes.syncBlock;

    // create sync block reference node
    referenceSyncBlockNode = syncBlock.createAndFill({
      resourceId: syncBlockStore.referenceManager.generateResourceIdForReference(syncBlockFindResult.node.attrs.resourceId)
    });
    if (!referenceSyncBlockNode) {
      var _api$analytics2;
      api === null || api === void 0 || (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 || (_api$analytics2 = _api$analytics2.actions) === null || _api$analytics2 === void 0 || _api$analytics2.fireAnalyticsEvent({
        eventType: EVENT_TYPE.OPERATIONAL,
        action: ACTION.ERROR,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_COPY,
        attributes: {
          error: 'Failed to create reference sync block node',
          resourceId: syncBlockFindResult.node.attrs.resourceId,
          inputMethod: inputMethod
        }
      });
      return false;
    }
  } else {
    referenceSyncBlockNode = syncBlockFindResult.node;
  }
  if (!referenceSyncBlockNode) {
    var _api$analytics3;
    api === null || api === void 0 || (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 || (_api$analytics3 = _api$analytics3.actions) === null || _api$analytics3 === void 0 || _api$analytics3.fireAnalyticsEvent({
      eventType: EVENT_TYPE.OPERATIONAL,
      action: ACTION.ERROR,
      actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
      actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_COPY,
      attributes: {
        error: 'No reference sync block node available',
        inputMethod: inputMethod
      }
    });
    return false;
  }
  var domNode = toDOM(referenceSyncBlockNode, schema);
  copyDomNode(domNode, referenceSyncBlockNode.type, selection);
  deferDispatch(function () {
    api === null || api === void 0 || api.core.actions.execute(function (_ref3) {
      var _api$analytics4;
      var tr = _ref3.tr;
      api === null || api === void 0 || (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 || (_api$analytics4 = _api$analytics4.actions) === null || _api$analytics4 === void 0 || _api$analytics4.fireAnalyticsEvent({
        eventType: EVENT_TYPE.OPERATIONAL,
        action: ACTION.COPIED,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_COPY,
        attributes: {
          resourceId: referenceSyncBlockNode.attrs.resourceId,
          inputMethod: inputMethod
        }
      });
      return tr.setMeta(syncedBlockPluginKey, {
        activeFlag: {
          id: FLAG_ID.SYNC_BLOCK_COPIED
        }
      });
    });
  });
  return true;
};
export var editSyncedBlockSource = function editSyncedBlockSource(syncBlockStore, api) {
  return function (state, dispatch, _view) {
    var _syncBlock$node;
    var syncBlock = findSyncBlock(state.schema, state.selection);
    var resourceId = syncBlock === null || syncBlock === void 0 || (_syncBlock$node = syncBlock.node) === null || _syncBlock$node === void 0 || (_syncBlock$node = _syncBlock$node.attrs) === null || _syncBlock$node === void 0 ? void 0 : _syncBlock$node.resourceId;
    if (!resourceId) {
      return false;
    }
    var syncBlockURL = syncBlockStore.referenceManager.getSyncBlockURL(resourceId);
    if (syncBlockURL) {
      var _api$analytics5;
      api === null || api === void 0 || (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 || _api$analytics5.actions.fireAnalyticsEvent({
        eventType: EVENT_TYPE.OPERATIONAL,
        action: ACTION.SYNCED_BLOCK_EDIT_SOURCE,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_SOURCE_URL,
        attributes: {
          resourceId: resourceId
        }
      });
      window.open(syncBlockURL, '_blank');
    } else {
      var _api$analytics6;
      var tr = state.tr;
      api === null || api === void 0 || (_api$analytics6 = api.analytics) === null || _api$analytics6 === void 0 || (_api$analytics6 = _api$analytics6.actions) === null || _api$analytics6 === void 0 || _api$analytics6.attachAnalyticsEvent({
        eventType: EVENT_TYPE.OPERATIONAL,
        action: ACTION.ERROR,
        actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
        actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_SOURCE_URL,
        attributes: {
          error: 'No URL resolved for synced block'
        }
      })(tr);
      dispatch === null || dispatch === void 0 || dispatch(tr);
    }
    return true;
  };
};
export var removeSyncedBlock = function removeSyncedBlock(api) {
  return function (state, dispatch, _view) {
    var nodes = state.schema.nodes,
      tr = state.tr;
    if (!dispatch) {
      return false;
    }
    var removeTr = tr;
    if (findSelectedNodeOfType(nodes.syncBlock)(tr.selection) || findSelectedNodeOfType(nodes.bodiedSyncBlock)(tr.selection)) {
      removeTr = removeSelectedNode(tr);
    } else {
      removeTr = removeParentNodeOfType(nodes.bodiedSyncBlock)(tr);
    }
    if (!removeTr) {
      return false;
    }
    dispatch(removeTr);
    api === null || api === void 0 || api.core.actions.focus();
    return true;
  };
};
export var removeSyncedBlockAtPos = function removeSyncedBlockAtPos(api, pos) {
  api === null || api === void 0 || api.core.actions.execute(function (_ref4) {
    var tr = _ref4.tr;
    var node = tr.doc.nodeAt(pos);
    if ((node === null || node === void 0 ? void 0 : node.type.name) === 'syncBlock') {
      var _node$nodeSize;
      return tr.replace(pos, pos + ((_node$nodeSize = node === null || node === void 0 ? void 0 : node.nodeSize) !== null && _node$nodeSize !== void 0 ? _node$nodeSize : 0));
    }
    return tr;
  });
};
/**
 * Deletes (bodied)SyncBlock node and paste its content to the editor
 */
export var unsync = function unsync(storeManager, isBodiedSyncBlock, view) {
  var _storeManager$referen;
  if (!view) {
    return false;
  }
  var state = view.state;
  var syncBlock = findSyncBlockOrBodiedSyncBlock(state.schema, state.selection);
  if (!syncBlock) {
    return false;
  }
  if (isBodiedSyncBlock) {
    var content = syncBlock === null || syncBlock === void 0 ? void 0 : syncBlock.node.content;
    var tr = state.tr;
    tr.replaceWith(syncBlock.pos, syncBlock.pos + syncBlock.node.nodeSize, content).setMeta('deletionReason', 'source-block-unsynced');
    view.dispatch(tr);
    return true;
  }

  // handle syncBlock unsync
  var syncBlockContent = (_storeManager$referen = storeManager.referenceManager.getFromCache(syncBlock.node.attrs.resourceId)) === null || _storeManager$referen === void 0 || (_storeManager$referen = _storeManager$referen.data) === null || _storeManager$referen === void 0 ? void 0 : _storeManager$referen.content;
  if (!syncBlockContent) {
    return false;
  }

  // use defaultSchema for serialization so we can serialize any type of nodes and marks despite current editor's schema might not allow it
  var contentFragment = Fragment.fromJSON(defaultSchema, syncBlockContent);
  var contentDOM = DOMSerializer.fromSchema(defaultSchema).serializeFragment(contentFragment);
  return pasteSyncBlockHTMLContent(contentDOM, view);
};