@atlaskit/editor-plugin-paste 0.1.22 → 0.2.0

package/dist/cjs/util/index.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addReplaceSelectedTableAnalytics = void 0;
+exports.applyTextMarksToSlice = applyTextMarksToSlice;
+exports.escapeLinks = escapeLinks;
+exports.getPasteSource = getPasteSource;
+exports.hasOnlyNodesOfType = hasOnlyNodesOfType;
+exports.htmlContainsSingleFile = htmlContainsSingleFile;
+exports.htmlHasInvalidLinkTags = void 0;
+exports.isCursorSelectionAtTextStartOrEnd = isCursorSelectionAtTextStartOrEnd;
+exports.isEmptyNode = isEmptyNode;
+exports.isPanelNode = isPanelNode;
+exports.isPastedFromExcel = isPastedFromExcel;
+exports.isPastedFromWord = isPastedFromWord;
+exports.isSelectionInsidePanel = isSelectionInsidePanel;
+exports.transformUnsupportedBlockCardToInline = exports.removeDuplicateInvalidLinks = exports.isSingleLine = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _legacyRankPlugins = require("@atlaskit/editor-common/legacy-rank-plugins");
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _utils3 = require("@atlaskit/editor-tables/utils");
+var _mediaClient = require("@atlaskit/media-client");
+function isPastedFromWord(html) {
+  return !!html && html.indexOf('urn:schemas-microsoft-com:office:word') >= 0;
+}
+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;
+}
+var isSingleLine = exports.isSingleLine = function isSingleLine(text) {
+  return !!text && text.trim().split('\n').length === 1;
+};
+function htmlContainsSingleFile(html) {
+  return !!html.match(/<img .*>/) && !(0, _mediaClient.isMediaBlobUrl)(html);
+}
+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
+function escapeLinks(text) {
+  return text.replace(/(\[([^\]]+)\]\()?((https?|ftp|jamfselfservice):\/\/[^\s"'>]+)/g, function (str) {
+    return str.match(/^(https?|ftp|jamfselfservice):\/\/[^\s"'>]+$/) ? "<".concat(str, ">") : str;
+  });
+}
+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;
+  };
+}
+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 = _model.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((0, _toConsumableArray2.default)(node.marks && !codeMark.isInSet(marks) && node.marks.filter(function (mark) {
+          return allowedMarksToPaste.includes(mark.type);
+        }) || []), (0, _toConsumableArray2.default)(parent.type.allowedMarks(marks).filter(function (mark) {
+          return mark.type !== linkMark;
+        }))).sort((0, _legacyRankPlugins.sortByOrderWithTypeName)('marks'));
+        return false;
+      }
+      return true;
+    });
+    return sliceCopy;
+  };
+}
+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) && _model.Mark.sameSet(emptyNode.marks, node.marks);
+}
+function isCursorSelectionAtTextStartOrEnd(selection) {
+  return selection instanceof _state.TextSelection && selection.empty && selection.$cursor && (!selection.$cursor.nodeBefore || !selection.$cursor.nodeAfter);
+}
+function isPanelNode(node) {
+  return Boolean(node && node.type.name === 'panel');
+}
+function isSelectionInsidePanel(selection) {
+  if (selection instanceof _state.NodeSelection && isPanelNode(selection.node)) {
+    return selection.node;
+  }
+  var panel = selection.$from.doc.type.schema.nodes.panel;
+  var panelPosition = (0, _utils2.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
+var htmlHasInvalidLinkTags = exports.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>">
+var removeDuplicateInvalidLinks = exports.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;
+};
+var addReplaceSelectedTableAnalytics = exports.addReplaceSelectedTableAnalytics = function addReplaceSelectedTableAnalytics(state, tr, editorAnalyticsAPI) {
+  if ((0, _utils3.isTableSelected)(state.selection)) {
+    var _getSelectedTableInfo = (0, _utils3.getSelectedTableInfo)(state.selection),
+      totalRowCount = _getSelectedTableInfo.totalRowCount,
+      totalColumnCount = _getSelectedTableInfo.totalColumnCount;
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+      action: _analytics.TABLE_ACTION.REPLACED,
+      actionSubject: _analytics.ACTION_SUBJECT.TABLE,
+      attributes: {
+        totalColumnCount: totalColumnCount,
+        totalRowCount: totalRowCount,
+        inputMethod: _analytics.INPUT_METHOD.CLIPBOARD
+      },
+      eventType: _analytics.EVENT_TYPE.TRACK
+    })(tr);
+    return tr;
+  }
+  return state.tr;
+};
+var transformUnsupportedBlockCardToInline = exports.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 = [];
+  (0, _utils.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 _model.Slice(_model.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 && (0, _utils.isSupportedInParent)(state, frag);
+};

package/dist/cjs/util/tinyMCE.js

@@ -0,0 +1,183 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapWithTable = exports.tryReconstructTableRows = exports.tryRebuildCompleteTableHtml = exports.isPastedFromTinyMCEConfluence = exports.htmlHasIncompleteTable = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _chunk = _interopRequireDefault(require("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;
+};
+var isPastedFromTinyMCEConfluence = exports.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.
+ */
+var wrapWithTable = exports.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 = (0, _chunk.default)(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, (0, _toConsumableArray2.default)(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, (0, _toConsumableArray2.default)(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.
+ */
+var tryReconstructTableRows = exports.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;
+};
+var htmlHasIncompleteTable = exports.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).
+ */
+var tryRebuildCompleteTableHtml = exports.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/es2019/actions.js

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

package/dist/es2019/commands.js

@@ -0,0 +1,236 @@
+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 const startTrackingPastedMacroPositions = pastedMacroPositions => createCommand(() => {
+  return {
+    type: ActionTypes.START_TRACKING_PASTED_MACRO_POSITIONS,
+    pastedMacroPositions
+  };
+});
+export const stopTrackingPastedMacroPositions = pastedMacroPositionKeys => createCommand(() => {
+  return {
+    type: ActionTypes.STOP_TRACKING_PASTED_MACRO_POSITIONS,
+    pastedMacroPositionKeys
+  };
+});
+
+// matchers for text lists
+const bullets = /^\s*[\*\-\u2022](\s+|\s+$)/;
+const numbers = /^\s*\d[\.\)](\s+|$)/;
+const getListType = (node, schema) => {
+  if (!node.text) {
+    return null;
+  }
+  const {
+    bulletList,
+    orderedList
+  } = schema.nodes;
+  return [{
+    node: bulletList,
+    matcher: bullets
+  }, {
+    node: orderedList,
+    matcher: numbers
+  }].reduce((lastMatch, listType) => {
+    if (lastMatch) {
+      return lastMatch;
+    }
+    const match = node.text.match(listType.matcher);
+    return match ? [listType.node, match[0].length] : lastMatch;
+  }, null);
+};
+const extractListFromParagraph = (node, parent, schema) => {
+  const {
+    hardBreak,
+    bulletList,
+    orderedList
+  } = schema.nodes;
+  const content = mapChildren(node.content, node => node);
+  const listTypes = [bulletList, orderedList];
+
+  // wrap each line into a listItem and a containing list
+  const listified = content.map((child, index) => {
+    const listMatch = getListType(child, schema);
+    const 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;
+    }
+    const [nodeType, length] = listMatch;
+
+    // convert to list item
+    const newText = child.text.substr(length);
+    const listItemNode = schema.nodes.listItem.createAndFill(undefined, schema.nodes.paragraph.createChecked(undefined, newText.length ? schema.text(newText) : undefined));
+    if (!listItemNode) {
+      return child;
+    }
+    const 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((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
+  const mockState = EditorState.create({
+    schema
+  });
+  let joinedListsTr;
+  const mockDispatch = tr => {
+    joinedListsTr = tr;
+  };
+  autoJoin((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
+    const containsList = listified.some(node => node.type === bulletList || node.type === orderedList);
+    if (listified.some(node => node.isText) && !containsList) {
+      return false;
+    }
+    dispatch(state.tr.replaceWith(0, 2, listified));
+    return true;
+  }, (before, after) => isListNode(before) && isListNode(after))(mockState, mockDispatch);
+  const fragment = joinedListsTr ? joinedListsTr.doc.content : Fragment.from(listified);
+
+  // try to re-wrap fragment in paragraph (which is the original node we unwrapped)
+  const {
+    paragraph
+  } = schema.nodes;
+  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 const upgradeTextToLists = (slice, schema) => {
+  return mapSlice(slice, (node, parent) => {
+    if (node.type === schema.nodes.paragraph) {
+      return extractListFromParagraph(node, parent, schema);
+    }
+    return node;
+  });
+};
+export const splitParagraphs = (slice, schema) => {
+  // exclude Text nodes with a code mark, since we transform those later
+  // into a codeblock
+  let hasCodeMark = false;
+  slice.content.forEach(child => {
+    hasCodeMark = hasCodeMark || child.marks.some(mark => mark.type === schema.marks.code);
+  });
+
+  // slice might just be a raw text string
+  if (schema.nodes.paragraph.validContent(slice.content) && !hasCodeMark) {
+    const replSlice = splitIntoParagraphs({
+      fragment: slice.content,
+      schema
+    });
+    return new Slice(replSlice, slice.openStart + 1, slice.openEnd + 1);
+  }
+  return mapSlice(slice, node => {
+    if (node.type === schema.nodes.paragraph) {
+      return splitIntoParagraphs({
+        fragment: node.content,
+        blockMarks: node.marks,
+        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 const splitIntoParagraphs = ({
+  fragment,
+  blockMarks = [],
+  schema
+}) => {
+  const paragraphs = [];
+  let curChildren = [];
+  let lastNode = null;
+  const {
+    hardBreak,
+    paragraph
+  } = schema.nodes;
+  fragment.forEach((node, i) => {
+    const 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, [...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, [...blockMarks]));
+      curChildren = [];
+      return;
+    }
+
+    // add to this paragraph
+    curChildren.push(node);
+    lastNode = node;
+  });
+  if (curChildren.length) {
+    paragraphs.push(paragraph.createChecked(undefined, curChildren, [...blockMarks]));
+  }
+  return Fragment.from(paragraphs.length ? paragraphs : [paragraph.createAndFill(undefined, undefined, [...blockMarks])]);
+};