@atlaskit/editor-core 182.0.2 → 182.1.0

package/dist/es2019/plugins/media/index.js

@@ -22,211 +22,215 @@ import { messages } from '../insert-block/ui/ToolbarInsertBlock/messages';
 import { ReactMediaNode } from './nodeviews/mediaNodeView';
 import { ReactMediaInlineNode } from './nodeviews/mediaInline';
 export { insertMediaSingleNode } from './utils/media-single';
-const mediaPlugin = options => ({
-  name: 'media',
-  nodes() {
-    const {
-      allowMediaGroup = true,
-      allowMediaSingle = false,
-      featureFlags
-    } = options || {};
-    const captions = getMediaFeatureFlag('captions', featureFlags);
-    const allowMediaInline = getMediaFeatureFlag('mediaInline', featureFlags);
-    const mediaSingleNode = captions ? mediaSingleWithCaption : mediaSingle;
-    return [{
-      name: 'mediaGroup',
-      node: mediaGroup
-    }, {
-      name: 'mediaSingle',
-      node: mediaSingleNode
-    }, {
-      name: 'media',
-      node: media
-    }, {
-      name: 'mediaInline',
-      node: mediaInline
-    }].filter(node => {
-      if (node.name === 'mediaGroup') {
-        return allowMediaGroup;
-      }
-      if (node.name === 'mediaSingle') {
-        return allowMediaSingle;
-      }
-      if (node.name === 'mediaInline') {
-        return allowMediaInline;
-      }
-      return true;
-    });
-  },
-  pmPlugins() {
-    const pmPlugins = [{
-      name: 'media',
-      plugin: ({
-        schema,
-        dispatch,
-        getIntl,
-        eventDispatcher,
-        providerFactory,
-        errorReporter,
-        portalProviderAPI,
-        reactContext,
-        dispatchAnalyticsEvent
-      }) => {
-        return createPlugin(schema, {
+const mediaPlugin = (options = {}, api) => {
+  var _api$dependencies, _api$dependencies$fea;
+  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$dependencies = api.dependencies) === null || _api$dependencies === void 0 ? void 0 : (_api$dependencies$fea = _api$dependencies.featureFlags) === null || _api$dependencies$fea === void 0 ? void 0 : _api$dependencies$fea.sharedState.currentState()) || {};
+  return {
+    name: 'media',
+    nodes() {
+      const {
+        allowMediaGroup = true,
+        allowMediaSingle = false,
+        featureFlags: mediaFeatureFlags
+      } = options || {};
+      const captions = getMediaFeatureFlag('captions', mediaFeatureFlags);
+      const allowMediaInline = getMediaFeatureFlag('mediaInline', mediaFeatureFlags);
+      const mediaSingleNode = captions ? mediaSingleWithCaption : mediaSingle;
+      return [{
+        name: 'mediaGroup',
+        node: mediaGroup
+      }, {
+        name: 'mediaSingle',
+        node: mediaSingleNode
+      }, {
+        name: 'media',
+        node: media
+      }, {
+        name: 'mediaInline',
+        node: mediaInline
+      }].filter(node => {
+        if (node.name === 'mediaGroup') {
+          return allowMediaGroup;
+        }
+        if (node.name === 'mediaSingle') {
+          return allowMediaSingle;
+        }
+        if (node.name === 'mediaInline') {
+          return allowMediaInline;
+        }
+        return true;
+      });
+    },
+    pmPlugins() {
+      const pmPlugins = [{
+        name: 'media',
+        plugin: ({
+          schema,
+          dispatch,
+          getIntl,
+          eventDispatcher,
           providerFactory,
-          nodeViews: {
-            mediaGroup: ReactMediaGroupNode(portalProviderAPI, eventDispatcher, providerFactory, options),
-            mediaSingle: ReactMediaSingleNode(portalProviderAPI, eventDispatcher, providerFactory, dispatchAnalyticsEvent, options),
-            media: ReactMediaNode(portalProviderAPI, eventDispatcher, providerFactory, options),
-            mediaInline: ReactMediaInlineNode(portalProviderAPI, eventDispatcher, providerFactory)
-          },
           errorReporter,
-          uploadErrorHandler: options && options.uploadErrorHandler,
-          waitForMediaUpload: options && options.waitForMediaUpload,
-          customDropzoneContainer: options && options.customDropzoneContainer,
-          customMediaPicker: options && options.customMediaPicker,
-          allowResizing: !!(options && options.allowResizing)
-        }, reactContext, getIntl, dispatch, options);
+          portalProviderAPI,
+          reactContext,
+          dispatchAnalyticsEvent
+        }) => {
+          return createPlugin(schema, {
+            providerFactory,
+            nodeViews: {
+              mediaGroup: ReactMediaGroupNode(portalProviderAPI, eventDispatcher, providerFactory, options),
+              mediaSingle: ReactMediaSingleNode(portalProviderAPI, eventDispatcher, providerFactory, dispatchAnalyticsEvent, options),
+              media: ReactMediaNode(portalProviderAPI, eventDispatcher, providerFactory, options),
+              mediaInline: ReactMediaInlineNode(portalProviderAPI, eventDispatcher, providerFactory)
+            },
+            errorReporter,
+            uploadErrorHandler: options && options.uploadErrorHandler,
+            waitForMediaUpload: options && options.waitForMediaUpload,
+            customDropzoneContainer: options && options.customDropzoneContainer,
+            customMediaPicker: options && options.customMediaPicker,
+            allowResizing: !!(options && options.allowResizing)
+          }, reactContext, getIntl, dispatch, options, featureFlags.newInsertionBehaviour);
+        }
+      }, {
+        name: 'mediaKeymap',
+        plugin: () => keymapPlugin(options)
+      }];
+      if (options && options.allowMediaSingle) {
+        pmPlugins.push({
+          name: 'mediaSingleKeymap',
+          plugin: ({
+            schema
+          }) => keymapMediaSinglePlugin(schema)
+        });
+      }
+      if (options && options.allowAltTextOnImages) {
+        pmPlugins.push({
+          name: 'mediaAltText',
+          plugin: createMediaAltTextPlugin
+        });
+        pmPlugins.push({
+          name: 'mediaAltTextKeymap',
+          plugin: ({
+            schema
+          }) => keymapMediaAltTextPlugin(schema)
+        });
+      }
+      if (options && options.allowLinking) {
+        pmPlugins.push({
+          name: 'mediaLinking',
+          plugin: ({
+            dispatch
+          }) => linkingPlugin(dispatch)
+        });
+        pmPlugins.push({
+          name: 'mediaLinkingKeymap',
+          plugin: ({
+            schema
+          }) => keymapLinkingPlugin(schema)
+        });
       }
-    }, {
-      name: 'mediaKeymap',
-      plugin: () => keymapPlugin(options)
-    }];
-    if (options && options.allowMediaSingle) {
-      pmPlugins.push({
-        name: 'mediaSingleKeymap',
-        plugin: ({
-          schema
-        }) => keymapMediaSinglePlugin(schema)
-      });
-    }
-    if (options && options.allowAltTextOnImages) {
-      pmPlugins.push({
-        name: 'mediaAltText',
-        plugin: createMediaAltTextPlugin
-      });
-      pmPlugins.push({
-        name: 'mediaAltTextKeymap',
-        plugin: ({
-          schema
-        }) => keymapMediaAltTextPlugin(schema)
-      });
-    }
-    if (options && options.allowLinking) {
-      pmPlugins.push({
-        name: 'mediaLinking',
-        plugin: ({
-          dispatch
-        }) => linkingPlugin(dispatch)
-      });
       pmPlugins.push({
-        name: 'mediaLinkingKeymap',
-        plugin: ({
-          schema
-        }) => keymapLinkingPlugin(schema)
-      });
-    }
-    pmPlugins.push({
-      name: 'mediaSelectionHandler',
-      plugin: () => {
-        const mediaSelectionHandlerPlugin = new SafePlugin({
-          key: new PluginKey('mediaSelectionHandlerPlugin'),
-          props: {
-            handleScrollToSelection: view => {
-              const {
-                state: {
-                  selection
+        name: 'mediaSelectionHandler',
+        plugin: () => {
+          const mediaSelectionHandlerPlugin = new SafePlugin({
+            key: new PluginKey('mediaSelectionHandlerPlugin'),
+            props: {
+              handleScrollToSelection: view => {
+                const {
+                  state: {
+                    selection
+                  }
+                } = view;
+                if (!(selection instanceof NodeSelection) || selection.node.type.name !== 'media') {
+                  return false;
                 }
-              } = view;
-              if (!(selection instanceof NodeSelection) || selection.node.type.name !== 'media') {
+                const {
+                  node,
+                  offset
+                } = view.domAtPos(selection.from);
+                if (
+                // Is the media element mounted already?
+                offset === node.childNodes.length) {
+                  // Media is not ready, so stop the scroll request
+                  return true;
+                }
+
+                // Media is ready, keep the scrolling request
                 return false;
               }
-              const {
-                node,
-                offset
-              } = view.domAtPos(selection.from);
-              if (
-              // Is the media element mounted already?
-              offset === node.childNodes.length) {
-                // Media is not ready, so stop the scroll request
-                return true;
-              }
-
-              // Media is ready, keep the scrolling request
-              return false;
             }
-          }
-        });
-        return mediaSelectionHandlerPlugin;
-      }
-    });
-    return pmPlugins;
-  },
-  contentComponent({
-    editorView,
-    appearance
-  }) {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(WithPluginState, {
-      editorView: editorView,
-      plugins: {
-        mediaState: pluginKey
-      },
-      render: ({
-        mediaState
-      }) => /*#__PURE__*/React.createElement(MediaPickerComponents, {
-        editorDomElement: editorView.dom,
-        mediaState: mediaState,
-        appearance: appearance
+          });
+          return mediaSelectionHandlerPlugin;
+        }
+      });
+      return pmPlugins;
+    },
+    contentComponent({
+      editorView,
+      appearance
+    }) {
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(WithPluginState, {
+        editorView: editorView,
+        plugins: {
+          mediaState: pluginKey
+        },
+        render: ({
+          mediaState
+        }) => /*#__PURE__*/React.createElement(MediaPickerComponents, {
+          editorDomElement: editorView.dom,
+          mediaState: mediaState,
+          appearance: appearance
+        })
+      }));
+    },
+    secondaryToolbarComponent({
+      editorView,
+      eventDispatcher,
+      disabled
+    }) {
+      return /*#__PURE__*/React.createElement(ToolbarMedia, {
+        editorView: editorView,
+        eventDispatcher: eventDispatcher,
+        pluginKey: pluginKey,
+        isDisabled: disabled,
+        isReducedSpacing: true
+      });
+    },
+    pluginsOptions: {
+      quickInsert: ({
+        formatMessage
+      }) => [{
+        id: 'media',
+        title: formatMessage(messages.mediaFiles),
+        description: formatMessage(messages.mediaFilesDescription),
+        priority: 400,
+        keywords: ['attachment', 'gif', 'media', 'picture', 'image', 'video'],
+        icon: () => /*#__PURE__*/React.createElement(IconImages, null),
+        action(insert, state) {
+          const pluginState = pluginKey.getState(state);
+          pluginState.showMediaPicker();
+          return addAnalytics(state, insert(''), {
+            action: ACTION.OPENED,
+            actionSubject: ACTION_SUBJECT.PICKER,
+            actionSubjectId: ACTION_SUBJECT_ID.PICKER_CLOUD,
+            attributes: {
+              inputMethod: INPUT_METHOD.QUICK_INSERT
+            },
+            eventType: EVENT_TYPE.UI
+          });
+        }
+      }],
+      floatingToolbar: (state, intl, providerFactory) => floatingToolbar(state, intl, {
+        providerFactory,
+        allowMediaInline: options && getMediaFeatureFlag('mediaInline', options.featureFlags),
+        allowResizing: options && options.allowResizing,
+        allowResizingInTables: options && options.allowResizingInTables,
+        allowLinking: options && options.allowLinking,
+        allowAdvancedToolBarOptions: options && options.allowAdvancedToolBarOptions,
+        allowAltTextOnImages: options && options.allowAltTextOnImages,
+        altTextValidator: options && options.altTextValidator
       })
-    }));
-  },
-  secondaryToolbarComponent({
-    editorView,
-    eventDispatcher,
-    disabled
-  }) {
-    return /*#__PURE__*/React.createElement(ToolbarMedia, {
-      editorView: editorView,
-      eventDispatcher: eventDispatcher,
-      pluginKey: pluginKey,
-      isDisabled: disabled,
-      isReducedSpacing: true
-    });
-  },
-  pluginsOptions: {
-    quickInsert: ({
-      formatMessage
-    }) => [{
-      id: 'media',
-      title: formatMessage(messages.mediaFiles),
-      description: formatMessage(messages.mediaFilesDescription),
-      priority: 400,
-      keywords: ['attachment', 'gif', 'media', 'picture', 'image', 'video'],
-      icon: () => /*#__PURE__*/React.createElement(IconImages, null),
-      action(insert, state) {
-        const pluginState = pluginKey.getState(state);
-        pluginState.showMediaPicker();
-        return addAnalytics(state, insert(''), {
-          action: ACTION.OPENED,
-          actionSubject: ACTION_SUBJECT.PICKER,
-          actionSubjectId: ACTION_SUBJECT_ID.PICKER_CLOUD,
-          attributes: {
-            inputMethod: INPUT_METHOD.QUICK_INSERT
-          },
-          eventType: EVENT_TYPE.UI
-        });
-      }
-    }],
-    floatingToolbar: (state, intl, providerFactory) => floatingToolbar(state, intl, {
-      providerFactory,
-      allowMediaInline: options && getMediaFeatureFlag('mediaInline', options.featureFlags),
-      allowResizing: options && options.allowResizing,
-      allowResizingInTables: options && options.allowResizingInTables,
-      allowLinking: options && options.allowLinking,
-      allowAdvancedToolBarOptions: options && options.allowAdvancedToolBarOptions,
-      allowAltTextOnImages: options && options.allowAltTextOnImages,
-      altTextValidator: options && options.altTextValidator
-    })
-  }
-});
+    }
+  };
+};
 export default mediaPlugin;

package/dist/es2019/plugins/media/nodeviews/mediaNodeView/media.js

@@ -1,5 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { withImageLoader } from '@atlaskit/editor-common/utils';
+import { AnalyticsContext } from '@atlaskit/analytics-next';
+import { MEDIA_CONTEXT } from '@atlaskit/analytics-namespaced-context';
 import { Card, CardLoading } from '@atlaskit/media-card';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import React, { Component } from 'react';
@@ -142,6 +144,12 @@ export class MediaNode extends Component {
       onContextMenu: this.selectMediaSingle,
       borderWidth: borderMark === null || borderMark === void 0 ? void 0 : borderMark.attrs.size,
       selected: selected
+    }, /*#__PURE__*/React.createElement(AnalyticsContext, {
+      data: {
+        [MEDIA_CONTEXT]: {
+          border: !!borderMark
+        }
+      }
     }, /*#__PURE__*/React.createElement(Card, {
       mediaClientConfig: mediaClientConfig,
       resizeMode: "stretchy-fit",
@@ -158,7 +166,7 @@ export class MediaNode extends Component {
       featureFlags: mediaOptions && mediaOptions.featureFlags,
       contextId: contextId,
       alt: alt
-    }));
+    })));
   }
 }
 export default withImageLoader(MediaNode);

package/dist/es2019/plugins/media/pm-plugins/main.js

@@ -45,7 +45,7 @@ const MEDIA_RESOLVED_STATES = ['ready', 'error', 'cancelled'];
 export class MediaPluginStateImplementation {
   // @ts-ignore: private is OK
 
-  constructor(_state, options, mediaOptions, _dispatch) {
+  constructor(_state, options, mediaOptions, newInsertionBehaviour, _dispatch) {
     _defineProperty(this, "allowsUploads", false);
     _defineProperty(this, "ignoreLinks", false);
     _defineProperty(this, "waitForMediaUpload", true);
@@ -164,7 +164,7 @@ export class MediaPluginStateImplementation {
         });
       }
       if (isMediaSingle(state.schema, mediaStateWithContext.fileMimeType)) {
-        insertMediaSingleNode(this.view, mediaStateWithContext, this.getInputMethod(pickerType), collection, this.mediaOptions && this.mediaOptions.alignLeftOnInsert);
+        insertMediaSingleNode(this.view, mediaStateWithContext, this.getInputMethod(pickerType), collection, this.mediaOptions && this.mediaOptions.alignLeftOnInsert, this.newInsertionBehaviour);
       } else if (getMediaFeatureFlag('mediaInline', (_this$mediaOptions2 = this.mediaOptions) === null || _this$mediaOptions2 === void 0 ? void 0 : _this$mediaOptions2.featureFlags) && !isInEmptyLine(state) && (!isInsidePotentialEmptyParagraph(state) || isInListItem(state)) && canInsertMediaInline(state)) {
         insertMediaInlineNode(this.view, mediaStateWithContext, collection, this.getInputMethod(pickerType));
       } else {
@@ -359,6 +359,7 @@ export class MediaPluginStateImplementation {
     });
     this.options = options;
     this.mediaOptions = mediaOptions;
+    this.newInsertionBehaviour = newInsertionBehaviour;
     this.dispatch = _dispatch;
     this.waitForMediaUpload = options.waitForMediaUpload === undefined ? true : options.waitForMediaUpload;
     const {
@@ -490,13 +491,13 @@ export class MediaPluginStateImplementation {
   }
 }
 export const getMediaPluginState = state => stateKey.getState(state);
-export const createPlugin = (_schema, options, reactContext, getIntl, dispatch, mediaOptions) => {
+export const createPlugin = (_schema, options, reactContext, getIntl, dispatch, mediaOptions, newInsertionBehaviour) => {
   const intl = getIntl();
   const dropPlaceholder = createDropPlaceholder(intl, mediaOptions && mediaOptions.allowDropzoneDropLine);
   return new SafePlugin({
     state: {
       init(_config, state) {
-        return new MediaPluginStateImplementation(state, options, mediaOptions, dispatch);
+        return new MediaPluginStateImplementation(state, options, mediaOptions, newInsertionBehaviour, dispatch);
       },
       apply(tr, pluginState) {
         // remap editing media single position if we're in collab

package/dist/es2019/plugins/media/utils/media-single.js

@@ -7,7 +7,6 @@ import { copyOptionalAttrsFromMediaState } from '../utils/media-common';
 import { mapSlice } from '../../../utils/slice';
 import { addAnalytics, ACTION, ACTION_SUBJECT, EVENT_TYPE, ACTION_SUBJECT_ID } from '../../analytics';
 import { safeInsert, shouldSplitSelectedNodeOnNodeInsertion } from '../../../utils/insert';
-import { getFeatureFlags } from '../../feature-flags-context';
 import { isImage } from './is-image';
 import { atTheBeginningOfBlock } from '../../../utils/prosemirror/position';
 import { getRandomHex } from '@atlaskit/media-common';
@@ -79,7 +78,7 @@ export const insertMediaAsMediaSingle = (view, node, inputMethod) => {
   };
   return insertNodesWithOptionalParagraph(nodes, analyticsAttributes)(state, dispatch);
 };
-export const insertMediaSingleNode = (view, mediaState, inputMethod, collection, alignLeftOnInsert) => {
+export const insertMediaSingleNode = (view, mediaState, inputMethod, collection, alignLeftOnInsert, newInsertionBehaviour) => {
   var _state$selection$$fro;
   if (collection === undefined) {
     return false;
@@ -108,9 +107,6 @@ export const insertMediaSingleNode = (view, mediaState, inputMethod, collection,
       inputMethod
     })(state, dispatch);
   } else {
-    const {
-      newInsertionBehaviour
-    } = getFeatureFlags(view.state);
     let tr = null;
     if (newInsertionBehaviour) {
       tr = safeInsert(node, state.selection.from)(state.tr);

package/dist/es2019/plugins/panel/pm-plugins/keymaps.js

@@ -1,5 +1,5 @@
 import { keymap } from 'prosemirror-keymap';
-import { setTextSelection, findParentNodeOfType } from 'prosemirror-utils';
+import { setTextSelection, findParentNodeOfType, hasParentNodeOfType } from 'prosemirror-utils';
 import { isEmptyNode } from '../../../utils';
 function findParentNode(selection, nodeType) {
   const parentPosition = findParentNodeOfType(nodeType)(selection);
@@ -51,7 +51,8 @@ export function keymapPlugin() {
       const isParentNodeAPanel = parentNodeType === panel;
 
       // Stops merging panels when deleting empty paragraph in between
-      if (isPreviousNodeAPanel && !isParentNodeAPanel || isInsideAnEmptyNode(selection, panel, state.schema) || isInsideAnEmptyNode(selection, blockquote, state.schema)) {
+      // Stops merging blockquotes with panels when deleting from start of blockquote
+      if (isPreviousNodeAPanel && !isParentNodeAPanel || isInsideAnEmptyNode(selection, panel, state.schema) || hasParentNodeOfType(blockquote)(selection)) {
         const content = $from.node($from.depth).content;
         const insertPos = previousPos.pos;
         deleteCurrentItem($from, tr).insert(insertPos, content);

package/dist/es2019/plugins/paste/handlers.js

@@ -6,7 +6,7 @@ import uuid from 'uuid/v4';
 import { replaceSelectedTable } from '@atlaskit/editor-tables/utils';
 import { compose, insideTable, isParagraph, isText, isLinkMark, insideTableCell, isInListItem } from '../../utils';
 import { mapSlice } from '../../utils/slice';
-import { INPUT_METHOD } from '../analytics';
+import { ACTION, INPUT_METHOD } from '../analytics';
 import { queueCardsFromChangedTr } from '../card/pm-plugins/doc';
 import { GapCursorSelection, Side } from '../selection/gap-cursor-selection';
 import { linkifyContent } from '../hyperlink/utils';
@@ -105,7 +105,7 @@ export function handlePasteIntoTaskOrDecisionOrPanel(slice) {
       // This maintains both the selection (destination) and the slice (paste content).
       safeInsert(transformedSlice.content)(tr).scrollIntoView();
     }
-    queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD);
+    queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD, ACTION.PASTED);
     if (dispatch) {
       dispatch(tr);
     }
@@ -385,7 +385,7 @@ export function handlePastePreservingMarks(slice) {
     // special case for plainTextSlice & linkMark: merge into existing link
     if (isPlainTextSlice && linkMark.isInSet(selectionMarks) && selectionMarks.length === 1) {
       const tr = closeHistory(state.tr).replaceSelectionWith(slice.content.firstChild.firstChild, true).setStoredMarks(selectionMarks).scrollIntoView();
-      queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD);
+      queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD, ACTION.PASTED);
       if (dispatch) {
         dispatch(tr);
       }
@@ -397,7 +397,7 @@ export function handlePastePreservingMarks(slice) {
     if (hasOnlyNodesOfType(bulletList, hardBreak, heading, listItem, paragraph, text, emoji, mention, orderedList)(slice)) {
       const transformedSlice = applyTextMarksToSlice(schema, selectionMarks)(slice);
       const tr = closeHistory(state.tr).replaceSelection(transformedSlice).setStoredMarks(selectionMarks).scrollIntoView();
-      queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD);
+      queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD, ACTION.PASTED);
       if (dispatch) {
         dispatch(tr);
       }
@@ -602,7 +602,7 @@ export function handleMarkdown(markdownSlice, from, to) {
       tr.replaceSelection(markdownSlice);
     }
     tr.setSelection(TextSelection.near(tr.doc.resolve(pastesFrom + markdownSlice.size), -1));
-    queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD);
+    queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD, ACTION.PASTED);
     if (dispatch) {
       dispatch(tr.scrollIntoView());
     }
@@ -819,7 +819,7 @@ export function handleRichText(slice) {
 
     // queue link cards, ignoring any errors
     if (dispatch) {
-      dispatch(queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD));
+      dispatch(queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD, ACTION.PASTED));
     }
     return true;
   };

package/dist/es2019/plugins/paste/index.js

@@ -2,18 +2,22 @@ import { createPlugin } from './pm-plugins/main';
 const pastePlugin = ({
   cardOptions,
   sanitizePrivateContent
-}) => ({
-  name: 'paste',
-  pmPlugins() {
-    return [{
-      name: 'paste',
-      plugin: ({
-        schema,
-        providerFactory,
-        dispatchAnalyticsEvent,
-        dispatch
-      }) => createPlugin(schema, dispatchAnalyticsEvent, dispatch, cardOptions, sanitizePrivateContent, providerFactory)
-    }];
-  }
-});
+}, api) => {
+  var _api$dependencies, _api$dependencies$fea;
+  const featureFlags = (api === null || api === void 0 ? void 0 : (_api$dependencies = api.dependencies) === null || _api$dependencies === void 0 ? void 0 : (_api$dependencies$fea = _api$dependencies.featureFlags) === null || _api$dependencies$fea === void 0 ? void 0 : _api$dependencies$fea.sharedState.currentState()) || {};
+  return {
+    name: 'paste',
+    pmPlugins() {
+      return [{
+        name: 'paste',
+        plugin: ({
+          schema,
+          providerFactory,
+          dispatchAnalyticsEvent,
+          dispatch
+        }) => createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFlags, cardOptions, sanitizePrivateContent, providerFactory)
+      }];
+    }
+  };
+};
 export default pastePlugin;