@atlaskit/editor-plugin-paste 0.1.22 → 0.2.0

package/dist/esm/index.js

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

package/dist/esm/plugin.js

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

package/dist/esm/plugins/media.js

@@ -0,0 +1,199 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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) {
+  var _schema$nodes = schema.nodes,
+    mediaSingle = _schema$nodes.mediaSingle,
+    layoutSection = _schema$nodes.layoutSection,
+    table = _schema$nodes.table,
+    bulletList = _schema$nodes.bulletList,
+    orderedList = _schema$nodes.orderedList,
+    expand = _schema$nodes.expand,
+    nestedExpand = _schema$nodes.nestedExpand;
+  return function (selection) {
+    var newSlice = slice;
+    if (hasParentNodeOfType([layoutSection, table, bulletList, orderedList, expand, nestedExpand])(selection)) {
+      newSlice = mapSlice(newSlice, function (node) {
+        var extendedOrLegacyAttrs = getBooleanFF('platform.editor.media.extended-resize-experience') ? {
+          layout: node.attrs.layout,
+          widthType: node.attrs.widthType,
+          width: node.attrs.width
+        } : {
+          layout: node.attrs.layout
+        };
+        var attrs = {};
+        if (hasParentNodeOfType([layoutSection, table])(selection)) {
+          // Supports layouts
+          attrs = _objectSpread({}, extendedOrLegacyAttrs);
+        } else if (hasParentNodeOfType([bulletList, orderedList, expand, nestedExpand])(selection)) {
+          // does not support other layouts
+          attrs = _objectSpread(_objectSpread({}, 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 var isImage = function isImage(fileType) {
+  return !!fileType && (fileType.indexOf('image/') > -1 || fileType.indexOf('video/') > -1);
+};
+export var transformSliceToCorrectMediaWrapper = function transformSliceToCorrectMediaWrapper(slice, schema) {
+  var _schema$nodes2 = schema.nodes,
+    mediaGroup = _schema$nodes2.mediaGroup,
+    mediaSingle = _schema$nodes2.mediaSingle,
+    media = _schema$nodes2.media;
+  return mapSlice(slice, function (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 var transformSliceToMediaSingleWithNewExperience = function transformSliceToMediaSingleWithNewExperience(slice, schema) {
+  var _schema$nodes3 = schema.nodes,
+    mediaInline = _schema$nodes3.mediaInline,
+    mediaSingle = _schema$nodes3.mediaSingle,
+    media = _schema$nodes3.media;
+  var newSlice = mapSlice(slice, function (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, function (node) {
+    var __mediaTraceId = getRandomHex(8);
+    if (node.type === media) {
+      return media.createChecked(_objectSpread(_objectSpread({}, 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(_objectSpread(_objectSpread({}, node.attrs), {}, {
+        __mediaTraceId: __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
+ */
+var isElementInvisible = function isElementInvisible(element) {
+  return element.style.opacity === '0' || element.style.display === 'none' || element.style.visibility === 'hidden';
+};
+var 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 var unwrapNestedMediaElements = function unwrapNestedMediaElements(html) {
+  var parser = new DOMParser();
+  var doc = parser.parseFromString(html, 'text/html');
+  var wrapper = doc.body;
+
+  // Remove Google Doc's wrapper <b> el
+  var docsWrapper = wrapper.querySelector('b[id^="docs-internal-guid-"]');
+  if (docsWrapper) {
+    unwrap(wrapper, docsWrapper);
+  }
+  var imageTags = wrapper.querySelectorAll('img');
+  if (!imageTags.length) {
+    return html;
+  }
+  imageTags.forEach(function (imageTag) {
+    // Capture the immediate parent, we may remove the media from here later.
+    var 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
+    var insertBeforeElement = walkUpTreeUntil(mediaParent, function (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/esm/pm-plugins/analytics.js

@@ -0,0 +1,364 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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';
+var 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
+};
+var 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(_ref) {
+  var schema = _ref.schema,
+    slice = _ref.slice;
+  var paragraph = schema.nodes.paragraph,
+    link = schema.marks.link;
+  var nodeOrMarkName = new Set();
+  slice.content.forEach(function (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;
+  }
+  var type = nodeOrMarkName.values().next().value;
+  var pasteContent = contentToPasteContent[type];
+  return pasteContent ? pasteContent : PasteContents.uncategorized;
+}
+export function getMediaTraceId(slice) {
+  var traceId;
+  mapSlice(slice, function (node) {
+    if (node.type.name === 'media' || node.type.name === 'mediaInline') {
+      traceId = node.attrs.__mediaTraceId;
+    }
+    return node;
+  });
+  return traceId;
+}
+function getActionSubjectId(_ref2) {
+  var selection = _ref2.selection,
+    schema = _ref2.schema;
+  var _schema$nodes = schema.nodes,
+    paragraph = _schema$nodes.paragraph,
+    listItem = _schema$nodes.listItem,
+    taskItem = _schema$nodes.taskItem,
+    decisionItem = _schema$nodes.decisionItem;
+  var parent = findParentNode(function (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;
+  }
+  var parentType = parent.node.type;
+  var 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: actionSubjectId,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.KEYBOARD,
+      pasteSize: text.length,
+      linksInPasteCount: linksInPasteCount
+    }
+  };
+}
+function createPastePayload(actionSubjectId, attributes, linkDomain) {
+  return _objectSpread({
+    action: ACTION.PASTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId: actionSubjectId,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: _objectSpread({
+      inputMethod: INPUT_METHOD.KEYBOARD
+    }, attributes)
+  }, linkDomain && linkDomain.length > 0 ? {
+    nonPrivacySafeAttributes: {
+      linkDomain: linkDomain
+    }
+  } : {});
+}
+function createPasteAnalyticsPayloadBySelection(event, slice, pasteContext) {
+  return function (selection) {
+    var text = event.clipboardData ? event.clipboardData.getData('text/plain') || event.clipboardData.getData('text/uri-list') : '';
+    var actionSubjectId = getActionSubjectId({
+      selection: selection,
+      schema: selection.$from.doc.type.schema
+    });
+    var pasteSize = slice.size;
+    var content = getContent({
+      schema: selection.$from.doc.type.schema,
+      slice: slice
+    });
+    var linkUrls = [];
+    var 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, function (node) {
+        var linkMark = node.marks.find(function (mark) {
+          return mark.type.name === 'link';
+        });
+        if (linkMark) {
+          linkUrls.push(linkMark.attrs.href);
+        }
+        return node;
+      });
+    }
+    if (pasteContext.asPlain) {
+      return createPasteAsPlainPayload(actionSubjectId, text, linkUrls.length);
+    }
+    var source = getPasteSource(event);
+    if (pasteContext.type === PasteTypes.plain) {
+      return createPastePayload(actionSubjectId, {
+        pasteSize: text.length,
+        type: pasteContext.type,
+        content: PasteContents.text,
+        source: source,
+        hyperlinkPasteOnText: false,
+        linksInPasteCount: linkUrls.length,
+        pasteSplitList: pasteContext.pasteSplitList
+      });
+    }
+    var linkDomains = linkUrls.map(getLinkDomain);
+    return createPastePayload(actionSubjectId, {
+      type: pasteContext.type,
+      pasteSize: pasteSize,
+      content: content,
+      source: source,
+      hyperlinkPasteOnText: !!pasteContext.hyperlinkPasteOnText,
+      linksInPasteCount: linkUrls.length,
+      mediaTraceId: 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 var sendPasteAnalyticsEvent = function sendPasteAnalyticsEvent(editorAnalyticsAPI) {
+  return function (view, event, slice, pasteContext) {
+    var tr = view.state.tr;
+    var payload = createPasteAnalyticsPayload(view, event, slice, pasteContext);
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(payload)(tr);
+    view.dispatch(tr);
+  };
+};
+export var handlePasteAsPlainTextWithAnalytics = function handlePasteAsPlainTextWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: PasteTypes.plain,
+      asPlain: true
+    }))(handlePasteAsPlainText(slice, event, editorAnalyticsAPI));
+  };
+};
+export var handlePasteIntoTaskAndDecisionWithAnalytics = function handlePasteIntoTaskAndDecisionWithAnalytics(view, event, slice, type, pluginInjectionApi) {
+  var _pluginInjectionApi$a, _pluginInjectionApi$c;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : _pluginInjectionApi$a.actions)(createPasteAnalyticsPayloadBySelection(event, slice, {
+    type: type
+  }))(handlePasteIntoTaskOrDecisionOrPanel(slice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 || (_pluginInjectionApi$c = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c === void 0 ? void 0 : _pluginInjectionApi$c.queueCardsFromChangedTr));
+};
+export var handlePasteIntoCaptionWithAnalytics = function handlePasteIntoCaptionWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice, type) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: type
+    }))(handlePasteIntoCaption(slice));
+  };
+};
+export var handleCodeBlockWithAnalytics = function handleCodeBlockWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice, text) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: PasteTypes.plain
+    }))(handleCodeBlock(text));
+  };
+};
+export var handleMediaSingleWithAnalytics = function handleMediaSingleWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice, type, insertMediaAsMediaSingle) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: type
+    }))(handleMediaSingle(INPUT_METHOD.CLIPBOARD, insertMediaAsMediaSingle)(slice));
+  };
+};
+export var handlePastePreservingMarksWithAnalytics = function handlePastePreservingMarksWithAnalytics(view, event, slice, type, pluginInjectionApi) {
+  var _pluginInjectionApi$a2, _pluginInjectionApi$c2;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a2 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.actions)(createPasteAnalyticsPayloadBySelection(event, slice, {
+    type: type
+  }))(handlePastePreservingMarks(slice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c2 = pluginInjectionApi.card) === null || _pluginInjectionApi$c2 === void 0 || (_pluginInjectionApi$c2 = _pluginInjectionApi$c2.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr));
+};
+export var handleMarkdownWithAnalytics = function handleMarkdownWithAnalytics(view, event, slice, pluginInjectionApi) {
+  var _pluginInjectionApi$a3, _pluginInjectionApi$c3;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === 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 || (_pluginInjectionApi$c3 = pluginInjectionApi.card) === null || _pluginInjectionApi$c3 === void 0 || (_pluginInjectionApi$c3 = _pluginInjectionApi$c3.actions) === null || _pluginInjectionApi$c3 === void 0 ? void 0 : _pluginInjectionApi$c3.queueCardsFromChangedTr));
+};
+export var handleRichTextWithAnalytics = function handleRichTextWithAnalytics(view, event, slice, pluginInjectionApi) {
+  var _pluginInjectionApi$a4, _pluginInjectionApi$c4;
+  return injectAnalyticsPayloadBeforeCommand(pluginInjectionApi === null || pluginInjectionApi === 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 || (_pluginInjectionApi$c4 = pluginInjectionApi.card) === null || _pluginInjectionApi$c4 === void 0 || (_pluginInjectionApi$c4 = _pluginInjectionApi$c4.actions) === null || _pluginInjectionApi$c4 === void 0 ? void 0 : _pluginInjectionApi$c4.queueCardsFromChangedTr));
+};
+var injectAnalyticsPayloadBeforeCommand = function injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI) {
+  return function (createPayloadByTransaction) {
+    return function (mainCommand) {
+      return function (state, dispatch, view) {
+        var originalTransaction = state.tr;
+        var fakeDispatch = function fakeDispatch(tr) {
+          originalTransaction = tr;
+        };
+        var result = mainCommand(state, fakeDispatch, view);
+        if (!result) {
+          return false;
+        }
+        if (dispatch && originalTransaction.docChanged) {
+          // it needs to know the selection before the changes
+          var payload = createPayloadByTransaction(state.selection);
+          editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(payload)(originalTransaction);
+          dispatch(originalTransaction);
+        }
+        return true;
+      };
+    };
+  };
+};
+export var handlePastePanelOrDecisionIntoListWithAnalytics = function handlePastePanelOrDecisionIntoListWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice, findRootParentListNode) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: PasteTypes.richText
+    }))(handlePastePanelOrDecisionContentIntoList(slice, findRootParentListNode));
+  };
+};
+export var handlePasteNonNestableBlockNodesIntoListWithAnalytics = function handlePasteNonNestableBlockNodesIntoListWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: PasteTypes.richText,
+      pasteSplitList: true
+    }))(handlePasteNonNestableBlockNodesIntoList(slice));
+  };
+};
+export var handleExpandWithAnalytics = function handleExpandWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: PasteTypes.richText,
+      pasteSplitList: true
+    }))(handleExpandPasteInTable(slice));
+  };
+};
+export var handleSelectedTableWithAnalytics = function handleSelectedTableWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: PasteTypes.richText
+    }))(handleSelectedTable(editorAnalyticsAPI)(slice));
+  };
+};
+export var handlePasteLinkOnSelectedTextWithAnalytics = function handlePasteLinkOnSelectedTextWithAnalytics(editorAnalyticsAPI) {
+  return function (view, event, slice, type) {
+    return injectAnalyticsPayloadBeforeCommand(editorAnalyticsAPI)(createPasteAnalyticsPayloadBySelection(event, slice, {
+      type: type,
+      hyperlinkPasteOnText: true
+    }))(handlePasteLinkOnSelectedText(slice));
+  };
+};
+export var createPasteMeasurePayload = function createPasteMeasurePayload(_ref3) {
+  var view = _ref3.view,
+    duration = _ref3.duration,
+    content = _ref3.content,
+    distortedDuration = _ref3.distortedDuration;
+  var 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: pasteIntoNode,
+      content: content,
+      time: duration,
+      distortedDuration: distortedDuration
+    }
+  };
+};
+export var getContentNodeTypes = function getContentNodeTypes(content) {
+  var nodeTypes = new Set();
+  if (content.size) {
+    content.forEach(function (node) {
+      if (node.content && node.content.size) {
+        nodeTypes = new Set([].concat(_toConsumableArray(nodeTypes), _toConsumableArray(getContentNodeTypes(node.content))));
+      }
+      nodeTypes.add(node.type.name);
+    });
+  }
+  return Array.from(nodeTypes);
+};

package/dist/esm/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) {
+  var text = '';
+  var blockSeparater = '\n\n';
+  slice.content.nodesBetween(0, slice.content.size, function (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();
+}