@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/extension/plugins/link/render-elem.js

@@ -1,7 +1,3 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
 import { Range } from '@seafile/slate';
 import { unWrapLinkNode } from './helpers';
@@ -9,100 +5,96 @@ import LinkHover from './hover';
 import EventBus from '../../../utils/event-bus';
 import { INTERNAL_EVENT } from '../../../constants';
 import { ELEMENT_TYPE } from '../../constants';
-var LinkHoverMenuComponent = /*#__PURE__*/function (_React$Component) {
-  _inherits(LinkHoverMenuComponent, _React$Component);
-  var _super = _createSuper(LinkHoverMenuComponent);
-  function LinkHoverMenuComponent(props) {
-    var _this;
-    _classCallCheck(this, LinkHoverMenuComponent);
-    _this = _super.call(this, props);
-    _this.registerEventHandle = function () {
-      document.addEventListener('click', _this.onHideLinkMenu);
+class LinkHoverMenuComponent extends React.Component {
+  constructor(props) {
+    super(props);
+    this.registerEventHandle = () => {
+      document.addEventListener('click', this.onHideLinkMenu);
     };
-    _this.unregisterEventHandle = function () {
-      document.removeEventListener('click', _this.onHideLinkMenu);
+    this.unregisterEventHandle = () => {
+      document.removeEventListener('click', this.onHideLinkMenu);
     };
-    _this.onHideLinkMenu = function () {
-      _this.setState({
+    this.onHideLinkMenu = () => {
+      this.setState({
         isShowLinkMenu: false
-      }, function () {
-        _this.unregisterEventHandle();
+      }, () => {
+        this.unregisterEventHandle();
       });
     };
-    _this.onLinkClick = function (e) {
-      var _e$target$getBounding = e.target.getBoundingClientRect(),
-        top = _e$target$getBounding.top,
-        left = _e$target$getBounding.left,
-        width = _e$target$getBounding.width;
+    this.onLinkClick = e => {
+      const {
+        top,
+        left,
+        width
+      } = e.target.getBoundingClientRect();
       // top = top distance - menu height
-      var menuTop = top - 42;
+      const menuTop = top - 42;
       // left = left distance - (menu width / 2) + (link with / 2)
-      var menuLeft = left - 140 / 2 + width / 2;
-      _this.setState({
+      const menuLeft = left - 140 / 2 + width / 2;
+      this.setState({
         isShowLinkMenu: true,
         menuPosition: {
           top: menuTop,
           left: menuLeft
         }
       });
-      setTimeout(function () {
-        _this.registerEventHandle();
+      setTimeout(() => {
+        this.registerEventHandle();
       }, 0);
     };
-    _this.deleteLink = function () {
-      var editor = _this.props.editor;
+    this.deleteLink = () => {
+      const {
+        editor
+      } = this.props;
       unWrapLinkNode(editor);
     };
-    _this.openDialog = function () {
-      var element = _this.props.element;
-      _this.eventBus.dispatch(INTERNAL_EVENT.INSERT_ELEMENT, {
+    this.openDialog = () => {
+      const {
+        element
+      } = this.props;
+      this.eventBus.dispatch(INTERNAL_EVENT.INSERT_ELEMENT, {
         type: ELEMENT_TYPE.LINK,
-        element: element
+        element
       });
     };
-    _this.state = {
+    this.state = {
       isShowLinkMenu: false,
       menuPosition: null
     };
-    _this.eventBus = EventBus.getInstance();
-    return _this;
+    this.eventBus = EventBus.getInstance();
   }
-  _createClass(LinkHoverMenuComponent, [{
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.unregisterEventHandle();
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props = this.props,
-        attributes = _this$props.attributes,
-        children = _this$props.children,
-        element = _this$props.element,
-        editor = _this$props.editor;
-      var _this$state = this.state,
-        isShowLinkMenu = _this$state.isShowLinkMenu,
-        menuPosition = _this$state.menuPosition;
-      var className = isShowLinkMenu ? 'seafile-ed-hovermenu-mouseclick' : null;
-      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", Object.assign({
-        className: className
-      }, attributes, {
-        onClick: this.onLinkClick
-      }), /*#__PURE__*/React.createElement("span", {
-        className: "virtual-link",
-        title: element.title
-      }, children)), isShowLinkMenu && Range.isCollapsed(editor.selection) && /*#__PURE__*/React.createElement(LinkHover, {
-        editor: editor,
-        menuPosition: menuPosition,
-        element: element,
-        onDeleteLink: this.deleteLink,
-        onEditLink: this.openDialog
-      }));
-    }
-  }]);
-  return LinkHoverMenuComponent;
-}(React.Component);
-var renderLink = function renderLink(props, editor) {
+  componentWillUnmount() {
+    this.unregisterEventHandle();
+  }
+  render() {
+    const {
+      attributes,
+      children,
+      element,
+      editor
+    } = this.props;
+    const {
+      isShowLinkMenu,
+      menuPosition
+    } = this.state;
+    const className = isShowLinkMenu ? 'seafile-ed-hovermenu-mouseclick' : null;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", Object.assign({
+      className: className
+    }, attributes, {
+      onClick: this.onLinkClick
+    }), /*#__PURE__*/React.createElement("span", {
+      className: "virtual-link",
+      title: element.title
+    }, children)), isShowLinkMenu && Range.isCollapsed(editor.selection) && /*#__PURE__*/React.createElement(LinkHover, {
+      editor: editor,
+      menuPosition: menuPosition,
+      element: element,
+      onDeleteLink: this.deleteLink,
+      onEditLink: this.openDialog
+    }));
+  }
+}
+const renderLink = (props, editor) => {
   return /*#__PURE__*/React.createElement(LinkHoverMenuComponent, Object.assign({}, props, {
     editor: editor
   }));

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

@@ -1,57 +1,47 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import { Editor, Element, Node, Range, Text } from '@seafile/slate';
 import { CHECK_LIST_ITEM, CODE_BLOCK, CODE_LINE, LIST_ITEM, PARAGRAPH, TABLE } from '../../constants';
 import { toggleList } from './transforms';
 import { getListTypes } from './queries';
-export var isMenuDisabled = function isMenuDisabled(editor, readonly) {
+export const isMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
   if (editor.selection == null) return true;
-  var selectedElements = [];
-  var nodeEntries = Editor.nodes(editor, {
+  let selectedElements = [];
+  const nodeEntries = Editor.nodes(editor, {
     universal: true
   });
-  var _iterator = _createForOfIteratorHelper(nodeEntries),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var nodeEntry = _step.value;
-      var _nodeEntry = _slicedToArray(nodeEntry, 1),
-        node = _nodeEntry[0];
-      if (Element.isElement(node)) selectedElements.push(node);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (let nodeEntry of nodeEntries) {
+    const [node] = nodeEntry;
+    if (Element.isElement(node)) selectedElements.push(node);
   }
-  var notMatch = selectedElements.some(function (element) {
+  const notMatch = selectedElements.some(element => {
     if (Editor.isVoid(editor, element) && Editor.isBlock(editor, element)) return true;
-    var type = element.type;
+    const {
+      type
+    } = element;
     if ([CODE_LINE, CODE_BLOCK, TABLE, CHECK_LIST_ITEM].includes(type)) return true;
     return false;
   });
   if (notMatch) return true;
   return false;
 };
-export var getListType = function getListType(editor, type) {
-  var selection = editor.selection;
+export const getListType = (editor, type) => {
+  const {
+    selection
+  } = editor;
   if (!selection) return;
-  var selectedListNodeEntry;
+  let selectedListNodeEntry;
   if (Range.isCollapsed(selection)) {
-    var _Editor$nodes = Editor.nodes(editor, {
-        match: function match(node) {
-          return getListTypes().includes(node.type);
-        },
-        mode: 'lowest'
-      }),
-      _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
-      nodeEntry = _Editor$nodes2[0];
+    const [nodeEntry] = Editor.nodes(editor, {
+      match: node => getListTypes().includes(node.type),
+      mode: 'lowest'
+    });
     selectedListNodeEntry = nodeEntry;
   } else {
-    var anchor = selection.anchor,
-      focus = selection.focus;
-    var commonNodeEntry = Node.common(editor, anchor.path, focus.path);
+    const {
+      anchor,
+      focus
+    } = selection;
+    const commonNodeEntry = Node.common(editor, anchor.path, focus.path);
     //  Select condition:
     // 1. Select in one list
     // 2. Select in one list item
@@ -64,42 +54,40 @@ export var getListType = function getListType(editor, type) {
       selectedListNodeEntry = Editor.parent(editor, commonNodeEntry[1]);
     } else if (Text.isText(commonNodeEntry[0])) {
       // Select in one line
-      var _Editor$nodes3 = Editor.nodes(editor, {
-          at: commonNodeEntry[1],
-          match: function match(node) {
-            return getListTypes().includes(node.type);
-          },
-          mode: 'lowest'
-        }),
-        _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1),
-        _nodeEntry2 = _Editor$nodes4[0];
-      selectedListNodeEntry = _nodeEntry2;
+      const [nodeEntry] = Editor.nodes(editor, {
+        at: commonNodeEntry[1],
+        match: node => getListTypes().includes(node.type),
+        mode: 'lowest'
+      });
+      selectedListNodeEntry = nodeEntry;
     }
   }
   return selectedListNodeEntry ? selectedListNodeEntry[0].type : PARAGRAPH;
 };
-export var setListType = function setListType(editor, type) {
+export const setListType = (editor, type) => {
   toggleList(editor, type);
 };
-export var getBeforeText = function getBeforeText(editor) {
-  var selection = editor.selection;
+export const getBeforeText = editor => {
+  const {
+    selection
+  } = editor;
   if (selection == null) return {
     beforeText: '',
     range: null
   };
-  var anchor = selection.anchor;
+  const {
+    anchor
+  } = selection;
   // Find the near text node above the current text
-  var _Editor$above = Editor.above(editor),
-    _Editor$above2 = _slicedToArray(_Editor$above, 2),
-    aboveNodePath = _Editor$above2[1];
-  var aboveNodeStartPoint = Editor.start(editor, aboveNodePath); // The starting position of the text node
-  var range = {
-    anchor: anchor,
+  const [, aboveNodePath] = Editor.above(editor);
+  const aboveNodeStartPoint = Editor.start(editor, aboveNodePath); // The starting position of the text node
+  const range = {
+    anchor,
     focus: aboveNodeStartPoint
   };
-  var beforeText = Editor.string(editor, range) || '';
+  const beforeText = Editor.string(editor, range) || '';
   return {
-    beforeText: beforeText,
-    range: range
+    beforeText,
+    range
   };
 };

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

@@ -1,7 +1,7 @@
 import ListMenu from './menu';
 import withList from './plugin';
 import { renderList, renderListItem, renderListLic } from './render-elem';
-var ListPlugin = {
+const ListPlugin = {
   type: 'list',
   nodeType: 'element',
   editorMenus: [ListMenu],

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

@@ -1,70 +1,58 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
 import { MENUS_CONFIG_MAP, ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
 import { focusEditor } from '../../../core';
 import { MenuItem } from '../../../commons';
 import { getListType, isMenuDisabled, setListType } from '../helpers';
-var ListMenu = /*#__PURE__*/function (_React$Component) {
-  _inherits(ListMenu, _React$Component);
-  var _super = _createSuper(ListMenu);
-  function ListMenu() {
-    var _this;
-    _classCallCheck(this, ListMenu);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _this.isActive = function () {
-      var _this$props = _this.props,
-        editor = _this$props.editor,
-        type = _this$props.type;
+class ListMenu extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.isActive = () => {
+      const {
+        editor,
+        type
+      } = this.props;
       return getListType(editor, type) === type;
     };
-    _this.isDisabled = function () {
-      var _this$props2 = _this.props,
-        editor = _this$props2.editor,
-        readonly = _this$props2.readonly;
+    this.isDisabled = () => {
+      const {
+        editor,
+        readonly
+      } = this.props;
       return isMenuDisabled(editor, readonly);
     };
-    _this.onMouseDown = function (e) {
+    this.onMouseDown = e => {
       e.preventDefault();
       e.stopPropagation();
-      if (_this.isDisabled()) return;
-      var _this$props3 = _this.props,
-        editor = _this$props3.editor,
-        type = _this$props3.type;
+      if (this.isDisabled()) return;
+      const {
+        editor,
+        type
+      } = this.props;
 
       // 执行命令
       setListType(editor, type);
       focusEditor(editor);
     };
-    return _this;
   }
-  _createClass(ListMenu, [{
-    key: "render",
-    value: function render() {
-      var _this$props4 = this.props,
-        isRichEditor = _this$props4.isRichEditor,
-        className = _this$props4.className,
-        type = _this$props4.type;
-      var menuConfig = MENUS_CONFIG_MAP[type];
-      var props = _objectSpread(_objectSpread({
-        isRichEditor: isRichEditor,
-        className: className
-      }, menuConfig), {}, {
-        disabled: this.isDisabled(),
-        isActive: this.isActive(),
-        onMouseDown: this.onMouseDown
-      });
-      return /*#__PURE__*/React.createElement(MenuItem, props);
-    }
-  }]);
-  return ListMenu;
-}(React.Component);
+  render() {
+    const {
+      isRichEditor,
+      className,
+      type
+    } = this.props;
+    const menuConfig = MENUS_CONFIG_MAP[type];
+    const props = _objectSpread(_objectSpread({
+      isRichEditor,
+      className
+    }, menuConfig), {}, {
+      disabled: this.isDisabled(),
+      isActive: this.isActive(),
+      onMouseDown: this.onMouseDown
+    });
+    return /*#__PURE__*/React.createElement(MenuItem, props);
+  }
+}
 ListMenu.defaultProps = {
   type: UNORDERED_LIST
 };

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

@@ -1,27 +1,26 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import slugid from 'slugid';
 import { LIST_ITEM, PARAGRAPH, UNORDERED_LIST } from '../../constants';
 import { generateEmptyElement } from '../../core';
-var List = /*#__PURE__*/_createClass(function List(options) {
-  _classCallCheck(this, List);
-  this.type = options.type || UNORDERED_LIST;
-  this.children = options.children || [{
-    text: ''
-  }];
-});
+class List {
+  constructor(options) {
+    this.type = options.type || UNORDERED_LIST;
+    this.children = options.children || [{
+      text: ''
+    }];
+  }
+}
 export default List;
-export var generateEmptyListItem = function generateEmptyListItem() {
+export const generateEmptyListItem = () => {
   return {
     id: slugid.nice(),
     type: LIST_ITEM,
     children: []
   };
 };
-export var generateEmptyListContent = function generateEmptyListContent() {
+export const generateEmptyListContent = () => {
   return generateEmptyElement(PARAGRAPH);
 };
-export var generateEmptyList = function generateEmptyList(type) {
+export const generateEmptyList = type => {
   return {
     id: slugid.nice(),
     type: type,

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

@@ -3,19 +3,23 @@ import { onTabHandle } from './on-tab-handle';
 import { normalizeList } from './normalize-list';
 import { insertFragmentList } from './insert-fragment-list';
 import { handleShortcut } from './shortcut';
-var withList = function withList(editor) {
-  var insertBreak = editor.insertBreak,
-    deleteBackWord = editor.deleteBackWord,
-    handleTab = editor.handleTab,
-    insertText = editor.insertText;
-  var newEditor = editor;
-  newEditor.insertBreak = function () {
+const withList = editor => {
+  const {
+    insertBreak,
+    deleteBackWord,
+    handleTab,
+    insertText
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
     if (insertBreakList(editor)) return;
     insertBreak();
     return;
   };
-  newEditor.deleteBackWord = function (unit) {
-    var selection = newEditor.selection;
+  newEditor.deleteBackWord = unit => {
+    const {
+      selection
+    } = newEditor;
     if (selection === null) {
       deleteBackWord(unit);
       return;
@@ -23,7 +27,7 @@ var withList = function withList(editor) {
     // nothing todo
     deleteBackWord(unit);
   };
-  newEditor.handleTab = function (event) {
+  newEditor.handleTab = event => {
     if (!newEditor.selection) {
       handleTab && handleTab();
       return;
@@ -33,8 +37,8 @@ var withList = function withList(editor) {
   };
   newEditor.insertFragment = insertFragmentList(newEditor);
   newEditor.normalizeNode = normalizeList(editor);
-  newEditor.insertText = function (text) {
-    var isPreventInsert = handleShortcut(newEditor, text);
+  newEditor.insertText = text => {
+    const isPreventInsert = handleShortcut(newEditor, text);
     if (isPreventInsert) return;
     return insertText(text);
   };

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

@@ -1,12 +1,12 @@
 import { isBlockAboveEmpty } from '../../../core';
 import { getListItemEntry } from '../queries';
 import { insertListItem, movedListItemUp } from '../transforms';
-export var insertBreakList = function insertBreakList(editor) {
+export const insertBreakList = editor => {
   if (!editor.selection) return;
 
   // moved | inserted
-  var moved = false;
-  var res = getListItemEntry(editor, {});
+  let moved = false;
+  const res = getListItemEntry(editor, {});
 
   // if selection is in a li, and li content is empty
   if (res) {
@@ -16,7 +16,7 @@ export var insertBreakList = function insertBreakList(editor) {
     }
   }
   if (!moved) {
-    var inserted = insertListItem(editor);
+    const inserted = insertListItem(editor);
     if (inserted) return true;
   }
   return;