@seafile/sdoc-editor 1.0.85 → 1.0.86

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

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isTopLevelListItem = exports.isTextNode = exports.isStartPoint = exports.isSelectionAtBlockStart = exports.isSelectionAtBlockEnd = exports.isRangeInSameBlock = exports.isRangeAcrossBlocks = exports.isMultiLevelList = exports.isLastNode = exports.isLastChild = exports.isHasImg = exports.isEndPoint = exports.isCurrentLineHasText = exports.isCurrentLineEmpty = exports.isBlockTextEmptyAfterSelection = exports.isBlockAboveEmpty = exports.isAncestorEmpty = exports.getTopLevelBlockNode = exports.getStartPoint = exports.getSelectedNodeEntryByType = exports.getSelectedNodeByTypes = exports.getSelectedNodeByType = exports.getSelectedElems = exports.getQueryOptions = exports.getPreviousPath = exports.getPrevNode = exports.getPointBefore = exports.getParentNode = exports.getNodes = exports.getNodeType = exports.getNodeEntries = exports.getNodeById = exports.getNode = exports.getNextSiblingNodes = exports.getNextNode = exports.getLastChildPath = exports.getLastChild = exports.getEndPoint = exports.getEditorString = exports.getDeepInlineChildren = exports.getCurrentNode = exports.getCommonNode = exports.getChildren = exports.getAboveNode = exports.getAboveBlockNode = exports.findPath = exports.findNode = exports.findDescendant = void 0;
+exports.someNode = exports.isTopLevelListItem = exports.isTextNode = exports.isStartPoint = exports.isSelectionAtBlockStart = exports.isSelectionAtBlockEnd = exports.isRangeInSameBlock = exports.isRangeAcrossBlocks = exports.isMultiLevelList = exports.isLastNode = exports.isLastChild = exports.isHasImg = exports.isFirstChild = exports.isEndPoint = exports.isCurrentLineHasText = exports.isCurrentLineEmpty = exports.isBlockTextEmptyAfterSelection = exports.isBlockAboveEmpty = exports.isAncestorEmpty = exports.getTopLevelBlockNode = exports.getStartPoint = exports.getSelectedNodeEntryByType = exports.getSelectedNodeByTypes = exports.getSelectedNodeByType = exports.getSelectedElems = exports.getQueryOptions = exports.getPreviousPath = exports.getPrevNode = exports.getPointBefore = exports.getParentNode = exports.getNodes = exports.getNodeType = exports.getNodeEntries = exports.getNodeById = exports.getNode = exports.getNextSiblingNodes = exports.getNextNode = exports.getLastChildPath = exports.getLastChild = exports.getEndPoint = exports.getEditorString = exports.getDeepInlineChildren = exports.getCurrentNode = exports.getCommonNode = exports.getChildren = exports.getAboveNode = exports.getAboveBlockNode = exports.findPath = exports.findNode = exports.findDescendant = void 0;
 var _slate = require("@seafile/slate");
 var _slateReact = require("@seafile/slate-react");
 var _utils = require("../utils");
@@ -553,4 +553,12 @@ exports.getEndPoint = getEndPoint;
 const getPointBefore = (editor, at) => {
   return _slate.Editor.before(editor, at);
 };
-exports.getPointBefore = getPointBefore;
+exports.getPointBefore = getPointBefore;
+const isFirstChild = path => {
+  return path.at(-1) === 0;
+};
+exports.isFirstChild = isFirstChild;
+const someNode = (editor, options) => {
+  return !!findNode(editor, options);
+};
+exports.someNode = someNode;

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/plugins/image/plugin.js

@@ -159,6 +159,9 @@ const withImage = editor => {
     }
     if ((0, _core.isSelectionAtBlockStart)(editor)) {
       const path = selection.anchor.path;
+      if ((0, _core.isFirstChild)(path)) {
+        return deleteBackward(unit);
+      }
       const beforePath = [path[0] - 1];
       const beforeBlock = _slate.Editor.node(editor, beforePath);
       if (beforeBlock && beforeBlock[0].type === _constants.IMAGE_BLOCK) {

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

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.generateEmptyListItem = exports.generateEmptyListContent = exports.generateEmptyList = exports.default = void 0;
+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");
@@ -25,6 +25,14 @@ const generateEmptyListItem = () => {
   };
 };
 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);
 };

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

@@ -14,6 +14,10 @@ var _core = require("../../../core");
 var _constants = require("../../../constants");
 var _helpers = require("../../../toolbar/side-toolbar/helpers");
 var _transforms = require("../transforms");
+var _queries = require("../queries");
+var _removeListItem = require("../transforms/remove-list-item");
+var _isAcrossListItems = require("../transforms/is-across-list-items");
+var _deleteMerge = require("../../../core/transforms/delete-merge");
 const withList = editor => {
   const {
     insertBreak,
@@ -35,28 +39,85 @@ const withList = editor => {
       deleteBackward(unit);
       return;
     }
-    const listItemEntry = (0, _core.getSelectedNodeEntryByType)(editor, _constants.LIST_ITEM);
-    if (listItemEntry) {
-      const [, listItemPath] = listItemEntry;
-
-      // Transforms to paragraph when press backspace at the start of the list item, and the list item is the first child of the list
-      const isAtStartOfListItem = _slate.Editor.isStart(editor, selection.anchor, listItemPath);
-      const isCollapsed = _slate.Range.isCollapsed(selection);
-      if (isCollapsed && isAtStartOfListItem) {
-        const previous = _slate.Editor.previous(editor, {
-          at: listItemPath
-        });
-        // previous is undefined when the list item is the first child of the list
-        if (!previous) {
-          (0, _transforms.unwrapList)(newEditor, {
-            at: listItemPath
+    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]
+              });
+            }
           });
-          const focusPoint = _slate.Editor.start(newEditor, listItemPath);
-          (0, _core.focusEditor)(newEditor, focusPoint);
-          return;
         }
       }
-    }
+      return moved;
+    };
+    if (deleteBackwardList()) return;
+
     // nothing todo
     deleteBackward(unit);
   };

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 _core = require("../../../core");
+var _constants = require("../../../constants");
+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-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 _core = require("../../../core");
+var _constants = require("../../../constants");
+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/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 _queries = require("../queries");
+var _core = require("../../../core");
+var _model = require("../model");
+var _moveListItemSublistToListItemSublist = require("./move-list-item-sublist-to-list-item-sublist");
+var _deleteMerge = require("../../../core/transforms/delete-merge");
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seafile/sdoc-editor",
-  "version": "1.0.85",
+  "version": "1.0.86",
   "private": false,
   "description": "This is a sdoc editor",
   "main": "dist/index.js",