@atlaskit/editor-plugin-paste 0.1.22 → 0.2.1

package/dist/es2019/index.js

@@ -1 +1 @@
-export {};
+export { pastePlugin } from './plugin';

package/dist/es2019/plugin.js

@@ -0,0 +1,38 @@
+import { createPlugin } from './pm-plugins/main';
+import { pluginKey } from './pm-plugins/plugin-factory';
+export const pastePlugin = ({
+  config,
+  api
+}) => {
+  var _api$featureFlags;
+  const {
+    cardOptions,
+    sanitizePrivateContent
+  } = config !== null && config !== void 0 ? config : {};
+  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$featureFlags = api.featureFlags) === null || _api$featureFlags === void 0 ? void 0 : _api$featureFlags.sharedState.currentState()) || {};
+  return {
+    name: 'paste',
+    pmPlugins() {
+      return [{
+        name: 'paste',
+        plugin: ({
+          schema,
+          providerFactory,
+          dispatchAnalyticsEvent,
+          dispatch
+        }) => createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFlags, api, cardOptions, sanitizePrivateContent, providerFactory)
+      }];
+    },
+    getSharedState: editorState => {
+      if (!editorState) {
+        return {
+          lastContentPasted: null
+        };
+      }
+      const pluginState = pluginKey.getState(editorState);
+      return {
+        lastContentPasted: pluginState.lastContentPasted
+      };
+    }
+  };
+};

package/dist/es2019/plugins/media.js

@@ -0,0 +1,204 @@
+import { DEFAULT_IMAGE_WIDTH } from '@atlaskit/editor-common/media-single';
+import { mapSlice, removeNestedEmptyEls, unwrap, walkUpTreeUntil } from '@atlaskit/editor-common/utils';
+import { hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { getRandomHex } from '@atlaskit/media-common';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
+
+/**
+ * Ensure correct layout in nested mode
+ *
+ * TODO: this func is only used in handlePaste, so layout update won't work for drop event
+ */
+export function transformSliceForMedia(slice, schema) {
+  const {
+    mediaSingle,
+    layoutSection,
+    table,
+    bulletList,
+    orderedList,
+    expand,
+    nestedExpand
+  } = schema.nodes;
+  return selection => {
+    let newSlice = slice;
+    if (hasParentNodeOfType([layoutSection, table, bulletList, orderedList, expand, nestedExpand])(selection)) {
+      newSlice = mapSlice(newSlice, node => {
+        const extendedOrLegacyAttrs = getBooleanFF('platform.editor.media.extended-resize-experience') ? {
+          layout: node.attrs.layout,
+          widthType: node.attrs.widthType,
+          width: node.attrs.width
+        } : {
+          layout: node.attrs.layout
+        };
+        let attrs = {};
+        if (hasParentNodeOfType([layoutSection, table])(selection)) {
+          // Supports layouts
+          attrs = {
+            ...extendedOrLegacyAttrs
+          };
+        } else if (hasParentNodeOfType([bulletList, orderedList, expand, nestedExpand])(selection)) {
+          // does not support other layouts
+          attrs = {
+            ...extendedOrLegacyAttrs,
+            layout: 'center'
+          };
+        }
+        return node.type.name === 'mediaSingle' ? mediaSingle.createChecked(attrs, node.content, node.marks) : node;
+      });
+    }
+    return newSlice;
+  };
+}
+
+// TODO move this to editor-common
+export const isImage = fileType => {
+  return !!fileType && (fileType.indexOf('image/') > -1 || fileType.indexOf('video/') > -1);
+};
+export const transformSliceToCorrectMediaWrapper = (slice, schema) => {
+  const {
+    mediaGroup,
+    mediaSingle,
+    media
+  } = schema.nodes;
+  return mapSlice(slice, (node, parent) => {
+    if (!parent && node.type === media) {
+      if (mediaSingle && (isImage(node.attrs.__fileMimeType) || node.attrs.type === 'external')) {
+        return mediaSingle.createChecked({}, node);
+      } else {
+        return mediaGroup.createChecked({}, [node]);
+      }
+    }
+    return node;
+  });
+};
+
+/**
+ * This func will be called when copy & paste, drag & drop external html with media, media files, and slices from editor
+ * Because width may not be available when transform, DEFAULT_IMAGE_WIDTH is used as a fallback
+ *
+ */
+export const transformSliceToMediaSingleWithNewExperience = (slice, schema) => {
+  const {
+    mediaInline,
+    mediaSingle,
+    media
+  } = schema.nodes;
+  const newSlice = mapSlice(slice, node => {
+    // This logic is duplicated in editor-plugin-ai where external images can be inserted
+    // from external sources through the use of AI.  The editor-plugin-ai package is avoiding
+    // sharing dependencies with editor-core to support products using it with various versions
+    // of editor packages.
+    // The duplication is in the following file:
+    // packages/editor/editor-plugin-ai/src/prebuilt/content-transformers/markdown-to-pm/markdown-transformer.ts
+    if (node.type === mediaSingle) {
+      return getBooleanFF('platform.editor.media.extended-resize-experience') ? mediaSingle.createChecked({
+        width: node.attrs.width || DEFAULT_IMAGE_WIDTH,
+        widthType: node.attrs.widthType || 'pixel',
+        layout: node.attrs.layout
+      }, node.content, node.marks) : node;
+    }
+    return node;
+  });
+  return mapSlice(newSlice, node => {
+    const __mediaTraceId = getRandomHex(8);
+    if (node.type === media) {
+      return media.createChecked({
+        ...node.attrs,
+        __external: node.attrs.type === 'external',
+        __mediaTraceId: node.attrs.type === 'external' ? null : __mediaTraceId
+      }, node.content, node.marks);
+    }
+    if (node.type.name === 'mediaInline') {
+      return mediaInline.createChecked({
+        ...node.attrs,
+        __mediaTraceId
+      }, node.content, node.marks);
+    }
+    return node;
+  });
+};
+
+/**
+ * Check base styles to see if an element will be invisible when rendered in a document.
+ * @param element
+ */
+const isElementInvisible = element => {
+  return element.style.opacity === '0' || element.style.display === 'none' || element.style.visibility === 'hidden';
+};
+const VALID_TAGS_CONTAINER = ['DIV', 'TD'];
+function canContainImage(element) {
+  if (!element) {
+    return false;
+  }
+  return VALID_TAGS_CONTAINER.indexOf(element.tagName) !== -1;
+}
+
+/**
+ * Given a html string, we attempt to hoist any nested `<img>` tags,
+ * not directly wrapped by a `<div>` as ProseMirror no-op's
+ * on those scenarios.
+ * @param html
+ */
+export const unwrapNestedMediaElements = html => {
+  const parser = new DOMParser();
+  let doc = parser.parseFromString(html, 'text/html');
+  const wrapper = doc.body;
+
+  // Remove Google Doc's wrapper <b> el
+  const docsWrapper = wrapper.querySelector('b[id^="docs-internal-guid-"]');
+  if (docsWrapper) {
+    unwrap(wrapper, docsWrapper);
+  }
+  const imageTags = wrapper.querySelectorAll('img');
+  if (!imageTags.length) {
+    return html;
+  }
+  imageTags.forEach(imageTag => {
+    // Capture the immediate parent, we may remove the media from here later.
+    const mediaParent = imageTag.parentElement;
+    if (!mediaParent) {
+      return;
+    }
+
+    // If either the parent or the image itself contains styles that would make
+    // them invisible on copy, dont paste them.
+    if (isElementInvisible(mediaParent) || isElementInvisible(imageTag)) {
+      mediaParent.removeChild(imageTag);
+      return;
+    }
+
+    // If its wrapped by a valid container we assume its safe to bypass.
+    // ProseMirror should handle these cases properly.
+    if (canContainImage(mediaParent) || mediaParent instanceof HTMLSpanElement && mediaParent.closest('[class*="emoji-common"]')) {
+      return;
+    }
+
+    // Find the top most element that the parent has a valid container for the image.
+    // Stop just before found the wrapper
+    const insertBeforeElement = walkUpTreeUntil(mediaParent, element => {
+      // If is at the top just use this element as reference
+      if (element.parentElement === wrapper) {
+        return true;
+      }
+      return canContainImage(element.parentElement);
+    });
+
+    // Here we try to insert the media right after its top most valid parent element
+    // Unless its the last element in our structure then we will insert above it.
+    if (insertBeforeElement && insertBeforeElement.parentElement) {
+      // Insert as close as possible to the most closest valid element index in the tree.
+      insertBeforeElement.parentElement.insertBefore(imageTag, insertBeforeElement.nextElementSibling || insertBeforeElement);
+
+      // Attempt to clean up lines left behind by the image
+      mediaParent.innerText = mediaParent.innerText.trim();
+      // Walk up and delete empty elements left over after removing the image tag
+      removeNestedEmptyEls(mediaParent);
+    }
+  });
+
+  // If last child is a hardbreak we don't want it
+  if (wrapper.lastElementChild && wrapper.lastElementChild.tagName === 'BR') {
+    wrapper.removeChild(wrapper.lastElementChild);
+  }
+  return wrapper.innerHTML;
+};

package/dist/es2019/pm-plugins/analytics.js

@@ -0,0 +1,332 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD, PasteContents, PasteTypes } from '@atlaskit/editor-common/analytics';
+import { getLinkDomain, mapSlice } from '@atlaskit/editor-common/utils';
+import { findParentNode } from '@atlaskit/editor-prosemirror/utils';
+import { handleCodeBlock, handleExpandPasteInTable, handleMarkdown, handleMediaSingle, handlePasteAsPlainText, handlePasteIntoCaption, handlePasteIntoTaskOrDecisionOrPanel, handlePasteLinkOnSelectedText, handlePasteNonNestableBlockNodesIntoList, handlePastePanelOrDecisionContentIntoList, handlePastePreservingMarks, handleRichText, handleSelectedTable } from '../handlers';
+import { getPasteSource } from '../util';
+const contentToPasteContent = {
+  url: PasteContents.url,
+  paragraph: PasteContents.text,
+  bulletList: PasteContents.bulletList,
+  orderedList: PasteContents.orderedList,
+  heading: PasteContents.heading,
+  blockquote: PasteContents.blockquote,
+  codeBlock: PasteContents.codeBlock,
+  panel: PasteContents.panel,
+  rule: PasteContents.rule,
+  mediaSingle: PasteContents.mediaSingle,
+  mediaCard: PasteContents.mediaCard,
+  mediaGroup: PasteContents.mediaGroup,
+  table: PasteContents.table,
+  tableCells: PasteContents.tableCells,
+  tableHeader: PasteContents.tableHeader,
+  tableRow: PasteContents.tableRow,
+  decisionList: PasteContents.decisionList,
+  decisionItem: PasteContents.decisionItem,
+  taskList: PasteContents.taskItem,
+  extension: PasteContents.extension,
+  bodiedExtension: PasteContents.bodiedExtension,
+  blockCard: PasteContents.blockCard,
+  layoutSection: PasteContents.layoutSection
+};
+const nodeToActionSubjectId = {
+  blockquote: ACTION_SUBJECT_ID.PASTE_BLOCKQUOTE,
+  blockCard: ACTION_SUBJECT_ID.PASTE_BLOCK_CARD,
+  bodiedExtension: ACTION_SUBJECT_ID.PASTE_BODIED_EXTENSION,
+  bulletList: ACTION_SUBJECT_ID.PASTE_BULLET_LIST,
+  codeBlock: ACTION_SUBJECT_ID.PASTE_CODE_BLOCK,
+  decisionList: ACTION_SUBJECT_ID.PASTE_DECISION_LIST,
+  extension: ACTION_SUBJECT_ID.PASTE_EXTENSION,
+  heading: ACTION_SUBJECT_ID.PASTE_HEADING,
+  mediaGroup: ACTION_SUBJECT_ID.PASTE_MEDIA_GROUP,
+  mediaSingle: ACTION_SUBJECT_ID.PASTE_MEDIA_SINGLE,
+  orderedList: ACTION_SUBJECT_ID.PASTE_ORDERED_LIST,
+  panel: ACTION_SUBJECT_ID.PASTE_PANEL,
+  rule: ACTION_SUBJECT_ID.PASTE_RULE,
+  table: ACTION_SUBJECT_ID.PASTE_TABLE,
+  tableCell: ACTION_SUBJECT_ID.PASTE_TABLE_CELL,
+  tableHeader: ACTION_SUBJECT_ID.PASTE_TABLE_HEADER,
+  tableRow: ACTION_SUBJECT_ID.PASTE_TABLE_ROW,
+  taskList: ACTION_SUBJECT_ID.PASTE_TASK_LIST
+};
+export function getContent({
+  schema,
+  slice
+}) {
+  const {
+    nodes: {
+      paragraph
+    },
+    marks: {
+      link
+    }
+  } = schema;
+  const nodeOrMarkName = new Set();
+  slice.content.forEach(node => {
+    if (node.type === paragraph && node.content.size === 0) {
+      // Skip empty paragraph
+      return;
+    }
+    if (node.type.name === 'text' && link.isInSet(node.marks)) {
+      nodeOrMarkName.add('url');
+      return;
+    }
+
+    // Check node contain link
+    if (node.type === paragraph && node.rangeHasMark(0, node.nodeSize - 2, link)) {
+      nodeOrMarkName.add('url');
+      return;
+    }
+    nodeOrMarkName.add(node.type.name);
+  });
+  if (nodeOrMarkName.size > 1) {
+    return PasteContents.mixed;
+  }
+  if (nodeOrMarkName.size === 0) {
+    return PasteContents.uncategorized;
+  }
+  const type = nodeOrMarkName.values().next().value;
+  const pasteContent = contentToPasteContent[type];
+  return pasteContent ? pasteContent : PasteContents.uncategorized;
+}
+export function getMediaTraceId(slice) {
+  let traceId;
+  mapSlice(slice, node => {
+    if (node.type.name === 'media' || node.type.name === 'mediaInline') {
+      traceId = node.attrs.__mediaTraceId;
+    }
+    return node;
+  });
+  return traceId;
+}
+function getActionSubjectId({
+  selection,
+  schema
+}) {
+  const {
+    nodes: {
+      paragraph,
+      listItem,
+      taskItem,
+      decisionItem
+    }
+  } = schema;
+  const parent = findParentNode(node => {
+    if (node.type !== paragraph && node.type !== listItem && node.type !== taskItem && node.type !== decisionItem) {
+      return true;
+    }
+    return false;
+  })(selection);
+  if (!parent) {
+    return ACTION_SUBJECT_ID.PASTE_PARAGRAPH;
+  }
+  const parentType = parent.node.type;
+  const actionSubjectId = nodeToActionSubjectId[parentType.name];
+  return actionSubjectId ? actionSubjectId : ACTION_SUBJECT_ID.PASTE_PARAGRAPH;
+}
+function createPasteAsPlainPayload(actionSubjectId, text, linksInPasteCount) {
+  return {
+    action: ACTION.PASTED_AS_PLAIN,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.KEYBOARD,
+      pasteSize: text.length,
+      linksInPasteCount
+    }
+  };
+}
+function createPastePayload(actionSubjectId, attributes, linkDomain) {
+  return {
+    action: ACTION.PASTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.KEYBOARD,
+      ...attributes
+    },
+    ...(linkDomain && linkDomain.length > 0 ? {
+      nonPrivacySafeAttributes: {
+        linkDomain
+      }
+    } : {})
+  };
+}
+function createPasteAnalyticsPayloadBySelection(event, slice, pasteContext) {
+  return selection => {
+    const text = event.clipboardData ? event.clipboardData.getData('text/plain') || event.clipboardData.getData('text/uri-list') : '';
+    const actionSubjectId = getActionSubjectId({
+      selection: selection,
+      schema: selection.$from.doc.type.schema
+    });
+    const pasteSize = slice.size;
+    const content = getContent({
+      schema: selection.$from.doc.type.schema,
+      slice
+    });
+    const linkUrls = [];
+    const mediaTraceId = getMediaTraceId(slice);
+
+    // If we have a link among the pasted content, grab the
+    // domain and send it up with the analytics event
+    if (content === PasteContents.url || content === PasteContents.mixed) {
+      mapSlice(slice, node => {
+        const linkMark = node.marks.find(mark => mark.type.name === 'link');
+        if (linkMark) {
+          linkUrls.push(linkMark.attrs.href);
+        }
+        return node;
+      });
+    }
+    if (pasteContext.asPlain) {
+      return createPasteAsPlainPayload(actionSubjectId, text, linkUrls.length);
+    }
+    const source = getPasteSource(event);
+    if (pasteContext.type === PasteTypes.plain) {
+      return createPastePayload(actionSubjectId, {
+        pasteSize: text.length,
+        type: pasteContext.type,
+        content: PasteContents.text,
+        source,
+        hyperlinkPasteOnText: false,
+        linksInPasteCount: linkUrls.length,
+        pasteSplitList: pasteContext.pasteSplitList
+      });
+    }
+    const linkDomains = linkUrls.map(getLinkDomain);
+    return createPastePayload(actionSubjectId, {
+      type: pasteContext.type,
+      pasteSize,
+      content,
+      source,
+      hyperlinkPasteOnText: !!pasteContext.hyperlinkPasteOnText,
+      linksInPasteCount: linkUrls.length,
+      mediaTraceId,
+      pasteSplitList: pasteContext.pasteSplitList
+    }, linkDomains);
+  };
+}
+export function createPasteAnalyticsPayload(view, event, slice, pasteContext) {
+  return createPasteAnalyticsPayloadBySelection(event, slice, pasteContext)(view.state.selection);
+}
+
+// TODO: ED-6612 We should not dispatch only analytics, it's preferred to wrap each command with his own analytics.
+// However, handlers like handleMacroAutoConvert dispatch multiple time,
+// so pasteCommandWithAnalytics is useless in this case.
+export const sendPasteAnalyticsEvent = editorAnalyticsAPI => (view, event, slice, pasteContext) => {
+  const tr = view.state.tr;
+  const payload = createPasteAnalyticsPayload(view, event, slice, pasteContext);
+  editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(payload)(tr);
+  view.dispatch(tr);
+};
+export const handlePasteAsPlainTextWithAnalytics = editorAnalyticsAPI => (view, event, slice) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type: PasteTypes.plain,
+  asPlain: true
+}))(handlePasteAsPlainText(slice, event, editorAnalyticsAPI));
+export const handlePasteIntoTaskAndDecisionWithAnalytics = (view, event, slice, type, pluginInjectionApi) => {
+  var _pluginInjectionApi$a, _pluginInjectionApi$c, _pluginInjectionApi$c2;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : _pluginInjectionApi$a.actions)(createPasteAnalyticsPayloadBySelection(event, slice, {
+    type
+  }))(handlePasteIntoTaskOrDecisionOrPanel(slice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 ? void 0 : (_pluginInjectionApi$c2 = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr));
+};
+export const handlePasteIntoCaptionWithAnalytics = editorAnalyticsAPI => (view, event, slice, type) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type
+}))(handlePasteIntoCaption(slice));
+export const handleCodeBlockWithAnalytics = editorAnalyticsAPI => (view, event, slice, text) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type: PasteTypes.plain
+}))(handleCodeBlock(text));
+export const handleMediaSingleWithAnalytics = editorAnalyticsAPI => (view, event, slice, type, insertMediaAsMediaSingle) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type
+}))(handleMediaSingle(INPUT_METHOD.CLIPBOARD, insertMediaAsMediaSingle)(slice));
+export const handlePastePreservingMarksWithAnalytics = (view, event, slice, type, pluginInjectionApi) => {
+  var _pluginInjectionApi$a2, _pluginInjectionApi$c3, _pluginInjectionApi$c4;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a2 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.actions)(createPasteAnalyticsPayloadBySelection(event, slice, {
+    type
+  }))(handlePastePreservingMarks(slice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c3 = pluginInjectionApi.card) === null || _pluginInjectionApi$c3 === void 0 ? void 0 : (_pluginInjectionApi$c4 = _pluginInjectionApi$c3.actions) === null || _pluginInjectionApi$c4 === void 0 ? void 0 : _pluginInjectionApi$c4.queueCardsFromChangedTr));
+};
+export const handleMarkdownWithAnalytics = (view, event, slice, pluginInjectionApi) => {
+  var _pluginInjectionApi$a3, _pluginInjectionApi$c5, _pluginInjectionApi$c6;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a3 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a3 === void 0 ? void 0 : _pluginInjectionApi$a3.actions)(createPasteAnalyticsPayloadBySelection(event, slice, {
+    type: PasteTypes.markdown
+  }))(handleMarkdown(slice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c5 = pluginInjectionApi.card) === null || _pluginInjectionApi$c5 === void 0 ? void 0 : (_pluginInjectionApi$c6 = _pluginInjectionApi$c5.actions) === null || _pluginInjectionApi$c6 === void 0 ? void 0 : _pluginInjectionApi$c6.queueCardsFromChangedTr));
+};
+export const handleRichTextWithAnalytics = (view, event, slice, pluginInjectionApi) => {
+  var _pluginInjectionApi$a4, _pluginInjectionApi$c7, _pluginInjectionApi$c8;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a4 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a4 === void 0 ? void 0 : _pluginInjectionApi$a4.actions)(createPasteAnalyticsPayloadBySelection(event, slice, {
+    type: PasteTypes.richText
+  }))(handleRichText(slice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c7 = pluginInjectionApi.card) === null || _pluginInjectionApi$c7 === void 0 ? void 0 : (_pluginInjectionApi$c8 = _pluginInjectionApi$c7.actions) === null || _pluginInjectionApi$c8 === void 0 ? void 0 : _pluginInjectionApi$c8.queueCardsFromChangedTr));
+};
+const injectAnalyticsPayloadBeforeCommand = editorAnalyticsAPI => createPayloadByTransaction => {
+  return mainCommand => {
+    return (state, dispatch, view) => {
+      let originalTransaction = state.tr;
+      const fakeDispatch = tr => {
+        originalTransaction = tr;
+      };
+      const result = mainCommand(state, fakeDispatch, view);
+      if (!result) {
+        return false;
+      }
+      if (dispatch && originalTransaction.docChanged) {
+        // it needs to know the selection before the changes
+        const payload = createPayloadByTransaction(state.selection);
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(payload)(originalTransaction);
+        dispatch(originalTransaction);
+      }
+      return true;
+    };
+  };
+};
+export const handlePastePanelOrDecisionIntoListWithAnalytics = editorAnalyticsAPI => (view, event, slice, findRootParentListNode) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type: PasteTypes.richText
+}))(handlePastePanelOrDecisionContentIntoList(slice, findRootParentListNode));
+export const handlePasteNonNestableBlockNodesIntoListWithAnalytics = editorAnalyticsAPI => (view, event, slice) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type: PasteTypes.richText,
+  pasteSplitList: true
+}))(handlePasteNonNestableBlockNodesIntoList(slice));
+export const handleExpandWithAnalytics = editorAnalyticsAPI => (view, event, slice) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type: PasteTypes.richText,
+  pasteSplitList: true
+}))(handleExpandPasteInTable(slice));
+export const handleSelectedTableWithAnalytics = editorAnalyticsAPI => (view, event, slice) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type: PasteTypes.richText
+}))(handleSelectedTable(editorAnalyticsAPI)(slice));
+export const handlePasteLinkOnSelectedTextWithAnalytics = editorAnalyticsAPI => (view, event, slice, type) => injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+  type,
+  hyperlinkPasteOnText: true
+}))(handlePasteLinkOnSelectedText(slice));
+export const createPasteMeasurePayload = ({
+  view,
+  duration,
+  content,
+  distortedDuration
+}) => {
+  const pasteIntoNode = getActionSubjectId({
+    selection: view.state.selection,
+    schema: view.state.schema
+  });
+  return {
+    action: ACTION.PASTED_TIMED,
+    actionSubject: ACTION_SUBJECT.EDITOR,
+    eventType: EVENT_TYPE.OPERATIONAL,
+    attributes: {
+      pasteIntoNode,
+      content,
+      time: duration,
+      distortedDuration
+    }
+  };
+};
+export const getContentNodeTypes = content => {
+  let nodeTypes = new Set();
+  if (content.size) {
+    content.forEach(node => {
+      if (node.content && node.content.size) {
+        nodeTypes = new Set([...nodeTypes, ...getContentNodeTypes(node.content)]);
+      }
+      nodeTypes.add(node.type.name);
+    });
+  }
+  return Array.from(nodeTypes);
+};

package/dist/es2019/pm-plugins/clipboard-text-serializer.js

@@ -0,0 +1,37 @@
+/**
+ * Returns a plain text serialization of a given slice. This is used for populating the plain text
+ * section of the clipboard on copy.
+ * The current implementation is bare bones - only inlineCards, blockCards and mentions are tested (they
+ * previously were empty on plain text copy).
+ * Unknown nodes are passed to node.textBetween().
+ *
+ * By default (without this function passed to the editor), the editor uses
+ * `slice.content.textBetween(0, slice.content.size, "\n\n")`
+ * (see https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextSerializer)
+ */
+export function clipboardTextSerializer(slice) {
+  let text = '';
+  const blockSeparater = '\n\n';
+  slice.content.nodesBetween(0, slice.content.size, node => {
+    if (node.type.isBlock) {
+      text += blockSeparater;
+    }
+    if (node.type.name === 'paragraph') {
+      return true;
+    } else if (node.type.name === 'hardBreak') {
+      text += '\n';
+    } else if (node.type.name === 'text') {
+      text += node.text;
+    } else if (node.type.name === 'inlineCard') {
+      text += node.attrs.url;
+    } else if (node.type.name === 'blockCard') {
+      text += node.attrs.url;
+    } else if (node.type.name === 'mention') {
+      text += node.attrs.text;
+    } else {
+      text += node.textBetween(0, node.content.size, '\n\n');
+    }
+    return false;
+  });
+  return text.trim();
+}