@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/extension/toolbar/side-toolbar/insert-below-menu.js

@@ -2,9 +2,11 @@ import React from 'react';
 import { UncontrolledPopover } from 'reactstrap';
 import InsertBlockMenu from './insert-block-menu';
 import { INSERT_POSITION } from '../../constants';
-var InsertBelowMenu = function InsertBelowMenu(_ref) {
-  var target = _ref.target,
-    slateNode = _ref.slateNode;
+const InsertBelowMenu = _ref => {
+  let {
+    target,
+    slateNode
+  } = _ref;
   return /*#__PURE__*/React.createElement(UncontrolledPopover, {
     boundariesElement: "viewport",
     target: target,

package/dist/basic-sdk/extension/toolbar/side-toolbar/insert-block-menu.js

@@ -1,4 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import React, { useCallback } from 'react';
 import { useSlateStatic } from '@seafile/slate-react';
@@ -13,54 +12,56 @@ import { ELEMENT_TYPE, INSERT_POSITION, LOCAL_IMAGE, SIDE_INSERT_MENUS_CONFIG }
 import EventBus from '../../../utils/event-bus';
 import { INTERNAL_EVENT } from '../../../constants';
 import DropdownMenuItem from '../../commons/dropdown-menu-item';
-var InsertBlockMenu = function InsertBlockMenu(_ref) {
-  var insertPosition = _ref.insertPosition,
-    slateNode = _ref.slateNode;
-  var editor = useSlateStatic();
-  var onInsertImageToggle = useCallback(function () {
-    var eventBus = EventBus.getInstance();
+const InsertBlockMenu = _ref => {
+  let {
+    insertPosition,
+    slateNode
+  } = _ref;
+  const editor = useSlateStatic();
+  const onInsertImageToggle = useCallback(() => {
+    const eventBus = EventBus.getInstance();
     if (insertPosition === INSERT_POSITION.CURRENT) {
       Transforms.select(editor, editor.selection.focus);
     }
     eventBus.dispatch(INTERNAL_EVENT.INSERT_ELEMENT, {
       type: LOCAL_IMAGE,
-      insertPosition: insertPosition,
-      slateNode: slateNode
+      insertPosition,
+      slateNode
     });
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor, insertPosition]);
-  var createTable = useCallback(function (size) {
-    var newInsertPosition = slateNode.type === ELEMENT_TYPE.LIST_ITEM ? INSERT_POSITION.AFTER : insertPosition;
+  const createTable = useCallback(size => {
+    const newInsertPosition = slateNode.type === ELEMENT_TYPE.LIST_ITEM ? INSERT_POSITION.AFTER : insertPosition;
     insertTable(editor, size, editor.selection, newInsertPosition);
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor, insertPosition, slateNode]);
-  var openLinkDialog = useCallback(function () {
-    var eventBus = EventBus.getInstance();
+  const openLinkDialog = useCallback(() => {
+    const eventBus = EventBus.getInstance();
     eventBus.dispatch(INTERNAL_EVENT.INSERT_ELEMENT, {
       type: ELEMENT_TYPE.LINK,
-      insertPosition: insertPosition,
-      slateNode: slateNode
+      insertPosition,
+      slateNode
     });
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [insertPosition]);
-  var onInsertCodeBlock = useCallback(function () {
-    var newInsertPosition = slateNode.type === ELEMENT_TYPE.LIST_ITEM ? INSERT_POSITION.AFTER : insertPosition;
+  const onInsertCodeBlock = useCallback(() => {
+    const newInsertPosition = slateNode.type === ELEMENT_TYPE.LIST_ITEM ? INSERT_POSITION.AFTER : insertPosition;
     changeToCodeBlock(editor, 'plaintext', newInsertPosition);
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor, insertPosition, slateNode]);
-  var onInsertList = useCallback(function (type) {
+  const onInsertList = useCallback(type => {
     toggleList(editor, type, insertPosition);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor, insertPosition, slateNode]);
-  var onInsertCheckList = useCallback(function () {
+  const onInsertCheckList = useCallback(() => {
     setCheckListItemType(editor, ELEMENT_TYPE.CHECK_LIST_ITEM, insertPosition);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor, insertPosition, slateNode]);
-  var onInsert = useCallback(function (type) {
+  const onInsert = useCallback(type => {
     insertElement(editor, type, insertPosition);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor, insertPosition, slateNode]);
@@ -87,24 +88,22 @@ var InsertBlockMenu = function InsertBlockMenu(_ref) {
     onClick: onInsertCodeBlock
   }), /*#__PURE__*/React.createElement(DropdownMenuItem, {
     menuConfig: _objectSpread({}, SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.UNORDERED_LIST]),
-    onClick: function onClick() {
+    onClick: () => {
       onInsertList(ELEMENT_TYPE.UNORDERED_LIST);
     }
   }), /*#__PURE__*/React.createElement(DropdownMenuItem, {
     menuConfig: _objectSpread({}, SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.ORDERED_LIST]),
-    onClick: function onClick() {
+    onClick: () => {
       onInsertList(ELEMENT_TYPE.ORDERED_LIST);
     }
   }), /*#__PURE__*/React.createElement(DropdownMenuItem, {
     menuConfig: _objectSpread({}, SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.CHECK_LIST_ITEM]),
     onClick: onInsertCheckList
-  }), [SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.PARAGRAPH]].concat(_toConsumableArray(SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.HEADER])).map(function (item) {
+  }), [SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.PARAGRAPH], ...SIDE_INSERT_MENUS_CONFIG[ELEMENT_TYPE.HEADER]].map(item => {
     return /*#__PURE__*/React.createElement(DropdownMenuItem, {
       key: item.id,
       menuConfig: item,
-      onClick: function onClick() {
-        return onInsert(item.type);
-      }
+      onClick: () => onInsert(item.type)
     });
   }));
 };

package/dist/basic-sdk/extension/toolbar/side-toolbar/side-menu.js

@@ -1,4 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { withTranslation } from 'react-i18next';
 import { useSlateStatic } from '@seafile/slate-react';
@@ -14,41 +13,40 @@ import DropdownMenuItem from '../../commons/dropdown-menu-item';
 import toaster from '../../../../components/toast';
 import { HEADER1, HEADER2, HEADER3 } from '../../constants';
 import './side-menu.css';
-var SideMenu = function SideMenu(_ref) {
-  var slateNode = _ref.slateNode,
-    isNodeEmpty = _ref.isNodeEmpty,
-    menuPosition = _ref.menuPosition,
-    onReset = _ref.onReset,
-    t = _ref.t;
-  var sideMenuRef = useRef(null);
-  var _useState = useState(''),
-    _useState2 = _slicedToArray(_useState, 2),
-    menuStyle = _useState2[0],
-    setMenuStyle = _useState2[1];
-  var editor = useSlateStatic();
-  useEffect(function () {
-    var eventBus = EventBus.getInstance();
-    var unsubscribeChange = eventBus.subscribe('change', onReset);
+const SideMenu = _ref => {
+  let {
+    slateNode,
+    isNodeEmpty,
+    menuPosition,
+    onReset,
+    t
+  } = _ref;
+  const sideMenuRef = useRef(null);
+  const [menuStyle, setMenuStyle] = useState('');
+  const editor = useSlateStatic();
+  useEffect(() => {
+    const eventBus = EventBus.getInstance();
+    const unsubscribeChange = eventBus.subscribe('change', onReset);
     return unsubscribeChange;
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  var onCopy = useCallback(function () {
+  const onCopy = useCallback(() => {
     onCopyNode(editor, slateNode);
     onReset();
   }, [editor, onReset, slateNode]);
-  var onCut = useCallback(function () {
+  const onCut = useCallback(() => {
     onCopyNode(editor, slateNode);
     onDeleteNode(editor, slateNode);
     onReset();
   }, [editor, onReset, slateNode]);
-  var onDelete = useCallback(function () {
+  const onDelete = useCallback(() => {
     onDeleteNode(editor, slateNode);
     onReset();
   }, [editor, onReset, slateNode]);
-  var onCopyHeaderLink = useCallback(function () {
-    var serviceUrl = context.getSetting('serviceUrl');
-    var sdocUuid = context.getSetting('docUuid');
-    var href = serviceUrl + "/smart-link/".concat(sdocUuid, "/#").concat(slateNode.id);
+  const onCopyHeaderLink = useCallback(() => {
+    const serviceUrl = context.getSetting('serviceUrl');
+    const sdocUuid = context.getSetting('docUuid');
+    const href = serviceUrl + "/smart-link/".concat(sdocUuid, "/#").concat(slateNode.id);
     copy(href);
     toaster.success(t('Copied'), {
       hasCloseButton: false,
@@ -56,10 +54,10 @@ var SideMenu = function SideMenu(_ref) {
     });
     onReset();
   }, [onReset, slateNode.id, t]);
-  useEffect(function () {
-    var top = menuPosition.top;
+  useEffect(() => {
+    let top = menuPosition.top;
     if (sideMenuRef.current) {
-      var overflowY = menuPosition.top + sideMenuRef.current.offsetHeight - document.body.clientHeight;
+      const overflowY = menuPosition.top + sideMenuRef.current.offsetHeight - document.body.clientHeight;
       if (overflowY > 0) {
         top = menuPosition.top - overflowY - 10;
       }

package/dist/basic-sdk/extension/toolbar/side-toolbar/transform-menus.js

@@ -5,23 +5,23 @@ import { useSlateStatic } from '@seafile/slate-react';
 import { onSetNodeType } from './helpers';
 import { SIDE_TRANSFORM_MENUS_CONFIG, LIST_ITEM_SUPPORTED_TRANSFORMATION, LIST_ITEM_CORRELATION_TYPE } from '../../constants';
 import DropdownMenuItem from '../../commons/dropdown-menu-item';
-var TransformMenus = function TransformMenus(_ref) {
-  var target = _ref.target,
-    slateNode = _ref.slateNode,
-    onReset = _ref.onReset,
-    t = _ref.t;
-  var editor = useSlateStatic();
-  var onSetType = useCallback(function (newType) {
+const TransformMenus = _ref => {
+  let {
+    target,
+    slateNode,
+    onReset,
+    t
+  } = _ref;
+  const editor = useSlateStatic();
+  const onSetType = useCallback(newType => {
     onSetNodeType(editor, slateNode, newType);
     onReset();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  var getSideMenusConfig = useCallback(function (SIDE_TRANSFORM_MENUS_CONFIG) {
-    var newSideMenusConfig = SIDE_TRANSFORM_MENUS_CONFIG;
+  const getSideMenusConfig = useCallback(SIDE_TRANSFORM_MENUS_CONFIG => {
+    let newSideMenusConfig = SIDE_TRANSFORM_MENUS_CONFIG;
     if (LIST_ITEM_CORRELATION_TYPE.includes(slateNode.type)) {
-      newSideMenusConfig = SIDE_TRANSFORM_MENUS_CONFIG.filter(function (item) {
-        return LIST_ITEM_SUPPORTED_TRANSFORMATION.includes(item.type);
-      });
+      newSideMenusConfig = SIDE_TRANSFORM_MENUS_CONFIG.filter(item => LIST_ITEM_SUPPORTED_TRANSFORMATION.includes(item.type));
     }
     return newSideMenusConfig;
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -36,13 +36,11 @@ var TransformMenus = function TransformMenus(_ref) {
     fade: false
   }, /*#__PURE__*/React.createElement("div", {
     className: "sdoc-dropdown-menu-container"
-  }, getSideMenusConfig(SIDE_TRANSFORM_MENUS_CONFIG).map(function (item) {
+  }, getSideMenusConfig(SIDE_TRANSFORM_MENUS_CONFIG).map(item => {
     return /*#__PURE__*/React.createElement(DropdownMenuItem, {
       key: item.id,
       menuConfig: item,
-      onClick: function onClick() {
-        return onSetType(item.type);
-      }
+      onClick: () => onSetType(item.type)
     });
   })));
 };

package/dist/basic-sdk/extension/utils/index.js

@@ -1,12 +1,12 @@
 import isUrl from 'is-url';
-export var IMAGE_TYPES = ['png', 'jpg', 'gif'];
-export var isImage = function isImage(url) {
+export const IMAGE_TYPES = ['png', 'jpg', 'gif'];
+export const isImage = url => {
   if (!url) return false;
   if (!isUrl(url)) return false;
-  var suffix = url.split('.')[1]; // http://xx/mm/*.png
+  const suffix = url.split('.')[1]; // http://xx/mm/*.png
   if (!suffix) return false;
   return IMAGE_TYPES.includes(suffix.toLowerCase());
 };
-export var isSameDomain = function isSameDomain(currentUrl, targetUrl) {
+export const isSameDomain = (currentUrl, targetUrl) => {
   return String(currentUrl).split('/')[2] === String(targetUrl).split('/')[2];
 };

package/dist/basic-sdk/highlight/index.js

@@ -1,19 +1,14 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Element } from '@seafile/slate';
 import { CODE_LINE } from '../extension/constants';
 import { SetNodeToDecorations } from './setNodeToDecorations';
-export var highlightDecorate = function highlightDecorate(editor) {
-  return function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      node = _ref2[0],
-      path = _ref2[1];
-    var ranges = [];
-    if (Element.isElement(node) && node.type === CODE_LINE) {
-      var _editor$nodeToDecorat;
-      ranges = (editor === null || editor === void 0 ? void 0 : (_editor$nodeToDecorat = editor.nodeToDecorations) === null || _editor$nodeToDecorat === void 0 ? void 0 : _editor$nodeToDecorat.get(node)) || [];
-      return ranges;
-    }
+export const highlightDecorate = editor => _ref => {
+  let [node, path] = _ref;
+  let ranges = [];
+  if (Element.isElement(node) && node.type === CODE_LINE) {
+    var _editor$nodeToDecorat;
+    ranges = (editor === null || editor === void 0 ? void 0 : (_editor$nodeToDecorat = editor.nodeToDecorations) === null || _editor$nodeToDecorat === void 0 ? void 0 : _editor$nodeToDecorat.get(node)) || [];
     return ranges;
-  };
+  }
+  return ranges;
 };
 export { SetNodeToDecorations };

package/dist/basic-sdk/highlight/setNodeToDecorations.js

@@ -1,105 +1,75 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import { Node, Element, Editor } from '@seafile/slate';
 import { useSlateStatic } from '@seafile/slate-react';
 import Prism, { normalizeTokens, normalizeTokensByLanguageType } from '../extension/plugins/code-block/prismjs';
 import { CODE_BLOCK } from '../extension/constants';
 import { getValidLang } from '../extension/plugins/code-block/helpers';
-var mergeMaps = function mergeMaps() {
-  var map = new Map();
+const mergeMaps = function () {
+  const map = new Map();
   for (var _len = arguments.length, maps = new Array(_len), _key = 0; _key < _len; _key++) {
     maps[_key] = arguments[_key];
   }
-  for (var _i = 0, _maps = maps; _i < _maps.length; _i++) {
-    var m = _maps[_i];
-    var _iterator = _createForOfIteratorHelper(m),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var item = _step.value;
-        map.set.apply(map, _toConsumableArray(item));
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+  for (const m of maps) {
+    for (const item of m) {
+      map.set(...item);
     }
   }
   return map;
 };
-var getChildNodeToDecorations = function getChildNodeToDecorations(_ref) {
-  var _ref2 = _slicedToArray(_ref, 2),
-    block = _ref2[0],
-    blockPath = _ref2[1];
-  var nodeToDecorations = new Map();
-  var text = block.children.map(function (line) {
-    return Node.string(line);
-  }).join('\n');
-  var language = getValidLang(block.language);
-  var tokens = Prism.tokenize(text, Prism.languages[language]);
+const getChildNodeToDecorations = _ref => {
+  let [block, blockPath] = _ref;
+  const nodeToDecorations = new Map();
+  const text = block.children.map(line => Node.string(line)).join('\n');
+  const language = getValidLang(block.language);
+  let tokens = Prism.tokenize(text, Prism.languages[language]);
   if (Object.keys(normalizeTokensByLanguageType).includes(language)) {
     tokens = normalizeTokensByLanguageType[language](tokens);
   }
-  var normalizedTokens = normalizeTokens(tokens); // make tokens flat and grouped by line
-  var blockChildren = block.children;
-  for (var index = 0; index < normalizedTokens.length; index++) {
-    var _tokens = normalizedTokens[index];
-    var element = blockChildren[index];
+  const normalizedTokens = normalizeTokens(tokens); // make tokens flat and grouped by line
+  const blockChildren = block.children;
+  for (let index = 0; index < normalizedTokens.length; index++) {
+    const tokens = normalizedTokens[index];
+    const element = blockChildren[index];
     if (element) {
       if (!nodeToDecorations.has(element)) {
         nodeToDecorations.set(element, []);
       }
     }
-    var start = 0;
-    var _iterator2 = _createForOfIteratorHelper(_tokens),
-      _step2;
-    try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        var token = _step2.value;
-        var length = token.content.length;
-        if (!length) {
-          continue;
-        }
-        var end = start + length;
-        var path = [].concat(_toConsumableArray(blockPath), [index, 0]);
-        var range = _objectSpread({
-          anchor: {
-            path: path,
-            offset: start
-          },
-          focus: {
-            path: path,
-            offset: end
-          },
-          token: true
-        }, Object.fromEntries(token.types.map(function (type) {
-          return [type, true];
-        })));
-        if (nodeToDecorations.get(element)) {
-          nodeToDecorations.get(element).push(range);
-        }
-        start = end;
+    let start = 0;
+    for (const token of tokens) {
+      const length = token.content.length;
+      if (!length) {
+        continue;
+      }
+      const end = start + length;
+      const path = [...blockPath, index, 0];
+      const range = _objectSpread({
+        anchor: {
+          path,
+          offset: start
+        },
+        focus: {
+          path,
+          offset: end
+        },
+        token: true
+      }, Object.fromEntries(token.types.map(type => [type, true])));
+      if (nodeToDecorations.get(element)) {
+        nodeToDecorations.get(element).push(range);
       }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
+      start = end;
     }
   }
   return nodeToDecorations;
 };
-export var SetNodeToDecorations = function SetNodeToDecorations() {
-  var editor = useSlateStatic();
-  var blockEntries = Array.from(Editor.nodes(editor, {
+export const SetNodeToDecorations = () => {
+  const editor = useSlateStatic();
+  const blockEntries = Array.from(Editor.nodes(editor, {
     at: [],
     mode: 'highest',
-    match: function match(n) {
-      return Element.isElement(n) && n.type === CODE_BLOCK;
-    }
+    match: n => Element.isElement(n) && n.type === CODE_BLOCK
   }));
-  var nodeToDecorations = mergeMaps.apply(void 0, _toConsumableArray(blockEntries.map(getChildNodeToDecorations)));
+  const nodeToDecorations = mergeMaps(...blockEntries.map(getChildNodeToDecorations));
   editor.nodeToDecorations = nodeToDecorations;
   return null;
 };

package/dist/basic-sdk/hooks/use-color-context.js

@@ -1,48 +1,40 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React, { useContext, useState } from 'react';
 import { DEFAULT_LAST_USED_FONT_COLOR, DEFAULT_LAST_USED_HIGHLIGHT_COLOR, DEFAULT_LAST_USED_TABLE_CELL_BACKGROUND_COLOR } from '../extension/constants';
-var ColorContext = React.createContext(null);
-export var ColorProvider = function ColorProvider(props) {
-  var _useState = useState(DEFAULT_LAST_USED_FONT_COLOR),
-    _useState2 = _slicedToArray(_useState, 2),
-    lastUsedFontColor = _useState2[0],
-    updateLastUsedFontColor = _useState2[1];
-  var _useState3 = useState(DEFAULT_LAST_USED_HIGHLIGHT_COLOR),
-    _useState4 = _slicedToArray(_useState3, 2),
-    lastUsedHighlightColor = _useState4[0],
-    updateLastUsedHighlightColor = _useState4[1];
-  var _useState5 = useState(DEFAULT_LAST_USED_TABLE_CELL_BACKGROUND_COLOR),
-    _useState6 = _slicedToArray(_useState5, 2),
-    lastUsedTableCellBackgroundColor = _useState6[0],
-    updateLastUsedTableCellBackgroundColor = _useState6[1];
+const ColorContext = React.createContext(null);
+export const ColorProvider = props => {
+  const [lastUsedFontColor, updateLastUsedFontColor] = useState(DEFAULT_LAST_USED_FONT_COLOR);
+  const [lastUsedHighlightColor, updateLastUsedHighlightColor] = useState(DEFAULT_LAST_USED_HIGHLIGHT_COLOR);
+  const [lastUsedTableCellBackgroundColor, updateLastUsedTableCellBackgroundColor] = useState(DEFAULT_LAST_USED_TABLE_CELL_BACKGROUND_COLOR);
   return /*#__PURE__*/React.createElement(ColorContext.Provider, {
     value: {
-      lastUsedFontColor: lastUsedFontColor,
-      updateLastUsedFontColor: updateLastUsedFontColor,
-      lastUsedHighlightColor: lastUsedHighlightColor,
-      updateLastUsedHighlightColor: updateLastUsedHighlightColor,
-      lastUsedTableCellBackgroundColor: lastUsedTableCellBackgroundColor,
-      updateLastUsedTableCellBackgroundColor: updateLastUsedTableCellBackgroundColor
+      lastUsedFontColor,
+      updateLastUsedFontColor,
+      lastUsedHighlightColor,
+      updateLastUsedHighlightColor,
+      lastUsedTableCellBackgroundColor,
+      updateLastUsedTableCellBackgroundColor
     }
   }, props.children);
 };
-export var useColorContext = function useColorContext() {
-  var context = useContext(ColorContext);
+export const useColorContext = () => {
+  const context = useContext(ColorContext);
   if (!context) {
     throw new Error('\'ColorContext\' is null');
   }
-  var lastUsedFontColor = context.lastUsedFontColor,
-    lastUsedHighlightColor = context.lastUsedHighlightColor,
-    lastUsedTableCellBackgroundColor = context.lastUsedTableCellBackgroundColor,
-    updateLastUsedFontColor = context.updateLastUsedFontColor,
-    updateLastUsedHighlightColor = context.updateLastUsedHighlightColor,
-    updateLastUsedTableCellBackgroundColor = context.updateLastUsedTableCellBackgroundColor;
+  const {
+    lastUsedFontColor,
+    lastUsedHighlightColor,
+    lastUsedTableCellBackgroundColor,
+    updateLastUsedFontColor,
+    updateLastUsedHighlightColor,
+    updateLastUsedTableCellBackgroundColor
+  } = context;
   return {
-    lastUsedFontColor: lastUsedFontColor,
-    updateLastUsedFontColor: updateLastUsedFontColor,
-    lastUsedHighlightColor: lastUsedHighlightColor,
-    updateLastUsedHighlightColor: updateLastUsedHighlightColor,
-    lastUsedTableCellBackgroundColor: lastUsedTableCellBackgroundColor,
-    updateLastUsedTableCellBackgroundColor: updateLastUsedTableCellBackgroundColor
+    lastUsedFontColor,
+    updateLastUsedFontColor,
+    lastUsedHighlightColor,
+    updateLastUsedHighlightColor,
+    lastUsedTableCellBackgroundColor,
+    updateLastUsedTableCellBackgroundColor
   };
 };

package/dist/basic-sdk/hooks/use-scroll-context.js

@@ -1,10 +1,12 @@
 import React, { useContext } from 'react';
-export var ScrollContext = React.createContext(null);
-export var useScrollContext = function useScrollContext() {
-  var context = useContext(ScrollContext);
+export const ScrollContext = React.createContext(null);
+export const useScrollContext = () => {
+  const context = useContext(ScrollContext);
   if (!context) {
     throw new Error('The \`useScrollContext\` hook must be used inside the <ScrollContext> component\'s context.');
   }
-  var scrollRef = context.scrollRef;
+  const {
+    scrollRef
+  } = context;
   return scrollRef;
 };

package/dist/basic-sdk/hooks/use-selection-element.js

@@ -1,14 +1,12 @@
 import { Editor, Element } from '@seafile/slate';
 import { useSlateStatic } from '@seafile/slate-react';
 import { useMemo } from 'react';
-export var useSelectionElement = function useSelectionElement() {
-  var editor = useSlateStatic();
-  var nodeEntry = useMemo(function () {
-    var nodeEntry = Editor.above(editor, {
+export const useSelectionElement = () => {
+  const editor = useSlateStatic();
+  const nodeEntry = useMemo(() => {
+    const nodeEntry = Editor.above(editor, {
       mode: 'lowest',
-      match: function match(n) {
-        return Element.isElement(n) && Editor.isBlock(editor, n);
-      }
+      match: n => Element.isElement(n) && Editor.isBlock(editor, n)
     });
     return nodeEntry;
     // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist/basic-sdk/hooks/use-selection-position.js

@@ -1,25 +1,23 @@
 import { ReactEditor, useSlateStatic } from '@seafile/slate-react';
 import { Editor, Element } from '@seafile/slate';
 import { useScrollContext } from './use-scroll-context';
-export var useSelectionPosition = function useSelectionPosition() {
-  var editor = useSlateStatic();
+export const useSelectionPosition = () => {
+  const editor = useSlateStatic();
   if (!editor.selection) return {
     x: 0,
     y: 0
   };
-  var node = Editor.above(editor, {
+  const node = Editor.above(editor, {
     mode: 'lowest',
-    match: function match(n) {
-      return Element.isElement(n) && Editor.isBlock(editor, n);
-    }
+    match: n => Element.isElement(n) && Editor.isBlock(editor, n)
   });
   if (!node) return {
     x: 0,
     y: 0
   };
   try {
-    var domNode = ReactEditor.toDOMNode(editor, node[0]);
-    var rect = domNode.getBoundingClientRect();
+    const domNode = ReactEditor.toDOMNode(editor, node[0]);
+    const rect = domNode.getBoundingClientRect();
     return rect;
   } catch (error) {
     // A new node has not yet been indexed, it cannot be retrieved, and the new node has no comment information, just do not display it
@@ -29,13 +27,13 @@ export var useSelectionPosition = function useSelectionPosition() {
     };
   }
 };
-export var useCommentListPosition = function useCommentListPosition() {
-  var selectionPosition = useSelectionPosition();
-  var headerHeight = 100;
-  var scrollRef = useScrollContext();
-  var _ref = scrollRef.current || {},
-    _ref$scrollTop = _ref.scrollTop,
-    scrollTop = _ref$scrollTop === void 0 ? 0 : _ref$scrollTop;
+export const useCommentListPosition = () => {
+  const selectionPosition = useSelectionPosition();
+  const headerHeight = 100;
+  const scrollRef = useScrollContext();
+  const {
+    scrollTop = 0
+  } = scrollRef.current || {};
   if (selectionPosition.y !== 0) {
     selectionPosition.y = selectionPosition.y - headerHeight + scrollTop;
   }