@seafile/sdoc-editor 1.0.53 → 1.0.55

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

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

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

@@ -1,11 +1,17 @@
-import { Transforms, Path, Editor } from '@seafile/slate';
-import { LIST_ITEM } from '../../../constants';
-import { getAboveNode, getNode, isLastChild } from '../../../core';
-import { hasListChild } from '../queries';
-import { moveListItemsToList } from './move-list-items-to-list';
-import { unwrapList } from './unwrap-list';
-import { generateEmptyList } from '../model';
-export const movedListItemUp = (editor, _ref) => {
+"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 _queries = require("../queries");
+var _moveListItemsToList = require("./move-list-items-to-list");
+var _unwrapList = require("./unwrap-list");
+var _model = require("../model");
+const movedListItemUp = (editor, _ref) => {
   let {
     list,
     listItem
@@ -15,10 +21,10 @@ export const movedListItemUp = (editor, _ref) => {
     const [liNode, liPath] = listItem;
 
     // 获取上层 list-item 节点
-    const liParent = getAboveNode(editor, {
+    const liParent = (0, _core.getAboveNode)(editor, {
       at: listPath,
       match: {
-        type: [LIST_ITEM]
+        type: [_constants.LIST_ITEM]
       }
     });
 
@@ -26,27 +32,27 @@ export const movedListItemUp = (editor, _ref) => {
     if (!liParent) {
       let toListPath = null;
       try {
-        toListPath = Path.next(listPath);
+        toListPath = _slate.Path.next(listPath);
       } catch (err) {
         return;
       }
-      const condA = hasListChild(liNode);
-      const condB = !isLastChild(list, liPath);
+      const condA = (0, _queries.hasListChild)(liNode);
+      const condB = !(0, _core.isLastChild)(list, liPath);
       if (condA || condB) {
         // 创建一个新的兄弟节点
-        const list = generateEmptyList(listNode.type);
-        Transforms.insertNodes(editor, list, {
+        const list = (0, _model.generateEmptyList)(listNode.type);
+        _slate.Transforms.insertNodes(editor, list, {
           at: toListPath
         });
       }
 
       // 如果包含子节点，将子节点移动到新创建的节点中
       if (condA) {
-        const toListNode = getNode(editor, toListPath);
+        const toListNode = (0, _core.getNode)(editor, toListPath);
         if (!toListNode) return;
 
         // 将子节点，移动到新创建的节点中
-        moveListItemsToList(editor, {
+        (0, _moveListItemsToList.moveListItemsToList)(editor, {
           formListItem: listItem,
           toList: [toListNode, toListPath]
         });
@@ -54,11 +60,11 @@ export const movedListItemUp = (editor, _ref) => {
 
       // 如果不是最后一个节点
       if (condB) {
-        const toListNode = getNode(editor, toListPath);
+        const toListNode = (0, _core.getNode)(editor, toListPath);
         if (!toListNode) return;
 
         // 将当前节点之后的兄弟节点，移动到新创建的 list 中
-        moveListItemsToList(editor, {
+        (0, _moveListItemsToList.moveListItemsToList)(editor, {
           fromList: list,
           fromStartIndex: liPath[liPath.length - 1] + 1,
           toList: [toListNode, toListPath],
@@ -67,7 +73,7 @@ export const movedListItemUp = (editor, _ref) => {
       }
 
       // unwrap the list
-      unwrapList(editor, {
+      (0, _unwrapList.unwrapList)(editor, {
         at: liPath.concat(0)
       });
       return true;
@@ -79,21 +85,21 @@ export const movedListItemUp = (editor, _ref) => {
     // li > list[ol] > li
     //               > li
     const toListPath = liPath.concat([1]);
-    if (!isLastChild(list, liPath)) {
+    if (!(0, _core.isLastChild)(list, liPath)) {
       // 此处取巧：
       // 第一步：把当前节点的兄弟节点，移动到当前节点 “子节点（ol）” 的孩子节点中
       // 第二步：把当前节点的字节点，移动为当前节点 “父节点” 的 “兄弟” 节点
-      if (!hasListChild(liNode)) {
-        const list = generateEmptyList(listNode.type);
-        Transforms.insertNodes(editor, list, {
+      if (!(0, _queries.hasListChild)(liNode)) {
+        const list = (0, _model.generateEmptyList)(listNode.type);
+        _slate.Transforms.insertNodes(editor, list, {
           at: toListPath
         });
       }
-      const toListNode = getNode(editor, toListPath);
+      const toListNode = (0, _core.getNode)(editor, toListPath);
       if (!toListNode) return;
 
       // move next siblings to li sublist
-      moveListItemsToList(editor, {
+      (0, _moveListItemsToList.moveListItemsToList)(editor, {
         fromListItem: liParent,
         toList: [toListNode, toListPath],
         fromStartIndex: liPath[liPath.length - 1] + 1,
@@ -103,16 +109,17 @@ export const movedListItemUp = (editor, _ref) => {
 
     // is last: true
     // li > list[ol] > li
-    const movedUpLiPath = Path.next(liParentPath);
-    Transforms.moveNodes(editor, {
+    const movedUpLiPath = _slate.Path.next(liParentPath);
+    _slate.Transforms.moveNodes(editor, {
       at: liPath,
       to: movedUpLiPath
     });
     return true;
   };
   let moved = false;
-  Editor.withoutNormalizing(editor, () => {
+  _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

@@ -1,7 +1,13 @@
-import { Editor, Path, Transforms } from '@seafile/slate';
-import { findDescendant, getLastChildPath, moveChildren } from '../../../core';
-import { getListTypes } from '../queries';
-export const moveListItemsToList = (editor, _ref) => {
+"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,
@@ -13,12 +19,12 @@ export const moveListItemsToList = (editor, _ref) => {
   } = _ref;
   let fromListPath = null;
   let moved = false;
-  Editor.withoutNormalizing(editor, () => {
+  _slate.Editor.withoutNormalizing(editor, () => {
     if (fromListItem) {
-      const fromListItemSubList = findDescendant(editor, {
+      const fromListItemSubList = (0, _core.findDescendant)(editor, {
         at: fromListItem[1],
         match: {
-          type: getListTypes()
+          type: (0, _queries.getListTypes)()
         }
       });
       if (!fromListItemSubList) return;
@@ -34,12 +40,12 @@ export const moveListItemsToList = (editor, _ref) => {
       if (toListIndex !== null) {
         to = toList[1].concat([toListIndex]);
       } else {
-        const lastChildPath = getLastChildPath(toList);
-        to = Path.next(lastChildPath);
+        const lastChildPath = (0, _core.getLastChildPath)(toList);
+        to = _slate.Path.next(lastChildPath);
       }
     }
     if (!to) return;
-    moved = moveChildren(editor, {
+    moved = (0, _core.moveChildren)(editor, {
       at: fromListPath,
       to,
       fromStartIndex
@@ -47,10 +53,11 @@ export const moveListItemsToList = (editor, _ref) => {
 
     // Remove the empty list
     if (deleteFromList) {
-      Transforms.delete(editor, {
+      _slate.Transforms.delete(editor, {
         at: fromListPath
       });
     }
   });
   return moved;
-};
+};
+exports.moveListItemsToList = moveListItemsToList;

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

@@ -1,20 +1,26 @@
-import { Editor, Path } from '@seafile/slate';
-import { PARAGRAPH } from '../../../constants';
-import { getNodeEntries } from '../../../core';
-import { isListNested } from '../queries';
-import { movedListItemDown } from './move-list-item-down';
-import { movedListItemUp } from './move-list-item-up';
-import { removeFirstListItem } from './remove-first-list-item';
-export const moveListItems = function (editor) {
+"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 = getNodeEntries(editor, {
+  const _nodes = (0, _core.getNodeEntries)(editor, {
     at,
     match: {
-      type: [PARAGRAPH]
+      type: [_constants.PARAGRAPH]
     }
   });
   const lics = Array.from(_nodes);
@@ -23,14 +29,14 @@ export const moveListItems = function (editor) {
   const highestLicPathRefs = [];
   lics.forEach(lic => {
     const licPath = lic[1];
-    const liPath = Path.parent(licPath);
+    const liPath = _slate.Path.parent(licPath);
     const isAncestor = highestLicPaths.some(path => {
-      const highestLiPath = Path.parent(path);
-      return Path.isAncestor(highestLiPath, liPath);
+      const highestLiPath = _slate.Path.parent(path);
+      return _slate.Path.isAncestor(highestLiPath, liPath);
     });
     if (!isAncestor) {
       highestLicPaths.push(licPath);
-      highestLicPathRefs.push(Editor.pathRef(editor, licPath));
+      highestLicPathRefs.push(_slate.Editor.pathRef(editor, licPath));
     }
   });
   const licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
@@ -38,24 +44,24 @@ export const moveListItems = function (editor) {
   licPathRefsToMove.forEach(licPathRef => {
     const licPath = licPathRef.unref();
     if (!licPath) return;
-    const listItem = Editor.parent(editor, licPath);
+    const listItem = _slate.Editor.parent(editor, licPath);
     if (!listItem || listItem[1].length === 0) return;
-    const parentList = Editor.parent(editor, listItem[1]);
+    const parentList = _slate.Editor.parent(editor, listItem[1]);
     if (!parentList) return;
     let _moved = false;
     if (increase) {
-      _moved = movedListItemDown(editor, {
+      _moved = (0, _moveListItemDown.movedListItemDown)(editor, {
         list: parentList,
         listItem: listItem
       });
-    } else if (isListNested(editor, parentList[1])) {
-      _moved = movedListItemUp(editor, {
+    } else if ((0, _queries.isListNested)(editor, parentList[1])) {
+      _moved = (0, _moveListItemUp.movedListItemUp)(editor, {
         list: parentList,
         listItem: listItem
       });
       return _moved;
     } else if (enableResetOnShiftTab) {
-      _moved = removeFirstListItem(editor, {
+      _moved = (0, _removeFirstListItem.removeFirstListItem)(editor, {
         list: parentList,
         listItem: listItem
       });
@@ -63,4 +69,5 @@ export const moveListItems = function (editor) {
     moved = _moved || moved;
   });
   return moved;
-};
+};
+exports.moveListItems = moveListItems;

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

@@ -1,49 +1,55 @@
-import { Transforms, Editor, Path, Element } from '@seafile/slate';
-import { PARAGRAPH } from '../../../constants';
-import { getChildren, getDeepInlineChildren, match } from '../../../core';
-import { getListTypes } from '../queries';
-import { movedListItemUp } from './move-list-item-up';
-import { generateEmptyListContent } from '../model';
-export const normalizeListItem = (editor, _ref) => {
+"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 _queries = require("../queries");
+var _moveListItemUp = require("./move-list-item-up");
+var _model = require("../model");
+const normalizeListItem = (editor, _ref) => {
   let {
     listItem
   } = _ref;
   let changed = false;
-  const validLiChildrenTypes = [...getListTypes(), PARAGRAPH];
+  const validLiChildrenTypes = [...(0, _queries.getListTypes)(), _constants.PARAGRAPH];
   const [, liPath] = listItem;
-  const liChildren = getChildren(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 Editor.pathRef(editor, childPath);
+    return _slate.Editor.pathRef(editor, childPath);
   });
   const firstLiChild = liChildren[0];
   const [firstLiChildNode, firstLiChildPath] = firstLiChild !== null && firstLiChild !== void 0 ? firstLiChild : [];
-  if (!firstLiChild || !Editor.isBlock(editor, firstLiChildNode)) {
-    const itemContent = generateEmptyListContent();
-    Transforms.insertNodes(editor, itemContent, {
+  if (!firstLiChild || !_slate.Editor.isBlock(editor, firstLiChildNode)) {
+    const itemContent = (0, _model.generateEmptyListContent)();
+    _slate.Transforms.insertNodes(editor, itemContent, {
       at: liPath.concat([0])
     });
     return true;
   }
-  if (Editor.isBlock(editor, firstLiChildNode) && !match(firstLiChildNode, [], {
-    type: [PARAGRAPH]
+  if (_slate.Editor.isBlock(editor, firstLiChildNode) && !(0, _core.match)(firstLiChildNode, [], {
+    type: [_constants.PARAGRAPH]
   })) {
-    if (match(firstLiChildNode, [], {
-      type: getListTypes()
+    if ((0, _core.match)(firstLiChildNode, [], {
+      type: (0, _queries.getListTypes)()
     })) {
-      const parent = Editor.parent(editor, listItem[1]);
+      const parent = _slate.Editor.parent(editor, listItem[1]);
       const subList = firstLiChild;
-      const children = getChildren(firstLiChild).reverse();
+      const children = (0, _core.getChildren)(firstLiChild).reverse();
       children.forEach(c => {
-        movedListItemUp(editor, {
+        (0, _moveListItemUp.movedListItemUp)(editor, {
           list: subList,
           listItem: c
         });
       });
-      Transforms.removeNodes(editor, {
+      _slate.Transforms.removeNodes(editor, {
         at: [...parent[1], 0]
       });
       return true;
@@ -51,38 +57,38 @@ export const normalizeListItem = (editor, _ref) => {
     if (validLiChildrenTypes.includes(firstLiChildNode.type)) {
       return true;
     }
-    Transforms.setNodes(editor, {
-      type: PARAGRAPH
+    _slate.Transforms.setNodes(editor, {
+      type: _constants.PARAGRAPH
     }, {
       at: firstLiChildPath
     });
     changed = true;
   }
-  const licChildren = getChildren(firstLiChild);
+  const licChildren = (0, _core.getChildren)(firstLiChild);
   if (licChildren.length) {
     var _licChildren;
     const blockPathRefs = [];
     const inlineChildren = [];
     for (const licChild of licChildren) {
-      if (!(Element.isElement(licChild[0]) && Editor.isBlock(editor, licChild[0]))) {
+      if (!(_slate.Element.isElement(licChild[0]) && _slate.Editor.isBlock(editor, licChild[0]))) {
         break;
       }
-      blockPathRefs.push(Editor.pathRef(editor, licChild[1]));
-      inlineChildren.push(...getDeepInlineChildren(editor, {
-        children: getChildren(licChild)
+      blockPathRefs.push(_slate.Editor.pathRef(editor, licChild[1]));
+      inlineChildren.push(...(0, _core.getDeepInlineChildren)(editor, {
+        children: (0, _core.getChildren)(licChild)
       }));
     }
-    const to = Path.next((_licChildren = licChildren[licChildren.length - 1]) === null || _licChildren === void 0 ? void 0 : _licChildren[1]);
+    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;
-      Transforms.moveNodes(editor, {
+      _slate.Transforms.moveNodes(editor, {
         at: path,
         to
       });
     });
     blockPathRefs.forEach(pathRef => {
       const path = pathRef.unref();
-      path && Transforms.removeNodes(editor, {
+      path && _slate.Transforms.removeNodes(editor, {
         at: path
       });
     });
@@ -93,10 +99,11 @@ export const normalizeListItem = (editor, _ref) => {
   if (changed) return true;
   invalidLiChildrenPathRefs.reverse().forEach(ref => {
     const path = ref.unref();
-    path && Transforms.moveNodes(editor, {
+    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

@@ -1,31 +1,38 @@
-import { Transforms, Path, Editor } from '@seafile/slate';
-import { ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
-import { match } from '../../../core';
-export const normalizeNestedList = function (editor) {
+"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 = Editor.parent(editor, path);
-  const hasParentList = parentNodeEntry && match(parentNodeEntry[0], [], {
-    type: [ORDERED_LIST, UNORDERED_LIST]
+  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 = Path.previous(path);
+    previousListItemPath = _slate.Path.previous(path);
   } catch (e) {
     return false;
   }
-  const previousSiblingItem = Editor.node(editor, previousListItemPath);
+  const previousSiblingItem = _slate.Editor.node(editor, previousListItemPath);
   if (previousSiblingItem) {
     const [, previousPath] = previousSiblingItem;
     const newPath = previousPath.concat([1]);
-    Transforms.moveNodes(editor, {
+    _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

@@ -1,17 +1,24 @@
-import { isListNested } from '../queries';
-import { movedListItemUp } from './move-list-item-up';
-export const removeFirstListItem = (editor, _ref) => {
+"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 (!isListNested(editor, listPath)) {
-    movedListItemUp(editor, {
+  if (!(0, _queries.isListNested)(editor, listPath)) {
+    (0, _moveListItemUp.movedListItemUp)(editor, {
       list,
       listItem
     });
     return true;
   }
   return false;
-};
+};
+exports.removeFirstListItem = removeFirstListItem;