@seafile/comment-editor 0.0.1-alpha.0

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

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _commons = require("../../../commons");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _helpers = require("../helpers");
+class ListMenu extends _react.default.Component {
+  constructor() {
+    super(...arguments);
+    (0, _defineProperty2.default)(this, "isActive", () => {
+      const {
+        editor,
+        type = _constants.UNORDERED_LIST
+      } = this.props;
+      return (0, _helpers.getListType)(editor, type) === type;
+    });
+    (0, _defineProperty2.default)(this, "isDisabled", () => {
+      const {
+        editor,
+        readonly
+      } = this.props;
+      return (0, _helpers.isMenuDisabled)(editor, readonly);
+    });
+    (0, _defineProperty2.default)(this, "onMouseDown", e => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (this.isDisabled()) return;
+      const {
+        editor,
+        type = _constants.UNORDERED_LIST
+      } = this.props;
+
+      // 执行命令
+      (0, _helpers.setListType)(editor, type);
+      (0, _core.focusEditor)(editor);
+    });
+  }
+  render() {
+    const {
+      isRichEditor,
+      className,
+      type = _constants.UNORDERED_LIST,
+      ariaLabel
+    } = this.props;
+    const menuConfig = _constants.MENUS_CONFIG_MAP[type];
+    const props = {
+      isRichEditor,
+      className,
+      ariaLabel,
+      ...menuConfig,
+      disabled: this.isDisabled(),
+      isActive: this.isActive(),
+      onMouseDown: this.onMouseDown
+    };
+    return /*#__PURE__*/_react.default.createElement(_commons.MenuItem, props);
+  }
+}
+var _default = exports.default = ListMenu;

package/dist/basic-sdk/extension/plugins/list/model.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateListItem = exports.generateEmptyListItem = exports.generateEmptyListContent = exports.generateEmptyList = exports.default = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+class List {
+  constructor(options) {
+    this.type = options.type || _constants.UNORDERED_LIST;
+    this.children = options.children || [{
+      text: ''
+    }];
+  }
+}
+var _default = exports.default = List;
+const generateEmptyListItem = () => {
+  return {
+    id: _slugid.default.nice(),
+    type: _constants.LIST_ITEM,
+    children: []
+  };
+};
+exports.generateEmptyListItem = generateEmptyListItem;
+const generateListItem = () => {
+  return {
+    id: _slugid.default.nice(),
+    type: _constants.LIST_ITEM,
+    children: [generateEmptyListContent()]
+  };
+};
+exports.generateListItem = generateListItem;
+const generateEmptyListContent = () => {
+  return (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+};
+exports.generateEmptyListContent = generateEmptyListContent;
+const generateEmptyList = type => {
+  return {
+    id: _slugid.default.nice(),
+    type: type,
+    children: []
+  };
+};
+exports.generateEmptyList = generateEmptyList;

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

@@ -0,0 +1,140 @@
+"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 _deleteMerge = require("../../../core/transforms/delete-merge");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+var _isAcrossListItems = require("../transforms/is-across-list-items");
+var _removeListItem = require("../transforms/remove-list-item");
+var _insertBreakList = require("./insert-break-list");
+var _insertFragmentList = require("./insert-fragment-list");
+var _normalizeList = require("./normalize-list");
+var _onTabHandle = require("./on-tab-handle");
+var _shortcut = require("./shortcut");
+const withList = editor => {
+  const {
+    insertBreak,
+    handleTab,
+    insertText,
+    deleteBackward
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
+    if ((0, _insertBreakList.insertBreakList)(editor)) return;
+    insertBreak();
+    return;
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (selection === null) {
+      deleteBackward(unit);
+      return;
+    }
+    const deleteBackwardList = () => {
+      const res = (0, _queries.getListItemEntry)(editor, {});
+      let moved = false;
+      if (res) {
+        const {
+          list,
+          listItem
+        } = res;
+        if ((0, _core.isSelectionAtBlockStart)(editor, {
+          match: node => node.type === _constants.LIST_ITEM
+        })) {
+          _slate.Editor.withoutNormalizing(editor, () => {
+            let moved = (0, _transforms.removeFirstListItem)(editor, {
+              list,
+              listItem
+            });
+            if (moved) return true;
+            moved = (0, _removeListItem.removeListItem)(editor, {
+              list,
+              listItem
+            });
+            if (moved) {
+              setTimeout(() => {
+                const previousLiPath = (0, _core.getPreviousPath)(listItem[1]);
+                (0, _core.focusEditor)(editor, _slate.Editor.end(editor, [...previousLiPath, 0]));
+              }, 0);
+              return;
+            }
+            if ((0, _core.isFirstChild)(listItem[1]) && !(0, _queries.isListNested)(editor, list[1])) {
+              (0, _transforms.unwrapList)(newEditor, {
+                at: listItem[1]
+              });
+              const focusPoint = _slate.Editor.start(newEditor, listItem[1]);
+              (0, _core.focusEditor)(newEditor, focusPoint);
+              moved = true;
+              return;
+            }
+            const pointBeforeListItem = _slate.Editor.before(editor, editor.selection.focus);
+            let currentLic = null;
+            let hasMultipleChildren = false;
+            const editorOptions = {
+              ...editor,
+              selection: {
+                anchor: editor.selection.anchor,
+                focus: pointBeforeListItem
+              }
+            };
+            if (pointBeforeListItem && (0, _isAcrossListItems.isAcrossListItems)(editorOptions)) {
+              // get closest lic ancestor of current selectable
+              const _licNodes = (0, _core.getNodeEntries)(editor, {
+                at: listItem[1],
+                match: node => node.type === _constants.PARAGRAPH,
+                mode: 'lowest'
+              });
+              currentLic = [..._licNodes][0];
+              hasMultipleChildren = currentLic[0].children.length > 1;
+            }
+            (0, _deleteMerge.deleteMerge)(editor, {
+              reverse: true,
+              unit
+            });
+            moved = true;
+            if (!currentLic || !hasMultipleChildren) return;
+            const leftoverListItem = _slate.Editor.node(editor, {
+              at: _slate.Path.parent(currentLic[1])
+            });
+            if (leftoverListItem && leftoverListItem[0].children.length === 0) {
+              // remove the leftover empty list item
+              _slate.Transforms.removeNodes(editor, {
+                at: leftoverListItem[1]
+              });
+            }
+          });
+        }
+      }
+      return moved;
+    };
+    if (deleteBackwardList()) return;
+
+    // nothing todo
+    deleteBackward(unit);
+  };
+  newEditor.handleTab = event => {
+    if (!newEditor.selection) {
+      handleTab && handleTab();
+      return;
+    }
+    if ((0, _onTabHandle.onTabHandle)(newEditor, event)) return;
+    handleTab && handleTab();
+  };
+  newEditor.insertFragment = (0, _insertFragmentList.insertFragmentList)(newEditor);
+  newEditor.normalizeNode = (0, _normalizeList.normalizeList)(editor);
+  newEditor.insertText = text => {
+    const isPreventInsert = (0, _shortcut.handleShortcut)(newEditor, text);
+    if (isPreventInsert) return;
+    return insertText(text);
+  };
+  return newEditor;
+};
+var _default = exports.default = withList;

package/dist/basic-sdk/extension/plugins/list/plugin/insert-break-list.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBreakList = void 0;
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+const insertBreakList = editor => {
+  if (!editor.selection) return;
+
+  // moved | inserted
+  let moved = false;
+  const res = (0, _queries.getListItemEntry)(editor, {});
+
+  // if selection is in a li, and li content is empty
+  if (res) {
+    if ((0, _core.isBlockAboveEmpty)(editor)) {
+      moved = (0, _transforms.movedListItemUp)(editor, res);
+      if (moved) return true;
+    }
+  }
+  if (!moved) {
+    const inserted = (0, _transforms.insertListItem)(editor);
+    if (inserted) return true;
+  }
+  return;
+};
+exports.insertBreakList = insertBreakList;

package/dist/basic-sdk/extension/plugins/list/plugin/insert-fragment-list.js

@@ -0,0 +1,176 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertFragmentList = exports.getTextAndListItemNodes = void 0;
+var _slate = require("@seafile/slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _queries = require("../queries");
+const isListRoot = node => {
+  return _slate.Element.isElement(node) && (0, _queries.getListTypes)().includes(node.type);
+};
+const getFirstAncestorOfType = (root, entry, _ref) => {
+  let {
+    type
+  } = _ref;
+  let ancestor = _slate.Path.parent(entry[1]);
+  while ((0, _core.getNode)(root, ancestor).type !== type) {
+    ancestor = _slate.Path.parent(ancestor);
+  }
+  return [(0, _core.getNode)(root, ancestor), ancestor];
+};
+const findListItemsWithContent = first => {
+  let prev = null;
+  let node = first;
+  while (isListRoot(node) || node.type === _constants.LIST_ITEM && node.children[0].type !== _constants.PARAGRAPH) {
+    prev = node;
+    [node] = node.children;
+  }
+  return prev ? prev.children : [node];
+};
+const trimList = listRoot => {
+  if (!isListRoot(listRoot)) {
+    return [listRoot];
+  }
+  const _texts = _slate.Node.texts(listRoot);
+  const textEntries = Array.from(_texts);
+  const commonAncestorEntry = textEntries.reduce((commonAncestor, textEntry) => {
+    return _slate.Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : (0, _core.getCommonNode)(listRoot, textEntry[1], commonAncestor[1]);
+  }, getFirstAncestorOfType(listRoot, textEntries[0], {
+    type: _constants.LIST_ITEM
+  }));
+
+  // is ul/ol: return children
+  // is not ul/ol
+  const [first, ...rest] = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]];
+  return [...findListItemsWithContent(first), ...rest];
+};
+const wrapNodeIntoListItem = node => {
+  return node.type === _constants.LIST_ITEM ? node : {
+    id: _slugid.default.nice(),
+    type: _constants.LIST_ITEM,
+    children: [node]
+  };
+};
+const isSingleLic = fragment => {
+  const isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
+  return isFragmentOnlyListRoot && [...(0, _core.getNodes)({
+    children: fragment
+  })].filter(entry => _slate.Element.isElement(entry[0])).filter(_ref2 => {
+    let [node] = _ref2;
+    return node.type === _constants.PARAGRAPH;
+  }).length === 1;
+};
+const getTextAndListItemNodes = (editor, fragment, liEntry, licEntry) => {
+  const [, liPath] = liEntry;
+  const [licNode, licPath] = licEntry;
+  const isEmptyNode = !_slate.Node.string(licNode);
+  // format copied fragment
+  // first: lic, path: [...liPath, 0, 0]
+  // rest: children, path: [...liPath, 1, 0]
+  const [first, ...rest] = fragment.flatMap(trimList).map(wrapNodeIntoListItem);
+  let textNode = null;
+  let listItemNodes = [];
+  if (isListRoot(fragment[0])) {
+    if (isSingleLic(fragment)) {
+      textNode = first;
+      listItemNodes = rest;
+    } else if (isEmptyNode) {
+      const li = (0, _core.getNode)(editor, liPath);
+      const [, ...currentSubLists] = li.children; // old
+
+      const [newLic, ...newSubLists] = first.children; // copied
+      // insert copied contents
+      _slate.Transforms.insertNodes(editor, newLic, {
+        at: _slate.Path.next(licPath),
+        select: true
+      });
+      _slate.Transforms.removeNodes(editor, {
+        at: licPath
+      });
+      if (newSubLists.length) {
+        if (currentSubLists.length) {
+          const path = [...liPath, 1, 0];
+          _slate.Transforms.insertNodes(editor, newSubLists[0].children, {
+            at: path,
+            select: true
+          });
+        } else {
+          _slate.Transforms.insertNodes(editor, newSubLists, {
+            at: _slate.Path.next(licPath),
+            select: true
+          });
+        }
+      }
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = rest;
+    } else {
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = [first, ...rest];
+    }
+  } else {
+    textNode = first;
+    listItemNodes = rest;
+    return {
+      textNode,
+      listItemNodes
+    };
+  }
+  return {
+    textNode,
+    listItemNodes
+  };
+};
+exports.getTextAndListItemNodes = getTextAndListItemNodes;
+const insertFragmentList = editor => {
+  const {
+    insertFragment: _insertFragment
+  } = editor;
+  return fragment => {
+    _slate.Editor.withoutNormalizing(editor, () => {
+      let liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _constants.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      if (!liEntry) {
+        const nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)(), ...fragment] : fragment;
+        return _insertFragment(nodes);
+      }
+      _slate.Transforms.insertFragment(editor, [(0, _core.generateDefaultText)()]); // need ' '
+
+      liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _constants.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      const licEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _constants.PARAGRAPH
+        },
+        mode: 'lowest'
+      });
+      if (!licEntry) {
+        const nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)(), ...fragment] : fragment;
+        return _insertFragment(nodes);
+      }
+      const {
+        textNode,
+        listItemNodes
+      } = getTextAndListItemNodes(editor, fragment, liEntry, licEntry);
+      _slate.Transforms.insertFragment(editor, [textNode]);
+      const [, liPath] = liEntry;
+      return _slate.Transforms.insertNodes(editor, listItemNodes, {
+        at: _slate.Path.next(liPath),
+        select: true
+      });
+    });
+  };
+};
+exports.insertFragmentList = insertFragmentList;

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

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeList = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _model = require("../model");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+const validChildrenTypes = [_constants.GROUP, _constants.LIST_ITEM];
+const normalizeList = editor => {
+  const {
+    normalizeNode
+  } = editor;
+  return _ref => {
+    let [node, path] = _ref;
+    if (!_slate.Element.isElement(node)) {
+      return normalizeNode([node, path]);
+    }
+    const listTypes = (0, _queries.getListTypes)();
+
+    // root
+    if (listTypes.includes(node.type)) {
+      const children = (0, _core.getChildren)([node, path]);
+      const nonLiChild = children.find(_ref2 => {
+        let [child] = _ref2;
+        return !validChildrenTypes.includes(child.type);
+      });
+      if (nonLiChild) {
+        const listItem = (0, _model.generateEmptyListItem)();
+        _slate.Transforms.wrapNodes(editor, listItem, {
+          at: nonLiChild[1]
+        });
+        return;
+      }
+    }
+    if ((0, _core.match)(node, [], {
+      type: listTypes
+    })) {
+      if (!node.children.length || !node.children.find(child => validChildrenTypes.includes(child.type))) {
+        _slate.Transforms.removeNodes(editor, {
+          at: path
+        });
+        return;
+      }
+      const nextPath = _slate.Path.next(path);
+      const nextNode = (0, _core.getNode)(editor, nextPath);
+      if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === node.type) {
+        (0, _transforms.moveListItemsToList)(editor, {
+          fromList: [nextNode, nextPath],
+          toList: [node, path],
+          deleteFromList: true
+        });
+      }
+      const prevPath = (0, _core.getPreviousPath)(path);
+      const prevNode = (0, _core.getNode)(editor, prevPath);
+      if ((prevNode === null || prevNode === void 0 ? void 0 : prevNode.type) === node.type) {
+        editor.normalizeNode([prevNode, prevPath]);
+        return;
+      }
+      if ((0, _transforms.normalizeNestedList)(editor, {
+        nestedListItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    if (node.type === _constants.LIST_ITEM) {
+      if ((0, _transforms.normalizeListItem)(editor, {
+        listItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    normalizeNode([node, path]);
+  };
+};
+exports.normalizeList = normalizeList;

package/dist/basic-sdk/extension/plugins/list/plugin/on-tab-handle.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onTabHandle = void 0;
+var _slate = require("@seafile/slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _transforms = require("../transforms");
+const onTabHandle = (editor, event) => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return;
+  const listSelected = (0, _core.findNode)(editor, {
+    type: [_constants.LIST_ITEM]
+  });
+  if (!listSelected) return false;
+  let workRange = editor.selection;
+  if (!_slate.Range.isCollapsed(selection)) {
+    let {
+      anchor,
+      focus
+    } = selection;
+    if (_slate.Range.isBackward(selection)) {
+      ({
+        anchor,
+        focus
+      } = {
+        anchor: {
+          ...selection.focus
+        },
+        focus: {
+          ...selection.anchor
+        }
+      });
+    }
+    const unHungRange = _slate.Editor.unhangRange(editor, {
+      anchor,
+      focus
+    });
+    if (unHungRange) {
+      workRange = unHungRange;
+      _slate.Transforms.select(editor, unHungRange);
+    }
+  }
+  const increase = (0, _isHotkey.default)('shift+tab', event) ? false : true;
+  if (workRange && listSelected) {
+    event.preventDefault();
+    (0, _transforms.moveListItems)(editor, {
+      at: workRange,
+      increase: increase,
+      enableResetOnShiftTab: true
+    });
+    return true;
+  }
+};
+exports.onTabHandle = onTabHandle;

package/dist/basic-sdk/extension/plugins/list/plugin/shortcut.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleShortcut = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _helpers = require("../helpers");
+var _model = require("../model");
+var _transforms = require("../transforms");
+/**
+ * @param {Editor} editor
+ * @param {String} text
+ * @returns {Boolean} isPreventInsert
+ */
+const handleShortcut = (editor, text) => {
+  if (text !== ' ') return false;
+  const {
+    selection
+  } = editor;
+  if (!_slate.Range.isCollapsed(selection)) return false;
+  let [aboveNode, aboveNodePath] = _slate.Editor.above(editor);
+  const aboveNodeRef = _slate.Editor.pathRef(editor, aboveNodePath);
+  if (aboveNode.type !== _constants.PARAGRAPH) return false;
+  // Match ordered list shortcut
+  const regShortcut = /^\s*[1-9]+\.\s*$/;
+  const {
+    beforeText,
+    range
+  } = (0, _helpers.getBeforeText)(editor);
+  const matchResult = beforeText.match(regShortcut);
+  const matchedText = matchResult && matchResult[0];
+  // If the match fails or the match is not at the beginning of the line, it is not a shortcut
+  if (!matchResult || matchResult.index !== 0) return false;
+  const previousNodePath = (0, _core.getPreviousPath)(aboveNodePath);
+
+  // No previous node means that the current paragraph is the first paragraph in the container
+  if (!previousNodePath) {
+    if (matchedText !== '1.') return false;
+    // Delete shortcut key text
+    _slate.Transforms.delete(editor, {
+      at: range
+    });
+    (0, _transforms.toggleList)(editor, _constants.ORDERED_LIST);
+    return true;
+  }
+  const [previousNode, previousPath] = _slate.Editor.node(editor, previousNodePath);
+  // If the previous node is not an ordered list and is not start with `1.`,it is not a shortcut
+  if (previousNode.type !== _constants.ORDERED_LIST && matchedText !== '1.') return false;
+  // If the previous node is not an ordered list and is start with `1.`,transforms to ordered list
+  if (previousNode.type !== _constants.ORDERED_LIST && matchedText === '1.') {
+    // Delete shortcut key text
+    _slate.Transforms.delete(editor, {
+      at: range
+    });
+    (0, _helpers.setListType)(editor, _constants.ORDERED_LIST);
+    (0, _core.focusEditor)(editor);
+    return true;
+  }
+  // Record the order number of the shortcut that will be inserted as a list item
+  const shortcutOrderNum = parseInt(matchResult[0].slice(0, -1));
+
+  // Check If order number is continuous
+  if (previousNode.children.length + 1 !== shortcutOrderNum) return false;
+
+  // Delete shortcut key text
+  _slate.Transforms.delete(editor, {
+    at: range
+  });
+  // Update aboveNode after delete shortcut text
+  [aboveNode] = _slate.Editor.above(editor);
+  const [, lastListItemPath] = (0, _core.getLastChild)([previousNode, previousPath]);
+  const targetInsertPath = _slate.Path.next(lastListItemPath);
+  // Wrap the paragraph in a list item
+  const insertedListItem = (0, _model.generateEmptyListItem)();
+  insertedListItem.children.push(aboveNode);
+  _slate.Transforms.insertNodes(editor, insertedListItem, {
+    at: targetInsertPath
+  });
+  _slate.Transforms.removeNodes(editor, {
+    at: aboveNodeRef.unref()
+  });
+  // Set the selection to the end of the inserted list item
+  _slate.Transforms.select(editor, _slate.Editor.end(editor, targetInsertPath));
+  return true;
+};
+exports.handleShortcut = handleShortcut;