@seafile/sdoc-editor 0.3.6 → 0.3.7

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

@@ -1,35 +1,32 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Transforms, Path, Editor } from '@seafile/slate';
 import { getListTypes } from '../queries';
 import { generateEmptyList } from '../model';
-export var movedListItemDown = function movedListItemDown(editor, _ref) {
-  var list = _ref.list,
-    listItem = _ref.listItem;
-  var moved = false;
-  var _list = _slicedToArray(list, 1),
-    listNode = _list[0];
-  var _listItem = _slicedToArray(listItem, 2),
-    listItemPath = _listItem[1];
-  var previousListItemPath = null;
+export const movedListItemDown = (editor, _ref) => {
+  let {
+    list,
+    listItem
+  } = _ref;
+  let moved = false;
+  const [listNode] = list;
+  const [, listItemPath] = listItem;
+  let previousListItemPath = null;
   try {
     previousListItemPath = Path.previous(listItemPath);
   } catch (e) {
     return;
   }
-  var previousSiblingItem = Editor.node(editor, previousListItemPath);
+  const previousSiblingItem = Editor.node(editor, previousListItemPath);
   if (previousSiblingItem) {
-    var _previousSiblingItem = _slicedToArray(previousSiblingItem, 2),
-      previousNode = _previousSiblingItem[0],
-      previousPath = _previousSiblingItem[1];
-    var subList = previousNode.children.find(function (n) {
+    const [previousNode, previousPath] = previousSiblingItem;
+    const subList = previousNode.children.find(n => {
       return getListTypes().includes(n.type);
     });
-    var newPath = previousPath.concat(subList ? [1, subList.children.length] : [1]);
-    Editor.withoutNormalizing(editor, function () {
+    const newPath = previousPath.concat(subList ? [1, subList.children.length] : [1]);
+    Editor.withoutNormalizing(editor, () => {
       if (!subList) {
         // Insert a list child element
-        var _list2 = generateEmptyList(listNode.type);
-        Transforms.wrapNodes(editor, _list2, {
+        const list = generateEmptyList(listNode.type);
+        Transforms.wrapNodes(editor, list, {
           at: listItemPath
         });
       }

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

@@ -1,4 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Transforms, Path, Editor } from '@seafile/slate';
 import { LIST_ITEM } from '../../../constants';
 import { getAboveNode, getNode, isLastChild } from '../../../core';
@@ -6,19 +5,17 @@ import { hasListChild } from '../queries';
 import { moveListItemsToList } from './move-list-items-to-list';
 import { unwrapList } from './unwrap-list';
 import { generateEmptyList } from '../model';
-export var movedListItemUp = function movedListItemUp(editor, _ref) {
-  var list = _ref.list,
-    listItem = _ref.listItem;
-  var move = function move() {
-    var _list = _slicedToArray(list, 2),
-      listNode = _list[0],
-      listPath = _list[1];
-    var _listItem = _slicedToArray(listItem, 2),
-      liNode = _listItem[0],
-      liPath = _listItem[1];
+export const movedListItemUp = (editor, _ref) => {
+  let {
+    list,
+    listItem
+  } = _ref;
+  const move = () => {
+    const [listNode, listPath] = list;
+    const [liNode, liPath] = listItem;
 
     // 获取上层 list-item 节点
-    var liParent = getAboveNode(editor, {
+    const liParent = getAboveNode(editor, {
       at: listPath,
       match: {
         type: [LIST_ITEM]
@@ -27,44 +24,44 @@ export var movedListItemUp = function movedListItemUp(editor, _ref) {
 
     // 如果上层节点不存在, 说明当前 list 为顶层 list, list[ol] > 'li'
     if (!liParent) {
-      var _toListPath = null;
+      let toListPath = null;
       try {
-        _toListPath = Path.next(listPath);
+        toListPath = Path.next(listPath);
       } catch (err) {
         return;
       }
-      var condA = hasListChild(liNode);
-      var condB = !isLastChild(list, liPath);
+      const condA = hasListChild(liNode);
+      const condB = !isLastChild(list, liPath);
       if (condA || condB) {
         // 创建一个新的兄弟节点
-        var _list2 = generateEmptyList(listNode.type);
-        Transforms.insertNodes(editor, _list2, {
-          at: _toListPath
+        const list = generateEmptyList(listNode.type);
+        Transforms.insertNodes(editor, list, {
+          at: toListPath
         });
       }
 
       // 如果包含子节点，将子节点移动到新创建的节点中
       if (condA) {
-        var toListNode = getNode(editor, _toListPath);
+        const toListNode = getNode(editor, toListPath);
         if (!toListNode) return;
 
         // 将子节点，移动到新创建的节点中
         moveListItemsToList(editor, {
           formListItem: listItem,
-          toList: [toListNode, _toListPath]
+          toList: [toListNode, toListPath]
         });
       }
 
       // 如果不是最后一个节点
       if (condB) {
-        var _toListNode = getNode(editor, _toListPath);
-        if (!_toListNode) return;
+        const toListNode = getNode(editor, toListPath);
+        if (!toListNode) return;
 
         // 将当前节点之后的兄弟节点，移动到新创建的 list 中
         moveListItemsToList(editor, {
           fromList: list,
           fromStartIndex: liPath[liPath.length - 1] + 1,
-          toList: [_toListNode, _toListPath],
+          toList: [toListNode, toListPath],
           deleteFromList: false
         });
       }
@@ -77,29 +74,28 @@ export var movedListItemUp = function movedListItemUp(editor, _ref) {
     }
 
     // 如果上层节点存在，说明当前 list 为 子 list, li > list[ol] > 'li'
-    var _liParent = _slicedToArray(liParent, 2),
-      liParentPath = _liParent[1];
+    const [, liParentPath] = liParent;
     // is last: false
     // li > list[ol] > li
     //               > li
-    var toListPath = liPath.concat([1]);
+    const toListPath = liPath.concat([1]);
     if (!isLastChild(list, liPath)) {
       // 此处取巧：
       // 第一步：把当前节点的兄弟节点，移动到当前节点 “子节点（ol）” 的孩子节点中
       // 第二步：把当前节点的字节点，移动为当前节点 “父节点” 的 “兄弟” 节点
       if (!hasListChild(liNode)) {
-        var _list3 = generateEmptyList(listNode.type);
-        Transforms.insertNodes(editor, _list3, {
+        const list = generateEmptyList(listNode.type);
+        Transforms.insertNodes(editor, list, {
           at: toListPath
         });
       }
-      var _toListNode2 = getNode(editor, toListPath);
-      if (!_toListNode2) return;
+      const toListNode = getNode(editor, toListPath);
+      if (!toListNode) return;
 
       // move next siblings to li sublist
       moveListItemsToList(editor, {
         fromListItem: liParent,
-        toList: [_toListNode2, toListPath],
+        toList: [toListNode, toListPath],
         fromStartIndex: liPath[liPath.length - 1] + 1,
         deleteFromList: false
       });
@@ -107,15 +103,15 @@ export var movedListItemUp = function movedListItemUp(editor, _ref) {
 
     // is last: true
     // li > list[ol] > li
-    var movedUpLiPath = Path.next(liParentPath);
+    const movedUpLiPath = Path.next(liParentPath);
     Transforms.moveNodes(editor, {
       at: liPath,
       to: movedUpLiPath
     });
     return true;
   };
-  var moved = false;
-  Editor.withoutNormalizing(editor, function () {
+  let moved = false;
+  Editor.withoutNormalizing(editor, () => {
     moved = move();
   });
   return moved;

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

@@ -1,21 +1,21 @@
 import { Editor, Path, Transforms } from '@seafile/slate';
 import { findDescendant, getLastChildPath, moveChildren } from '../../../core';
 import { getListTypes } from '../queries';
-export var moveListItemsToList = function moveListItemsToList(editor, _ref) {
-  var fromList = _ref.fromList,
-    fromListItem = _ref.fromListItem,
-    fromStartIndex = _ref.fromStartIndex,
-    _to = _ref.to,
-    toList = _ref.toList,
-    _ref$toListIndex = _ref.toListIndex,
-    toListIndex = _ref$toListIndex === void 0 ? null : _ref$toListIndex,
-    _ref$deleteFromList = _ref.deleteFromList,
-    deleteFromList = _ref$deleteFromList === void 0 ? true : _ref$deleteFromList;
-  var fromListPath = null;
-  var moved = false;
-  Editor.withoutNormalizing(editor, function () {
+export const moveListItemsToList = (editor, _ref) => {
+  let {
+    fromList,
+    fromListItem,
+    fromStartIndex,
+    to: _to,
+    toList,
+    toListIndex = null,
+    deleteFromList = true
+  } = _ref;
+  let fromListPath = null;
+  let moved = false;
+  Editor.withoutNormalizing(editor, () => {
     if (fromListItem) {
-      var fromListItemSubList = findDescendant(editor, {
+      const fromListItemSubList = findDescendant(editor, {
         at: fromListItem[1],
         match: {
           type: getListTypes()
@@ -28,21 +28,21 @@ export var moveListItemsToList = function moveListItemsToList(editor, _ref) {
     } else {
       return;
     }
-    var to = null;
+    let to = null;
     if (_to) to = _to;
     if (toList) {
       if (toListIndex !== null) {
         to = toList[1].concat([toListIndex]);
       } else {
-        var lastChildPath = getLastChildPath(toList);
+        const lastChildPath = getLastChildPath(toList);
         to = Path.next(lastChildPath);
       }
     }
     if (!to) return;
     moved = moveChildren(editor, {
       at: fromListPath,
-      to: to,
-      fromStartIndex: fromStartIndex
+      to,
+      fromStartIndex
     });
 
     // Remove the empty list

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

@@ -5,28 +5,27 @@ 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 var moveListItems = function moveListItems(editor) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    _ref$increase = _ref.increase,
-    increase = _ref$increase === void 0 ? true : _ref$increase,
-    _ref$at = _ref.at,
-    at = _ref$at === void 0 ? editor.selection : _ref$at,
-    enableResetOnShiftTab = _ref.enableResetOnShiftTab;
-  var _nodes = getNodeEntries(editor, {
-    at: at,
+export const moveListItems = function (editor) {
+  let {
+    increase = true,
+    at = editor.selection,
+    enableResetOnShiftTab
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const _nodes = getNodeEntries(editor, {
+    at,
     match: {
       type: [PARAGRAPH]
     }
   });
-  var lics = Array.from(_nodes);
+  const lics = Array.from(_nodes);
   if (!lics.length) return;
-  var highestLicPaths = [];
-  var highestLicPathRefs = [];
-  lics.forEach(function (lic) {
-    var licPath = lic[1];
-    var liPath = Path.parent(licPath);
-    var isAncestor = highestLicPaths.some(function (path) {
-      var highestLiPath = Path.parent(path);
+  const highestLicPaths = [];
+  const highestLicPathRefs = [];
+  lics.forEach(lic => {
+    const licPath = lic[1];
+    const liPath = Path.parent(licPath);
+    const isAncestor = highestLicPaths.some(path => {
+      const highestLiPath = Path.parent(path);
       return Path.isAncestor(highestLiPath, liPath);
     });
     if (!isAncestor) {
@@ -34,16 +33,16 @@ export var moveListItems = function moveListItems(editor) {
       highestLicPathRefs.push(Editor.pathRef(editor, licPath));
     }
   });
-  var licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
-  var moved = false;
-  licPathRefsToMove.forEach(function (licPathRef) {
-    var licPath = licPathRef.unref();
+  const licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
+  let moved = false;
+  licPathRefsToMove.forEach(licPathRef => {
+    const licPath = licPathRef.unref();
     if (!licPath) return;
-    var listItem = Editor.parent(editor, licPath);
+    const listItem = Editor.parent(editor, licPath);
     if (!listItem) return;
-    var parentList = Editor.parent(editor, listItem[1]);
+    const parentList = Editor.parent(editor, listItem[1]);
     if (!parentList) return;
-    var _moved = false;
+    let _moved = false;
     if (increase) {
       _moved = movedListItemDown(editor, {
         list: parentList,

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

@@ -1,35 +1,28 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 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 var normalizeListItem = function normalizeListItem(editor, _ref) {
-  var listItem = _ref.listItem;
-  var changed = false;
-  var validLiChildrenTypes = [].concat(_toConsumableArray(getListTypes()), [PARAGRAPH]);
-  var _listItem = _slicedToArray(listItem, 2),
-    liPath = _listItem[1];
-  var liChildren = getChildren(listItem);
-  var invalidLiChildrenPathRefs = liChildren.filter(function (_ref2) {
-    var _ref3 = _slicedToArray(_ref2, 1),
-      child = _ref3[0];
+export const normalizeListItem = (editor, _ref) => {
+  let {
+    listItem
+  } = _ref;
+  let changed = false;
+  const validLiChildrenTypes = [...getListTypes(), PARAGRAPH];
+  const [, liPath] = listItem;
+  const liChildren = getChildren(listItem);
+  const invalidLiChildrenPathRefs = liChildren.filter(_ref2 => {
+    let [child] = _ref2;
     return !validLiChildrenTypes.includes(child.type);
-  }).map(function (_ref4) {
-    var _ref5 = _slicedToArray(_ref4, 2),
-      childPath = _ref5[1];
+  }).map(_ref3 => {
+    let [, childPath] = _ref3;
     return Editor.pathRef(editor, childPath);
   });
-  var firstLiChild = liChildren[0];
-  var _ref6 = firstLiChild !== null && firstLiChild !== void 0 ? firstLiChild : [],
-    _ref7 = _slicedToArray(_ref6, 2),
-    firstLiChildNode = _ref7[0],
-    firstLiChildPath = _ref7[1];
+  const firstLiChild = liChildren[0];
+  const [firstLiChildNode, firstLiChildPath] = firstLiChild !== null && firstLiChild !== void 0 ? firstLiChild : [];
   if (!firstLiChild || !Editor.isBlock(editor, firstLiChildNode)) {
-    var itemContent = generateEmptyListContent();
+    const itemContent = generateEmptyListContent();
     Transforms.insertNodes(editor, itemContent, {
       at: liPath.concat([0])
     });
@@ -41,17 +34,17 @@ export var normalizeListItem = function normalizeListItem(editor, _ref) {
     if (match(firstLiChildNode, [], {
       type: getListTypes()
     })) {
-      var parent = Editor.parent(editor, listItem[1]);
-      var subList = firstLiChild;
-      var children = getChildren(firstLiChild).reverse();
-      children.forEach(function (c) {
+      const parent = Editor.parent(editor, listItem[1]);
+      const subList = firstLiChild;
+      const children = getChildren(firstLiChild).reverse();
+      children.forEach(c => {
         movedListItemUp(editor, {
           list: subList,
           listItem: c
         });
       });
       Transforms.removeNodes(editor, {
-        at: [].concat(_toConsumableArray(parent[1]), [0])
+        at: [...parent[1], 0]
       });
       return true;
     }
@@ -65,40 +58,30 @@ export var normalizeListItem = function normalizeListItem(editor, _ref) {
     });
     changed = true;
   }
-  var licChildren = getChildren(firstLiChild);
+  const licChildren = getChildren(firstLiChild);
   if (licChildren.length) {
     var _licChildren;
-    var blockPathRefs = [];
-    var inlineChildren = [];
-    var _iterator = _createForOfIteratorHelper(licChildren),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var licChild = _step.value;
-        if (!(Element.isElement(licChild[0]) && Editor.isBlock(editor, licChild[0]))) {
-          break;
-        }
-        blockPathRefs.push(Editor.pathRef(editor, licChild[1]));
-        inlineChildren.push.apply(inlineChildren, _toConsumableArray(getDeepInlineChildren(editor, {
-          children: getChildren(licChild)
-        })));
+    const blockPathRefs = [];
+    const inlineChildren = [];
+    for (const licChild of licChildren) {
+      if (!(Element.isElement(licChild[0]) && Editor.isBlock(editor, licChild[0]))) {
+        break;
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+      blockPathRefs.push(Editor.pathRef(editor, licChild[1]));
+      inlineChildren.push(...getDeepInlineChildren(editor, {
+        children: getChildren(licChild)
+      }));
     }
-    var to = Path.next((_licChildren = licChildren[licChildren.length - 1]) === null || _licChildren === void 0 ? void 0 : _licChildren[1]);
-    inlineChildren.reverse().forEach(function (_ref8) {
-      var _ref9 = _slicedToArray(_ref8, 2),
-        path = _ref9[1];
+    const to = 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, {
         at: path,
-        to: to
+        to
       });
     });
-    blockPathRefs.forEach(function (pathRef) {
-      var path = pathRef.unref();
+    blockPathRefs.forEach(pathRef => {
+      const path = pathRef.unref();
       path && Transforms.removeNodes(editor, {
         at: path
       });
@@ -108,8 +91,8 @@ export var normalizeListItem = function normalizeListItem(editor, _ref) {
     }
   }
   if (changed) return true;
-  invalidLiChildrenPathRefs.reverse().forEach(function (ref) {
-    var path = ref.unref();
+  invalidLiChildrenPathRefs.reverse().forEach(ref => {
+    const path = ref.unref();
     path && Transforms.moveNodes(editor, {
       at: path,
       to: firstLiChildPath.concat([0])

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

@@ -1,28 +1,26 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Transforms, Path, Editor } from '@seafile/slate';
 import { ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
 import { match } from '../../../core';
-export var normalizeNestedList = function normalizeNestedList(editor) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    nestedListItem = _ref.nestedListItem;
-  var _nestedListItem = _slicedToArray(nestedListItem, 2),
-    path = _nestedListItem[1];
-  var parentNodeEntry = Editor.parent(editor, path);
-  var hasParentList = parentNodeEntry && match(parentNodeEntry[0], [], {
+export 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]
   });
   if (!hasParentList) return false;
-  var previousListItemPath = null;
+  let previousListItemPath = null;
   try {
     previousListItemPath = Path.previous(path);
   } catch (e) {
     return false;
   }
-  var previousSiblingItem = Editor.node(editor, previousListItemPath);
+  const previousSiblingItem = Editor.node(editor, previousListItemPath);
   if (previousSiblingItem) {
-    var _previousSiblingItem = _slicedToArray(previousSiblingItem, 2),
-      previousPath = _previousSiblingItem[1];
-    var newPath = previousPath.concat([1]);
+    const [, previousPath] = previousSiblingItem;
+    const newPath = previousPath.concat([1]);
     Transforms.moveNodes(editor, {
       at: path,
       to: newPath

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

@@ -1,15 +1,15 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { isListNested } from '../queries';
 import { movedListItemUp } from './move-list-item-up';
-export var removeFirstListItem = function removeFirstListItem(editor, _ref) {
-  var list = _ref.list,
-    listItem = _ref.listItem;
-  var _list = _slicedToArray(list, 2),
-    listPath = _list[1];
+export const removeFirstListItem = (editor, _ref) => {
+  let {
+    list,
+    listItem
+  } = _ref;
+  const [, listPath] = list;
   if (!isListNested(editor, listPath)) {
     movedListItemUp(editor, {
-      list: list,
-      listItem: listItem
+      list,
+      listItem
     });
     return true;
   }