@atlaskit/editor-plugin-paste 0.1.22 → 0.2.0

package/dist/es2019/util/index.js

@@ -0,0 +1,209 @@
+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 const isSingleLine = text => {
+  return !!text && text.trim().split('\n').length === 1;
+};
+export function htmlContainsSingleFile(html) {
+  return !!html.match(/<img .*>/) && !isMediaBlobUrl(html);
+}
+export function getPasteSource(event) {
+  const 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, str => {
+    return str.match(/^(https?|ftp|jamfselfservice):\/\/[^\s"'>]+$/) ? `<${str}>` : str;
+  });
+}
+export function hasOnlyNodesOfType(...nodeTypes) {
+  return slice => {
+    let hasOnlyNodesOfType = true;
+    slice.content.descendants(node => {
+      hasOnlyNodesOfType = hasOnlyNodesOfType && nodeTypes.indexOf(node.type) > -1;
+      return hasOnlyNodesOfType;
+    });
+    return hasOnlyNodesOfType;
+  };
+}
+export function applyTextMarksToSlice(schema, marks) {
+  return slice => {
+    const {
+      marks: {
+        code: codeMark,
+        link: linkMark,
+        annotation: annotationMark
+      }
+    } = schema;
+    if (!Array.isArray(marks) || marks.length === 0) {
+      return slice;
+    }
+    const sliceCopy = Slice.fromJSON(schema, slice.toJSON() || {});
+
+    // allow links and annotations to be pasted
+    const allowedMarksToPaste = [linkMark, annotationMark];
+    sliceCopy.content.descendants((node, _pos, parent) => {
+      if (node.isText && parent && parent.isBlock) {
+        // @ts-ignore - [unblock prosemirror bump] assigning to readonly prop
+        node.marks = [
+        // remove all marks from pasted slice when applying code mark
+        // and exclude all marks that are not allowed to be pasted
+        ...(node.marks && !codeMark.isInSet(marks) && node.marks.filter(mark => allowedMarksToPaste.includes(mark.type)) || []),
+        // add marks to a slice if they're allowed in parent node
+        // and exclude link marks
+        ...parent.type.allowedMarks(marks).filter(mark => mark.type !== linkMark)].sort(sortByOrderWithTypeName('marks'));
+        return false;
+      }
+      return true;
+    });
+    return sliceCopy;
+  };
+}
+export function isEmptyNode(node) {
+  if (!node) {
+    return false;
+  }
+  const {
+    type: nodeType
+  } = node;
+  const 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;
+  }
+  const {
+    doc: {
+      type: {
+        schema: {
+          nodes: {
+            panel
+          }
+        }
+      }
+    }
+  } = selection.$from;
+  const 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 const 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 const removeDuplicateInvalidLinks = html => {
+  if (htmlHasInvalidLinkTags(html)) {
+    const htmlArray = html.split(/(?=<a)/);
+    const htmlArrayWithoutInvalidLinks = htmlArray.filter(item => {
+      return !(item.includes('<a') && item.includes('"></a>')) && !(item.includes('<a') && !item.includes('</a>'));
+    });
+    const fixedHtml = htmlArrayWithoutInvalidLinks.join('').replace(/<\/a><\/a>/gi, '</a>').replace(/<a>/gi, '<a');
+    return fixedHtml;
+  }
+  return html;
+};
+export const addReplaceSelectedTableAnalytics = (state, tr, editorAnalyticsAPI) => {
+  if (isTableSelected(state.selection)) {
+    const {
+      totalRowCount,
+      totalColumnCount
+    } = getSelectedTableInfo(state.selection);
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+      action: TABLE_ACTION.REPLACED,
+      actionSubject: ACTION_SUBJECT.TABLE,
+      attributes: {
+        totalColumnCount,
+        totalRowCount,
+        inputMethod: INPUT_METHOD.CLIPBOARD
+      },
+      eventType: EVENT_TYPE.TRACK
+    })(tr);
+    return tr;
+  }
+  return state.tr;
+};
+export const transformUnsupportedBlockCardToInline = (slice, state, cardOptions) => {
+  const {
+    blockCard,
+    inlineCard
+  } = state.schema.nodes;
+  const children = [];
+  mapChildren(slice.content, (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
+ */
+const isBlockCardSupported = (state, frag, allowBlockCards) => {
+  return allowBlockCards && isSupportedInParent(state, frag);
+};

package/dist/es2019/util/tinyMCE.js

@@ -0,0 +1,168 @@
+import chunk from 'lodash/chunk';
+const isPastedFromTinyMCE = pasteEvent => {
+  var _pasteEvent$clipboard, _pasteEvent$clipboard2, _pasteEvent$clipboard3;
+  return (_pasteEvent$clipboard = pasteEvent === null || pasteEvent === void 0 ? void 0 : (_pasteEvent$clipboard2 = pasteEvent.clipboardData) === null || _pasteEvent$clipboard2 === void 0 ? void 0 : (_pasteEvent$clipboard3 = _pasteEvent$clipboard2.types) === null || _pasteEvent$clipboard3 === void 0 ? void 0 : _pasteEvent$clipboard3.some(mimeType => mimeType === 'x-tinymce/html')) !== null && _pasteEvent$clipboard !== void 0 ? _pasteEvent$clipboard : false;
+};
+export const 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 const wrapWithTable = html => {
+  const parser = new DOMParser();
+  const nonTableWrappedDoc = parser.parseFromString(html, 'text/html');
+  const tableWrappedDoc = parser.parseFromString(`<table>${html}</table>`, 'text/html');
+  tableWrappedDoc.body.querySelectorAll('meta').forEach(meta => {
+    tableWrappedDoc.head.prepend(meta);
+  });
+  return {
+    tableWrappedDoc,
+    nonTableWrappedDoc
+  };
+};
+const exactlyDivisible = (larger, smaller) => larger % smaller === 0;
+const getTableElementsInfo = doc => {
+  const cellCount = doc.querySelectorAll('td').length;
+  const thCount = doc.querySelectorAll('th').length;
+  const mergedCellCount = doc.querySelectorAll('td[colspan]:not([colspan="1"])').length;
+  let hasThAfterTd = false;
+  const thsAndCells = doc.querySelectorAll('th,td');
+  for (let i = 0, cellFound = false; i < thsAndCells.length; i++) {
+    if (cellFound && thsAndCells[i].nodeName === 'TH') {
+      hasThAfterTd = true;
+      break;
+    }
+    if (thsAndCells[i].nodeName === 'TD') {
+      cellFound = true;
+    }
+  }
+  const onlyTh = thCount > 0 && cellCount === 0;
+  const onlyCells = cellCount > 0 && thCount === 0;
+  const 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,
+    thCount,
+    mergedCellCount,
+    hasThAfterTd,
+    hasIncompleteRow: !hasCompleteRow
+  };
+};
+const configureTableRows = (doc, colsInRow) => {
+  var _Array$from;
+  const tableHeadersAndCells = Array.from(doc.body.querySelectorAll('th,td'));
+  const evenlySplitChunks = chunk(tableHeadersAndCells, colsInRow);
+  const tableBody = doc.body.querySelector('tbody');
+  evenlySplitChunks.forEach(chunk => {
+    const tr = doc.createElement('tr');
+    tableBody === null || tableBody === void 0 ? void 0 : tableBody.append(tr);
+    tr.append(...chunk);
+  });
+  // We remove any leftover empty rows which may cause fabric editor
+  // to no-op when parsing the table
+  const emptyRows = (_Array$from = Array.from(tableBody.querySelectorAll('tr'))) === null || _Array$from === void 0 ? void 0 : _Array$from.filter(row => row.innerHTML.trim().length === 0);
+  emptyRows.forEach(row => row.remove());
+  return doc.body.innerHTML;
+};
+const fillIncompleteRowWithEmptyCells = (doc, thCount, cellCount) => {
+  var _lastCell$parentEleme;
+  let extraCellsCount = 0;
+  while (!exactlyDivisible(cellCount + extraCellsCount, thCount)) {
+    extraCellsCount++;
+  }
+  const extraEmptyCells = Array.from(Array(extraCellsCount)).map(() => doc.createElement('td'));
+  const lastCell = doc.body.querySelector('td:last-of-type');
+  lastCell === null || lastCell === void 0 ? void 0 : (_lastCell$parentEleme = lastCell.parentElement) === null || _lastCell$parentEleme === void 0 ? void 0 : _lastCell$parentEleme.append(...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 const tryReconstructTableRows = doc => {
+  let {
+    cellCount,
+    thCount,
+    mergedCellCount,
+    hasThAfterTd,
+    hasIncompleteRow
+  } = getTableElementsInfo(doc);
+  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
+    const {
+      updatedCellCount
+    } = fillIncompleteRowWithEmptyCells(doc, thCount, cellCount);
+    cellCount = updatedCellCount;
+  }
+  for (let possibleColsInRow = thCount; possibleColsInRow > 0; possibleColsInRow--) {
+    if (exactlyDivisible(thCount, possibleColsInRow) && exactlyDivisible(cellCount, possibleColsInRow)) {
+      return configureTableRows(doc, possibleColsInRow);
+    }
+  }
+  return doc.body.innerHTML;
+};
+export const 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 const 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.
+  const {
+    nonTableWrappedDoc,
+    tableWrappedDoc
+  } = wrapWithTable(incompleteTableHtml);
+  const didPreserveTableElements = Boolean(!nonTableWrappedDoc.body.querySelector('th, td') && tableWrappedDoc.body.querySelector('th, td'));
+  const 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) {
+    const completeTableHtml = tryReconstructTableRows(tableWrappedDoc);
+    return completeTableHtml;
+  }
+  return null;
+};

package/dist/esm/actions.js

@@ -0,0 +1,6 @@
+export var 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["ON_PASTE"] = "ON_PASTE";
+  return PastePluginActionTypes;
+}({});

package/dist/esm/commands.js

@@ -0,0 +1,249 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { isListNode, mapChildren, mapSlice } from '@atlaskit/editor-common/utils';
+import { autoJoin } from '@atlaskit/editor-prosemirror/commands';
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { PastePluginActionTypes as ActionTypes } from './actions';
+import { createCommand } from './pm-plugins/plugin-factory';
+
+/**
+ * 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 var startTrackingPastedMacroPositions = function startTrackingPastedMacroPositions(pastedMacroPositions) {
+  return createCommand(function () {
+    return {
+      type: ActionTypes.START_TRACKING_PASTED_MACRO_POSITIONS,
+      pastedMacroPositions: pastedMacroPositions
+    };
+  });
+};
+export var stopTrackingPastedMacroPositions = function stopTrackingPastedMacroPositions(pastedMacroPositionKeys) {
+  return createCommand(function () {
+    return {
+      type: ActionTypes.STOP_TRACKING_PASTED_MACRO_POSITIONS,
+      pastedMacroPositionKeys: pastedMacroPositionKeys
+    };
+  });
+};
+
+// matchers for text lists
+var bullets = /^\s*[\*\-\u2022](\s+|\s+$)/;
+var numbers = /^\s*\d[\.\)](\s+|$)/;
+var getListType = function getListType(node, schema) {
+  if (!node.text) {
+    return null;
+  }
+  var _schema$nodes = schema.nodes,
+    bulletList = _schema$nodes.bulletList,
+    orderedList = _schema$nodes.orderedList;
+  return [{
+    node: bulletList,
+    matcher: bullets
+  }, {
+    node: orderedList,
+    matcher: numbers
+  }].reduce(function (lastMatch, listType) {
+    if (lastMatch) {
+      return lastMatch;
+    }
+    var match = node.text.match(listType.matcher);
+    return match ? [listType.node, match[0].length] : lastMatch;
+  }, null);
+};
+var extractListFromParagraph = function extractListFromParagraph(node, parent, schema) {
+  var _schema$nodes2 = schema.nodes,
+    hardBreak = _schema$nodes2.hardBreak,
+    bulletList = _schema$nodes2.bulletList,
+    orderedList = _schema$nodes2.orderedList;
+  var content = mapChildren(node.content, function (node) {
+    return node;
+  });
+  var listTypes = [bulletList, orderedList];
+
+  // wrap each line into a listItem and a containing list
+  var listified = content.map(function (child, index) {
+    var listMatch = getListType(child, schema);
+    var prevChild = index > 0 && content[index - 1];
+
+    // only extract list when preceded by a hardbreak
+    if (prevChild && prevChild.type !== hardBreak) {
+      return child;
+    }
+    if (!listMatch || !child.text) {
+      return child;
+    }
+    var _listMatch = _slicedToArray(listMatch, 2),
+      nodeType = _listMatch[0],
+      length = _listMatch[1];
+
+    // convert to list item
+    var newText = child.text.substr(length);
+    var listItemNode = schema.nodes.listItem.createAndFill(undefined, schema.nodes.paragraph.createChecked(undefined, newText.length ? schema.text(newText) : undefined));
+    if (!listItemNode) {
+      return child;
+    }
+    var newList = nodeType.createChecked(undefined, [listItemNode]);
+    // Check whether our new list is valid content in our current structure,
+    // otherwise dont convert.
+    if (parent && !parent.type.validContent(Fragment.from(newList))) {
+      return child;
+    }
+    return newList;
+  }).filter(function (child, idx, arr) {
+    // remove hardBreaks that have a list node on either side
+
+    // wasn't hardBreak, leave as-is
+    if (child.type !== hardBreak) {
+      return child;
+    }
+    if (idx > 0 && listTypes.indexOf(arr[idx - 1].type) > -1) {
+      // list node on the left
+      return null;
+    }
+    if (idx < arr.length - 1 && listTypes.indexOf(arr[idx + 1].type) > -1) {
+      // list node on the right
+      return null;
+    }
+    return child;
+  });
+
+  // try to join
+  var mockState = EditorState.create({
+    schema: schema
+  });
+  var joinedListsTr;
+  var mockDispatch = function mockDispatch(tr) {
+    joinedListsTr = tr;
+  };
+  autoJoin(function (state, dispatch) {
+    if (!dispatch) {
+      return false;
+    }
+
+    // Return false to prevent replaceWith from wrapping the text node in a paragraph
+    // paragraph since that will be done later. If it's done here, it will fail
+    // the paragraph.validContent check.
+    // Dont return false if there are lists, as they arent validContent for paragraphs
+    // and will result in hanging textNodes
+    var containsList = listified.some(function (node) {
+      return node.type === bulletList || node.type === orderedList;
+    });
+    if (listified.some(function (node) {
+      return node.isText;
+    }) && !containsList) {
+      return false;
+    }
+    dispatch(state.tr.replaceWith(0, 2, listified));
+    return true;
+  }, function (before, after) {
+    return isListNode(before) && isListNode(after);
+  })(mockState, mockDispatch);
+  var fragment = joinedListsTr ? joinedListsTr.doc.content : Fragment.from(listified);
+
+  // try to re-wrap fragment in paragraph (which is the original node we unwrapped)
+  var paragraph = schema.nodes.paragraph;
+  if (paragraph.validContent(fragment)) {
+    return Fragment.from(paragraph.create(node.attrs, fragment, node.marks));
+  }
+
+  // fragment now contains other nodes, get Prosemirror to wrap with ContentMatch later
+  return fragment;
+};
+
+// above will wrap everything in paragraphs for us
+export var upgradeTextToLists = function upgradeTextToLists(slice, schema) {
+  return mapSlice(slice, function (node, parent) {
+    if (node.type === schema.nodes.paragraph) {
+      return extractListFromParagraph(node, parent, schema);
+    }
+    return node;
+  });
+};
+export var splitParagraphs = function splitParagraphs(slice, schema) {
+  // exclude Text nodes with a code mark, since we transform those later
+  // into a codeblock
+  var hasCodeMark = false;
+  slice.content.forEach(function (child) {
+    hasCodeMark = hasCodeMark || child.marks.some(function (mark) {
+      return mark.type === schema.marks.code;
+    });
+  });
+
+  // slice might just be a raw text string
+  if (schema.nodes.paragraph.validContent(slice.content) && !hasCodeMark) {
+    var replSlice = splitIntoParagraphs({
+      fragment: slice.content,
+      schema: schema
+    });
+    return new Slice(replSlice, slice.openStart + 1, slice.openEnd + 1);
+  }
+  return mapSlice(slice, function (node) {
+    if (node.type === schema.nodes.paragraph) {
+      return splitIntoParagraphs({
+        fragment: node.content,
+        blockMarks: node.marks,
+        schema: schema
+      });
+    }
+    return node;
+  });
+};
+
+/**
+ * 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 var splitIntoParagraphs = function splitIntoParagraphs(_ref) {
+  var fragment = _ref.fragment,
+    _ref$blockMarks = _ref.blockMarks,
+    blockMarks = _ref$blockMarks === void 0 ? [] : _ref$blockMarks,
+    schema = _ref.schema;
+  var paragraphs = [];
+  var curChildren = [];
+  var lastNode = null;
+  var _schema$nodes3 = schema.nodes,
+    hardBreak = _schema$nodes3.hardBreak,
+    paragraph = _schema$nodes3.paragraph;
+  fragment.forEach(function (node, i) {
+    var isNodeValidContentForParagraph = schema.nodes.paragraph.validContent(Fragment.from(node));
+    if (!isNodeValidContentForParagraph) {
+      paragraphs.push(node);
+      return;
+    }
+    // ED-14725 Fixed the issue that it make duplicated line
+    // when pasting <br /> from google docs.
+    if (i === 0 && node.type === hardBreak) {
+      paragraphs.push(paragraph.createChecked(undefined, curChildren, _toConsumableArray(blockMarks)));
+      lastNode = node;
+      return;
+    } else if (lastNode && lastNode.type === hardBreak && node.type === hardBreak) {
+      // double hardbreak
+
+      // backtrack a little; remove the trailing hardbreak we added last loop
+      curChildren.pop();
+
+      // create a new paragraph
+      paragraphs.push(paragraph.createChecked(undefined, curChildren, _toConsumableArray(blockMarks)));
+      curChildren = [];
+      return;
+    }
+
+    // add to this paragraph
+    curChildren.push(node);
+    lastNode = node;
+  });
+  if (curChildren.length) {
+    paragraphs.push(paragraph.createChecked(undefined, curChildren, _toConsumableArray(blockMarks)));
+  }
+  return Fragment.from(paragraphs.length ? paragraphs : [paragraph.createAndFill(undefined, undefined, _toConsumableArray(blockMarks))]);
+};