@titaui/pc 1.10.35 → 1.10.39

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

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setColor = setColor;
+exports.toggleMark = toggleMark;
+
+var _util = require("../../util");
+
+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); }
+
+function setColor(editor, type, color) {
+  var state = editor.state; //@ts-ignore
+
+  var _state$selection = state.selection,
+      empty = _state$selection.empty,
+      $cursor = _state$selection.$cursor,
+      ranges = _state$selection.ranges,
+      from = _state$selection.from,
+      to = _state$selection.to;
+  if (empty && !$cursor || !markApplies(state.doc, ranges, type)) return false;
+
+  if ($cursor) {
+    if (type.isInSet(state.storedMarks || $cursor.marks() || !color)) editor.view.dispatch(state.tr.removeStoredMark(type));else editor.view.dispatch(state.tr.addStoredMark(type.create({
+      color: color
+    })));
+    return true;
+  }
+
+  var tr = state.tr;
+
+  if (!color) {
+    tr.removeMark(state.selection.from, state.selection.to, type);
+  } else {
+    var isShared = (0, _util.isSharedMark)(editor, from, to, type, {
+      color: color
+    });
+    tr.removeMark(state.selection.from, state.selection.to, type);
+    if (!isShared) tr.addMark(from, to, type.create({
+      color: color
+    }));
+  }
+
+  editor.view.dispatch(tr.scrollIntoView());
+  editor.view.focus();
+  return true;
+}
+
+function markApplies(doc, ranges, type) {
+  var _loop = function _loop(i) {
+    var _ranges$i = ranges[i],
+        $from = _ranges$i.$from,
+        $to = _ranges$i.$to;
+    var can = $from.depth == 0 ? doc.type.allowsMarkType(type) : false;
+    doc.nodesBetween($from.pos, $to.pos, function (node) {
+      if (can) return false;
+      can = node.inlineContent && node.type.allowsMarkType(type);
+    });
+    if (can) return {
+      v: true
+    };
+  };
+
+  for (var i = 0; i < ranges.length; i++) {
+    var _ret = _loop(i);
+
+    if (_typeof(_ret) === "object") return _ret.v;
+  }
+
+  return false;
+}
+
+function toggleMark(markType, attrs) {
+  return function (state, dispatch) {
+    var _state$selection2 = state.selection,
+        empty = _state$selection2.empty,
+        $cursor = _state$selection2.$cursor,
+        ranges = _state$selection2.ranges;
+    if (empty && !$cursor || !markApplies(state.doc, ranges, markType)) return false;
+
+    if (dispatch) {
+      if ($cursor) {
+        if (markType.isInSet(state.storedMarks || $cursor.marks())) dispatch(state.tr.removeStoredMark(markType));else dispatch(state.tr.addStoredMark(markType.create(attrs)));
+      } else {
+        var has = false,
+            tr = state.tr;
+
+        for (var i = 0; !has && i < ranges.length; i++) {
+          var _ranges$i2 = ranges[i],
+              $from = _ranges$i2.$from,
+              $to = _ranges$i2.$to;
+          has = state.doc.rangeHasMark($from.pos, $to.pos, markType);
+        }
+
+        for (var _i = 0; _i < ranges.length; _i++) {
+          var _ranges$_i = ranges[_i],
+              _$from = _ranges$_i.$from,
+              _$to = _ranges$_i.$to;
+
+          if (has) {
+            tr.removeMark(_$from.pos, _$to.pos, markType);
+          } else {
+            var _$exec, _$exec2;
+
+            var from = _$from.pos,
+                to = _$to.pos,
+                start = _$from.nodeAfter,
+                end = _$to.nodeBefore;
+            var spaceStart = start && start.isText ? ((_$exec = /^\s*/.exec(start.text)) === null || _$exec === void 0 ? void 0 : _$exec[0].length) || 0 : 0;
+            var spaceEnd = end && end.isText ? ((_$exec2 = /\s*$/.exec(end.text)) === null || _$exec2 === void 0 ? void 0 : _$exec2[0].length) || 0 : 0;
+
+            if (from + spaceStart < to) {
+              from += spaceStart;
+              to -= spaceEnd;
+            }
+
+            tr.addMark(from, to, markType.create(attrs));
+          }
+        }
+
+        dispatch(tr.scrollIntoView());
+      }
+    }
+
+    return true;
+  };
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FontColor = exports.BackgroundColor = void 0;
+var FontColor;
+exports.FontColor = FontColor;
+
+(function (FontColor) {
+  FontColor["default"] = "#3F4755";
+  FontColor["black1"] = "#141C28";
+  FontColor["black2"] = "#6F7886";
+  FontColor["black3"] = "#A4ACB9";
+  FontColor["red1"] = "#F02673";
+  FontColor["red2"] = "#F05E5E";
+  FontColor["yellow1"] = "#F0A326";
+  FontColor["yellow2"] = "#F6BD16";
+  FontColor["green1"] = "#5AD8A6";
+  FontColor["green2"] = "#26D8F0";
+  FontColor["blue1"] = "#3D26F0";
+  FontColor["blue2"] = "#2879FF";
+  FontColor["purple1"] = "#A226F0";
+})(FontColor || (exports.FontColor = FontColor = {}));
+
+var BackgroundColor;
+exports.BackgroundColor = BackgroundColor;
+
+(function (BackgroundColor) {
+  BackgroundColor["default"] = "transparent";
+  BackgroundColor["red2"] = "rgba(240, 94, 94, 0.2)";
+  BackgroundColor["yellow2"] = "rgba(246, 189, 22, 0.2)";
+  BackgroundColor["grenn2"] = "rgba(90, 216, 166, 0.2)";
+  BackgroundColor["blue2"] = "rgba(40, 121, 255, 0.2)";
+  BackgroundColor["purple2"] = "rgba(162, 38, 240, 0.2)";
+  BackgroundColor["gray2"] = "rgba(191, 199, 213, 0.2)";
+  BackgroundColor["red1"] = "rgba(240, 94, 94, 0.6)";
+  BackgroundColor["yellow1"] = "rgba(246, 189, 22, 0.6)";
+  BackgroundColor["green1"] = "rgba(90, 216, 166, 0.6)";
+  BackgroundColor["blue1"] = "rgba(40, 121, 255, 0.6)";
+  BackgroundColor["purple1"] = "rgba(162, 38, 240, 0.6)";
+  BackgroundColor["gray1"] = "rgba(191, 199, 213, 0.6)";
+})(BackgroundColor || (exports.BackgroundColor = BackgroundColor = {}));

package/lib/components/rich-editor/plugins/inline/color/index.css

@@ -0,0 +1,61 @@
+.tita-rich-editor-color-selector {
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+  padding: 12px 21px 0;
+  width: 234px;
+  height: 208px;
+  background: #ffffff;
+  box-shadow: 0px 4px 12px 0px rgba(127, 145, 180, 0.2);
+  border-radius: 12px;
+}
+
+.tita-rich-editor-color-selector__icon {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.tita-rich-editor-color-selector__title {
+  font-size: 12px;
+  font-weight: 400;
+  color: #6f7886;
+  line-height: 18px;
+  padding-left: 3px;
+  margin-bottom: 4px;
+}
+
+.tita-rich-editor-color-selector__color-box {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: space-between;
+}
+
+.tita-rich-editor-color-selector__color-box > div {
+  border: 1px solid #e9ecf0;
+}
+
+.tita-rich-editor-color-selector__item {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  width: 26px;
+  height: 26px;
+  border-radius: 4px;
+  margin: 3px;
+  color: #3f4755;
+  cursor: pointer;
+}
+
+.tita-rich-editor-color-selector__item:hover {
+  border: 1px solid rgba(40, 121, 255, 0.3);
+  box-shadow: 0 0 0 1px #fff inset;
+}
+
+.tita-rich-editor-color-selector__item--active {
+  border: 1px solid #2879ff !important;
+  box-shadow: 0 0 0 1px #fff inset;
+}

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

@@ -0,0 +1,209 @@
+"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.FontColorSchema = exports.FONT_COLOR_SCHEMA_NAME = exports.ColorPlugin = exports.ColorController = exports.BackgroundColorSchema = exports.BACKGROUND_COLOR_SCHEMA_NAME = 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 _selector = _interopRequireDefault(require("./selector"));
+
+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 = 'color';
+var FONT_COLOR_SCHEMA_NAME = 'fontColor';
+exports.FONT_COLOR_SCHEMA_NAME = FONT_COLOR_SCHEMA_NAME;
+var BACKGROUND_COLOR_SCHEMA_NAME = 'backgroundColor';
+exports.BACKGROUND_COLOR_SCHEMA_NAME = BACKGROUND_COLOR_SCHEMA_NAME;
+var colorReg = /^\s*(rgba\([^)]+\)|rgb\([^)]+\)|#[\d|a-f]{3,6})|\w*/i;
+
+var getColorAttrs = function getColorAttrs(style) {
+  var color = style;
+
+  if (color) {
+    return {
+      color: color
+    };
+  }
+
+  return false;
+};
+
+var FontColorSchema = /*#__PURE__*/function (_InlineSchema) {
+  _inherits(FontColorSchema, _InlineSchema);
+
+  var _super = _createSuper(FontColorSchema);
+
+  function FontColorSchema() {
+    var _this;
+
+    _classCallCheck(this, FontColorSchema);
+
+    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 = FONT_COLOR_SCHEMA_NAME, _this.attrs = {
+      color: {
+        "default": ''
+      }
+    }, _this.parseDOM = [{
+      style: 'color',
+      getAttrs: getColorAttrs
+    }, {
+      tag: '*[color]',
+      getAttrs: function getAttrs(dom) {
+        return getColorAttrs(dom.getAttribute('color'));
+      }
+    }], _assertThisInitialized(_this)));
+  }
+
+  _createClass(FontColorSchema, [{
+    key: "toDOM",
+    value: function toDOM(node) {
+      return ["span", {
+        style: "color:".concat(node.attrs.color || '')
+      }, 0];
+    }
+  }]);
+
+  return FontColorSchema;
+}(_schema.InlineSchema);
+
+exports.FontColorSchema = FontColorSchema;
+
+var getBgAttrs = function getBgAttrs(style) {
+  var colorMatch = style.match(colorReg);
+  if (!colorMatch) return false;
+  var background = colorMatch[0];
+
+  if (background) {
+    return {
+      color: background
+    };
+  }
+
+  return false;
+};
+
+var BackgroundColorSchema = /*#__PURE__*/function (_InlineSchema2) {
+  _inherits(BackgroundColorSchema, _InlineSchema2);
+
+  var _super2 = _createSuper(BackgroundColorSchema);
+
+  function BackgroundColorSchema() {
+    var _this2;
+
+    _classCallCheck(this, BackgroundColorSchema);
+
+    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 = BACKGROUND_COLOR_SCHEMA_NAME, _this2.attrs = {
+      color: {
+        "default": ''
+      }
+    }, _this2.parseDOM = [{
+      style: 'background',
+      getAttrs: getBgAttrs
+    }, {
+      style: 'background-color',
+      getAttrs: getBgAttrs
+    }], _assertThisInitialized(_this2)));
+  }
+
+  _createClass(BackgroundColorSchema, [{
+    key: "toDOM",
+    value: function toDOM(node) {
+      return ["span", {
+        style: "background-color:".concat(node.attrs.color || '')
+      }, 0];
+    }
+  }]);
+
+  return BackgroundColorSchema;
+}(_schema.InlineSchema);
+
+exports.BackgroundColorSchema = BackgroundColorSchema;
+
+var ColorController = /*#__PURE__*/function (_BaseController) {
+  _inherits(ColorController, _BaseController);
+
+  var _super3 = _createSuper(ColorController);
+
+  function ColorController() {
+    var _this3;
+
+    _classCallCheck(this, ColorController);
+
+    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.toolbar = {
+      title: '文字颜色',
+      icon: 'tu-icon-text-color',
+      handler: function handler(editor) {
+        (0, _prosemirrorCommands.toggleMark)(editor.state.schema.marks[PLUGIN_NAME])(editor.state, editor.view.dispatch);
+        editor.view.focus();
+      },
+      renderMenu: _selector["default"]
+    }, _assertThisInitialized(_this3)));
+  }
+
+  return _createClass(ColorController);
+}(_controller["default"]);
+
+exports.ColorController = ColorController;
+
+var ColorPlugin = /*#__PURE__*/function (_BasePlugin) {
+  _inherits(ColorPlugin, _BasePlugin);
+
+  var _super4 = _createSuper(ColorPlugin);
+
+  function ColorPlugin() {
+    var _this4;
+
+    _classCallCheck(this, ColorPlugin);
+
+    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.name = PLUGIN_NAME, _this4.schema = [FontColorSchema, BackgroundColorSchema], _this4.controller = ColorController, _assertThisInitialized(_this4)));
+  }
+
+  return _createClass(ColorPlugin);
+}(_plugin["default"]);
+
+exports.ColorPlugin = ColorPlugin;