@seafile/sdoc-editor 2.0.82 → 2.0.83

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

@@ -1,47 +0,0 @@
-"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

@@ -1,140 +0,0 @@
-"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

@@ -1,30 +0,0 @@
-"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

@@ -1,176 +0,0 @@
-"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

@@ -1,80 +0,0 @@
-"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

@@ -1,61 +0,0 @@
-"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

@@ -1,89 +0,0 @@
-"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;

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

@@ -1,55 +0,0 @@
-"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;