@titaui/pc 1.16.22 → 1.16.25-beta.1

package/lib/components/rich-editor/plugins/block/lists/pm-plugins/input-rule.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInputRule = createInputRule;
+exports["default"] = inputRulePlugin;
+exports.insertList = void 0;
+
+var _prosemirrorInputrules = require("prosemirror-inputrules");
+
+var _analytics = require("../../../analytics");
+
+var _inputRules = require("../../../utils/input-rules");
+
+var _analytics2 = require("../../analytics");
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function createInputRule(regexp, nodeType) {
+  return (0, _prosemirrorInputrules.wrappingInputRule)(regexp, nodeType, {}, function (_, node) {
+    return node.type === nodeType;
+  });
+}
+
+var insertList = function insertList(state, listType, listTypeName, start, end) {
+  // To ensure that match is done after HardBreak.
+  var hardBreak = state.schema.nodes.hardBreak;
+
+  if (state.doc.resolve(start).nodeAfter.type !== hardBreak) {
+    return null;
+  } // To ensure no nesting is done.
+
+
+  if (state.doc.resolve(start).depth > 1) {
+    return null;
+  } // Track event
+
+
+  _analytics.analyticsService.trackEvent("atlassian.editor.format.list.".concat(listTypeName, ".autoformatting")); // Split at the start of autoformatting and delete formatting characters.
+
+
+  var tr = state.tr["delete"](start, end).split(start); // If node has more content split at the end of autoformatting.
+
+  var currentNode = tr.doc.nodeAt(start + 1);
+  tr.doc.nodesBetween(start, start + currentNode.nodeSize, function (node, pos) {
+    if (node.type === hardBreak) {
+      tr = tr.split(pos + 1)["delete"](pos, pos + 1);
+    }
+  }); // Wrap content in list node
+
+  var listItem = state.schema.nodes.listItem;
+  var position = tr.doc.resolve(start + 2);
+  var range = position.blockRange(position);
+  tr = tr.wrap(range, [{
+    type: listType
+  }, {
+    type: listItem
+  }]);
+  return tr;
+};
+/**
+ * Create input rules for bullet list node
+ *
+ * @param {Schema} schema
+ * @returns {InputRule[]}
+ */
+
+
+exports.insertList = insertList;
+
+function getBulletListInputRules(schema) {
+  var ruleWithBulletListAnalytics = (0, _analytics2.ruleWithAnalytics)(function () {
+    return {
+      action: _analytics2.ACTION.FORMATTED,
+      actionSubject: _analytics2.ACTION_SUBJECT.TEXT,
+      actionSubjectId: _analytics2.ACTION_SUBJECT_ID.FORMAT_LIST_BULLET,
+      eventType: _analytics2.EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: _analytics2.INPUT_METHOD.FORMATTING
+      }
+    };
+  }); // NOTE: we decided to restrict the creation of bullet lists to only "*"x
+
+  var asteriskRule = (0, _inputRules.defaultInputRuleHandler)(createInputRule(/^\s*([\*\-]) $/, schema.nodes.bulletList), true);
+  asteriskRule.handler = (0, _analytics.trackAndInvoke)('atlassian.editor.format.list.bullet.autoformatting', asteriskRule.handler);
+  var leafNodeAsteriskRule = (0, _inputRules.createInputRule)(new RegExp("".concat(_inputRules.leafNodeReplacementCharacter, "\\s*([\\*\\-]) $")), function (state, _match, start, end) {
+    return insertList(state, schema.nodes.bulletList, 'bullet', start, end);
+  }, true);
+  return [ruleWithBulletListAnalytics(asteriskRule), ruleWithBulletListAnalytics(leafNodeAsteriskRule)];
+}
+/**
+ * Create input rules for strong mark
+ *
+ * @param {Schema} schema
+ * @returns {InputRule[]}
+ */
+
+
+function getOrderedListInputRules(schema) {
+  var ruleWithOrderedListAnalytics = (0, _analytics2.ruleWithAnalytics)(function () {
+    return {
+      action: _analytics2.ACTION.FORMATTED,
+      actionSubject: _analytics2.ACTION_SUBJECT.TEXT,
+      actionSubjectId: _analytics2.ACTION_SUBJECT_ID.FORMAT_LIST_NUMBER,
+      eventType: _analytics2.EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod: _analytics2.INPUT_METHOD.FORMATTING
+      }
+    };
+  }); // NOTE: There is a built in input rule for ordered lists in ProseMirror. However, that
+  // input rule will allow for a list to start at any given number, which isn't allowed in
+  // markdown (where a ordered list will always start on 1). This is a slightly modified
+  // version of that input rule.
+
+  var numberOneRule = (0, _inputRules.defaultInputRuleHandler)(createInputRule(/^(1)[\.\)] $/, schema.nodes.orderedList), true);
+  numberOneRule.handler = (0, _analytics.trackAndInvoke)('atlassian.editor.format.list.numbered.autoformatting', numberOneRule.handler);
+  var leafNodeNumberOneRule = (0, _inputRules.createInputRule)(new RegExp("".concat(_inputRules.leafNodeReplacementCharacter, "(1)[\\.\\)] $")), function (state, _match, start, end) {
+    return insertList(state, schema.nodes.orderedList, 'numbered', start, end);
+  }, true);
+  return [ruleWithOrderedListAnalytics(numberOneRule), ruleWithOrderedListAnalytics(leafNodeNumberOneRule)];
+}
+
+function inputRulePlugin(schema) {
+  var rules = [];
+
+  if (schema.nodes.bulletList) {
+    rules.push.apply(rules, _toConsumableArray(getBulletListInputRules(schema)));
+  }
+
+  if (schema.nodes.orderedList) {
+    rules.push.apply(rules, _toConsumableArray(getOrderedListInputRules(schema)));
+  }
+
+  if (rules.length !== 0) {
+    return (0, _prosemirrorInputrules.inputRules)({
+      rules: rules
+    });
+  }
+
+  return;
+}

package/lib/components/rich-editor/plugins/block/lists/pm-plugins/keymap.js

@@ -0,0 +1,33 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.keymapPlugin = keymapPlugin;
+
+var _prosemirrorKeymap = require("prosemirror-keymap");
+
+var keymaps = _interopRequireWildcard(require("../../../../keymaps"));
+
+var _commond = require("../commond");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function keymapPlugin() {
+  var list = {};
+  keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.toggleOrderedList), (0, _commond.toggleList)('orderedList'), list);
+  keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.toggleBulletList), (0, _commond.toggleList)('bulletList'), list);
+  keymaps.bindKeymapWithCommand(keymaps.indentList.common, (0, _commond.indentList)(), list);
+  keymaps.bindKeymapWithCommand(keymaps.outdentList.common, (0, _commond.outdentList)(), list);
+  keymaps.bindKeymapWithCommand(keymaps.enter.common, _commond.enterKeyCommand, list);
+  keymaps.bindKeymapWithCommand(keymaps.backspace.common, _commond.backspaceKeyCommand, list);
+  return (0, _prosemirrorKeymap.keymap)(list);
+}
+
+var _default = keymapPlugin;
+exports["default"] = _default;

package/lib/components/rich-editor/plugins/block/lists/pm-plugins/main.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginKey = exports["default"] = exports.PmListPlugin = void 0;
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _utils = require("../utils");
+
+var _mark = require("../../../../utils/mark");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var pluginKey = new _prosemirrorState.PluginKey('listsPlugin');
+exports.pluginKey = pluginKey;
+
+var PmListPlugin = function PmListPlugin(dispatch) {
+  return new _prosemirrorState.Plugin({
+    state: {
+      init: function init() {
+        return {
+          bulletListActive: false,
+          bulletListDisabled: false,
+          orderedListActive: false,
+          orderedListDisabled: false
+        };
+      },
+      apply: function apply(tr, pluginState, _, state) {
+        var _state$schema$nodes = state.schema.nodes,
+            bulletList = _state$schema$nodes.bulletList,
+            orderedList = _state$schema$nodes.orderedList;
+        var listParent = (0, _prosemirrorUtils.findParentNodeOfType)([bulletList, orderedList])(tr.selection);
+        var bulletListActive = !!listParent && listParent.node.type === bulletList;
+        var orderedListActive = !!listParent && listParent.node.type === orderedList;
+        var bulletListDisabled = !(bulletListActive || orderedListActive || (0, _utils.isWrappingPossible)(bulletList, state));
+        var orderedListDisabled = !(bulletListActive || orderedListActive || (0, _utils.isWrappingPossible)(orderedList, state));
+
+        if (bulletListActive !== pluginState.bulletListActive || orderedListActive !== pluginState.orderedListActive || bulletListDisabled !== pluginState.bulletListDisabled || orderedListDisabled !== pluginState.orderedListDisabled) {
+          var nextPluginState = _objectSpread(_objectSpread({}, pluginState), {}, {
+            bulletListActive: bulletListActive,
+            orderedListActive: orderedListActive,
+            bulletListDisabled: bulletListDisabled,
+            orderedListDisabled: orderedListDisabled
+          });
+
+          dispatch(pluginKey, nextPluginState);
+          return nextPluginState;
+        }
+
+        return pluginState;
+      }
+    },
+    view: function view() {
+      return {
+        update: function update(_ref) {
+          var state = _ref.state,
+              dispatch = _ref.dispatch;
+          var _state$schema$nodes2 = state.schema.nodes,
+              bulletList = _state$schema$nodes2.bulletList,
+              orderedList = _state$schema$nodes2.orderedList;
+          var _state$schema$marks = state.schema.marks,
+              alignment = _state$schema$marks.alignment,
+              indentation = _state$schema$marks.indentation;
+          var listParent = (0, _prosemirrorUtils.findParentNodeOfType)([bulletList, orderedList])(state.tr.selection);
+
+          if (!listParent) {
+            return;
+          }
+          /** Block mark if exists should be removed when toggled to list items */
+
+
+          var removeMarks = (0, _mark.removeBlockMarks)(state, [alignment, indentation]);
+
+          if (removeMarks) {
+            dispatch(removeMarks);
+          }
+        }
+      };
+    },
+    key: pluginKey
+  });
+};
+
+exports.PmListPlugin = PmListPlugin;
+var _default = PmListPlugin;
+exports["default"] = _default;

package/lib/components/rich-editor/plugins/block/lists/styles.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listsStyles = void 0;
+
+var _styledComponents = require("styled-components");
+
+var _templateObject;
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+var listsStyles = (0, _styledComponents.css)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  .ProseMirror li {\n    position: relative;\n\n    > p:not(:first-child) {\n      margin: 4px 0 0 0;\n    }\n  }\n\n  /* Make sure li selections wrap around markers */\n  li.ProseMirror-selectednode {\n    outline: none;\n  }\n\n  li.ProseMirror-selectednode::after {\n    content: '';\n    position: absolute;\n    left: -32px;\n    right: -2px;\n    top: -2px;\n    bottom: -2px;\n    border: 2px solid #8cf;\n    pointer-events: none;\n  }\n"])));
+exports.listsStyles = listsStyles;

package/lib/components/rich-editor/plugins/block/lists/transforms.js

@@ -0,0 +1,347 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.liftFollowingList = liftFollowingList;
+exports.liftSelectionList = liftSelectionList;
+exports.upgradeTextToLists = exports.splitParagraphs = void 0;
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var _prosemirrorCommands = require("prosemirror-commands");
+
+var _node = require("./utils/node");
+
+var _slice = require("../../../utils/slice");
+
+var _indentation = require("./utils/indentation");
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function liftListItem(selection, tr) {
+  var $from = selection.$from,
+      $to = selection.$to;
+  var nodeType = tr.doc.type.schema.nodes.listItem;
+  var range = $from.blockRange($to, function (node) {
+    return !!node.childCount && !!node.firstChild && node.firstChild.type === nodeType;
+  });
+
+  if (!range || range.depth < 2 || $from.node(range.depth - 1).type !== nodeType) {
+    return tr;
+  }
+
+  var end = range.end;
+  var endOfList = $to.end(range.depth);
+
+  if (end < endOfList) {
+    tr.step(new _prosemirrorTransform.ReplaceAroundStep(end - 1, endOfList, end, endOfList, new _prosemirrorModel.Slice(_prosemirrorModel.Fragment.from(nodeType.create(undefined, range.parent.copy())), 1, 0), 1, true));
+    range = new _prosemirrorModel.NodeRange(tr.doc.resolve($from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+
+  return tr.lift(range, (0, _prosemirrorTransform.liftTarget)(range)).scrollIntoView();
+} // Function will lift list item following selection to level-1.
+
+
+function liftFollowingList(from, to, rootListDepth, tr) {
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var lifted = false;
+  tr.doc.nodesBetween(from, to, function (node, pos) {
+    if (!lifted && node.type === listItem && pos > from) {
+      lifted = true;
+      var listDepth = rootListDepth + 3;
+
+      while (listDepth > rootListDepth + 2) {
+        var start = tr.doc.resolve(tr.mapping.map(pos));
+        listDepth = start.depth;
+        var end = tr.doc.resolve(tr.mapping.map(pos + node.textContent.length));
+        var sel = new _prosemirrorState.TextSelection(start, end);
+        tr = liftListItem(sel, tr);
+      }
+    }
+  });
+  return tr;
+} // The function will list paragraphs in selection out to level 1 below root list.
+
+
+function liftSelectionList(selection, tr) {
+  var from = selection.from,
+      to = selection.to;
+  var paragraph = tr.doc.type.schema.nodes.paragraph;
+  var listCol = [];
+  tr.doc.nodesBetween(from, to, function (node, pos) {
+    if (node.type === paragraph) {
+      listCol.push({
+        node: node,
+        pos: pos
+      });
+    }
+  });
+
+  for (var i = listCol.length - 1; i >= 0; i--) {
+    var _paragraph = listCol[i];
+    var start = tr.doc.resolve(tr.mapping.map(_paragraph.pos));
+
+    if (start.depth > 0) {
+      var end = void 0;
+
+      if (_paragraph.node.textContent && _paragraph.node.textContent.length > 0) {
+        end = tr.doc.resolve(tr.mapping.map(_paragraph.pos + _paragraph.node.textContent.length));
+      } else {
+        end = tr.doc.resolve(tr.mapping.map(_paragraph.pos + 1));
+      }
+
+      var range = start.blockRange(end);
+
+      if (range) {
+        tr.lift(range, (0, _indentation.getListLiftTarget)(start));
+      }
+    }
+  }
+
+  return tr;
+} // 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 = (0, _slice.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(_prosemirrorModel.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 = _prosemirrorState.EditorState.create({
+    schema: schema
+  });
+
+  var joinedListsTr;
+
+  var mockDispatch = function mockDispatch(tr) {
+    joinedListsTr = tr;
+  };
+
+  (0, _prosemirrorCommands.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 (0, _node.isListNode)(before) && (0, _node.isListNode)(after);
+  })(mockState, mockDispatch);
+  var fragment = joinedListsTr ? joinedListsTr.doc.content : _prosemirrorModel.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 _prosemirrorModel.Fragment.from(paragraph.create(node.attrs, fragment, node.marks));
+  } // fragment now contains other nodes, get Prosemirror to wrap with ContentMatch later
+
+
+  return fragment;
+};
+/**
+ * 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.
+ */
+
+
+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) {
+    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 _prosemirrorModel.Fragment.from(paragraphs.length ? paragraphs : [paragraph.createAndFill(undefined, undefined, _toConsumableArray(blockMarks))]);
+};
+
+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 _prosemirrorModel.Slice(replSlice, slice.openStart + 1, slice.openEnd + 1);
+  }
+
+  return (0, _slice.mapSlice)(slice, function (node) {
+    if (node.type === schema.nodes.paragraph) {
+      return splitIntoParagraphs({
+        fragment: node.content,
+        blockMarks: node.marks,
+        schema: schema
+      });
+    }
+
+    return node;
+  });
+}; // above will wrap everything in paragraphs for us
+
+
+exports.splitParagraphs = splitParagraphs;
+
+var upgradeTextToLists = function upgradeTextToLists(slice, schema) {
+  return (0, _slice.mapSlice)(slice, function (node, parent) {
+    if (node.type === schema.nodes.paragraph) {
+      return extractListFromParagraph(node, parent, schema);
+    }
+
+    return node;
+  });
+};
+
+exports.upgradeTextToLists = upgradeTextToLists;