@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/extension/plugins/list/transforms/normalize-list-item.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeListItem = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+var _queries = require("../queries");
+var _moveListItemUp = require("./move-list-item-up");
+const normalizeListItem = (editor, _ref) => {
+  let {
+    listItem
+  } = _ref;
+  let changed = false;
+  const validLiChildrenTypes = [...(0, _queries.getListTypes)(), _constants.PARAGRAPH, _constants.GROUP];
+  const [, liPath] = listItem;
+  const liChildren = (0, _core.getChildren)(listItem);
+  const invalidLiChildrenPathRefs = liChildren.filter(_ref2 => {
+    let [child] = _ref2;
+    return !validLiChildrenTypes.includes(child.type);
+  }).map(_ref3 => {
+    let [, childPath] = _ref3;
+    return _slate.Editor.pathRef(editor, childPath);
+  });
+  const firstLiChild = liChildren[0];
+  const [firstLiChildNode, firstLiChildPath] = firstLiChild !== null && firstLiChild !== void 0 ? firstLiChild : [];
+  if (!firstLiChild || !_slate.Editor.isBlock(editor, firstLiChildNode)) {
+    const itemContent = (0, _model.generateEmptyListContent)();
+    _slate.Transforms.insertNodes(editor, itemContent, {
+      at: liPath.concat([0])
+    });
+    return true;
+  }
+  if (_slate.Editor.isBlock(editor, firstLiChildNode) && !(0, _core.match)(firstLiChildNode, [], {
+    type: [_constants.PARAGRAPH]
+  })) {
+    if ((0, _core.match)(firstLiChildNode, [], {
+      type: (0, _queries.getListTypes)()
+    })) {
+      const parent = _slate.Editor.parent(editor, listItem[1]);
+      const subList = firstLiChild;
+      const children = (0, _core.getChildren)(firstLiChild).reverse();
+      children.forEach(c => {
+        (0, _moveListItemUp.movedListItemUp)(editor, {
+          list: subList,
+          listItem: c
+        });
+      });
+      _slate.Transforms.removeNodes(editor, {
+        at: [...parent[1], 0]
+      });
+      return true;
+    }
+    if (validLiChildrenTypes.includes(firstLiChildNode.type)) {
+      return true;
+    }
+    _slate.Transforms.setNodes(editor, {
+      type: _constants.PARAGRAPH
+    }, {
+      at: firstLiChildPath
+    });
+    changed = true;
+  }
+  const licChildren = (0, _core.getChildren)(firstLiChild);
+  if (licChildren.length) {
+    var _licChildren;
+    const blockPathRefs = [];
+    const inlineChildren = [];
+    for (const licChild of licChildren) {
+      if (!(_slate.Element.isElement(licChild[0]) && _slate.Editor.isBlock(editor, licChild[0]))) {
+        break;
+      }
+      blockPathRefs.push(_slate.Editor.pathRef(editor, licChild[1]));
+      inlineChildren.push(...(0, _core.getDeepInlineChildren)(editor, {
+        children: (0, _core.getChildren)(licChild)
+      }));
+    }
+    const to = _slate.Path.next((_licChildren = licChildren[licChildren.length - 1]) === null || _licChildren === void 0 ? void 0 : _licChildren[1]);
+    inlineChildren.reverse().forEach(_ref4 => {
+      let [, path] = _ref4;
+      _slate.Transforms.moveNodes(editor, {
+        at: path,
+        to
+      });
+    });
+    blockPathRefs.forEach(pathRef => {
+      const path = pathRef.unref();
+      path && _slate.Transforms.removeNodes(editor, {
+        at: path
+      });
+    });
+    if (blockPathRefs.length) {
+      changed = true;
+    }
+  }
+  if (changed) return true;
+  invalidLiChildrenPathRefs.reverse().forEach(ref => {
+    const path = ref.unref();
+    path && _slate.Transforms.moveNodes(editor, {
+      at: path,
+      to: firstLiChildPath.concat([0])
+    });
+  });
+  return !!invalidLiChildrenPathRefs.length;
+};
+exports.normalizeListItem = normalizeListItem;

package/dist/basic-sdk/extension/plugins/list/transforms/normalize-nested-list.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeNestedList = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+const normalizeNestedList = function (editor) {
+  let {
+    nestedListItem
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const [, path] = nestedListItem;
+  const parentNodeEntry = _slate.Editor.parent(editor, path);
+  const hasParentList = parentNodeEntry && (0, _core.match)(parentNodeEntry[0], [], {
+    type: [_constants.ORDERED_LIST, _constants.UNORDERED_LIST]
+  });
+  if (!hasParentList) return false;
+  let previousListItemPath = null;
+  try {
+    previousListItemPath = _slate.Path.previous(path);
+  } catch (e) {
+    return false;
+  }
+  const previousSiblingItem = _slate.Editor.node(editor, previousListItemPath);
+  if (previousSiblingItem) {
+    const [, previousPath] = previousSiblingItem;
+    const newPath = previousPath.concat([1]);
+    _slate.Transforms.moveNodes(editor, {
+      at: path,
+      to: newPath
+    });
+    return true;
+  }
+  return false;
+};
+exports.normalizeNestedList = normalizeNestedList;

package/dist/basic-sdk/extension/plugins/list/transforms/remove-first-list-item.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeFirstListItem = void 0;
+var _queries = require("../queries");
+var _moveListItemUp = require("./move-list-item-up");
+const removeFirstListItem = (editor, _ref) => {
+  let {
+    list,
+    listItem
+  } = _ref;
+  const [, listPath] = list;
+  if (!(0, _queries.isListNested)(editor, listPath)) {
+    (0, _moveListItemUp.movedListItemUp)(editor, {
+      list,
+      listItem
+    });
+    return true;
+  }
+  return false;
+};
+exports.removeFirstListItem = removeFirstListItem;

package/dist/basic-sdk/extension/plugins/list/transforms/remove-list-item.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeListItem = void 0;
+var _slate = require("@seafile/slate");
+var _core = require("../../../core");
+var _deleteMerge = require("../../../core/transforms/delete-merge");
+var _model = require("../model");
+var _queries = require("../queries");
+var _moveListItemSublistToListItemSublist = require("./move-list-item-sublist-to-list-item-sublist");
+var _moveListItemsToList = require("./move-list-items-to-list");
+const removeListItem = (editor, _ref) => {
+  let {
+    list,
+    listItem,
+    reverse = true
+  } = _ref;
+  const [liNode, liPath] = listItem;
+  if (_slate.Range.isExpanded(editor.selection) || !(0, _queries.hasListChild)(liNode)) {
+    return false;
+  }
+  const previousLiPath = (0, _core.getPreviousPath)(liPath);
+  let success = false;
+  _slate.Editor.withoutNormalizing(editor, () => {
+    if (previousLiPath) {
+      const previousLi = _slate.Editor.node(editor, previousLiPath);
+      if (!previousLi) return;
+      let tempLiPath = _slate.Path.next(liPath);
+      let tempLiNode = (0, _model.generateListItem)();
+      _slate.Transforms.insertNodes(editor, tempLiNode, {
+        at: tempLiPath
+      });
+      const tempLi = _slate.Editor.node(editor, tempLiPath);
+      if (!tempLi) return;
+      const tempLiPathRef = _slate.Editor.pathRef(editor, tempLi[1]);
+      (0, _moveListItemSublistToListItemSublist.moveListItemSublistItemsToListItemSublist)(editor, {
+        fromListItem: listItem,
+        toListItem: tempLi
+      });
+      (0, _deleteMerge.deleteMerge)(editor, {
+        reverse
+      });
+      tempLiPath = tempLiPathRef.unref();
+      (0, _moveListItemSublistToListItemSublist.moveListItemSublistItemsToListItemSublist)(editor, {
+        fromListItem: [tempLi[0], tempLiPath],
+        toListItem: previousLi
+      });
+      _slate.Transforms.removeNodes(editor, {
+        at: tempLiPath
+      });
+      success = true;
+      return;
+    }
+    (0, _moveListItemsToList.moveListItemsToList)(editor, {
+      fromListItem: listItem,
+      toList: list,
+      toListIndex: 1
+    });
+  });
+  return success;
+};
+exports.removeListItem = removeListItem;

package/dist/basic-sdk/extension/plugins/list/transforms/toggle-list.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+var _queries = require("../queries");
+var _unwrapList = require("./unwrap-list");
+const wrapLineList = (editor, type) => {
+  const list = (0, _model.generateEmptyList)(type);
+  _slate.Transforms.wrapNodes(editor, list);
+  const nodeEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants.PARAGRAPH);
+  if (!nodeEntry) return;
+
+  // select is paragraph
+  // 1 handle paragraph
+
+  // 2 wrap list_item
+  const [, path] = nodeEntry;
+  const listItem = (0, _model.generateEmptyListItem)();
+  _slate.Transforms.wrapNodes(editor, listItem, {
+    at: path
+  });
+  return;
+};
+const wrapRangeList = (editor, type) => {
+  // 选中的是一个区间
+  _slate.Editor.withoutNormalizing(editor, () => {
+    // 1. 获取公共祖先
+    const [startPoint, endPoint] = _slate.Range.edges(editor.selection);
+    const commonAncestor = _slate.Node.common(editor, startPoint.path, endPoint.path);
+    const listTypes = (0, _queries.getListTypes)();
+
+    // 2. 公共祖先如果是 ordered_list | unordered_list
+    if (listTypes.includes(commonAncestor[0].type) || commonAncestor[0].type === _constants.LIST_ITEM) {
+      if (commonAncestor[0].type !== type) {
+        const start = _slate.Range.start(editor.selection);
+        const end = _slate.Range.end(editor.selection);
+        const options = {
+          at: start,
+          match: {
+            type: listTypes
+          },
+          mode: 'lowest'
+        };
+        const startList = (0, _core.findNode)(editor, options);
+        const endList = (0, _core.findNode)(editor, {
+          ...options,
+          ...{
+            at: end
+          }
+        });
+        const rangeLength = Math.min(startList[1].length, endList[1].length);
+        _slate.Transforms.setNodes(editor, {
+          type
+        }, {
+          at: editor.selection,
+          match: (n, path) => _slate.Element.isElement(n) && listTypes.includes(n.type) && path.length >= rangeLength,
+          mode: 'all'
+        });
+      } else {
+        (0, _unwrapList.unwrapList)(editor);
+      }
+      return;
+    }
+
+    // 获取选中的所有节点的子元素
+    const rootPathLength = commonAncestor[1].length;
+    const _nodes = (0, _core.getNodeEntries)(editor, {
+      mode: 'all'
+    });
+    const nodes = Array.from(_nodes).filter(_ref => {
+      let [, path] = _ref;
+      return path.length === rootPathLength + 1;
+    });
+    nodes.forEach(n => {
+      if (listTypes.includes(n[0].type)) {
+        _slate.Transforms.setNodes(editor, {
+          type
+        }, {
+          at: n[1],
+          match: _n => _slate.Element.isElement(_n) && listTypes.includes(_n.type),
+          mode: 'all'
+        });
+      } else {
+        // select content is paragraph
+        // 1 handle content
+
+        // 2. wrap list_item
+        const listItem = (0, _model.generateEmptyListItem)();
+        _slate.Transforms.wrapNodes(editor, listItem, {
+          at: n[1]
+        });
+
+        // 3. wrap list
+        const list = (0, _model.generateEmptyList)(type);
+        _slate.Transforms.wrapNodes(editor, list, {
+          at: n[1]
+        });
+      }
+    });
+  });
+};
+const toggleList = function (editor, type, insertPosition) {
+  let focusSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  if (insertPosition === _constants.INSERT_POSITION.AFTER) {
+    const list = (0, _model.generateEmptyList)(type);
+    const listContent = (0, _model.generateEmptyListContent)();
+    const path = _slate.Editor.path(editor, editor.selection);
+    _slate.Transforms.insertNodes(editor, listContent, {
+      at: [path[0] + 1]
+    });
+    _slate.Transforms.select(editor, [path[0] + 1]);
+    _slate.Transforms.wrapNodes(editor, list);
+    return;
+  }
+  _slate.Editor.withoutNormalizing(editor, () => {
+    const {
+      selection
+    } = editor;
+    if (!selection) return false;
+    const [currentNode] = (0, _core.getCurrentNode)(editor);
+
+    // selection is collapsed, anchor === focus
+    // selection is in one block
+    if (_slate.Range.isCollapsed(selection) || !(0, _core.isRangeAcrossBlocks)(editor)) {
+      const res = (0, _queries.getListItemEntry)(editor);
+      if (res) {
+        const {
+          list
+        } = res;
+        // 选中内容的类型是另一个类型, 如： select_type: ordered_list, 将被切换为 unordered_list
+        if (list[0].type !== type) {
+          const match = n => (0, _queries.getListTypes)().includes((0, _core.getNodeType)(n));
+          _slate.Transforms.setNodes(editor, {
+            type
+          }, {
+            at: editor.selection,
+            match: match,
+            mode: 'lowest'
+          });
+        } else {
+          (0, _unwrapList.unwrapList)(editor);
+        }
+      } else {
+        wrapLineList(editor, type);
+      }
+
+      // When currentNode is empty
+      if (!_slate.Node.string(currentNode) && currentNode.children.length === 1 && focusSelection) {
+        (0, _core.focusEditor)(editor, editor.selection);
+      }
+      return;
+    }
+
+    // selection is a range
+    wrapRangeList(editor, type);
+  });
+};
+var _default = exports.default = toggleList;

package/dist/basic-sdk/extension/plugins/list/transforms/unwrap-list.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unwrapList = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _queries = require("../queries");
+const unwrapList = function (editor) {
+  let {
+    at
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const ancestorListTypeCheck = () => {
+    if ((0, _core.getAboveNode)(editor, {
+      match: {
+        type: (0, _queries.getListTypes)()
+      }
+    })) {
+      return true;
+    }
+
+    // The selection's common node might be a list type
+    if (!at && editor.selection) {
+      const commonNode = _slate.Node.common(editor, editor.selection.anchor.path, editor.selection.focus.path);
+      if (_slate.Element.isElement(commonNode[0]) && (0, _queries.getListTypes)().includes(commonNode[0].type)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  _slate.Editor.withoutNormalizing(editor, () => {
+    do {
+      // unwrap list_item
+      _slate.Transforms.unwrapNodes(editor, {
+        at,
+        match: n => (0, _core.getNodeType)(n) === _constants.LIST_ITEM,
+        split: true
+      });
+
+      // unwrap list
+      _slate.Transforms.unwrapNodes(editor, {
+        at,
+        match: n => (0, _queries.getListTypes)().includes((0, _core.getNodeType)(n)),
+        split: true
+      });
+    } while (ancestorListTypeCheck());
+  });
+};
+exports.unwrapList = unwrapList;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _plugin = _interopRequireDefault(require("./plugin"));
+const MarkDownPlugin = {
+  editorPlugin: _plugin.default
+};
+var _default = exports.default = MarkDownPlugin;

package/dist/basic-sdk/extension/plugins/markdown/plugin.js

@@ -0,0 +1,202 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _constants2 = require("../../constants");
+var _core = require("../../core");
+var _helpers = require("../blockquote/helpers");
+var _transforms = require("../list/transforms");
+// Title shortcut
+const TITLE_SHORT_CUT = {
+  '#': _constants2.HEADER1,
+  '##': _constants2.HEADER2,
+  '###': _constants2.HEADER3,
+  '####': _constants2.HEADER4,
+  '#####': _constants2.HEADER5,
+  '######': _constants2.HEADER6
+};
+
+// List shortcut
+const LIST_SHORT_CUT = {
+  '*': _constants2.UNORDERED_LIST,
+  '-': _constants2.UNORDERED_LIST
+};
+
+// Reference shortcut key
+const REFERENCE_SHORT_CUT = {
+  '>': _constants2.BLOCKQUOTE
+};
+const KEY_TO_TYPE_FOR_SPACE_DEFAULT_EDITOR = {
+  ...TITLE_SHORT_CUT,
+  ...LIST_SHORT_CUT,
+  ...REFERENCE_SHORT_CUT
+};
+const KEY_TO_TYPE_FOR_SPACE_COMMENT_EDITOR = {
+  ...LIST_SHORT_CUT
+};
+const KEY_TO_INLINE_TYPE_FOR_SPACE = {
+  // Inline shortcut keys
+  '**': _constants2.TEXT_STYLE_MAP.BOLD,
+  '*': _constants2.TEXT_STYLE_MAP.ITALIC,
+  '***': _constants2.TEXT_STYLE_MAP.BOLD_ITALIC
+};
+const getBeforeText = editor => {
+  const {
+    selection
+  } = editor;
+  if (selection == null) return {
+    beforeText: '',
+    range: null
+  };
+  const {
+    anchor,
+    focus
+  } = selection;
+  const lastIndex = focus.path[focus.path.length - 1];
+  if (lastIndex !== 0) return {
+    beforeText: '',
+    range: null
+  };
+  const range = {
+    anchor,
+    focus: {
+      path: focus.path,
+      offset: 0
+    }
+  };
+  const beforeText = _slate.Editor.string(editor, range) || '';
+  return {
+    beforeText,
+    range
+  };
+};
+const withMarkDown = editor => {
+  const {
+    insertText
+  } = editor;
+  const newEditor = editor;
+  const KEY_TO_TYPE_FOR_SPACE = newEditor.editorType === _constants.COMMENT_EDITOR ? KEY_TO_TYPE_FOR_SPACE_COMMENT_EDITOR : KEY_TO_TYPE_FOR_SPACE_DEFAULT_EDITOR;
+
+  // When entering a space, convert markdown
+  newEditor.insertText = text => {
+    const {
+      selection
+    } = editor;
+    if (selection == null) return insertText(text);
+    if (_slate.Range.isExpanded(selection)) return insertText(text);
+    if ((0, _core.getSelectedNodeByType)(editor, _constants2.PARAGRAPH) == null) return insertText(text); // It must be in paragraph
+    if (text !== ' ') return insertText(text); // The value must be an input space
+
+    // Gets the text before the space
+    const {
+      beforeText,
+      range
+    } = getBeforeText(editor);
+    if (!beforeText || !range) return insertText(text);
+
+    // Based on the keyword, find the type of element you want to convert
+    const type = KEY_TO_TYPE_FOR_SPACE[beforeText.trim()];
+    const italicAndBoldType = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-3)];
+    const boldType = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-2)];
+    const italicType = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-1)];
+    if (!type && !boldType && !italicType && !italicAndBoldType) return insertText(text);
+    if (italicAndBoldType === _constants2.TEXT_STYLE_MAP.BOLD_ITALIC) {
+      const restStr = beforeText === null || beforeText === void 0 ? void 0 : beforeText.slice(0, beforeText.length - 3);
+      const startOffset = restStr === null || restStr === void 0 ? void 0 : restStr.lastIndexOf('***');
+      const endOffset = (beforeText === null || beforeText === void 0 ? void 0 : beforeText.lastIndexOf('***')) + 3;
+      if (startOffset !== -3) {
+        _slate.Transforms.delete(editor, {
+          at: {
+            anchor: {
+              path: range.focus.path,
+              offset: startOffset
+            },
+            focus: {
+              ...selection.focus
+            }
+          },
+          voids: true
+        });
+        const newText = beforeText.slice(startOffset + 3, endOffset - 3);
+        _slate.Editor.addMark(editor, _constants2.TEXT_STYLE_MAP.BOLD, true);
+        _slate.Editor.addMark(editor, _constants2.TEXT_STYLE_MAP.ITALIC, true);
+        return insertText(newText);
+      }
+    }
+    if (boldType === _constants2.TEXT_STYLE_MAP.BOLD) {
+      const restStr = beforeText.slice(0, beforeText.length - 2);
+      const startOffset = restStr.lastIndexOf('**');
+      const endOffset = beforeText.lastIndexOf('**') + 2;
+      if (startOffset === -1) {
+        return insertText(text);
+      }
+      _slate.Transforms.delete(editor, {
+        at: {
+          anchor: {
+            path: range.focus.path,
+            offset: startOffset
+          },
+          focus: {
+            ...selection.focus
+          }
+        },
+        voids: true
+      });
+      const newType = boldType.toLowerCase();
+      const newText = beforeText.slice(startOffset + 2, endOffset - 2);
+      _slate.Editor.addMark(editor, newType, true);
+      return insertText(newText);
+    }
+
+    // demos
+    // 1 '*'
+    // 2 'acd * add *'
+    if (italicType === _constants2.TEXT_STYLE_MAP.ITALIC) {
+      const restStr = beforeText === null || beforeText === void 0 ? void 0 : beforeText.slice(0, beforeText.length - 1);
+      const startOffset = restStr === null || restStr === void 0 ? void 0 : restStr.lastIndexOf('*');
+      const endOffset = (beforeText === null || beforeText === void 0 ? void 0 : beforeText.lastIndexOf('*')) + 1;
+      if (startOffset === -1 && restStr.length > 0) {
+        return insertText(text);
+      }
+      if (startOffset !== -1) {
+        _slate.Transforms.delete(editor, {
+          at: {
+            anchor: {
+              path: range.focus.path,
+              offset: startOffset
+            },
+            focus: {
+              ...selection.focus
+            }
+          },
+          voids: true
+        });
+        const newType = italicType.toLowerCase();
+        const newText = beforeText.slice(startOffset + 1, endOffset - 1);
+        _slate.Editor.addMark(editor, newType, true);
+        return insertText(newText);
+      }
+    }
+
+    // Delete element
+    _slate.Transforms.select(editor, range);
+    _slate.Transforms.delete(editor);
+    if (type === _constants2.UNORDERED_LIST) {
+      (0, _transforms.toggleList)(editor, type, null, false);
+      return;
+    }
+    if (type === _constants2.BLOCKQUOTE) {
+      (0, _helpers.setBlockQuoteType)(editor, false);
+      return;
+    }
+    _slate.Transforms.setNodes(editor, {
+      type
+    });
+  };
+  return newEditor;
+};
+var _default = exports.default = withMarkDown;