@seafile/comment-editor 0.0.1-alpha.0

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

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deleteMerge = void 0;
+var _slate = require("@seafile/slate");
+/**
+ *
+ * @param {*} editor
+ * @param {*} options { at, distance, hanging, reverse, test, unit, voids }
+ */
+const deleteMerge = function (editor) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  _slate.Editor.withoutNormalizing(editor, () => {
+    const {
+      distance = 1,
+      reverse = false,
+      unit = 'character',
+      voids = false
+    } = options;
+    let {
+      at = editor.selection,
+      hanging = false
+    } = options;
+    if (!at) {
+      return;
+    }
+    if (_slate.Range.isRange(at) && _slate.Range.isCollapsed(at)) {
+      at = at.anchor;
+    }
+    if (_slate.Point.isPoint(at)) {
+      const furthestVoid = _slate.Editor.void(editor, {
+        at,
+        mode: 'highest'
+      });
+      if (!voids && furthestVoid) {
+        const [, voidPath] = furthestVoid;
+        at = voidPath;
+      } else {
+        const opts = {
+          distance,
+          unit
+        };
+        const 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
+      });
+      return;
+    }
+    if (_slate.Range.isCollapsed(at)) {
+      return;
+    }
+    if (!hanging) {
+      at = _slate.Editor.unhangRange(editor, at, {
+        voids
+      });
+    }
+    let [start, end] = _slate.Range.edges(at);
+    const startBlock = _slate.Editor.above(editor, {
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n),
+      at: start,
+      voids
+    });
+    const endBlock = _slate.Editor.above(editor, {
+      match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n),
+      at: end,
+      voids
+    });
+    const isAcrossBlocks = startBlock && endBlock && !_slate.Path.equals(startBlock[1], endBlock[1]);
+    const isSingleText = _slate.Path.equals(start.path, end.path);
+    const startVoid = voids ? null : _slate.Editor.void(editor, {
+      at: start,
+      mode: 'highest'
+    });
+    const endVoid = voids ? null : _slate.Editor.void(editor, {
+      at: end,
+      mode: 'highest'
+    });
+    if (startVoid) {
+      const before = _slate.Editor.before(editor, start);
+      if (before && startBlock && _slate.Path.isAncestor(startBlock[1], before.path)) {
+        start = before;
+      }
+    }
+    if (endVoid) {
+      const after = _slate.Editor.after(editor, end);
+      if (after && endVoid && _slate.Path.isAncestor(endBlock[1], after.path)) {
+        end = after;
+      }
+    }
+    const matches = [];
+    let lastPath = undefined;
+    const _nodes = _slate.Editor.nodes(editor, {
+      at,
+      voids
+    });
+    for (const entry of _nodes) {
+      const [node, path] = entry;
+      if (lastPath && _slate.Path.compare(path, lastPath) === 0) {
+        continue;
+      }
+      if (!voids && _slate.Editor.isVoid(editor, node) || !_slate.Path.isCommon(path, start.path) && !_slate.Path.isCommon(path, end.path)) {
+        matches.push(entry);
+        lastPath = path;
+      }
+    }
+    const pathRefs = Array.from(matches, _ref => {
+      let [, p] = _ref;
+      return _slate.Editor.pathRef(editor, p);
+    });
+    const startRef = _slate.Editor.pointRef(editor, start);
+    const endRef = _slate.Editor.pointRef(editor, end);
+    if (!isSingleText && !startVoid) {
+      const point = startRef.current;
+      const [node] = _slate.Editor.leaf(editor, point);
+      const {
+        path
+      } = point;
+      const {
+        offset
+      } = start;
+      const text = node.text.slice(offset);
+      editor.apply({
+        type: 'remove_text',
+        path,
+        offset,
+        text
+      });
+    }
+    for (const pathRef of pathRefs) {
+      const path = pathRef.unref();
+      _slate.Transforms.removeNodes(editor, {
+        at: path,
+        voids
+      });
+    }
+    if (!endVoid) {
+      const point = endRef.current;
+      const [node] = _slate.Editor.leaf(editor, point);
+      const {
+        path
+      } = point;
+      const offset = isSingleText ? start.offset : 0;
+      const text = node.text.slice(offset, end.offset);
+      editor.apply({
+        offset,
+        path,
+        text,
+        type: 'remove_text'
+      });
+    }
+    if (!isSingleText && isAcrossBlocks && endRef.current && start.current) {
+      _slate.Transforms.mergeNodes(editor, {
+        at: endRef.current,
+        hanging: true,
+        voids
+      });
+    }
+    const point = endRef.unref() || startRef.unref();
+    if (options.at == null && point) {
+      _slate.Transforms.select(editor, point);
+    }
+  });
+};
+exports.deleteMerge = deleteMerge;

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

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

package/dist/basic-sdk/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 () {
+      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 () {
+      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 () {
+      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 () {
+      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 () {
+      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 () {
+      return _rebase[key];
+    }
+  });
+});

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveChildren = void 0;
+var _slate = require("@seafile/slate");
+var _queries = require("../queries");
+const moveChildren = (editor, _ref) => {
+  let {
+    at,
+    to,
+    match,
+    fromStartIndex = 0
+  } = _ref;
+  let moved = 0;
+  const parentPath = _slate.Path.isPath(at) ? at : at[1];
+  const 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 (let i = parentNode.children.length - 1; i >= fromStartIndex; i--) {
+    const childPath = [...parentPath, i];
+    const childNode = (0, _queries.getNode)(editor, childPath);
+    if (!match || childNode && match([childNode, childPath])) {
+      _slate.Transforms.moveNodes(editor, {
+        at: childPath,
+        to
+      });
+      moved++;
+    }
+  }
+  return moved;
+};
+exports.moveChildren = moveChildren;

package/dist/basic-sdk/extension/core/transforms/rebase.js

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

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeNodeChildren = void 0;
+var _slate = require("@seafile/slate");
+const removeNodeChildren = (editor, path, options) => {
+  const nodeChildren = _slate.Node.children(editor, path, {
+    reverse: true
+  });
+  for (const [, childPath] of nodeChildren) {
+    _slate.Transforms.removeNodes(editor, {
+      ...options,
+      at: childPath
+    });
+  }
+};
+exports.removeNodeChildren = removeNodeChildren;

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateRebaseParentNodeByPath = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _constants2 = require("../../constants");
+var _queries = require("../queries");
+const updateRebaseParentNodeByPath = (editor, path) => {
+  const parentPath = path.slice(0, -1);
+  const parentNode = (0, _queries.getNode)(editor, parentPath);
+  if (![_constants2.ELEMENT_TYPE.ORDERED_LIST, _constants2.ELEMENT_TYPE.UNORDERED_LIST].includes(parentNode.type)) return;
+  const newParentElement = {
+    ...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(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
+  });
+};
+exports.updateRebaseParentNodeByPath = updateRebaseParentNodeByPath;

package/dist/basic-sdk/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 _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+const match = (node, path, predicate) => {
+  if (!predicate) return true;
+  if (typeof predicate === 'object') {
+    return Object.entries(predicate).every(_ref => {
+      let [key, value] = _ref;
+      if (value && !Array.isArray(value)) {
+        return node[key] === value;
+      }
+      value = value ? value : [];
+      return value.includes(node[key]);
+    });
+  }
+  return predicate(node, path);
+};
+exports.match = match;
+const generateDefaultText = text => {
+  return {
+    id: _slugid.default.nice(),
+    text: text || ''
+  };
+};
+exports.generateDefaultText = generateDefaultText;
+const generateDefaultParagraph = () => {
+  return {
+    id: _slugid.default.nice(),
+    type: _constants.PARAGRAPH,
+    children: [generateDefaultText()]
+  };
+};
+exports.generateDefaultParagraph = generateDefaultParagraph;
+const generateEmptyElement = function (type) {
+  let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let text = arguments.length > 2 ? arguments[2] : undefined;
+  return {
+    id: _slugid.default.nice(),
+    type,
+    ...props,
+    children: [generateDefaultText(text)]
+  };
+};
+exports.generateEmptyElement = generateEmptyElement;

package/dist/basic-sdk/extension/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.createDefaultEditor = exports.createCommentEditor = void 0;
+Object.defineProperty(exports, "renderLeaf", {
+  enumerable: true,
+  get: function () {
+    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 _renderLeaf = _interopRequireDefault(require("./render/render-leaf"));
+const baseEditor = (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)()));
+const defaultEditor = _plugins.default === null || _plugins.default === void 0 ? void 0 : _plugins.default.reduce((editor, pluginItem) => {
+  const withPlugin = pluginItem.editorPlugin;
+  if (withPlugin) {
+    return withPlugin(editor);
+  }
+  return editor;
+}, baseEditor);
+const createDefaultEditor = () => {
+  const defaultEditor = _plugins.default === null || _plugins.default === void 0 ? void 0 : _plugins.default.reduce((editor, pluginItem) => {
+    const withPlugin = pluginItem.editorPlugin;
+    if (withPlugin) {
+      return withPlugin(editor);
+    }
+    return editor;
+  }, (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)())));
+  return defaultEditor;
+};
+exports.createDefaultEditor = createDefaultEditor;
+const createCommentEditor = () => {
+  const defaultEditor = _plugins.CommentPlugins === null || _plugins.CommentPlugins === void 0 ? void 0 : _plugins.CommentPlugins.reduce((editor, pluginItem) => {
+    const withPlugin = pluginItem.editorPlugin;
+    if (withPlugin) {
+      return withPlugin(editor);
+    }
+    return editor;
+  }, (0, _slateHistory.withHistory)((0, _slateReact.withReact)((0, _slate.createEditor)())));
+  return defaultEditor;
+};
+exports.createCommentEditor = createCommentEditor;
+var _default = exports.default = defaultEditor;

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

@@ -0,0 +1,26 @@
+"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) {
+  let {
+    className = 'big'
+  } = _ref;
+  const {
+    t
+  } = (0, _reactI18next.useTranslation)('sdoc-editor');
+  const classnames = (0, _classnames.default)('sdoc-ask-ai-icon', className);
+  return /*#__PURE__*/_react.default.createElement("img", {
+    className: classnames,
+    src: _sdocAskAi.default,
+    alt: t('Ask_AI')
+  });
+}

package/dist/basic-sdk/extension/plugins/ai/ai-icon/style.css

@@ -0,0 +1,22 @@
+.sdoc-ask-ai-icon.big {
+  position: absolute;
+  width: 18px;
+  height: 18px;
+  left: 16px;
+}
+
+.sdoc-ask-ai-icon.small {
+  width: 12px;
+  height: 13px;
+  margin-right: 4px;
+}
+
+.sdoc-ai-result-header div {
+  display: flex;
+}
+
+.sdoc-ai-result-header .sdoc-ask-ai-icon.big {
+  position: relative;
+  left: 0;
+  margin-right: 10px;
+}

package/dist/basic-sdk/extension/plugins/ai/ai-menu/ai-context-menu.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = AIContextMenu;
+var _react = _interopRequireWildcard(require("react"));
+var _constants = require("../../../../constants");
+var _eventBus = _interopRequireDefault(require("../../../../utils/event-bus"));
+var _constants2 = require("../../../constants");
+var _menuItem = _interopRequireDefault(require("./menu-item"));
+require("./style.css");
+function AIContextMenu(_ref) {
+  let {
+    isRichEditor
+  } = _ref;
+  const onAiClick = (0, _react.useCallback)(event => {
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_constants.INTERNAL_EVENT.INSERT_ELEMENT, {
+      type: _constants2.ELEMENT_TYPE.ASK_AI,
+      slateNode: null
+    });
+  }, []);
+  const aiProps = {
+    id: 'context-toolbar-ai',
+    isRichEditor,
+    className: 'menu-group-item sdoc-ask-ai-menu-container',
+    disabled: false,
+    isActive: false,
+    onMouseDown: onAiClick,
+    'iconClass': 'sdocfont sdoc-ask-ai',
+    'text': 'Ask_AI',
+    'ariaLabel': 'Ask_AI',
+    'type': 'sdoc-ask-ai'
+  };
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("div", {
+    className: "sdoc-context-menu-divider"
+  }), /*#__PURE__*/_react.default.createElement(_menuItem.default, aiProps));
+}