@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/extension/plugins/list/queries/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isListNested = exports.hasListChild = exports.getListTypes = exports.getListItemEntry = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+const getListTypes = () => {
+  return [_constants.ORDERED_LIST, _constants.UNORDERED_LIST];
+};
+exports.getListTypes = getListTypes;
+const getListItemEntry = function (editor) {
+  let {
+    at = editor.selection
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let _at = null;
+  if (_slate.Range.isRange(at) && !_slate.Range.isCollapsed(at)) {
+    _at = at.focus.path;
+  } else if (_slate.Range.isRange(at)) {
+    _at = at.anchor.path;
+  } else {
+    _at = at;
+  }
+  if (_at) {
+    const node = _slate.Node.get(editor, _at);
+    if (node) {
+      const listItem = _slate.Editor.above(editor, {
+        at: _at,
+        match: n => _slate.Element.isElement(n) && n.type === _constants.LIST_ITEM
+      });
+      if (listItem) {
+        const list = _slate.Editor.parent(editor, listItem[1]);
+        return {
+          list,
+          listItem
+        };
+      }
+    }
+  }
+  return null;
+};
+exports.getListItemEntry = getListItemEntry;
+const hasListChild = node => {
+  return node.children.some(n => {
+    return _slate.Element.isElement(n) && getListTypes().includes(n.type);
+  });
+};
+exports.hasListChild = hasListChild;
+const isListNested = (editor, listPath) => {
+  var _Editor$parent;
+  const listParentNode = (_Editor$parent = _slate.Editor.parent(editor, listPath)) === null || _Editor$parent === void 0 ? void 0 : _Editor$parent[0];
+  return (listParentNode === null || listParentNode === void 0 ? void 0 : listParentNode.type) === _constants.LIST_ITEM;
+};
+exports.isListNested = isListNested;

package/dist/basic-sdk/extension/plugins/list/render-elem.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderListLic = exports.renderListItem = exports.renderList = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _constants = require("../../constants");
+const renderList = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element: node
+  } = props;
+  const Tag = node.type === _constants.ORDERED_LIST ? 'ol' : 'ul';
+  return /*#__PURE__*/_react.default.createElement(Tag, Object.assign({
+    "data-id": node.id,
+    className: "list-container d-flex flex-column"
+  }, attributes), children);
+};
+exports.renderList = renderList;
+const renderListItem = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  const {
+    align
+  } = element.children[0];
+  let className = '';
+  switch (align) {
+    case 'center':
+      className = 'align-self-center';
+      break;
+    case 'right':
+      className = 'align-self-end';
+      break;
+    default:
+      className = '';
+  }
+  const isBold = element.children[0].children.every(item => item.bold === true);
+  return /*#__PURE__*/_react.default.createElement("li", Object.assign({
+    "data-id": element.id
+  }, attributes, {
+    className: (0, _classnames.default)(className, {
+      'sdoc-li-bold': isBold
+    })
+  }), children);
+};
+exports.renderListItem = renderListItem;
+const renderListLic = (props, editor) => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  return /*#__PURE__*/_react.default.createElement("div", Object.assign({
+    "data-id": element.id
+  }, attributes), children);
+};
+exports.renderListLic = renderListLic;

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

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "insertListItem", {
+  enumerable: true,
+  get: function () {
+    return _insertListItem.insertListItem;
+  }
+});
+Object.defineProperty(exports, "moveListItems", {
+  enumerable: true,
+  get: function () {
+    return _moveListItems.moveListItems;
+  }
+});
+Object.defineProperty(exports, "moveListItemsToList", {
+  enumerable: true,
+  get: function () {
+    return _moveListItemsToList.moveListItemsToList;
+  }
+});
+Object.defineProperty(exports, "movedListItemDown", {
+  enumerable: true,
+  get: function () {
+    return _moveListItemDown.movedListItemDown;
+  }
+});
+Object.defineProperty(exports, "movedListItemUp", {
+  enumerable: true,
+  get: function () {
+    return _moveListItemUp.movedListItemUp;
+  }
+});
+Object.defineProperty(exports, "normalizeListItem", {
+  enumerable: true,
+  get: function () {
+    return _normalizeListItem.normalizeListItem;
+  }
+});
+Object.defineProperty(exports, "normalizeNestedList", {
+  enumerable: true,
+  get: function () {
+    return _normalizeNestedList.normalizeNestedList;
+  }
+});
+Object.defineProperty(exports, "removeFirstListItem", {
+  enumerable: true,
+  get: function () {
+    return _removeFirstListItem.removeFirstListItem;
+  }
+});
+Object.defineProperty(exports, "toggleList", {
+  enumerable: true,
+  get: function () {
+    return _toggleList.default;
+  }
+});
+Object.defineProperty(exports, "unwrapList", {
+  enumerable: true,
+  get: function () {
+    return _unwrapList.unwrapList;
+  }
+});
+var _insertListItem = require("./insert-list-item");
+var _moveListItemDown = require("./move-list-item-down");
+var _moveListItemUp = require("./move-list-item-up");
+var _moveListItems = require("./move-list-items");
+var _moveListItemsToList = require("./move-list-items-to-list");
+var _normalizeListItem = require("./normalize-list-item");
+var _normalizeNestedList = require("./normalize-nested-list");
+var _removeFirstListItem = require("./remove-first-list-item");
+var _toggleList = _interopRequireDefault(require("./toggle-list"));
+var _unwrapList = require("./unwrap-list");

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

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertListItem = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+// list > list_item > paragraph
+const insertListItem = editor => {
+  const paragraphEntry = (0, _core.getAboveNode)(editor, {
+    match: {
+      type: _constants.PARAGRAPH
+    }
+  });
+  if (!paragraphEntry) return false;
+  const [, paragraphPath] = paragraphEntry;
+  const listItemEntry = _slate.Editor.parent(editor, paragraphPath);
+  if (!listItemEntry) return false;
+  const [listItemNode, listItemPath] = listItemEntry;
+  if (listItemNode.type !== _constants.LIST_ITEM) return false;
+  let success = false;
+  _slate.Editor.withoutNormalizing(editor, () => {
+    var _editor$selection;
+    if (!_slate.Range.isCollapsed(editor.selection)) {
+      // 删除选中的内容
+      _slate.Transforms.delete(editor, {
+        at: editor.selection
+      });
+    }
+    const _isStartPoint = (0, _core.isStartPoint)(editor, (_editor$selection = editor.selection) === null || _editor$selection === void 0 ? void 0 : _editor$selection.focus, paragraphPath);
+    const isEndPoint = (0, _core.isBlockTextEmptyAfterSelection)(editor);
+    const nextParagraphPath = _slate.Path.next(paragraphPath);
+    const nextListItemPath = _slate.Path.next(listItemPath);
+    if (_isStartPoint) {
+      // listItem 有内容，光标在开始
+      const itemContent = (0, _model.generateEmptyListContent)();
+      _slate.Transforms.insertNodes(editor, itemContent, {
+        at: listItemPath
+      });
+      const listItem = (0, _model.generateEmptyListItem)();
+      _slate.Transforms.wrapNodes(editor, listItem, {
+        at: listItemPath
+      });
+      success = true;
+      return;
+    }
+    if (!isEndPoint) {
+      // listItem 有内容，光标在中间
+      _slate.Transforms.splitNodes(editor);
+      const listItem = (0, _model.generateEmptyListItem)();
+      _slate.Transforms.wrapNodes(editor, listItem, {
+        at: nextParagraphPath
+      });
+      _slate.Transforms.moveNodes(editor, {
+        at: nextParagraphPath,
+        to: nextListItemPath
+      });
+      _slate.Transforms.select(editor, nextListItemPath);
+      _slate.Transforms.collapse(editor, {
+        edge: 'start'
+      });
+      success = true;
+    } else {
+      var _Editor$marks;
+      // listItem 有内容，光标在结尾
+      const marks = (_Editor$marks = _slate.Editor.marks(editor)) === null || _Editor$marks === void 0 ? void 0 : _Editor$marks.key;
+      const itemContent = (0, _model.generateEmptyListContent)();
+      _slate.Transforms.insertNodes(editor, {
+        ...itemContent,
+        ...marks
+      }, {
+        at: nextListItemPath
+      });
+      const listItem = (0, _model.generateEmptyListItem)();
+      _slate.Transforms.wrapNodes(editor, listItem, {
+        at: nextListItemPath
+      });
+      _slate.Transforms.select(editor, nextListItemPath);
+      success = true;
+    }
+    if (listItemNode.children.length > 1) {
+      _slate.Transforms.moveNodes(editor, {
+        at: nextParagraphPath,
+        to: nextListItemPath.concat(1)
+      });
+      success = true;
+    }
+  });
+  return success;
+};
+exports.insertListItem = insertListItem;

package/dist/basic-sdk/extension/plugins/list/transforms/is-across-list-items.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAcrossListItems = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+const isAcrossListItems = editor => {
+  const {
+    selection
+  } = editor;
+  if (!selection || _slate.Range.isCollapsed(selection)) {
+    return false;
+  }
+  const isAcrossBlocks = (0, _core.isRangeAcrossBlocks)(editor);
+  if (!isAcrossBlocks) return false;
+  return (0, _core.someNode)(editor, {
+    match: {
+      type: _constants.LIST_ITEM
+    }
+  });
+};
+exports.isAcrossListItems = isAcrossListItems;

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.movedListItemDown = void 0;
+var _slate = require("@seafile/slate");
+var _model = require("../model");
+var _queries = require("../queries");
+const movedListItemDown = (editor, _ref) => {
+  let {
+    list,
+    listItem
+  } = _ref;
+  let moved = false;
+  const [listNode] = list;
+  const [, listItemPath] = listItem;
+  let previousListItemPath = null;
+  try {
+    previousListItemPath = _slate.Path.previous(listItemPath);
+  } catch (e) {
+    return;
+  }
+  const previousSiblingItem = _slate.Editor.node(editor, previousListItemPath);
+  if (previousSiblingItem) {
+    const [previousNode, previousPath] = previousSiblingItem;
+    const subList = previousNode.children.find(n => {
+      return (0, _queries.getListTypes)().includes(n.type);
+    });
+    const newPath = previousPath.concat(subList ? [1, subList.children.length] : [1]);
+    _slate.Editor.withoutNormalizing(editor, () => {
+      if (!subList) {
+        // Insert a list child element
+        const list = (0, _model.generateEmptyList)(listNode.type);
+        _slate.Transforms.wrapNodes(editor, list, {
+          at: listItemPath
+        });
+      }
+      _slate.Transforms.moveNodes(editor, {
+        at: listItemPath,
+        to: newPath
+      });
+      moved = true;
+    });
+  }
+  return moved;
+};
+exports.movedListItemDown = movedListItemDown;

package/dist/basic-sdk/extension/plugins/list/transforms/move-list-item-sublist-to-list-item-sublist.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveListItemSublistItemsToListItemSublist = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+const moveListItemSublistItemsToListItemSublist = (editor, _ref) => {
+  let {
+    fromListItem,
+    start,
+    toListItem
+  } = _ref;
+  const [, fromListItemPath] = fromListItem;
+  const [, toListItemPath] = toListItem;
+  let moved = 0;
+  _slate.Editor.withoutNormalizing(editor, () => {
+    const fromListItemSublist = (0, _core.findDescendant)(editor, {
+      at: fromListItemPath,
+      match: {
+        type: _constants.LIST_TYPE_ARRAY
+      }
+    });
+    if (!fromListItemSublist) return;
+    const [, fromListItemSublistPath] = fromListItemSublist;
+    const toListItemSublist = (0, _core.findDescendant)(editor, {
+      at: toListItemPath,
+      match: {
+        type: _constants.LIST_TYPE_ARRAY
+      }
+    });
+    let to = null;
+    if (!toListItemSublist) {
+      const fromList = _slate.Editor.parent(editor, fromListItemPath);
+      if (!fromList) return;
+      const [fromListNode] = fromList;
+      const fromListType = fromListNode.type;
+      const toListItemSublistPath = toListItemPath.concat([1]);
+      const list = (0, _model.generateEmptyList)(fromListType);
+      _slate.Transforms.insertNodes(editor, list, {
+        at: toListItemSublistPath
+      });
+      to = toListItemSublistPath.concat([0]);
+    } else if (start) {
+      const [, toListItemSublistPath] = toListItemSublist;
+      to = toListItemSublistPath.concat([0]);
+    } else {
+      to = _slate.Path.next((0, _core.getLastChildPath)(toListItemSublist));
+    }
+    moved = (0, _core.moveChildren)(editor, {
+      at: fromListItemSublistPath,
+      to
+    });
+    _slate.Transforms.delete(editor, {
+      at: fromListItemSublistPath
+    });
+  });
+  return moved;
+};
+exports.moveListItemSublistItemsToListItemSublist = moveListItemSublistItemsToListItemSublist;

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

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.movedListItemUp = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+var _queries = require("../queries");
+var _moveListItemsToList = require("./move-list-items-to-list");
+var _unwrapList = require("./unwrap-list");
+const movedListItemUp = (editor, _ref) => {
+  let {
+    list,
+    listItem
+  } = _ref;
+  const move = () => {
+    const [listNode, listPath] = list;
+    const [liNode, liPath] = listItem;
+
+    // 获取上层 list-item 节点
+    const liParent = (0, _core.getAboveNode)(editor, {
+      at: listPath,
+      match: {
+        type: [_constants.LIST_ITEM]
+      }
+    });
+
+    // 如果上层节点不存在, 说明当前 list 为顶层 list, list[ol] > 'li'
+    if (!liParent) {
+      let toListPath = null;
+      try {
+        toListPath = _slate.Path.next(listPath);
+      } catch (err) {
+        return;
+      }
+      const condA = (0, _queries.hasListChild)(liNode);
+      const condB = !(0, _core.isLastChild)(list, liPath);
+      if (condA || condB) {
+        // 创建一个新的兄弟节点
+        const list = (0, _model.generateEmptyList)(listNode.type);
+        _slate.Transforms.insertNodes(editor, list, {
+          at: toListPath
+        });
+      }
+
+      // 如果包含子节点，将子节点移动到新创建的节点中
+      if (condA) {
+        const toListNode = (0, _core.getNode)(editor, toListPath);
+        if (!toListNode) return;
+
+        // 将子节点，移动到新创建的节点中
+        (0, _moveListItemsToList.moveListItemsToList)(editor, {
+          formListItem: listItem,
+          toList: [toListNode, toListPath]
+        });
+      }
+
+      // 如果不是最后一个节点
+      if (condB) {
+        const toListNode = (0, _core.getNode)(editor, toListPath);
+        if (!toListNode) return;
+
+        // 将当前节点之后的兄弟节点，移动到新创建的 list 中
+        (0, _moveListItemsToList.moveListItemsToList)(editor, {
+          fromList: list,
+          fromStartIndex: liPath[liPath.length - 1] + 1,
+          toList: [toListNode, toListPath],
+          deleteFromList: false
+        });
+      }
+
+      // unwrap the list
+      (0, _unwrapList.unwrapList)(editor, {
+        at: liPath.concat(0)
+      });
+      return true;
+    }
+
+    // 如果上层节点存在，说明当前 list 为 子 list, li > list[ol] > 'li'
+    const [, liParentPath] = liParent;
+    // is last: false
+    // li > list[ol] > li
+    //               > li
+    const toListPath = liPath.concat([1]);
+    if (!(0, _core.isLastChild)(list, liPath)) {
+      // 此处取巧：
+      // 第一步：把当前节点的兄弟节点，移动到当前节点 “子节点（ol）” 的孩子节点中
+      // 第二步：把当前节点的字节点，移动为当前节点 “父节点” 的 “兄弟” 节点
+      if (!(0, _queries.hasListChild)(liNode)) {
+        const list = (0, _model.generateEmptyList)(listNode.type);
+        _slate.Transforms.insertNodes(editor, list, {
+          at: toListPath
+        });
+      }
+      const toListNode = (0, _core.getNode)(editor, toListPath);
+      if (!toListNode) return;
+
+      // move next siblings to li sublist
+      (0, _moveListItemsToList.moveListItemsToList)(editor, {
+        fromListItem: liParent,
+        toList: [toListNode, toListPath],
+        fromStartIndex: liPath[liPath.length - 1] + 1,
+        deleteFromList: false
+      });
+    }
+
+    // is last: true
+    // li > list[ol] > li
+    const movedUpLiPath = _slate.Path.next(liParentPath);
+    _slate.Transforms.moveNodes(editor, {
+      at: liPath,
+      to: movedUpLiPath
+    });
+    return true;
+  };
+  let moved = false;
+  _slate.Editor.withoutNormalizing(editor, () => {
+    moved = move();
+  });
+  return moved;
+};
+exports.movedListItemUp = movedListItemUp;

package/dist/basic-sdk/extension/plugins/list/transforms/move-list-items-to-list.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveListItemsToList = void 0;
+var _slate = require("@seafile/slate");
+var _core = require("../../../core");
+var _queries = require("../queries");
+const moveListItemsToList = (editor, _ref) => {
+  let {
+    fromList,
+    fromListItem,
+    fromStartIndex,
+    to: _to,
+    toList,
+    toListIndex = null,
+    deleteFromList = true
+  } = _ref;
+  let fromListPath = null;
+  let moved = false;
+  _slate.Editor.withoutNormalizing(editor, () => {
+    if (fromListItem) {
+      const fromListItemSubList = (0, _core.findDescendant)(editor, {
+        at: fromListItem[1],
+        match: {
+          type: (0, _queries.getListTypes)()
+        }
+      });
+      if (!fromListItemSubList) return;
+      fromListPath = fromListItemSubList === null || fromListItemSubList === void 0 ? void 0 : fromListItemSubList[1];
+    } else if (fromList) {
+      fromListPath = fromList[1];
+    } else {
+      return;
+    }
+    let to = null;
+    if (_to) to = _to;
+    if (toList) {
+      if (toListIndex !== null) {
+        to = toList[1].concat([toListIndex]);
+      } else {
+        const lastChildPath = (0, _core.getLastChildPath)(toList);
+        to = _slate.Path.next(lastChildPath);
+      }
+    }
+    if (!to) return;
+    moved = (0, _core.moveChildren)(editor, {
+      at: fromListPath,
+      to,
+      fromStartIndex
+    });
+
+    // Remove the empty list
+    if (deleteFromList) {
+      _slate.Transforms.delete(editor, {
+        at: fromListPath
+      });
+    }
+  });
+  return moved;
+};
+exports.moveListItemsToList = moveListItemsToList;

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

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveListItems = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _moveListItemDown = require("./move-list-item-down");
+var _moveListItemUp = require("./move-list-item-up");
+var _removeFirstListItem = require("./remove-first-list-item");
+const moveListItems = function (editor) {
+  let {
+    increase = true,
+    at = editor.selection,
+    enableResetOnShiftTab
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const _nodes = (0, _core.getNodeEntries)(editor, {
+    at,
+    match: {
+      type: [_constants.PARAGRAPH]
+    }
+  });
+  const lics = Array.from(_nodes);
+  if (!lics.length) return;
+  const highestLicPaths = [];
+  const highestLicPathRefs = [];
+  lics.forEach(lic => {
+    const licPath = lic[1];
+    const liPath = _slate.Path.parent(licPath);
+    const isAncestor = highestLicPaths.some(path => {
+      const highestLiPath = _slate.Path.parent(path);
+      return _slate.Path.isAncestor(highestLiPath, liPath);
+    });
+    if (!isAncestor) {
+      highestLicPaths.push(licPath);
+      highestLicPathRefs.push(_slate.Editor.pathRef(editor, licPath));
+    }
+  });
+  const licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
+  let moved = false;
+  licPathRefsToMove.forEach(licPathRef => {
+    const licPath = licPathRef.unref();
+    if (!licPath) return;
+    const listItem = _slate.Editor.parent(editor, licPath);
+    if (!listItem || listItem[1].length === 0) return;
+    const parentList = _slate.Editor.parent(editor, listItem[1]);
+    if (!parentList) return;
+    let _moved = false;
+    if (increase) {
+      _moved = (0, _moveListItemDown.movedListItemDown)(editor, {
+        list: parentList,
+        listItem: listItem
+      });
+    } else if ((0, _queries.isListNested)(editor, parentList[1])) {
+      _moved = (0, _moveListItemUp.movedListItemUp)(editor, {
+        list: parentList,
+        listItem: listItem
+      });
+      return _moved;
+    } else if (enableResetOnShiftTab) {
+      _moved = (0, _removeFirstListItem.removeFirstListItem)(editor, {
+        list: parentList,
+        listItem: listItem
+      });
+    }
+    moved = _moved || moved;
+  });
+  return moved;
+};
+exports.moveListItems = moveListItems;