@seafile/sdoc-editor 2.0.81 → 2.0.83

package/dist/extension/core/transforms/delete-merge.js

@@ -0,0 +1,198 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deleteMerge = void 0;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+/**
+ *
+ * @param {*} editor
+ * @param {*} options { at, distance, hanging, reverse, test, unit, voids }
+ */
+var deleteMerge = exports.deleteMerge = function deleteMerge(editor) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  _slate.Editor.withoutNormalizing(editor, function () {
+    var _options$distance = options.distance,
+      distance = _options$distance === void 0 ? 1 : _options$distance,
+      _options$reverse = options.reverse,
+      reverse = _options$reverse === void 0 ? false : _options$reverse,
+      _options$unit = options.unit,
+      unit = _options$unit === void 0 ? 'character' : _options$unit,
+      _options$voids = options.voids,
+      voids = _options$voids === void 0 ? false : _options$voids;
+    var _options$at = options.at,
+      at = _options$at === void 0 ? editor.selection : _options$at,
+      _options$hanging = options.hanging,
+      hanging = _options$hanging === void 0 ? false : _options$hanging;
+    if (!at) {
+      return;
+    }
+    if (_slate.Range.isRange(at) && _slate.Range.isCollapsed(at)) {
+      at = at.anchor;
+    }
+    if (_slate.Point.isPoint(at)) {
+      var furthestVoid = _slate.Editor["void"](editor, {
+        at: at,
+        mode: 'highest'
+      });
+      if (!voids && furthestVoid) {
+        var _furthestVoid = (0, _slicedToArray2["default"])(furthestVoid, 2),
+          voidPath = _furthestVoid[1];
+        at = voidPath;
+      } else {
+        var opts = {
+          distance: distance,
+          unit: unit
+        };
+        var target = reverse ? _slate.Editor.before(editor, at, opts) || _slate.Editor.start(editor, []) : _slate.Editor.after(editor, at.opts) || _slate.Editor.end(editor, []);
+        at = {
+          anchor: at,
+          focus: target
+        };
+        hanging = true;
+      }
+    }
+    if (_slate.Path.isPath(at)) {
+      _slate.Transforms.removeNodes(editor, at, {
+        voids: voids
+      });
+      return;
+    }
+    if (_slate.Range.isCollapsed(at)) {
+      return;
+    }
+    if (!hanging) {
+      at = _slate.Editor.unhangRange(editor, at, {
+        voids: voids
+      });
+    }
+    var _Range$edges = _slate.Range.edges(at),
+      _Range$edges2 = (0, _slicedToArray2["default"])(_Range$edges, 2),
+      start = _Range$edges2[0],
+      end = _Range$edges2[1];
+    var startBlock = _slate.Editor.above(editor, {
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      },
+      at: start,
+      voids: voids
+    });
+    var endBlock = _slate.Editor.above(editor, {
+      match: function match(n) {
+        return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+      },
+      at: end,
+      voids: voids
+    });
+    var isAcrossBlocks = startBlock && endBlock && !_slate.Path.equals(startBlock[1], endBlock[1]);
+    var isSingleText = _slate.Path.equals(start.path, end.path);
+    var startVoid = voids ? null : _slate.Editor["void"](editor, {
+      at: start,
+      mode: 'highest'
+    });
+    var endVoid = voids ? null : _slate.Editor["void"](editor, {
+      at: end,
+      mode: 'highest'
+    });
+    if (startVoid) {
+      var before = _slate.Editor.before(editor, start);
+      if (before && startBlock && _slate.Path.isAncestor(startBlock[1], before.path)) {
+        start = before;
+      }
+    }
+    if (endVoid) {
+      var after = _slate.Editor.after(editor, end);
+      if (after && endVoid && _slate.Path.isAncestor(endBlock[1], after.path)) {
+        end = after;
+      }
+    }
+    var matches = [];
+    var lastPath = undefined;
+    var _nodes = _slate.Editor.nodes(editor, {
+      at: at,
+      voids: voids
+    });
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(_nodes),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        var _entry = (0, _slicedToArray2["default"])(entry, 2),
+          _node2 = _entry[0],
+          _path3 = _entry[1];
+        if (lastPath && _slate.Path.compare(_path3, lastPath) === 0) {
+          continue;
+        }
+        if (!voids && _slate.Editor.isVoid(editor, _node2) || !_slate.Path.isCommon(_path3, start.path) && !_slate.Path.isCommon(_path3, end.path)) {
+          matches.push(entry);
+          lastPath = _path3;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    var pathRefs = Array.from(matches, function (_ref) {
+      var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+        p = _ref2[1];
+      return _slate.Editor.pathRef(editor, p);
+    });
+    var startRef = _slate.Editor.pointRef(editor, start);
+    var endRef = _slate.Editor.pointRef(editor, end);
+    if (!isSingleText && !startVoid) {
+      var _point = startRef.current;
+      var _Editor$leaf = _slate.Editor.leaf(editor, _point),
+        _Editor$leaf2 = (0, _slicedToArray2["default"])(_Editor$leaf, 1),
+        node = _Editor$leaf2[0];
+      var path = _point.path;
+      var _start = start,
+        offset = _start.offset;
+      var text = node.text.slice(offset);
+      editor.apply({
+        type: 'remove_text',
+        path: path,
+        offset: offset,
+        text: text
+      });
+    }
+    for (var _i = 0, _pathRefs = pathRefs; _i < _pathRefs.length; _i++) {
+      var pathRef = _pathRefs[_i];
+      var _path = pathRef.unref();
+      _slate.Transforms.removeNodes(editor, {
+        at: _path,
+        voids: voids
+      });
+    }
+    if (!endVoid) {
+      var _point2 = endRef.current;
+      var _Editor$leaf3 = _slate.Editor.leaf(editor, _point2),
+        _Editor$leaf4 = (0, _slicedToArray2["default"])(_Editor$leaf3, 1),
+        _node = _Editor$leaf4[0];
+      var _path2 = _point2.path;
+      var _offset = isSingleText ? start.offset : 0;
+      var _text = _node.text.slice(_offset, end.offset);
+      editor.apply({
+        offset: _offset,
+        path: _path2,
+        text: _text,
+        type: 'remove_text'
+      });
+    }
+    if (!isSingleText && isAcrossBlocks && endRef.current && start.current) {
+      _slate.Transforms.mergeNodes(editor, {
+        at: endRef.current,
+        hanging: true,
+        voids: voids
+      });
+    }
+    var point = endRef.unref() || startRef.unref();
+    if (options.at == null && point) {
+      _slate.Transforms.select(editor, point);
+    }
+  });
+};

package/dist/extension/core/transforms/focus-editor.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusEditor = void 0;
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var focusEditor = exports.focusEditor = function focusEditor(editor, target) {
+  if (target) {
+    _slate.Editor.withoutNormalizing(editor, function () {
+      _slate.Transforms.deselect(editor);
+      _slate.Transforms.select(editor, target);
+    });
+  }
+  _slateReact.ReactEditor.focus(editor);
+};

package/dist/extension/core/transforms/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _moveChildren = require("./move-children");
+Object.keys(_moveChildren).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _moveChildren[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _moveChildren[key];
+    }
+  });
+});
+var _removeNodeChildren = require("./remove-node-children");
+Object.keys(_removeNodeChildren).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _removeNodeChildren[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _removeNodeChildren[key];
+    }
+  });
+});
+var _focusEditor = require("./focus-editor");
+Object.keys(_focusEditor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _focusEditor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _focusEditor[key];
+    }
+  });
+});
+var _replaceNode = require("./replace-node");
+Object.keys(_replaceNode).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _replaceNode[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _replaceNode[key];
+    }
+  });
+});
+var _updateParentNode = require("./update-parent-node");
+Object.keys(_updateParentNode).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _updateParentNode[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _updateParentNode[key];
+    }
+  });
+});
+var _rebase = require("./rebase");
+Object.keys(_rebase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _rebase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _rebase[key];
+    }
+  });
+});

package/dist/extension/core/transforms/move-children.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveChildren = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _slate = require("@seafile/slate");
+var _queries = require("../queries");
+var moveChildren = exports.moveChildren = function moveChildren(editor, _ref) {
+  var at = _ref.at,
+    to = _ref.to,
+    match = _ref.match,
+    _ref$fromStartIndex = _ref.fromStartIndex,
+    fromStartIndex = _ref$fromStartIndex === void 0 ? 0 : _ref$fromStartIndex;
+  var moved = 0;
+  var parentPath = _slate.Path.isPath(at) ? at : at[1];
+  var parentNode = _slate.Path.isPath(at) ? (0, _queries.getNode)(editor, parentPath) : at[0];
+  if (!parentNode) return moved;
+  // There have none children in a not block element
+  if (!_slate.Editor.isBlock(editor, parentNode)) return moved;
+  for (var i = parentNode.children.length - 1; i >= fromStartIndex; i--) {
+    var childPath = [].concat((0, _toConsumableArray2["default"])(parentPath), [i]);
+    var childNode = (0, _queries.getNode)(editor, childPath);
+    if (!match || childNode && match([childNode, childPath])) {
+      _slate.Transforms.moveNodes(editor, {
+        at: childPath,
+        to: to
+      });
+      moved++;
+    }
+  }
+  return moved;
+};

package/dist/extension/core/transforms/rebase.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceRebaseNodeChildren = exports.replaceRebaseNode = exports.rebaseNode = exports.deleteRebaseNodeMark = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../constants");
+var _queries = require("../queries");
+var _removeNodeChildren = require("./remove-node-children");
+var replaceRebaseNodeChildren = exports.replaceRebaseNodeChildren = function replaceRebaseNodeChildren(editor, _ref) {
+  var at = _ref.at,
+    nodes = _ref.nodes,
+    insertOptions = _ref.insertOptions,
+    removeOptions = _ref.removeOptions;
+  (0, _removeNodeChildren.removeNodeChildren)(editor, at, removeOptions);
+  _slate.Transforms.insertNodes(editor, nodes, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, insertOptions), {}, {
+    at: at.concat([0])
+  }));
+};
+var replaceRebaseNode = exports.replaceRebaseNode = function replaceRebaseNode(editor) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    at = _ref2.at,
+    nodes = _ref2.nodes,
+    insertOptions = _ref2.insertOptions,
+    removeOptions = _ref2.removeOptions;
+  var parentPath = at.slice(0, -1);
+  var parentNode = at.length > 1 ? (0, _queries.getNode)(editor, parentPath) : {};
+  if ([_constants.ELEMENT_TYPE.ORDERED_LIST, _constants.ELEMENT_TYPE.UNORDERED_LIST].includes(parentNode.type)) {
+    var newChildren = parentNode.children.slice(0);
+    newChildren.splice.apply(newChildren, [at[at.length - 1], 1].concat((0, _toConsumableArray2["default"])(nodes)));
+    replaceRebaseNodeChildren(editor, {
+      at: parentPath,
+      nodes: newChildren
+    });
+    return;
+  }
+  _slate.Transforms.removeNodes(editor, (0, _objectSpread2["default"])({
+    at: at
+  }, removeOptions));
+  _slate.Transforms.insertNodes(editor, nodes, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, insertOptions), {}, {
+    at: at
+  }));
+};
+var deleteRebaseNodeMark = exports.deleteRebaseNodeMark = function deleteRebaseNodeMark(editor, path, element) {
+  var marks = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var newElement = (0, _objectSpread2["default"])({}, element);
+  marks.forEach(function (markItem) {
+    newElement[markItem] && delete newElement[markItem];
+  });
+  _slate.Transforms.removeNodes(editor, {
+    at: path
+  });
+  _slate.Transforms.insertNodes(editor, newElement, {
+    at: path
+  });
+};
+var rebaseNode = exports.rebaseNode = function rebaseNode(editor, callback) {
+  if (!callback) return;
+  _slate.Editor.withoutNormalizing(editor, function () {
+    callback && callback();
+  });
+};

package/dist/extension/core/transforms/remove-node-children.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeNodeChildren = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _slate = require("@seafile/slate");
+var removeNodeChildren = exports.removeNodeChildren = function removeNodeChildren(editor, path, options) {
+  var nodeChildren = _slate.Node.children(editor, path, {
+    reverse: true
+  });
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(nodeChildren),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = (0, _slicedToArray2["default"])(_step.value, 2),
+        childPath = _step$value[1];
+      _slate.Transforms.removeNodes(editor, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options), {}, {
+        at: childPath
+      }));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+};

package/dist/extension/core/transforms/replace-node.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceNodeChildren = exports.replaceNode = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _removeNodeChildren = require("./remove-node-children");
+var replaceNodeChildren = exports.replaceNodeChildren = function replaceNodeChildren(editor, _ref) {
+  var at = _ref.at,
+    nodes = _ref.nodes,
+    insertOptions = _ref.insertOptions,
+    removeOptions = _ref.removeOptions;
+  _slate.Editor.withoutNormalizing(editor, function () {
+    (0, _removeNodeChildren.removeNodeChildren)(editor, at, removeOptions);
+    _slate.Transforms.insertNodes(editor, nodes, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, insertOptions), {}, {
+      at: at.concat([0])
+    }));
+  });
+};
+var replaceNode = exports.replaceNode = function replaceNode(editor) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    at = _ref2.at,
+    nodes = _ref2.nodes,
+    insertOptions = _ref2.insertOptions,
+    removeOptions = _ref2.removeOptions;
+  _slate.Editor.withoutNormalizing(editor, function () {
+    _slate.Transforms.removeNodes(editor, (0, _objectSpread2["default"])({
+      at: at
+    }, removeOptions));
+    _slate.Transforms.insertNodes(editor, nodes, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, insertOptions), {}, {
+      at: at
+    }));
+  });
+};

package/dist/extension/core/transforms/update-parent-node.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateRebaseParentNodeByPath = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _constants2 = require("../../constants");
+var _queries = require("../queries");
+var updateRebaseParentNodeByPath = exports.updateRebaseParentNodeByPath = function updateRebaseParentNodeByPath(editor, path) {
+  var parentPath = path.slice(0, -1);
+  var parentNode = (0, _queries.getNode)(editor, parentPath);
+  if (![_constants2.ELEMENT_TYPE.ORDERED_LIST, _constants2.ELEMENT_TYPE.UNORDERED_LIST].includes(parentNode.type)) return;
+  var newParentElement = (0, _objectSpread2["default"])({}, parentNode);
+  newParentElement[_constants.REBASE_MARK_KEY.REBASE_TYPE] && delete newParentElement[_constants.REBASE_MARK_KEY.REBASE_TYPE];
+  newParentElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT] && delete newParentElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
+  newParentElement[_constants.REBASE_MARK_KEY.ORIGIN] && delete newParentElement[_constants.REBASE_MARK_KEY.ORIGIN];
+  newParentElement['children'] = newParentElement['children'].map(function (item) {
+    item[_constants.REBASE_MARK_KEY.REBASE_TYPE] && delete item[_constants.REBASE_MARK_KEY.REBASE_TYPE];
+    item[_constants.REBASE_MARK_KEY.OLD_ELEMENT] && delete item[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
+    item[_constants.REBASE_MARK_KEY.ORIGIN] && delete item[_constants.REBASE_MARK_KEY.ORIGIN];
+    return item;
+  });
+  _slate.Transforms.removeNodes(editor, {
+    at: parentPath
+  });
+  _slate.Transforms.insertNodes(editor, newParentElement, {
+    at: parentPath
+  });
+};

package/dist/extension/core/utils/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.match = exports.generateEmptyElement = exports.generateDefaultText = exports.generateDefaultParagraph = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var match = exports.match = function match(node, path, predicate) {
+  if (!predicate) return true;
+  if (typeof predicate === 'object') {
+    return Object.entries(predicate).every(function (_ref) {
+      var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      if (value && !Array.isArray(value)) {
+        return node[key] === value;
+      }
+      value = value ? value : [];
+      return value.includes(node[key]);
+    });
+  }
+  return predicate(node, path);
+};
+var generateDefaultText = exports.generateDefaultText = function generateDefaultText(text) {
+  return {
+    id: _slugid["default"].nice(),
+    text: text || ''
+  };
+};
+var generateDefaultParagraph = exports.generateDefaultParagraph = function generateDefaultParagraph() {
+  return {
+    id: _slugid["default"].nice(),
+    type: _constants.PARAGRAPH,
+    children: [generateDefaultText()]
+  };
+};
+var generateEmptyElement = exports.generateEmptyElement = function generateEmptyElement(type) {
+  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var text = arguments.length > 2 ? arguments[2] : undefined;
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+    id: _slugid["default"].nice(),
+    type: type
+  }, props), {}, {
+    children: [generateDefaultText(text)]
+  });
+};

package/dist/extension/index.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ContextToolbar", {
+  enumerable: true,
+  get: function get() {
+    return _toolbar.ContextToolbar;
+  }
+});
+Object.defineProperty(exports, "HeaderToolbar", {
+  enumerable: true,
+  get: function get() {
+    return _toolbar.HeaderToolbar;
+  }
+});
+Object.defineProperty(exports, "SideToolbar", {
+  enumerable: true,
+  get: function get() {
+    return _toolbar.SideToolbar;
+  }
+});
+exports["default"] = exports.createWikiEditor = exports.createDefaultEditor = exports.createCommentEditor = void 0;
+Object.defineProperty(exports, "renderElement", {
+  enumerable: true,
+  get: function get() {
+    return _renderElement["default"];
+  }
+});
+Object.defineProperty(exports, "renderLeaf", {
+  enumerable: true,
+  get: function get() {
+    return _renderLeaf["default"];
+  }
+});
+var _slate = require("@seafile/slate");
+var _slateHistory = require("@seafile/slate-history");
+var _slateReact = require("@seafile/slate-react");
+var _plugins = _interopRequireWildcard(require("./plugins"));
+var _renderElement = _interopRequireDefault(require("./render/render-element"));
+var _renderLeaf = _interopRequireDefault(require("./render/render-leaf"));
+var _toolbar = require("./toolbar");
+var baseEditor = (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)()));
+var defaultEditor = _plugins["default"] === null || _plugins["default"] === void 0 ? void 0 : _plugins["default"].reduce(function (editor, pluginItem) {
+  var withPlugin = pluginItem.editorPlugin;
+  if (withPlugin) {
+    return withPlugin(editor);
+  }
+  return editor;
+}, baseEditor);
+var createDefaultEditor = exports.createDefaultEditor = function createDefaultEditor() {
+  var defaultEditor = _plugins["default"] === null || _plugins["default"] === void 0 ? void 0 : _plugins["default"].reduce(function (editor, pluginItem) {
+    var withPlugin = pluginItem.editorPlugin;
+    if (withPlugin) {
+      return withPlugin(editor);
+    }
+    return editor;
+  }, (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)())));
+  return defaultEditor;
+};
+var createWikiEditor = exports.createWikiEditor = function createWikiEditor() {
+  var defaultEditor = _plugins.WikiPlugins === null || _plugins.WikiPlugins === void 0 ? void 0 : _plugins.WikiPlugins.reduce(function (editor, pluginItem) {
+    var withPlugin = pluginItem.editorPlugin;
+    if (withPlugin) {
+      return withPlugin(editor);
+    }
+    return editor;
+  }, (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)())));
+  return defaultEditor;
+};
+var createCommentEditor = exports.createCommentEditor = function createCommentEditor() {
+  var defaultEditor = _plugins.CommentPlugins === null || _plugins.CommentPlugins === void 0 ? void 0 : _plugins.CommentPlugins.reduce(function (editor, pluginItem) {
+    var withPlugin = pluginItem.editorPlugin;
+    if (withPlugin) {
+      return withPlugin(editor);
+    }
+    return editor;
+  }, (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)())));
+  return defaultEditor;
+};
+var _default = exports["default"] = defaultEditor;

package/dist/extension/plugins/ai/ai-icon/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = AIIcon;
+var _react = _interopRequireDefault(require("react"));
+var _reactI18next = require("react-i18next");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _sdocAskAi = _interopRequireDefault(require("../../../../assets/images/sdoc-ask-ai.png"));
+require("./style.css");
+function AIIcon(_ref) {
+  var _ref$className = _ref.className,
+    className = _ref$className === void 0 ? 'big' : _ref$className;
+  var _useTranslation = (0, _reactI18next.useTranslation)('sdoc-editor'),
+    t = _useTranslation.t;
+  var classnames = (0, _classnames["default"])('sdoc-ask-ai-icon', className);
+  return /*#__PURE__*/_react["default"].createElement("img", {
+    className: classnames,
+    src: _sdocAskAi["default"],
+    alt: t('Ask_AI')
+  });
+}