@atlaskit/editor-plugin-paste 0.1.22 → 0.2.0

package/dist/esm/util/index.js

@@ -0,0 +1,194 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD, TABLE_ACTION } from '@atlaskit/editor-common/analytics';
+import { sortByOrderWithTypeName } from '@atlaskit/editor-common/legacy-rank-plugins';
+import { isSupportedInParent, mapChildren } from '@atlaskit/editor-common/utils';
+import { Fragment, Mark, Slice } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import { getSelectedTableInfo, isTableSelected } from '@atlaskit/editor-tables/utils';
+import { isMediaBlobUrl } from '@atlaskit/media-client';
+export function isPastedFromWord(html) {
+  return !!html && html.indexOf('urn:schemas-microsoft-com:office:word') >= 0;
+}
+export function isPastedFromExcel(html) {
+  return !!html && html.indexOf('urn:schemas-microsoft-com:office:excel') >= 0;
+}
+function isPastedFromDropboxPaper(html) {
+  return !!html && !!html.match(/class=\"\s?author-d-.+"/gim);
+}
+function isPastedFromGoogleDocs(html) {
+  return !!html && !!html.match(/id=\"docs-internal-guid-.+"/gim);
+}
+function isPastedFromGoogleSpreadSheets(html) {
+  return !!html && !!html.match(/data-sheets-.+=/gim);
+}
+function isPastedFromPages(html) {
+  return !!html && html.indexOf('content="Cocoa HTML Writer"') >= 0;
+}
+function isPastedFromFabricEditor(html) {
+  return !!html && html.indexOf('data-pm-slice="') >= 0;
+}
+export var isSingleLine = function isSingleLine(text) {
+  return !!text && text.trim().split('\n').length === 1;
+};
+export function htmlContainsSingleFile(html) {
+  return !!html.match(/<img .*>/) && !isMediaBlobUrl(html);
+}
+export function getPasteSource(event) {
+  var html = event.clipboardData.getData('text/html');
+  if (isPastedFromDropboxPaper(html)) {
+    return 'dropbox-paper';
+  } else if (isPastedFromWord(html)) {
+    return 'microsoft-word';
+  } else if (isPastedFromExcel(html)) {
+    return 'microsoft-excel';
+  } else if (isPastedFromGoogleDocs(html)) {
+    return 'google-docs';
+  } else if (isPastedFromGoogleSpreadSheets(html)) {
+    return 'google-spreadsheets';
+  } else if (isPastedFromPages(html)) {
+    return 'apple-pages';
+  } else if (isPastedFromFabricEditor(html)) {
+    return 'fabric-editor';
+  }
+  return 'uncategorized';
+}
+
+// @see https://product-fabric.atlassian.net/browse/ED-3159
+// @see https://github.com/markdown-it/markdown-it/issues/38
+export function escapeLinks(text) {
+  return text.replace(/(\[([^\]]+)\]\()?((https?|ftp|jamfselfservice):\/\/[^\s"'>]+)/g, function (str) {
+    return str.match(/^(https?|ftp|jamfselfservice):\/\/[^\s"'>]+$/) ? "<".concat(str, ">") : str;
+  });
+}
+export function hasOnlyNodesOfType() {
+  for (var _len = arguments.length, nodeTypes = new Array(_len), _key = 0; _key < _len; _key++) {
+    nodeTypes[_key] = arguments[_key];
+  }
+  return function (slice) {
+    var hasOnlyNodesOfType = true;
+    slice.content.descendants(function (node) {
+      hasOnlyNodesOfType = hasOnlyNodesOfType && nodeTypes.indexOf(node.type) > -1;
+      return hasOnlyNodesOfType;
+    });
+    return hasOnlyNodesOfType;
+  };
+}
+export function applyTextMarksToSlice(schema, marks) {
+  return function (slice) {
+    var _schema$marks = schema.marks,
+      codeMark = _schema$marks.code,
+      linkMark = _schema$marks.link,
+      annotationMark = _schema$marks.annotation;
+    if (!Array.isArray(marks) || marks.length === 0) {
+      return slice;
+    }
+    var sliceCopy = Slice.fromJSON(schema, slice.toJSON() || {});
+
+    // allow links and annotations to be pasted
+    var allowedMarksToPaste = [linkMark, annotationMark];
+    sliceCopy.content.descendants(function (node, _pos, parent) {
+      if (node.isText && parent && parent.isBlock) {
+        // @ts-ignore - [unblock prosemirror bump] assigning to readonly prop
+        node.marks = [].concat(_toConsumableArray(node.marks && !codeMark.isInSet(marks) && node.marks.filter(function (mark) {
+          return allowedMarksToPaste.includes(mark.type);
+        }) || []), _toConsumableArray(parent.type.allowedMarks(marks).filter(function (mark) {
+          return mark.type !== linkMark;
+        }))).sort(sortByOrderWithTypeName('marks'));
+        return false;
+      }
+      return true;
+    });
+    return sliceCopy;
+  };
+}
+export function isEmptyNode(node) {
+  if (!node) {
+    return false;
+  }
+  var nodeType = node.type;
+  var emptyNode = nodeType.createAndFill();
+  return emptyNode && emptyNode.nodeSize === node.nodeSize && emptyNode.content.eq(node.content) && Mark.sameSet(emptyNode.marks, node.marks);
+}
+export function isCursorSelectionAtTextStartOrEnd(selection) {
+  return selection instanceof TextSelection && selection.empty && selection.$cursor && (!selection.$cursor.nodeBefore || !selection.$cursor.nodeAfter);
+}
+export function isPanelNode(node) {
+  return Boolean(node && node.type.name === 'panel');
+}
+export function isSelectionInsidePanel(selection) {
+  if (selection instanceof NodeSelection && isPanelNode(selection.node)) {
+    return selection.node;
+  }
+  var panel = selection.$from.doc.type.schema.nodes.panel;
+  var panelPosition = findParentNodeOfType(panel)(selection);
+  if (panelPosition) {
+    return panelPosition.node;
+  }
+  return null;
+}
+
+// https://product-fabric.atlassian.net/browse/ED-11714
+// Checks for broken html that comes from links in a list item copied from Notion
+export var htmlHasInvalidLinkTags = function htmlHasInvalidLinkTags(html) {
+  return !!html && (html.includes('</a></a>') || html.includes('"></a><a'));
+};
+
+// https://product-fabric.atlassian.net/browse/ED-11714
+// Example of broken html edge case we're solving
+// <li><a href="http://www.atlassian.com\"<a> href="http://www.atlassian.com\"http://www.atlassian.com</a></a></li>">
+export var removeDuplicateInvalidLinks = function removeDuplicateInvalidLinks(html) {
+  if (htmlHasInvalidLinkTags(html)) {
+    var htmlArray = html.split(/(?=<a)/);
+    var htmlArrayWithoutInvalidLinks = htmlArray.filter(function (item) {
+      return !(item.includes('<a') && item.includes('"></a>')) && !(item.includes('<a') && !item.includes('</a>'));
+    });
+    var fixedHtml = htmlArrayWithoutInvalidLinks.join('').replace(/<\/a><\/a>/gi, '</a>').replace(/<a>/gi, '<a');
+    return fixedHtml;
+  }
+  return html;
+};
+export var addReplaceSelectedTableAnalytics = function addReplaceSelectedTableAnalytics(state, tr, editorAnalyticsAPI) {
+  if (isTableSelected(state.selection)) {
+    var _getSelectedTableInfo = getSelectedTableInfo(state.selection),
+      totalRowCount = _getSelectedTableInfo.totalRowCount,
+      totalColumnCount = _getSelectedTableInfo.totalColumnCount;
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+      action: TABLE_ACTION.REPLACED,
+      actionSubject: ACTION_SUBJECT.TABLE,
+      attributes: {
+        totalColumnCount: totalColumnCount,
+        totalRowCount: totalRowCount,
+        inputMethod: INPUT_METHOD.CLIPBOARD
+      },
+      eventType: EVENT_TYPE.TRACK
+    })(tr);
+    return tr;
+  }
+  return state.tr;
+};
+export var transformUnsupportedBlockCardToInline = function transformUnsupportedBlockCardToInline(slice, state, cardOptions) {
+  var _state$schema$nodes = state.schema.nodes,
+    blockCard = _state$schema$nodes.blockCard,
+    inlineCard = _state$schema$nodes.inlineCard;
+  var children = [];
+  mapChildren(slice.content, function (node, i, frag) {
+    var _cardOptions$allowBlo;
+    if (node.type === blockCard && !isBlockCardSupported(state, frag, (_cardOptions$allowBlo = cardOptions === null || cardOptions === void 0 ? void 0 : cardOptions.allowBlockCards) !== null && _cardOptions$allowBlo !== void 0 ? _cardOptions$allowBlo : false)) {
+      children.push(inlineCard.createChecked(node.attrs, node.content, node.marks));
+    } else {
+      children.push(node);
+    }
+  });
+  return new Slice(Fragment.fromArray(children), slice.openStart, slice.openEnd);
+};
+/**
+ * Function to determine if a block card is supported by the editor
+ * @param state
+ * @param frag
+ * @param allowBlockCards
+ * @returns
+ */
+var isBlockCardSupported = function isBlockCardSupported(state, frag, allowBlockCards) {
+  return allowBlockCards && isSupportedInParent(state, frag);
+};

package/dist/esm/util/tinyMCE.js

@@ -0,0 +1,176 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import chunk from 'lodash/chunk';
+var isPastedFromTinyMCE = function isPastedFromTinyMCE(pasteEvent) {
+  var _pasteEvent$clipboard, _pasteEvent$clipboard2;
+  return (_pasteEvent$clipboard = pasteEvent === null || pasteEvent === void 0 || (_pasteEvent$clipboard2 = pasteEvent.clipboardData) === null || _pasteEvent$clipboard2 === void 0 || (_pasteEvent$clipboard2 = _pasteEvent$clipboard2.types) === null || _pasteEvent$clipboard2 === void 0 ? void 0 : _pasteEvent$clipboard2.some(function (mimeType) {
+    return mimeType === 'x-tinymce/html';
+  })) !== null && _pasteEvent$clipboard !== void 0 ? _pasteEvent$clipboard : false;
+};
+export var isPastedFromTinyMCEConfluence = function isPastedFromTinyMCEConfluence(pasteEvent, html) {
+  return isPastedFromTinyMCE(pasteEvent) && !!html && !!html.match(/class=\"\s?(confluenceTd|confluenceTh|confluenceTable).+"/gim);
+};
+
+/**
+ * Wraps html markup with a `<table>` and uses `DOMParser` to generate
+ * and return both the table-wrapped and non-table-wrapped DOM document
+ * instances.
+ */
+export var wrapWithTable = function wrapWithTable(html) {
+  var parser = new DOMParser();
+  var nonTableWrappedDoc = parser.parseFromString(html, 'text/html');
+  var tableWrappedDoc = parser.parseFromString("<table>".concat(html, "</table>"), 'text/html');
+  tableWrappedDoc.body.querySelectorAll('meta').forEach(function (meta) {
+    tableWrappedDoc.head.prepend(meta);
+  });
+  return {
+    tableWrappedDoc: tableWrappedDoc,
+    nonTableWrappedDoc: nonTableWrappedDoc
+  };
+};
+var exactlyDivisible = function exactlyDivisible(larger, smaller) {
+  return larger % smaller === 0;
+};
+var getTableElementsInfo = function getTableElementsInfo(doc) {
+  var cellCount = doc.querySelectorAll('td').length;
+  var thCount = doc.querySelectorAll('th').length;
+  var mergedCellCount = doc.querySelectorAll('td[colspan]:not([colspan="1"])').length;
+  var hasThAfterTd = false;
+  var thsAndCells = doc.querySelectorAll('th,td');
+  for (var i = 0, cellFound = false; i < thsAndCells.length; i++) {
+    if (cellFound && thsAndCells[i].nodeName === 'TH') {
+      hasThAfterTd = true;
+      break;
+    }
+    if (thsAndCells[i].nodeName === 'TD') {
+      cellFound = true;
+    }
+  }
+  var onlyTh = thCount > 0 && cellCount === 0;
+  var onlyCells = cellCount > 0 && thCount === 0;
+  var hasCompleteRow =
+  // we take header-only and cell-only tables to be
+  // row-complete
+  onlyTh || onlyCells ||
+  // if headers and cells can "fit" against each other,
+  // then we assume a complete row exists
+  (exactlyDivisible(thCount, cellCount) || exactlyDivisible(cellCount, thCount)) &&
+  // all numbers are divisible by 1, so we carve out a specific
+  // check for when there is only 1 table cell, and more than 1
+  // table header.
+  !(thCount > 1 && cellCount === 1);
+  return {
+    cellCount: cellCount,
+    thCount: thCount,
+    mergedCellCount: mergedCellCount,
+    hasThAfterTd: hasThAfterTd,
+    hasIncompleteRow: !hasCompleteRow
+  };
+};
+var configureTableRows = function configureTableRows(doc, colsInRow) {
+  var _Array$from;
+  var tableHeadersAndCells = Array.from(doc.body.querySelectorAll('th,td'));
+  var evenlySplitChunks = chunk(tableHeadersAndCells, colsInRow);
+  var tableBody = doc.body.querySelector('tbody');
+  evenlySplitChunks.forEach(function (chunk) {
+    var tr = doc.createElement('tr');
+    tableBody === null || tableBody === void 0 || tableBody.append(tr);
+    tr.append.apply(tr, _toConsumableArray(chunk));
+  });
+  // We remove any leftover empty rows which may cause fabric editor
+  // to no-op when parsing the table
+  var emptyRows = (_Array$from = Array.from(tableBody.querySelectorAll('tr'))) === null || _Array$from === void 0 ? void 0 : _Array$from.filter(function (row) {
+    return row.innerHTML.trim().length === 0;
+  });
+  emptyRows.forEach(function (row) {
+    return row.remove();
+  });
+  return doc.body.innerHTML;
+};
+var fillIncompleteRowWithEmptyCells = function fillIncompleteRowWithEmptyCells(doc, thCount, cellCount) {
+  var _lastCell$parentEleme;
+  var extraCellsCount = 0;
+  while (!exactlyDivisible(cellCount + extraCellsCount, thCount)) {
+    extraCellsCount++;
+  }
+  var extraEmptyCells = Array.from(Array(extraCellsCount)).map(function () {
+    return doc.createElement('td');
+  });
+  var lastCell = doc.body.querySelector('td:last-of-type');
+  lastCell === null || lastCell === void 0 || (_lastCell$parentEleme = lastCell.parentElement) === null || _lastCell$parentEleme === void 0 || _lastCell$parentEleme.append.apply(_lastCell$parentEleme, _toConsumableArray(extraEmptyCells));
+  return {
+    updatedCellCount: cellCount + extraCellsCount
+  };
+};
+
+/**
+ * Given a DOM document, it will try to rebuild table rows by using the
+ * table headers count as an initial starting point for the assumed
+ * number of columns that make up a row (`colsInRow`). It will slowly
+ * decrease that `colsInRow` count until it finds exact fit for table
+ * headers and cells with `colsInRow` else it returns the original
+ * document's markup.
+ *
+ * NOTE: It will NOT try to rebuild table rows if it encounters merged cells
+ * or compex table configurations (where table headers exist after normal
+ * table cells). It will build a single column table if NO table
+ * headers exist.
+ */
+export var tryReconstructTableRows = function tryReconstructTableRows(doc) {
+  var _getTableElementsInfo = getTableElementsInfo(doc),
+    cellCount = _getTableElementsInfo.cellCount,
+    thCount = _getTableElementsInfo.thCount,
+    mergedCellCount = _getTableElementsInfo.mergedCellCount,
+    hasThAfterTd = _getTableElementsInfo.hasThAfterTd,
+    hasIncompleteRow = _getTableElementsInfo.hasIncompleteRow;
+  if (mergedCellCount || hasThAfterTd) {
+    // bail out to avoid handling more complex table structures
+    return doc.body.innerHTML;
+  }
+  if (!thCount) {
+    // if no table headers exist for reference, fallback to a single column table structure
+    return configureTableRows(doc, 1);
+  }
+  if (hasIncompleteRow) {
+    // if shift-click selection copies a partial table row to the clipboard,
+    // and we do have table headers for reference, then we add empty table cells
+    // to fill out the partial row
+    var _fillIncompleteRowWit = fillIncompleteRowWithEmptyCells(doc, thCount, cellCount),
+      updatedCellCount = _fillIncompleteRowWit.updatedCellCount;
+    cellCount = updatedCellCount;
+  }
+  for (var possibleColsInRow = thCount; possibleColsInRow > 0; possibleColsInRow--) {
+    if (exactlyDivisible(thCount, possibleColsInRow) && exactlyDivisible(cellCount, possibleColsInRow)) {
+      return configureTableRows(doc, possibleColsInRow);
+    }
+  }
+  return doc.body.innerHTML;
+};
+export var htmlHasIncompleteTable = function htmlHasIncompleteTable(html) {
+  return !html.includes('<table ') && (html.includes('<td ') || html.includes('<th '));
+};
+
+/**
+ * Strictly for ED-7331. Given incomplete table html from tinyMCE, it will try to rebuild
+ * a whole valid table. If it rebuilds the table, it may first rebuild it as a single
+ * row table, so this also then tries to reconstruct the table rows/columns if
+ * possible (best effort).
+ */
+export var tryRebuildCompleteTableHtml = function tryRebuildCompleteTableHtml(incompleteTableHtml) {
+  // first we try wrapping the table elements with <table> and let DOMParser try to rebuild
+  // a valid DOM tree. we also keep the non-wrapped table for comparison purposes.
+  var _wrapWithTable = wrapWithTable(incompleteTableHtml),
+    nonTableWrappedDoc = _wrapWithTable.nonTableWrappedDoc,
+    tableWrappedDoc = _wrapWithTable.tableWrappedDoc;
+  var didPreserveTableElements = Boolean(!nonTableWrappedDoc.body.querySelector('th, td') && tableWrappedDoc.body.querySelector('th, td'));
+  var isExpectedStructure = tableWrappedDoc.querySelectorAll('body > table:only-child') && !tableWrappedDoc.querySelector("body > table > tbody > tr > :not(th,td)");
+
+  // if DOMParser saves table elements that we would otherwise lose, and
+  // if the table html is what we'd expect (a single table, with no extraneous
+  // elements in table rows other than th, td), then we can now also try to
+  // rebuild table rows/columns.
+  if (didPreserveTableElements && isExpectedStructure) {
+    var completeTableHtml = tryReconstructTableRows(tableWrappedDoc);
+    return completeTableHtml;
+  }
+  return null;
+};

package/dist/types/actions.d.ts

@@ -0,0 +1,21 @@
+import type { LastContentPasted } from './types';
+export declare enum PastePluginActionTypes {
+    START_TRACKING_PASTED_MACRO_POSITIONS = "START_TRACKING_PASTED_MACRO_POSITIONS",
+    STOP_TRACKING_PASTED_MACRO_POSITIONS = "STOP_TRACKING_PASTED_MACRO_POSITIONS",
+    ON_PASTE = "ON_PASTE"
+}
+export interface StartTrackingPastedMacroPositions {
+    type: PastePluginActionTypes.START_TRACKING_PASTED_MACRO_POSITIONS;
+    pastedMacroPositions: {
+        [key: string]: number;
+    };
+}
+export interface OnPaste {
+    type: PastePluginActionTypes.ON_PASTE;
+    contentPasted: LastContentPasted;
+}
+export interface StopTrackingPastedMacroPositions {
+    type: PastePluginActionTypes.STOP_TRACKING_PASTED_MACRO_POSITIONS;
+    pastedMacroPositionKeys: string[];
+}
+export type PastePluginAction = StartTrackingPastedMacroPositions | StopTrackingPastedMacroPositions | OnPaste;

package/dist/types/commands.d.ts

@@ -0,0 +1,29 @@
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Mark, Schema } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Use this to register macro link positions during a paste operation, that you
+ * want to track in a document over time, through any document changes.
+ *
+ * @param positions a map of string keys (custom position references) and position values e.g. { ['my-key-1']: 11 }
+ *
+ * **Context**: This is neccessary if there is an async process or an unknown period of time
+ * between obtaining an original position, and wanting to know about what its final eventual
+ * value. In that scenario, positions will need to be actively tracked and mapped in plugin
+ * state so that they can be mapped through any other independent document change transactions being
+ * dispatched to the editor that could affect their value.
+ */
+export declare const startTrackingPastedMacroPositions: (pastedMacroPositions: {
+    [key: string]: number;
+}) => import("@atlaskit/editor-common/types").Command;
+export declare const stopTrackingPastedMacroPositions: (pastedMacroPositionKeys: string[]) => import("@atlaskit/editor-common/types").Command;
+export declare const upgradeTextToLists: (slice: Slice, schema: Schema) => Slice;
+export declare const splitParagraphs: (slice: Slice, schema: Schema) => Slice;
+/**
+ * Walks the slice, creating paragraphs that were previously separated by hardbreaks.
+ * Returns the original paragraph node (as a fragment), or a fragment containing multiple nodes.
+ */
+export declare const splitIntoParagraphs: ({ fragment, blockMarks, schema, }: {
+    fragment: Fragment;
+    blockMarks?: readonly Mark[] | undefined;
+    schema: Schema;
+}) => Fragment;

package/dist/types/edge-cases/index.d.ts

@@ -0,0 +1,11 @@
+import type { Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function insertSliceForLists({ tr, slice, schema, }: {
+    tr: Transaction;
+    slice: Slice;
+    schema: Schema;
+}): void | Transaction;
+export declare function insertSliceForListsInsideBlockquote({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): Transaction | undefined;

package/dist/types/edge-cases/lists.d.ts

@@ -0,0 +1,18 @@
+import type { Node as PMNode, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function insertSliceIntoEmptyNode({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): void;
+export declare function insertSliceAtNodeEdge({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): void;
+export declare function insertSliceIntoRangeSelectionInsideList({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): Transaction | undefined;
+export declare function insertSliceInsideOfPanelNodeSelected(panelNode: PMNode): ({ tr, slice }: {
+    tr: Transaction;
+    slice: Slice;
+}) => void;

package/dist/types/handlers.d.ts

@@ -0,0 +1,55 @@
+import type { EditorAnalyticsAPI, InputMethodInsertMedia } from '@atlaskit/editor-common/analytics';
+import type { CardOptions, QueueCardsFromTransactionAction } from '@atlaskit/editor-common/card';
+import type { ExtensionAutoConvertHandler } from '@atlaskit/editor-common/extensions';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { RunMacroAutoConvert } from '@atlaskit/editor-plugin-extension';
+import type { FindRootParentListNode } from '@atlaskit/editor-plugin-list';
+import type { InsertMediaAsMediaSingle } from '@atlaskit/editor-plugin-media/types';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection } from '@atlaskit/editor-prosemirror/state';
+export declare function handleMention(slice: Slice, schema: Schema): Slice;
+export declare function handlePasteIntoTaskOrDecisionOrPanel(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
+export declare function handlePasteNonNestableBlockNodesIntoList(slice: Slice): Command;
+export declare const doesSelectionWhichStartsOrEndsInListContainEntireList: (selection: Selection, findRootParentListNode: FindRootParentListNode | undefined) => boolean;
+export declare function handlePastePanelOrDecisionContentIntoList(slice: Slice, findRootParentListNode: FindRootParentListNode | undefined): Command;
+export declare function handlePasteLinkOnSelectedText(slice: Slice): Command;
+export declare function handlePasteAsPlainText(slice: Slice, _event: ClipboardEvent, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): Command;
+export declare function handlePastePreservingMarks(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
+export declare function handleMacroAutoConvert(text: string, slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined, runMacroAutoConvert: RunMacroAutoConvert | undefined, cardsOptions?: CardOptions, extensionAutoConverter?: ExtensionAutoConvertHandler): Command;
+export declare function handleCodeBlock(text: string): Command;
+export declare function handleMediaSingle(inputMethod: InputMethodInsertMedia, insertMediaAsMediaSingle: InsertMediaAsMediaSingle | undefined): (slice: Slice) => Command;
+export declare function handleExpandPasteInTable(slice: Slice): Command;
+export declare function handleMarkdown(markdownSlice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined, from?: number, to?: number): Command;
+export declare function handleParagraphBlockMarks(state: EditorState, slice: Slice): Slice;
+/**
+ * ED-6300: When a nested list is pasted in a table cell and the slice has openStart > openEnd,
+ * it splits the table. As a workaround, we flatten the list to even openStart and openEnd.
+ *
+ * Note: this only happens if the first child is a list
+ *
+ * Example: copying "one" and "two"
+ * - zero
+ *   - one
+ * - two
+ *
+ * Before:
+ * ul
+ *   ┗━ li
+ *     ┗━ ul
+ *       ┗━ li
+ *         ┗━ p -> "one"
+ *   ┗━ li
+ *     ┗━ p -> "two"
+ *
+ * After:
+ * ul
+ *   ┗━ li
+ *     ┗━ p -> "one"
+ *   ┗━ li
+ *     ┗━p -> "two"
+ */
+export declare function flattenNestedListInSlice(slice: Slice): Slice;
+export declare function handleRichText(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
+export declare function handlePasteIntoCaption(slice: Slice): Command;
+export declare const handleSelectedTable: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (slice: Slice) => Command;

package/dist/types/index.d.ts

@@ -1 +1,2 @@
 export type { PastePlugin, PastePluginOptions, PastePluginState, LastContentPasted, } from './types';
+export { pastePlugin } from './plugin';

package/dist/types/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { PastePlugin } from './types';
+export declare const pastePlugin: PastePlugin;

package/dist/types/plugins/media.d.ts

@@ -0,0 +1,23 @@
+import type { Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Ensure correct layout in nested mode
+ *
+ * TODO: this func is only used in handlePaste, so layout update won't work for drop event
+ */
+export declare function transformSliceForMedia(slice: Slice, schema: Schema): (selection: Selection) => Slice;
+export declare const isImage: (fileType?: string) => boolean;
+export declare const transformSliceToCorrectMediaWrapper: (slice: Slice, schema: Schema) => Slice;
+/**
+ * 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 declare const transformSliceToMediaSingleWithNewExperience: (slice: Slice, schema: Schema) => Slice;
+/**
+ * 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 declare const unwrapNestedMediaElements: (html: string) => string;

package/dist/types/pm-plugins/analytics.d.ts

@@ -0,0 +1,44 @@
+import type { AnalyticsEventPayload, EditorAnalyticsAPI, PasteContent, PasteType } from '@atlaskit/editor-common/analytics';
+import type { Command, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { FindRootParentListNode } from '@atlaskit/editor-plugin-list';
+import type { InsertMediaAsMediaSingle } from '@atlaskit/editor-plugin-media/types';
+import type { Fragment, Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { PastePlugin } from '../index';
+type PasteContext = {
+    type: PasteType;
+    asPlain?: boolean;
+    /** Has the hyperlink been pasted while text is selected, making the text into a link? */
+    hyperlinkPasteOnText?: boolean;
+    /** Did this paste action split a list in half? */
+    pasteSplitList?: boolean;
+};
+type GetContentProps = {
+    schema: Schema;
+    slice: Slice;
+};
+export declare function getContent({ schema, slice }: GetContentProps): PasteContent;
+export declare function getMediaTraceId(slice: Slice): undefined;
+export declare function createPasteAnalyticsPayload(view: EditorView, event: ClipboardEvent, slice: Slice, pasteContext: PasteContext): AnalyticsEventPayload;
+export declare const sendPasteAnalyticsEvent: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, pasteContext: PasteContext) => void;
+export declare const handlePasteAsPlainTextWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handlePasteIntoTaskAndDecisionWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handlePasteIntoCaptionWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType) => Command;
+export declare const handleCodeBlockWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, text: string) => Command;
+export declare const handleMediaSingleWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType, insertMediaAsMediaSingle: InsertMediaAsMediaSingle | undefined) => Command;
+export declare const handlePastePreservingMarksWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handleMarkdownWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handleRichTextWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handlePastePanelOrDecisionIntoListWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, findRootParentListNode: FindRootParentListNode | undefined) => Command;
+export declare const handlePasteNonNestableBlockNodesIntoListWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handleExpandWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handleSelectedTableWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handlePasteLinkOnSelectedTextWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType) => Command;
+export declare const createPasteMeasurePayload: ({ view, duration, content, distortedDuration, }: {
+    view: EditorView;
+    duration: number;
+    content: Array<string>;
+    distortedDuration: boolean;
+}) => AnalyticsEventPayload;
+export declare const getContentNodeTypes: (content: Fragment) => string[];
+export {};

package/dist/types/pm-plugins/clipboard-text-serializer.d.ts

@@ -0,0 +1,13 @@
+import type { Slice } from '@atlaskit/editor-prosemirror/model';
+/**
+ * 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 declare function clipboardTextSerializer(slice: Slice): string;

package/dist/types/pm-plugins/main.d.ts

@@ -0,0 +1,12 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI, FeatureFlags } from '@atlaskit/editor-common/types';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { PastePlugin } from '../index';
+export { pluginKey as stateKey } from './plugin-factory';
+export declare const isInsideBlockQuote: (state: EditorState) => boolean;
+export declare function createPlugin(schema: Schema, dispatchAnalyticsEvent: DispatchAnalyticsEvent, dispatch: Dispatch, featureFlags: FeatureFlags, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined, cardOptions?: CardOptions, sanitizePrivateContent?: boolean, providerFactory?: ProviderFactory): SafePlugin<import("../types").PastePluginState>;

package/dist/types/pm-plugins/plugin-factory.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const pluginKey: PluginKey<any>;
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: import("..").PastePluginState | ((state: import("prosemirror-state").EditorState) => import("..").PastePluginState)) => import("prosemirror-state").SafeStateField<import("..").PastePluginState>, createCommand: <A = import("../actions").PastePluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState) => import("..").PastePluginState;

package/dist/types/reducer.d.ts

@@ -0,0 +1,3 @@
+import type { PastePluginAction as Action } from './actions';
+import type { PastePluginState as State } from './types';
+export declare const reducer: (state: State, action: Action) => State;

package/dist/types/util/index.d.ts

@@ -0,0 +1,21 @@
+import type { EditorAnalyticsAPI, PasteSource } from '@atlaskit/editor-common/analytics';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Mark, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function isPastedFromWord(html?: string): boolean;
+export declare function isPastedFromExcel(html?: string): boolean;
+export declare const isSingleLine: (text: string) => boolean;
+export declare function htmlContainsSingleFile(html: string): boolean;
+export declare function getPasteSource(event: ClipboardEvent): PasteSource;
+export declare function escapeLinks(text: string): string;
+export declare function hasOnlyNodesOfType(...nodeTypes: NodeType[]): (slice: Slice) => boolean;
+export declare function applyTextMarksToSlice(schema: Schema, marks?: readonly Mark[]): (slice: Slice) => Slice;
+export declare function isEmptyNode(node: PMNode | null | undefined): boolean | null;
+export declare function isCursorSelectionAtTextStartOrEnd(selection: Selection): boolean | null;
+export declare function isPanelNode(node: PMNode | null | undefined): boolean;
+export declare function isSelectionInsidePanel(selection: Selection): PMNode | null;
+export declare const htmlHasInvalidLinkTags: (html?: string) => boolean;
+export declare const removeDuplicateInvalidLinks: (html: string) => string;
+export declare const addReplaceSelectedTableAnalytics: (state: EditorState, tr: Transaction, editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Transaction;
+export declare const transformUnsupportedBlockCardToInline: (slice: Slice, state: EditorState, cardOptions?: CardOptions) => Slice;