@atlaskit/editor-plugin-paste-options-toolbar 0.2.0

package/dist/cjs/util/format-handlers.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatRichText = exports.formatPlainText = exports.formatMarkdown = void 0;
+exports.getMarkdownSlice = getMarkdownSlice;
+exports.getRichTextSlice = void 0;
+var _monitoring = require("@atlaskit/editor-common/monitoring");
+var _paste = require("@atlaskit/editor-common/paste");
+var _editorMarkdownTransformer = require("@atlaskit/editor-markdown-transformer");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _index = require("./index");
+var formatMarkdown = exports.formatMarkdown = function formatMarkdown(state, pasteStartPos, plaintext) {
+  var schema = state.schema;
+  var tr = state.tr;
+  var selection = tr.selection;
+  if (pasteStartPos < 0) {
+    return tr;
+  }
+  var resolvedPasteStartPos = tr.doc.resolve(pasteStartPos);
+  var parentOffset = resolvedPasteStartPos.parentOffset;
+  if (parentOffset === 0 && resolvedPasteStartPos.depth > 0) {
+    pasteStartPos = resolvedPasteStartPos.before();
+  }
+  var markdownSlice = getMarkdownSlice(plaintext, schema, selection);
+  if (!markdownSlice) {
+    return tr;
+  }
+  var pasteEndPos = selection.$to.pos;
+  pasteSliceIntoTransactionWithSelectionAdjust({
+    tr: tr,
+    pasteStartPos: pasteStartPos,
+    pasteEndPos: pasteEndPos,
+    slice: markdownSlice
+  });
+  return tr;
+};
+var getRichTextSlice = exports.getRichTextSlice = function getRichTextSlice(state, pasteStartPos) {
+  var tr = state.tr;
+  var selection = tr.selection;
+  var pasteEndPos = selection.$to.pos;
+  return state.doc.slice(pasteStartPos, pasteEndPos);
+};
+var formatRichText = exports.formatRichText = function formatRichText(state, pasteStartPos, richTextSlice) {
+  var tr = state.tr;
+  var selection = tr.selection;
+  if (pasteStartPos < 0) {
+    return tr;
+  }
+  if (richTextSlice === _model.Slice.empty) {
+    return tr;
+  }
+  var pasteEndPos = selection.$to.pos;
+  var resolvedPasteStartPos = tr.doc.resolve(pasteStartPos);
+  var parentOffset = resolvedPasteStartPos.parentOffset;
+  if (parentOffset === 0 && resolvedPasteStartPos.depth > 0) {
+    pasteStartPos = resolvedPasteStartPos.before();
+  }
+  richTextSliceTransactionWithSelectionAdjust({
+    tr: tr,
+    pasteStartPos: pasteStartPos,
+    pasteEndPos: pasteEndPos,
+    slice: richTextSlice
+  });
+  return tr;
+};
+var formatPlainText = exports.formatPlainText = function formatPlainText(state, pasteStartPos, plaintext) {
+  var tr = state.tr,
+    schema = state.schema;
+
+  //not possible to create plain text slice with empty string
+  if (pasteStartPos < 0 || plaintext === '') {
+    return tr;
+  }
+  var selection = tr.selection;
+  var pasteEndPos = selection.$to.pos;
+  var resolvedPasteStartPos = tr.doc.resolve(pasteStartPos);
+  var parentOffset = resolvedPasteStartPos.parentOffset;
+  if (parentOffset === 0 && resolvedPasteStartPos.depth > 0) {
+    pasteStartPos = resolvedPasteStartPos.before();
+  }
+  var plainTextNode = schema.text(plaintext);
+  var plainTextFragment = _model.Fragment.from(schema.nodes.paragraph.createAndFill(null, plainTextNode));
+  var plainTextSlice = new _model.Slice(plainTextFragment, resolvedPasteStartPos.depth, resolvedPasteStartPos.depth);
+  pasteSliceIntoTransactionWithSelectionAdjust({
+    tr: tr,
+    pasteStartPos: pasteStartPos,
+    pasteEndPos: pasteEndPos,
+    slice: plainTextSlice
+  });
+  return tr;
+};
+function pasteSliceIntoTransactionWithSelectionAdjust(_ref) {
+  var tr = _ref.tr,
+    pasteStartPos = _ref.pasteStartPos,
+    pasteEndPos = _ref.pasteEndPos,
+    slice = _ref.slice;
+  tr.replaceRange(pasteStartPos, pasteEndPos, slice);
+
+  // ProseMirror doesn't give a proper way to tell us where something was inserted.
+  // However, we can know "how" it inserted something.
+  //
+  // So, instead of weird depth calculations, we can use the step produced by the transform.
+  // For instance:
+  //    The `replaceStep.to and replaceStep.from`, tell us the real position
+  //    where the content will be insert.
+  //    Then, we can use the `tr.mapping.map` to the updated position after the replace operation
+  var replaceStep = tr.steps[0];
+  if (!(replaceStep instanceof _transform.ReplaceStep)) {
+    return tr;
+  }
+  var lastInsertNode = replaceStep.slice.content.lastChild;
+  var emptyNodeReference = lastInsertNode === null || lastInsertNode === void 0 ? void 0 : lastInsertNode.type.createAndFill();
+  var isLastNodeEmpty = (emptyNodeReference === null || emptyNodeReference === void 0 ? void 0 : emptyNodeReference.nodeSize) === (lastInsertNode === null || lastInsertNode === void 0 ? void 0 : lastInsertNode.nodeSize);
+  var isStepSplitingTarget = !(lastInsertNode !== null && lastInsertNode !== void 0 && lastInsertNode.isLeaf) && isLastNodeEmpty;
+  var $nextHead = tr.doc.resolve(tr.mapping.map(replaceStep.to));
+  var $nextPosition = isStepSplitingTarget && $nextHead.depth > 0 ? tr.doc.resolve($nextHead.before()) : $nextHead;
+
+  // The findFrom will make search for both: TextSelection and NodeSelections.
+  var nextSelection = _state.Selection.findFrom($nextPosition, -1);
+  if (nextSelection) {
+    tr.setSelection(nextSelection);
+  }
+}
+function richTextSliceTransactionWithSelectionAdjust(_ref2) {
+  var tr = _ref2.tr,
+    pasteStartPos = _ref2.pasteStartPos,
+    pasteEndPos = _ref2.pasteEndPos,
+    slice = _ref2.slice;
+  tr.replaceRange(pasteStartPos, pasteEndPos, slice);
+
+  // ProseMirror doesn't give a proper way to tell us where something was inserted.
+  // However, we can know "how" it inserted something.
+  //
+  // So, instead of weird depth calculations, we can use the step produced by the transform.
+  // For instance:
+  //    The `replaceStep.to and replaceStep.from`, tell us the real position
+  //    where the content will be insert.
+  //    Then, we can use the `tr.mapping.map` to the updated position after the replace operation
+  var replaceStep = tr.steps[0];
+  if (!(replaceStep instanceof _transform.ReplaceStep)) {
+    return tr;
+  }
+  var nextPosition = tr.mapping.map(replaceStep.to);
+
+  // The findFrom will make search for both: TextSelection and NodeSelections.
+  var nextSelection = _state.Selection.findFrom(tr.doc.resolve(Math.min(nextPosition, tr.doc.content.size)), -1);
+  if (nextSelection) {
+    tr.setSelection(nextSelection);
+  }
+}
+function getMarkdownSlice(text, schema, selection) {
+  var targetOpenStartNode = selection.$from.parent;
+  var targetOpenEndNode = selection.$to.parent;
+  try {
+    var _doc$content$firstChi, _doc$content$lastChil;
+    var textInput = text;
+    var textSplitByCodeBlock = textInput.split(/```/);
+    for (var i = 0; i < textSplitByCodeBlock.length; i++) {
+      if (i % 2 === 0) {
+        textSplitByCodeBlock[i] = textSplitByCodeBlock[i].replace(/\\/g, '\\\\');
+      }
+    }
+    textInput = textSplitByCodeBlock.join('```');
+    var atlassianMarkDownParser = new _editorMarkdownTransformer.MarkdownTransformer(schema, _paste.md);
+    var doc = atlassianMarkDownParser.parse((0, _index.escapeLinks)(textInput));
+    if (!doc || !doc.content) {
+      return;
+    }
+    var canMergeOpenStart = targetOpenStartNode.type === ((_doc$content$firstChi = doc.content.firstChild) === null || _doc$content$firstChi === void 0 ? void 0 : _doc$content$firstChi.type);
+    var canMergeOpenEnd = targetOpenEndNode.type === ((_doc$content$lastChil = doc.content.lastChild) === null || _doc$content$lastChil === void 0 ? void 0 : _doc$content$lastChil.type);
+    var $start = _state.Selection.atStart(doc).$from;
+    var $end = _state.Selection.atEnd(doc).$from;
+    var openStart = canMergeOpenStart ? $start.depth : 0;
+    var openEnd = canMergeOpenEnd ? $end.depth : 0;
+    return new _model.Slice(doc.content, openStart, openEnd);
+  } catch (error) {
+    (0, _monitoring.logException)(error, {
+      location: 'editor-plugin-paste-options-toolbar/util'
+    });
+    return;
+  }
+}

package/dist/cjs/util/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapeLinks = escapeLinks;
+exports.hasRuleNode = exports.hasMediaNode = exports.hasLinkMark = void 0;
+exports.isPastedFromFabricEditor = isPastedFromFabricEditor;
+function isPastedFromFabricEditor(pastedFrom) {
+  return pastedFrom === 'fabric-editor';
+}
+
+// @see https://product-fabric.atlassian.net/browse/ED-3159
+// @see https://github.com/markdown-it/markdown-it/issues/38
+function escapeLinks(text) {
+  return text.replace(/(\[([^\]]+)\]\()?((https?|ftp|jamfselfservice):\/\/[^\s"'>]+)/g, function (str) {
+    return str.match(/^(https?|ftp|jamfselfservice):\/\/[^\s"'>]+$/) ? "<".concat(str, ">") : str;
+  });
+}
+var hasMediaNode = exports.hasMediaNode = function hasMediaNode(slice) {
+  if (!slice) {
+    return false;
+  }
+  var hasMedia = false;
+  slice.content.descendants(function (node) {
+    if (['media', 'mediaInline', 'mediaGroup', 'mediaSingle'].includes(node.type.name)) {
+      hasMedia = true;
+      return false;
+    }
+    return true;
+  });
+  return hasMedia;
+};
+var hasRuleNode = exports.hasRuleNode = function hasRuleNode(slice, schema) {
+  var hasRuleNode = false;
+  slice.content.nodesBetween(0, slice.content.size, function (node, start) {
+    if (node.type === schema.nodes.rule) {
+      hasRuleNode = true;
+    }
+  });
+  return hasRuleNode;
+};
+var hasLinkMark = exports.hasLinkMark = function hasLinkMark(state, pasteStartPos, pasteEndPos) {
+  return state.doc.rangeHasMark(pasteStartPos, pasteEndPos, state.schema.marks.link);
+};

package/dist/es2019/actions.js

@@ -0,0 +1,9 @@
+export let PastePluginActionTypes = /*#__PURE__*/function (PastePluginActionTypes) {
+  PastePluginActionTypes["START_TRACKING_PASTED_MACRO_POSITIONS"] = "START_TRACKING_PASTED_MACRO_POSITIONS";
+  PastePluginActionTypes["STOP_TRACKING_PASTED_MACRO_POSITIONS"] = "STOP_TRACKING_PASTED_MACRO_POSITIONS";
+  PastePluginActionTypes["SHOW_PASTE_OPTIONS"] = "SHOW_PASTE_OPTIONS";
+  PastePluginActionTypes["HIDE_PASTE_OPTIONS"] = "HIDE_PASTE_OPTIONS";
+  PastePluginActionTypes["HIGHLIGHT_CONTENT"] = "HIGHLIGHT_CONTENT";
+  PastePluginActionTypes["CHANGE_FORMAT"] = "CHANGE_FORMAT";
+  return PastePluginActionTypes;
+}({});

package/dist/es2019/commands.js

@@ -0,0 +1,134 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD, PasteContents, PasteTypes } from '@atlaskit/editor-common/analytics';
+import { withAnalytics } from '@atlaskit/editor-common/editor-analytics';
+import { PastePluginActionTypes as ActionTypes } from './actions';
+import { createCommand } from './pm-plugins/plugin-factory';
+import { pasteOptionsPluginKey, ToolbarDropdownOption } from './types';
+import { formatMarkdown, formatPlainText, formatRichText } from './util/format-handlers';
+export const showToolbar = (lastContentPasted, selectedOption) => {
+  const commandAction = editorState => {
+    return {
+      type: ActionTypes.SHOW_PASTE_OPTIONS,
+      data: {
+        selectedOption,
+        plaintext: lastContentPasted.text,
+        isPlainText: lastContentPasted.isPlainText,
+        richTextSlice: lastContentPasted.pastedSlice,
+        pasteStartPos: lastContentPasted.pasteStartPos,
+        pasteEndPos: lastContentPasted.pasteEndPos
+      }
+    };
+  };
+  return createCommand(commandAction);
+};
+export const changeToPlainText = (pasteStartPos, plaintext) => {
+  const plaintextTransformer = (tr, state) => {
+    return formatPlainText(state, pasteStartPos, plaintext);
+  };
+  const commandAction = editorState => {
+    return {
+      type: ActionTypes.CHANGE_FORMAT,
+      data: {
+        selectedOption: ToolbarDropdownOption.PlainText
+      }
+    };
+  };
+  return createCommand(commandAction, plaintextTransformer);
+};
+export const changeToPlainTextWithAnalytics = (editorAnalyticsAPI, sliceSize) => (pasteStartPos, plaintext) => {
+  return withAnalytics(editorAnalyticsAPI, {
+    action: ACTION.PASTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.TOOLBAR,
+      type: PasteTypes.plain,
+      content: PasteContents.text,
+      pasteSize: sliceSize
+    }
+  })(changeToPlainText(pasteStartPos, plaintext));
+};
+export const dropdownClickHandler = () => {
+  return highlightContent();
+};
+export const changeToRichText = pasteStartPos => {
+  const transformer = (tr, state) => {
+    const pastePluginState = pasteOptionsPluginKey.getState(state);
+    return formatRichText(state, pasteStartPos, pastePluginState.richTextSlice);
+  };
+  const commandAction = editorState => {
+    return {
+      type: ActionTypes.CHANGE_FORMAT,
+      data: {
+        selectedOption: ToolbarDropdownOption.RichText
+      }
+    };
+  };
+  return createCommand(commandAction, transformer);
+};
+export const changeToRichTextWithAnalytics = editorAnalyticsAPI => pasteStartPos => {
+  const payloadCallback = state => {
+    var _pastePluginState$ric;
+    const pastePluginState = pasteOptionsPluginKey.getState(state);
+    return {
+      action: ACTION.PASTED,
+      actionSubject: ACTION_SUBJECT.DOCUMENT,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: INPUT_METHOD.TOOLBAR,
+        type: PasteTypes.richText,
+        content: PasteContents.text,
+        pasteSize: ((_pastePluginState$ric = pastePluginState.richTextSlice) === null || _pastePluginState$ric === void 0 ? void 0 : _pastePluginState$ric.size) || 0
+      }
+    };
+  };
+  return withAnalytics(editorAnalyticsAPI, payloadCallback)(changeToRichText(pasteStartPos));
+};
+export const changeToMarkDown = (pasteStartPos, plaintext) => {
+  const markdownTransformer = (tr, state) => {
+    return formatMarkdown(state, pasteStartPos, plaintext);
+  };
+  const commandAction = editorState => {
+    return {
+      type: ActionTypes.CHANGE_FORMAT,
+      data: {
+        selectedOption: ToolbarDropdownOption.Markdown
+      }
+    };
+  };
+  return createCommand(commandAction, markdownTransformer);
+};
+export const changeToMarkdownWithAnalytics = (editorAnalyticsAPI, sliceSize) => (pasteStartPos, plaintext) => {
+  return withAnalytics(editorAnalyticsAPI, {
+    action: ACTION.PASTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.TOOLBAR,
+      type: PasteTypes.markdown,
+      content: PasteContents.text,
+      pasteSize: sliceSize
+    }
+  })(changeToMarkDown(pasteStartPos, plaintext));
+};
+export const highlightContent = () => {
+  const commandAction = editorState => {
+    return {
+      type: ActionTypes.HIGHLIGHT_CONTENT
+    };
+  };
+  return createCommand(commandAction);
+};
+export const hideToolbar = () => {
+  const commandAction = editorState => {
+    return {
+      type: ActionTypes.HIDE_PASTE_OPTIONS
+    };
+  };
+  return createCommand(commandAction);
+};
+export const checkAndHideToolbar = view => {
+  const pluginState = pasteOptionsPluginKey.getState(view.state);
+  if (pluginState.showToolbar) {
+    hideToolbar()(view.state, view.dispatch);
+  }
+};

package/dist/es2019/index.js

@@ -0,0 +1 @@
+export { pasteOptionsToolbarPlugin } from './plugin';

package/dist/es2019/messages.js

@@ -0,0 +1,23 @@
+import { defineMessages } from 'react-intl-next';
+export const messages = defineMessages({
+  pasteOptions: {
+    id: 'fabric.editor.pasteOptions',
+    defaultMessage: 'Paste options floating controls',
+    description: 'Opens a menu with additional paste options'
+  },
+  plainText: {
+    id: 'fabric.editor.plainText',
+    defaultMessage: 'Use plain text',
+    description: 'Converts pasted text into plain text'
+  },
+  markdown: {
+    id: 'fabric.editor.useMarkdown',
+    defaultMessage: 'Use Markdown',
+    description: 'Converts pasted text into Markdown'
+  },
+  richText: {
+    id: 'fabric.editor.richText',
+    defaultMessage: 'Use rich text',
+    description: 'Converts pasted text into Rich text'
+  }
+});

package/dist/es2019/plugin.js

@@ -0,0 +1,64 @@
+import { useEffect } from 'react';
+import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
+import { hideToolbar, showToolbar } from './commands';
+import { createPlugin } from './pm-plugins/main';
+import { buildToolbar, isToolbarVisible } from './toolbar';
+import { pasteOptionsPluginKey, ToolbarDropdownOption } from './types';
+export const pasteOptionsToolbarPlugin = ({
+  config,
+  api
+}) => {
+  var _api$analytics;
+  const editorAnalyticsAPI = api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions;
+  return {
+    name: 'pasteOptionsToolbarPlugin',
+    pmPlugins() {
+      return [{
+        name: 'pasteOptionsToolbarPlugin',
+        plugin: ({
+          dispatch
+        }) => createPlugin(dispatch)
+      }];
+    },
+    pluginsOptions: {
+      floatingToolbar(state, intl) {
+        const pastePluginState = pasteOptionsPluginKey.getState(state);
+        const {
+          showToolbar,
+          pasteStartPos,
+          plaintext
+        } = pastePluginState || {};
+        if (showToolbar) {
+          return buildToolbar(state, pasteStartPos, plaintext, intl, editorAnalyticsAPI);
+        }
+        return;
+      }
+    },
+    usePluginHook({
+      editorView
+    }) {
+      const {
+        pasteState
+      } = useSharedPluginState(api, ['paste']);
+      const lastContentPasted = pasteState === null || pasteState === void 0 ? void 0 : pasteState.lastContentPasted;
+      useEffect(() => {
+        if (!lastContentPasted) {
+          hideToolbar()(editorView.state, editorView.dispatch);
+          return;
+        }
+        let selectedOption = ToolbarDropdownOption.None;
+        if (!lastContentPasted.isPlainText) {
+          selectedOption = ToolbarDropdownOption.RichText;
+        } else if (lastContentPasted.isShiftPressed) {
+          selectedOption = ToolbarDropdownOption.PlainText;
+        } else {
+          selectedOption = ToolbarDropdownOption.Markdown;
+        }
+        if (!isToolbarVisible(editorView.state, lastContentPasted)) {
+          return;
+        }
+        showToolbar(lastContentPasted, selectedOption)(editorView.state, editorView.dispatch);
+      }, [lastContentPasted, editorView]);
+    }
+  };
+};

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

@@ -0,0 +1,7 @@
+export const PASTE_TOOLBAR_CLASS = 'ak-editor-paste-toolbar';
+export const PASTE_TOOLBAR_MENU_ID = 'ak-editor-paste-toolbar-item-dropdownList';
+export const TEXT_HIGHLIGHT_CLASS = 'text-highlight';
+export const PASTE_HIGHLIGHT_DECORATION_KEY = 'paste-highlight-decoration-key';
+export const PASTE_TOOLBAR_ITEM_CLASS = 'ak-editor-paste-toolbar-item';
+export const EDITOR_WRAPPER_CLASS = 'akEditor';
+export const PASTE_OPTIONS_TEST_ID = 'paste-options-testid';

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

@@ -0,0 +1,63 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { checkAndHideToolbar } from '../commands';
+import { pasteOptionsPluginKey, ToolbarDropdownOption } from '../types';
+import { PASTE_HIGHLIGHT_DECORATION_KEY, TEXT_HIGHLIGHT_CLASS } from './constants';
+import { createPluginState } from './plugin-factory';
+export function createPlugin(dispatch) {
+  return new SafePlugin({
+    key: pasteOptionsPluginKey,
+    state: createPluginState(dispatch, {
+      showToolbar: false,
+      pasteStartPos: 0,
+      pasteEndPos: 0,
+      plaintext: '',
+      isPlainText: false,
+      highlightContent: false,
+      highlightDecorationSet: DecorationSet.empty,
+      richTextSlice: Slice.empty,
+      selectedOption: ToolbarDropdownOption.None
+    }),
+    view(editorView) {
+      return {
+        update(view, prevState) {
+          return prevState;
+        }
+      };
+    },
+    props: {
+      handleDOMEvents: {
+        // Hide toolbar when clicked outside the editor
+        blur: checkAndHideToolbar,
+        // Hide toolbar when clicked anywhere within the editor, tr.getMeta('pointer') does not work if clicked on the same line after pasting so relying on mousedown event
+        mousedown: checkAndHideToolbar
+      },
+      handleKeyDown: view => {
+        checkAndHideToolbar(view);
+        return false;
+      },
+      decorations: state => {
+        var _pasteOptionsPluginKe, _pasteOptionsPluginKe2;
+        const {
+          highlightContent,
+          pasteStartPos
+        } = pasteOptionsPluginKey.getState(state) || {};
+        let decorationSet = (_pasteOptionsPluginKe = (_pasteOptionsPluginKe2 = pasteOptionsPluginKey.getState(state)) === null || _pasteOptionsPluginKe2 === void 0 ? void 0 : _pasteOptionsPluginKe2.highlightDecorationSet) !== null && _pasteOptionsPluginKe !== void 0 ? _pasteOptionsPluginKe : DecorationSet.empty;
+        if (!highlightContent) {
+          return decorationSet;
+        }
+        const {
+          selection
+        } = state.tr;
+        const pasteEndPos = selection.$anchor.pos;
+        const highlightDecoration = Decoration.inline(pasteStartPos, pasteEndPos, {
+          class: TEXT_HIGHLIGHT_CLASS
+        }, {
+          key: PASTE_HIGHLIGHT_DECORATION_KEY
+        });
+        return decorationSet.add(state.doc, [highlightDecoration]);
+      }
+    }
+  });
+}

package/dist/es2019/pm-plugins/plugin-factory.js

@@ -0,0 +1,23 @@
+import { pluginFactory } from '@atlaskit/editor-common/utils';
+import { reducer } from '../reducer';
+import { pasteOptionsPluginKey } from '../types';
+export const {
+  createPluginState,
+  createCommand,
+  getPluginState
+} = pluginFactory(pasteOptionsPluginKey, reducer, {
+  mapping: (tr, pluginState) => {
+    return pluginState;
+  },
+  onSelectionChanged: (tr, pluginState) => {
+    // Detect click outside the editor
+    if (tr.getMeta('outsideProsemirrorEditorClicked')) {
+      return {
+        ...pluginState,
+        showToolbar: false,
+        highlightContent: false
+      };
+    }
+    return pluginState;
+  }
+});

package/dist/es2019/reducer.js

@@ -0,0 +1,44 @@
+import { PastePluginActionTypes as ActionTypes } from './actions';
+export const reducer = (state, action) => {
+  switch (action.type) {
+    case ActionTypes.SHOW_PASTE_OPTIONS:
+      {
+        return {
+          ...state,
+          showToolbar: true,
+          highlightContent: false,
+          isPlainText: action.data.isPlainText,
+          plaintext: action.data.plaintext,
+          selectedOption: action.data.selectedOption,
+          richTextSlice: action.data.richTextSlice,
+          pasteStartPos: action.data.pasteStartPos,
+          pasteEndPos: action.data.pasteEndPos
+        };
+      }
+    case ActionTypes.HIDE_PASTE_OPTIONS:
+      {
+        return {
+          ...state,
+          highlightContent: false,
+          showToolbar: false
+        };
+      }
+    case ActionTypes.HIGHLIGHT_CONTENT:
+      {
+        return {
+          ...state,
+          highlightContent: true
+        };
+      }
+    case ActionTypes.CHANGE_FORMAT:
+      {
+        return {
+          ...state,
+          highlightContent: true,
+          selectedOption: action.data.selectedOption
+        };
+      }
+    default:
+      return state;
+  }
+};

package/dist/es2019/styles.js

@@ -0,0 +1 @@
+export { textHighlightStyle } from './ui/styles';