@titaui/pc 1.10.35 → 1.10.39

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

@@ -0,0 +1,302 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listBackspace = exports.calcJoinListScenario = void 0;
+
+var _commands = require("../../../../utils/commands");
+
+var _node = require("../utils/node");
+
+var _selection = require("../utils/selection");
+
+var _BACKSPACE_COMMANDS;
+
+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; }
+
+//Cases below refer to the cases found in this document: https://product-fabric.atlassian.net/wiki/spaces/E/pages/1146954996/List+Backspace+and+Delete+Behaviour
+//Case for two adjacent list items of the same indentation
+var listBackspaceCase2 = function listBackspaceCase2(tr, dispatch, $prev, $head) {
+  /* CASE 2
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |textInsertPos| }       //Cant have children since that would be Case 4
+   *   |$prev||childrenGInsertPos| }
+   *   ListItem E {
+   *     Paragraph F { |$head| text2 }
+   *     ...Children G
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph C { text1text2 }
+   *     ...Children G
+   *   }
+   * }
+   *
+   */
+  var listItemE = $head.node(-1); //Head is inside listItem E so it must have a first and last child
+
+  if (!listItemE.firstChild) {
+    return false;
+  }
+
+  var beforeListItemE = $head.before(-1);
+  var afterListItemE = $head.after(-1);
+  var textInsertPos = $prev.pos - 1; //Paragraph D must be directly behind $prev otherwise it would be case 4
+
+  var childrenGInsertPos = $prev.pos;
+  var textContent = $head.parent.content;
+  var childrenGContent = listItemE.content.cut(listItemE.firstChild.nodeSize);
+  (0, _commands.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, [[textContent, textInsertPos], [childrenGContent, childrenGInsertPos]], [[beforeListItemE, afterListItemE]]);
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return true;
+}; //Case for two adjacent list items with the first being of lower indentation
+
+
+var listBackspaceCase3 = function listBackspaceCase3(tr, dispatch, $prev, $head) {
+  /* CASE 3
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1 |$prev||textInsertPos| } |childrenHInsertPos|
+   *     List E { |childrenJInsertPos|
+   *       ListItem F {
+   *         Paragraph G { |$head| text2 }
+   *         ...Children H
+   *         List? I {
+   *           ...Children J
+   *         }
+   *       }
+   *       ...Children K
+   *     }
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     ...Children C
+   *     Paragraph D { text1text2 }
+   *     ...Children H
+   *     List E {
+   *       ...Children J
+   *       ...Children K
+   *     }
+   *   }
+   * }
+   *
+   */
+  var listE = $head.node(-2);
+  var listItemF = $head.node(-1); //Head is inside listItem F so it must have a first and last child
+
+  if (!listItemF.firstChild || !listItemF.lastChild) {
+    return false;
+  }
+
+  var beforeListE = $head.before(-2);
+  var beforeListItemF = $head.before(-1);
+  var afterParagraphD = $prev.after();
+  var afterListE = $head.after(-2);
+  var afterListItemF = $head.after(-1);
+  var startListE = $head.start(-2);
+  var containsChildrenJ = (0, _node.isListNode)(listItemF.lastChild);
+  var shouldRemoveListE = listE.childCount === 1 && !containsChildrenJ; //Assures no Children J and K
+
+  var textInsertPos = $prev.pos;
+  var childrenHInsertPos = afterParagraphD;
+  var childrenJInsertPos = startListE;
+  var textContent = $head.parent.content;
+  var childrenHContent = containsChildrenJ ? listItemF.content.cut(listItemF.firstChild.nodeSize, listItemF.nodeSize - listItemF.lastChild.nodeSize - 2) : listItemF.content.cut(listItemF.firstChild.nodeSize); //If Children J doesn't exist then Children H will include the last node
+
+  var childrenJContent = listItemF.lastChild.content; //Will be invalid if there are no Children J but it will be unused
+
+  (0, _commands.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, containsChildrenJ ? [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos], [childrenJContent, childrenJInsertPos]] : [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos]], [shouldRemoveListE ? [beforeListE, afterListE] : [beforeListItemF, afterListItemF]]);
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return true;
+}; //Case for two adjacent list items with the first being of greater indentation
+
+
+var listBackspaceCase4 = function listBackspaceCase4(tr, dispatch, $prev, $head, $last) {
+  /* CASE 4
+   * Initial Structure:
+   *
+   * List A {
+   *   ListItem B {
+   *     Paragraph C { text1 }
+   *     ...Children D
+   *     List E {
+   *       ...
+   *         List F {       //May be multiple levels of lists
+   *           ...Children G
+   *           ListItem H {        //Last node of the block
+   *             ...Children I
+   *             Paragraph J { text2 |$last||textInsertPos| } |childrenMInsertPos|        //Cant have children since this ListItem is the last of the block
+   *           }
+   *         }
+   *       ...
+   *     |childrenOInsertPosition| }
+   *   |$prev| }
+   *   ListItem K {
+   *      Paragraph L { |$head| text3 }
+   *      ...Children M
+   *      List? N {
+   *       ...Children O
+   *      }
+   *   }
+   * }
+   *
+   * Converts to:
+   *
+   * List A {
+   *   ListItem B {
+   *     Paragraph C { text1 }
+   *     ...Children D
+   *     List E {
+   *       ...
+   *         List F {
+   *           ...Children G
+   *           ListItem H {
+   *             ...Children I
+   *             Paragraph J { text2text3 }
+   *             ...Children M
+   *           }
+   *         }
+   *       ...
+   *       ...Children O
+   *     }
+   *   }
+   * }
+   *
+   */
+  if (!$last) {
+    //Exit if an invalid last was given as a parameter
+    return false;
+  }
+
+  var listItemK = $head.node(-1); //Head is inside listItem K so it must have a first and last child
+
+  if (!listItemK.firstChild || !listItemK.lastChild) {
+    return false;
+  }
+
+  var paragraphL = $head.parent;
+  var beforeListItemK = $head.before(-1);
+  var afterParagraphJ = $last.after();
+  var afterListItemK = $head.after(-1);
+  var containsChildrenO = (0, _node.isListNode)(listItemK.lastChild);
+  var textInsertPos = $last.pos;
+  var childrenMInsertPos = afterParagraphJ;
+  var childrenOInsertPos = $prev.pos - 1; //Last item of listItem B must be a list therefore we can simply decrement $prev to get there
+
+  var textContent = paragraphL.content;
+  var childrenMContent = containsChildrenO ? listItemK.content.cut(listItemK.firstChild.nodeSize, listItemK.nodeSize - listItemK.lastChild.nodeSize - 2) : listItemK.content.cut(listItemK.firstChild.nodeSize);
+  var childrenOContent = listItemK.lastChild.content;
+  (0, _commands.insertContentDeleteRange)(tr, function (tr) {
+    return tr.doc.resolve(textInsertPos);
+  }, containsChildrenO ? [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos], [childrenOContent, childrenOInsertPos]] : [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos]], [[beforeListItemK, afterListItemK]]);
+
+  if (dispatch) {
+    dispatch(tr);
+  }
+
+  return true;
+};
+
+var ScenariosAllowed;
+
+(function (ScenariosAllowed) {
+  ScenariosAllowed[ScenariosAllowed["JOIN_SIBLINGS"] = 0] = "JOIN_SIBLINGS";
+  ScenariosAllowed[ScenariosAllowed["JOIN_DESCENDANT_TO_PARENT"] = 1] = "JOIN_DESCENDANT_TO_PARENT";
+  ScenariosAllowed[ScenariosAllowed["JOIN_TO_SIBLING_DESCENDANT"] = 2] = "JOIN_TO_SIBLING_DESCENDANT";
+})(ScenariosAllowed || (ScenariosAllowed = {}));
+
+var BACKSPACE_COMMANDS = (_BACKSPACE_COMMANDS = {}, _defineProperty(_BACKSPACE_COMMANDS, ScenariosAllowed.JOIN_SIBLINGS, listBackspaceCase2), _defineProperty(_BACKSPACE_COMMANDS, ScenariosAllowed.JOIN_DESCENDANT_TO_PARENT, listBackspaceCase3), _defineProperty(_BACKSPACE_COMMANDS, ScenariosAllowed.JOIN_TO_SIBLING_DESCENDANT, listBackspaceCase4), _BACKSPACE_COMMANDS);
+
+var calcJoinListScenario = function calcJoinListScenario(walkNode, $head, tr) {
+  var $prev = walkNode.$pos,
+      prevFoundNode = walkNode.foundNode;
+  var prevInList = (0, _selection.isPosInsideList)($prev);
+  var headInParagraph = (0, _selection.isPosInsideParagraph)($head);
+  var headInFirstChild = $head.index(-1) === 0;
+  var headInList = (0, _selection.isPosInsideList)($head); //Must be at the start of the selection of the first child in the listItem
+
+  if (!prevFoundNode || !prevInList || !headInParagraph || !headInFirstChild || !headInList) {
+    return false;
+  }
+
+  var prevInParagraph = (0, _selection.isPosInsideParagraph)($prev);
+
+  if (prevInParagraph) {
+    return [ScenariosAllowed.JOIN_DESCENDANT_TO_PARENT, null];
+  }
+
+  var prevParentLastChildIsList = $prev.parent.lastChild && (0, _node.isListNode)($prev.parent.lastChild);
+  var prevParentLastChildIsParagraph = (0, _node.isParagraphNode)($prev.parent.lastChild); // Will search for the possible last node for case 4 (where the list could be indented multiple times)
+  // $last is required to determine whether we are in case 2 or 4
+
+  var $last = tr.doc.resolve($prev.pos);
+  var lastFoundNode;
+
+  do {
+    var _walkNode = (0, _commands.walkPrevNode)($last);
+
+    $last = _walkNode.$pos;
+    lastFoundNode = _walkNode.foundNode;
+  } while (lastFoundNode && !$last.parent.isTextblock);
+
+  var lastInParagraph = (0, _selection.isPosInsideParagraph)($last);
+
+  if (lastFoundNode && prevParentLastChildIsList && lastInParagraph) {
+    return [ScenariosAllowed.JOIN_TO_SIBLING_DESCENDANT, $last];
+  } else if (prevParentLastChildIsParagraph) {
+    return [ScenariosAllowed.JOIN_SIBLINGS, null];
+  }
+
+  return false;
+};
+
+exports.calcJoinListScenario = calcJoinListScenario;
+
+var listBackspace = function listBackspace(state, dispatch) {
+  var tr = state.tr,
+      $head = state.selection.$head;
+  var walkNode = (0, _commands.walkPrevNode)($head);
+
+  if (!(0, _commands.isEmptySelectionAtStart)(state)) {
+    return false;
+  }
+
+  var scenario = calcJoinListScenario(walkNode, $head, tr);
+
+  if (!scenario) {
+    return false;
+  }
+
+  return BACKSPACE_COMMANDS[scenario[0]](tr, dispatch, walkNode.$pos, $head, scenario[1]);
+};
+
+exports.listBackspace = listBackspace;

package/lib/components/rich-editor/plugins/block/lists/commond/outdent-list.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.outdentList = outdentList;
+
+var _selection = require("../utils/selection");
+
+var _find = require("../utils/find");
+
+var _outdentListItemsSelected = require("../actions/outdent-list-items-selected");
+
+function outdentList() {
+  return function (state, dispatch) {
+    if (!(0, _selection.isInsideListItem)(state)) {
+      return false;
+    }
+
+    var $from = state.selection.$from;
+    var parentListNode = (0, _find.findFirstParentListNode)($from);
+
+    if (!parentListNode) {
+      // Even though this is a non-operation, we don't want to send this event to the browser. Because if we return false, the browser will move the focus to another place
+      return true;
+    }
+
+    var customTr = state.tr;
+    (0, _outdentListItemsSelected.outdentListItemsSelected)(customTr);
+
+    if (!customTr || !customTr.docChanged) {
+      // Even though this is a non-operation, we don't want to send this event to the browser. Because if we return false, the browser will move the focus to another place
+      // If inside table cell and can't outdent list, then let it handle by table keymap
+      return !(0, _selection.isInsideTableCell)(state);
+    }
+
+    if (dispatch) {
+      dispatch(customTr);
+    }
+
+    return true;
+  };
+}

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

@@ -0,0 +1,222 @@
+"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.OrderedListSchema = exports.ListPlugin = exports.ListItemSchema = exports.ListController = exports.BulletListSchema = void 0;
+
+var _controller = _interopRequireDefault(require("../../../models/controller"));
+
+var _plugin = _interopRequireDefault(require("../../../models/plugin"));
+
+var _schema = require("../../../models/schema");
+
+var _commond = require("./commond");
+
+var _keymap = _interopRequireDefault(require("./pm-plugins/keymap"));
+
+var _main = _interopRequireWildcard(require("./pm-plugins/main"));
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var PLUGIN_NAME = 'list';
+var preCls = 'tita-rich-editor';
+
+var BulletListSchema = /*#__PURE__*/function (_BlockSchema) {
+  _inherits(BulletListSchema, _BlockSchema);
+
+  var _super = _createSuper(BulletListSchema);
+
+  function BulletListSchema() {
+    var _this;
+
+    _classCallCheck(this, BulletListSchema);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _possibleConstructorReturn(_this, (_this = _super.call.apply(_super, [this].concat(args)), _this.name = 'bulletList', _this.content = 'listItem+', _this.parseDOM = [{
+      tag: "ul"
+    }], _assertThisInitialized(_this)));
+  }
+
+  _createClass(BulletListSchema, [{
+    key: "toDOM",
+    value: function toDOM(node) {
+      return ["ul", {
+        "class": preCls + '-ul'
+      }, 0];
+    }
+  }]);
+
+  return BulletListSchema;
+}(_schema.BlockSchema);
+
+exports.BulletListSchema = BulletListSchema;
+
+var OrderedListSchema = /*#__PURE__*/function (_BlockSchema2) {
+  _inherits(OrderedListSchema, _BlockSchema2);
+
+  var _super2 = _createSuper(OrderedListSchema);
+
+  function OrderedListSchema() {
+    var _this2;
+
+    _classCallCheck(this, OrderedListSchema);
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return _possibleConstructorReturn(_this2, (_this2 = _super2.call.apply(_super2, [this].concat(args)), _this2.name = 'orderedList', _this2.content = 'listItem+', _this2.attrs = {
+      order: {
+        "default": 1
+      }
+    }, _this2.parseDOM = [{
+      tag: "ol",
+      getAttrs: function getAttrs(dom) {
+        return {
+          order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1
+        };
+      }
+    }], _this2.toDOM = function (node) {
+      return node.attrs.order == 1 ? ["ol", 0] : ["ol", {
+        start: node.attrs.order
+      }, 0];
+    }, _assertThisInitialized(_this2)));
+  }
+
+  return _createClass(OrderedListSchema);
+}(_schema.BlockSchema);
+
+exports.OrderedListSchema = OrderedListSchema;
+
+var ListItemSchema = /*#__PURE__*/function (_BlockSchema3) {
+  _inherits(ListItemSchema, _BlockSchema3);
+
+  var _super3 = _createSuper(ListItemSchema);
+
+  function ListItemSchema() {
+    var _this3;
+
+    _classCallCheck(this, ListItemSchema);
+
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+
+    return _possibleConstructorReturn(_this3, (_this3 = _super3.call.apply(_super3, [this].concat(args)), _this3.name = 'listItem', _this3.group = 'listItem', _this3.content = 'paragraph block*', _this3.parseDOM = [{
+      tag: "li"
+    }], _assertThisInitialized(_this3)));
+  }
+
+  _createClass(ListItemSchema, [{
+    key: "toDOM",
+    value: function toDOM(node) {
+      return ["li", {
+        "class": preCls + '-li'
+      }, 0];
+    }
+  }]);
+
+  return ListItemSchema;
+}(_schema.BlockSchema);
+
+exports.ListItemSchema = ListItemSchema;
+
+var ListController = /*#__PURE__*/function (_BaseController) {
+  _inherits(ListController, _BaseController);
+
+  var _super4 = _createSuper(ListController);
+
+  function ListController() {
+    var _this4;
+
+    _classCallCheck(this, ListController);
+
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+
+    return _possibleConstructorReturn(_this4, (_this4 = _super4.call.apply(_super4, [this].concat(args)), _this4.toolbar = [{
+      title: '无序列表',
+      icon: 'tu-icon-text-bullet-list',
+      handler: function handler(editor) {
+        (0, _commond.toggleBulletList)(editor.view);
+        editor.view.focus();
+      },
+      active: function active(state) {
+        return _main.pluginKey.getState(state).bulletListActive;
+      },
+      disabled: function disabled(state) {
+        return _main.pluginKey.getState(state).bulletListDisabled;
+      }
+    }, {
+      title: '有序列表',
+      icon: 'tu-icon-text-number-list',
+      handler: function handler(editor) {
+        (0, _commond.toggleOrderedList)(editor.view);
+        editor.view.focus();
+      },
+      active: function active(state) {
+        return _main.pluginKey.getState(state).orderedListActive;
+      },
+      disabled: function disabled(state) {
+        return _main.pluginKey.getState(state).orderedListDisabled;
+      }
+    }], _this4.pmPlugins = [_main["default"], _keymap["default"]], _assertThisInitialized(_this4)));
+  }
+
+  return _createClass(ListController);
+}(_controller["default"]);
+
+exports.ListController = ListController;
+
+var ListPlugin = /*#__PURE__*/function (_BasePlugin) {
+  _inherits(ListPlugin, _BasePlugin);
+
+  var _super5 = _createSuper(ListPlugin);
+
+  function ListPlugin() {
+    var _this5;
+
+    _classCallCheck(this, ListPlugin);
+
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+
+    return _possibleConstructorReturn(_this5, (_this5 = _super5.call.apply(_super5, [this].concat(args)), _this5.name = PLUGIN_NAME, _this5.schema = [BulletListSchema, OrderedListSchema, ListItemSchema], _this5.controller = ListController, _assertThisInitialized(_this5)));
+  }
+
+  return _createClass(ListPlugin);
+}(_plugin["default"]);
+
+exports.ListPlugin = ListPlugin;

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.messages = void 0;
+
+var _reactIntl = require("react-intl");
+
+// Common Translations will live here
+var messages = (0, _reactIntl.defineMessages)({
+  unorderedList: {
+    id: 'fabric.editor.unorderedList',
+    defaultMessage: 'Bullet list',
+    description: 'A list with bullets. Also known as an “unordered” list'
+  },
+  unorderedListDescription: {
+    id: 'fabric.editor.unorderedList.description',
+    defaultMessage: 'Create an unordered list',
+    description: ''
+  },
+  orderedList: {
+    id: 'fabric.editor.orderedList',
+    defaultMessage: 'Numbered list',
+    description: 'A list with ordered items 1… 2… 3…'
+  },
+  orderedListDescription: {
+    id: 'fabric.editor.orderedList.description',
+    defaultMessage: 'Create an ordered list',
+    description: ''
+  },
+  lists: {
+    id: 'fabric.editor.lists',
+    defaultMessage: 'Lists',
+    description: 'Menu shows ordered/bullet list and unordered/numbered lists'
+  }
+});
+exports.messages = messages;