@titaui/pc 1.10.35 → 1.10.39

package/lib/components/rich-editor/plugins/inline/color/selector.js

@@ -0,0 +1,252 @@
+"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;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _popup = _interopRequireDefault(require("../../../../popup"));
+
+require("./index.css");
+
+var _consts = require("./consts");
+
+var _commond = require("./commond");
+
+var _index2 = require("./index");
+
+var _events = require("../../../consts/events");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 _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 _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 preCls = 'tita-rich-editor-color-selector';
+
+function ColorSelector(_ref) {
+  var editor = _ref.editor,
+      config = _ref.config,
+      color = _ref.color,
+      background = _ref.background,
+      onClickItem = _ref.onClickItem;
+  var fontColors = (0, _react.useMemo)(function () {
+    var colors = [];
+
+    var _loop = function _loop(key) {
+      if (key == 'default') return "continue";
+      var c = _consts.FontColor[key];
+      var cls = (0, _classnames["default"])("".concat(preCls, "__item"), config.icon, _defineProperty({}, "".concat(preCls, "__item--active"), color == c));
+      colors.push( /*#__PURE__*/_react["default"].createElement("div", {
+        key: c,
+        className: cls,
+        style: {
+          color: c
+        },
+        onClick: function onClick() {
+          onClickItem(editor.state.schema.marks[_index2.FONT_COLOR_SCHEMA_NAME], c);
+        }
+      }));
+    };
+
+    for (var key in _consts.FontColor) {
+      var _ret = _loop(key);
+
+      if (_ret === "continue") continue;
+    }
+
+    return colors;
+  }, [color]);
+  var backgroundColors = (0, _react.useMemo)(function () {
+    var colors = [];
+
+    var _loop2 = function _loop2(key) {
+      if (key == 'default') return "continue";
+      var color = _consts.BackgroundColor[key];
+      var cls = (0, _classnames["default"])("".concat(preCls, "__item"), config.icon, _defineProperty({}, "".concat(preCls, "__item--active"), background == color));
+      colors.push( /*#__PURE__*/_react["default"].createElement("div", {
+        key: color,
+        className: cls,
+        style: {
+          backgroundColor: color
+        },
+        onClick: function onClick() {
+          onClickItem(editor.state.schema.marks[_index2.BACKGROUND_COLOR_SCHEMA_NAME], color);
+        }
+      }));
+    };
+
+    for (var key in _consts.BackgroundColor) {
+      var _ret2 = _loop2(key);
+
+      if (_ret2 === "continue") continue;
+    }
+
+    return colors;
+  }, [background]);
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: preCls
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: preCls + '__title'
+  }, "\u6587\u5B57\u989C\u8272"), /*#__PURE__*/_react["default"].createElement("div", {
+    className: preCls + '__color-box',
+    style: {
+      marginBottom: 10
+    }
+  }, fontColors), /*#__PURE__*/_react["default"].createElement("div", {
+    className: preCls + '__title'
+  }, "\u80CC\u666F\u989C\u8272"), /*#__PURE__*/_react["default"].createElement("div", {
+    className: preCls + '__color-box'
+  }, backgroundColors));
+}
+
+function ColorSelectorPop(_ref2) {
+  var editor = _ref2.editor,
+      config = _ref2.config;
+
+  var _useState = (0, _react.useState)(),
+      _useState2 = _slicedToArray(_useState, 2),
+      activeColor = _useState2[0],
+      setActiveColor = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      activeBackground = _useState4[0],
+      setActiveBackground = _useState4[1];
+
+  var storedColor = (0, _react.useRef)({
+    color: undefined,
+    background: undefined
+  });
+  var handleClickItem = (0, _react.useCallback)(function (type, color) {
+    var currentColor = type.name == _index2.FONT_COLOR_SCHEMA_NAME ? activeColor : activeBackground;
+    var c = color === currentColor ? undefined : color;
+
+    if (type.name == _index2.FONT_COLOR_SCHEMA_NAME) {
+      storedColor.current.color = c;
+      setActiveColor(c);
+    } else {
+      storedColor.current.background = c;
+      setActiveBackground(c);
+    }
+
+    (0, _commond.setColor)(editor, type, color);
+    editor.view.focus();
+  }, [activeColor, activeBackground]);
+  (0, _react.useEffect)(function () {
+    editor.on(_events.EDITOR_STATE_CHANGE, function (state) {
+      var _state$selection = state.selection,
+          from = _state$selection.from,
+          to = _state$selection.to,
+          $from = _state$selection.$from;
+      var fontColor = '';
+      var backgroundColor = '';
+
+      if (from == to) {
+        var marks = state.storedMarks || $from.marks();
+        marks.forEach(function (mark) {
+          if (mark.type.name == _index2.FONT_COLOR_SCHEMA_NAME) {
+            if (fontColor && fontColor != mark.attrs.color) fontColor = _consts.FontColor["default"];
+            if (!fontColor) fontColor = mark.attrs.color;
+          }
+
+          if (mark.type.name == _index2.BACKGROUND_COLOR_SCHEMA_NAME) {
+            if (backgroundColor && backgroundColor != mark.attrs.color) backgroundColor = _consts.BackgroundColor["default"];
+            if (!backgroundColor) backgroundColor = mark.attrs.color;
+          }
+        });
+      } else {
+        state.doc.nodesBetween(from, to, function (node) {
+          node.marks.forEach(function (mark) {
+            if (mark.type.name == _index2.FONT_COLOR_SCHEMA_NAME) {
+              if (fontColor && fontColor != mark.attrs.color) fontColor = _consts.FontColor["default"];
+              if (!fontColor) fontColor = mark.attrs.color;
+            }
+
+            if (mark.type.name == _index2.BACKGROUND_COLOR_SCHEMA_NAME) {
+              if (backgroundColor && backgroundColor != mark.attrs.color) backgroundColor = _consts.BackgroundColor["default"];
+              if (!backgroundColor) backgroundColor = mark.attrs.color;
+            }
+          });
+        });
+      }
+
+      if (fontColor && !backgroundColor) {
+        backgroundColor = _consts.BackgroundColor["default"];
+      }
+
+      if (backgroundColor && !fontColor) {
+        fontColor = _consts.FontColor["default"];
+      }
+
+      if (!fontColor && !backgroundColor) {
+        fontColor = storedColor.current.color || _consts.FontColor["default"];
+        backgroundColor = storedColor.current.background || _consts.BackgroundColor["default"];
+      }
+
+      fontColor && setActiveColor(fontColor);
+      backgroundColor && setActiveBackground(backgroundColor);
+    });
+  }, []);
+  var handleClickMenu = (0, _react.useCallback)(function () {
+    (0, _commond.setColor)(editor, editor.state.schema.marks[_index2.FONT_COLOR_SCHEMA_NAME], activeColor);
+    (0, _commond.setColor)(editor, editor.state.schema.marks[_index2.BACKGROUND_COLOR_SCHEMA_NAME], activeBackground);
+    editor.view.focus();
+  }, [activeColor, activeBackground]);
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: preCls + '__icon',
+    onMouseOver: function onMouseOver(e) {
+      return e.stopPropagation();
+    },
+    onMouseEnter: function onMouseEnter(e) {
+      return e.stopPropagation();
+    },
+    style: {
+      backgroundColor: activeBackground || _consts.BackgroundColor["default"],
+      color: activeColor || _consts.FontColor["default"]
+    },
+    onClick: handleClickMenu
+  }, /*#__PURE__*/_react["default"].createElement(_popup["default"], {
+    action: ["hover"],
+    popupPlacement: "top",
+    popup: /*#__PURE__*/_react["default"].createElement(ColorSelector, {
+      editor: editor,
+      config: config,
+      color: activeColor,
+      background: activeBackground,
+      onClickItem: handleClickItem
+    })
+  }, /*#__PURE__*/_react["default"].createElement("span", {
+    className: config.icon
+  })));
+}
+
+var _default = function _default(editor, config) {
+  return /*#__PURE__*/_react["default"].createElement(ColorSelectorPop, {
+    editor: editor,
+    config: config
+  });
+};
+
+exports["default"] = _default;

package/lib/components/rich-editor/plugins/inline/delete-line/index.js

@@ -0,0 +1,147 @@
+"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.DeleteLineSchema = exports.DeleteLinePlugin = exports.DeleteLineController = void 0;
+
+var _plugin = _interopRequireDefault(require("../../../models/plugin"));
+
+var _schema = require("../../../models/schema");
+
+var _controller = _interopRequireDefault(require("../../../models/controller"));
+
+var _prosemirrorCommands = require("prosemirror-commands");
+
+var _mark = require("../../../utils/mark");
+
+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 = 'deleteLine';
+
+var getAttrs = function getAttrs(value) {
+  if (/line-through/i.test(value)) {
+    return true;
+  }
+
+  return false;
+};
+
+var DeleteLineSchema = /*#__PURE__*/function (_InlineSchema) {
+  _inherits(DeleteLineSchema, _InlineSchema);
+
+  var _super = _createSuper(DeleteLineSchema);
+
+  function DeleteLineSchema() {
+    var _this;
+
+    _classCallCheck(this, DeleteLineSchema);
+
+    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 = PLUGIN_NAME, _this.parseDOM = [{
+      tag: 's',
+      priority: 25
+    }, {
+      tag: 'strike',
+      priority: 25
+    }, {
+      tag: 'del',
+      priority: 25
+    }, {
+      style: 'text-decoration-line',
+      getAttrs: getAttrs
+    }], _assertThisInitialized(_this)));
+  }
+
+  _createClass(DeleteLineSchema, [{
+    key: "toDOM",
+    value: function toDOM() {
+      return ["s", {
+        style: 'text-decoration:line-through;'
+      }, 0];
+    }
+  }]);
+
+  return DeleteLineSchema;
+}(_schema.InlineSchema);
+
+exports.DeleteLineSchema = DeleteLineSchema;
+
+var DeleteLineController = /*#__PURE__*/function (_BaseController) {
+  _inherits(DeleteLineController, _BaseController);
+
+  var _super2 = _createSuper(DeleteLineController);
+
+  function DeleteLineController() {
+    var _this2;
+
+    _classCallCheck(this, DeleteLineController);
+
+    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.toolbar = {
+      title: '删除线',
+      icon: 'tu-icon-text-delline',
+      handler: function handler(editor) {
+        (0, _prosemirrorCommands.toggleMark)(editor.state.schema.marks[PLUGIN_NAME])(editor.state, editor.view.dispatch);
+        editor.view.focus();
+      },
+      active: function active(state) {
+        return (0, _mark.selectionContainsMark)(state, PLUGIN_NAME);
+      }
+    }, _assertThisInitialized(_this2)));
+  }
+
+  return _createClass(DeleteLineController);
+}(_controller["default"]);
+
+exports.DeleteLineController = DeleteLineController;
+
+var DeleteLinePlugin = /*#__PURE__*/function (_BasePlugin) {
+  _inherits(DeleteLinePlugin, _BasePlugin);
+
+  var _super3 = _createSuper(DeleteLinePlugin);
+
+  function DeleteLinePlugin() {
+    var _this3;
+
+    _classCallCheck(this, DeleteLinePlugin);
+
+    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 = PLUGIN_NAME, _this3.schema = DeleteLineSchema, _this3.controller = DeleteLineController, _assertThisInitialized(_this3)));
+  }
+
+  return _createClass(DeleteLinePlugin);
+}(_plugin["default"]);
+
+exports.DeleteLinePlugin = DeleteLinePlugin;

package/lib/components/rich-editor/plugins/inline/em/index.js

@@ -0,0 +1,93 @@
+"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.EmSchema = exports.EmPlugin = void 0;
+
+var _plugin = _interopRequireDefault(require("../../../models/plugin"));
+
+var _schema = require("../../../models/schema");
+
+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 = 'em';
+
+var EmSchema = /*#__PURE__*/function (_InlineSchema) {
+  _inherits(EmSchema, _InlineSchema);
+
+  var _super = _createSuper(EmSchema);
+
+  function EmSchema() {
+    var _this;
+
+    _classCallCheck(this, EmSchema);
+
+    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 = PLUGIN_NAME, _this.parseDOM = [{
+      tag: "i"
+    }, {
+      tag: "em"
+    }, {
+      style: "font-style=italic"
+    }], _assertThisInitialized(_this)));
+  }
+
+  _createClass(EmSchema, [{
+    key: "toDOM",
+    value: function toDOM() {
+      return ["em", 0];
+    }
+  }]);
+
+  return EmSchema;
+}(_schema.InlineSchema);
+
+exports.EmSchema = EmSchema;
+
+var EmPlugin = /*#__PURE__*/function (_BasePlugin) {
+  _inherits(EmPlugin, _BasePlugin);
+
+  var _super2 = _createSuper(EmPlugin);
+
+  function EmPlugin() {
+    var _this2;
+
+    _classCallCheck(this, EmPlugin);
+
+    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 = PLUGIN_NAME, _this2.schema = EmSchema, _assertThisInitialized(_this2)));
+  }
+
+  return _createClass(EmPlugin);
+}(_plugin["default"]);
+
+exports.EmPlugin = EmPlugin;

package/lib/components/rich-editor/plugins/inline/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _deleteLine = require("./delete-line");
+
+Object.keys(_deleteLine).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _deleteLine[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _deleteLine[key];
+    }
+  });
+});
+
+var _em = require("./em");
+
+Object.keys(_em).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _em[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _em[key];
+    }
+  });
+});
+
+var _strong = require("./strong");
+
+Object.keys(_strong).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _strong[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _strong[key];
+    }
+  });
+});
+
+var _underLine = require("./under-line");
+
+Object.keys(_underLine).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _underLine[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _underLine[key];
+    }
+  });
+});
+
+var _color = require("./color");
+
+Object.keys(_color).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _color[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _color[key];
+    }
+  });
+});
+
+var _link = require("./link");
+
+Object.keys(_link).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _link[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _link[key];
+    }
+  });
+});