@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/extension/plugins/code-block/helpers.js

@@ -1,22 +1,20 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import copy from 'copy-to-clipboard';
 import { Transforms, Editor, Node } from '@seafile/slate';
 import slugid from 'slugid';
 import { CODE_BLOCK, CODE_LINE, INSERT_POSITION, PARAGRAPH } from '../../constants';
 import { getNodeType, getSelectedNodeByType, getSelectedElems } from '../../core';
 import { genCodeLangs } from './prismjs';
-export var isMenuDisabled = function isMenuDisabled(editor, readonly) {
+export const isMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
-  var selection = editor.selection;
+  const {
+    selection
+  } = editor;
   if (selection == null) return true;
-  var selectedElems = getSelectedElems(editor);
-  var hasVoid = selectedElems.some(function (elem) {
-    return editor.isVoid(elem);
-  });
+  const selectedElems = getSelectedElems(editor);
+  const hasVoid = selectedElems.some(elem => editor.isVoid(elem));
   if (hasVoid) return true;
-  var isMatch = selectedElems.some(function (elem) {
-    var type = getNodeType(elem);
+  const isMatch = selectedElems.some(elem => {
+    const type = getNodeType(elem);
     if (type === CODE_BLOCK || type === PARAGRAPH) return true;
     return false;
   });
@@ -24,53 +22,41 @@ export var isMenuDisabled = function isMenuDisabled(editor, readonly) {
   return true; // disable
 };
 
-export var getSelectCodeElem = function getSelectCodeElem(editor) {
-  var codeNode = getSelectedNodeByType(editor, CODE_BLOCK);
+export const getSelectCodeElem = editor => {
+  const codeNode = getSelectedNodeByType(editor, CODE_BLOCK);
   if (codeNode == null) return null;
   return codeNode;
 };
-export var changeToCodeBlock = function changeToCodeBlock(editor) {
-  var language = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : INSERT_POSITION.CURRENT;
+export const changeToCodeBlock = function (editor) {
+  let language = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : INSERT_POSITION.CURRENT;
   // Summarizes the strings for the selected highest-level node
-  var strArr = [];
+  let strArr = [];
   if (position === INSERT_POSITION.AFTER) {
     strArr = [''];
   } else {
     // Select the plain text of the node
-    var nodeEntries = Editor.nodes(editor, {
-      match: function match(n) {
-        return editor.children.includes(n);
-      },
+    const nodeEntries = Editor.nodes(editor, {
+      match: n => editor.children.includes(n),
       // Matches the selected node at the highest level
       universal: true
     });
-    var _iterator = _createForOfIteratorHelper(nodeEntries),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var nodeEntry = _step.value;
-        var _nodeEntry = _slicedToArray(nodeEntry, 1),
-          n = _nodeEntry[0];
-        if (n) strArr.push(Node.string(n));
-      }
-
-      // Deletes the selected node at the highest level
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+    for (let nodeEntry of nodeEntries) {
+      const [n] = nodeEntry;
+      if (n) strArr.push(Node.string(n));
     }
+
+    // Deletes the selected node at the highest level
     Transforms.removeNodes(editor, {
       mode: 'highest'
     });
   }
 
   // Insert the codeBlockNode node
-  var newCodeBlockNode = {
+  const newCodeBlockNode = {
     id: slugid.nice(),
     type: CODE_BLOCK,
-    language: language,
+    language,
     style: {
       white_space: 'nowrap' // default nowrap
     },
@@ -84,7 +70,7 @@ export var changeToCodeBlock = function changeToCodeBlock(editor) {
       }]
     }]
   };
-  var path = Editor.path(editor, editor.selection);
+  const path = Editor.path(editor, editor.selection);
   if (position === INSERT_POSITION.AFTER) {
     Transforms.insertNodes(editor, newCodeBlockNode, {
       mode: 'highest',
@@ -93,8 +79,8 @@ export var changeToCodeBlock = function changeToCodeBlock(editor) {
     Transforms.select(editor, [path[0] + 1, 0, 0]);
     return;
   }
-  var atPath = path ? [path[0]] : editor.selection;
-  var atPoint = path ? {
+  const atPath = path ? [path[0]] : editor.selection;
+  const atPoint = path ? {
     anchor: {
       offset: 0,
       path: [path[0], 0, 0]
@@ -110,12 +96,12 @@ export var changeToCodeBlock = function changeToCodeBlock(editor) {
   });
   Transforms.select(editor, atPoint);
 };
-export var changeToPlainText = function changeToPlainText(editor) {
-  var elem = getSelectCodeElem(editor);
+export const changeToPlainText = editor => {
+  const elem = getSelectCodeElem(editor);
   if (elem == null) return;
 
   // Get code text
-  var str = Node.string(elem);
+  const str = Node.string(elem);
 
   // Delete the highest level node, -> "the code-block node"
   Transforms.removeNodes(editor, {
@@ -123,7 +109,7 @@ export var changeToPlainText = function changeToPlainText(editor) {
   });
 
   // Insert p node
-  var pList = str.split('\n').map(function (s) {
+  const pList = str.split('\n').map(s => {
     return {
       id: elem.id,
       type: PARAGRAPH,
@@ -137,34 +123,30 @@ export var changeToPlainText = function changeToPlainText(editor) {
     mode: 'highest'
   });
 };
-export var setClipboardCodeBlockData = function setClipboardCodeBlockData(value) {
+export const setClipboardCodeBlockData = value => {
   // Insert text into the clipboard for use on other pages
-  var text = value.children.map(function (line) {
-    return Node.string(line);
-  }).join('\n');
+  const text = value.children.map(line => Node.string(line)).join('\n');
   copy(text, {
     format: 'text/plain',
-    onCopy: function onCopy(data) {
+    onCopy: data => {
       // Set the sdoc editor to format the data
       data.setData('text/code-block', JSON.stringify(value));
     }
   });
 };
-export var deleteBackwardByLength = function deleteBackwardByLength(editor, len) {
-  var i = len >= 4 ? 4 : len;
+export const deleteBackwardByLength = (editor, len) => {
+  let i = len >= 4 ? 4 : len;
   while (i > 0) {
     Editor.deleteBackward(editor, 'word');
     i--;
   }
 };
-export var getSelectedLangOption = function getSelectedLangOption(lang) {
-  var langs = genCodeLangs();
-  var selectedLangOption = langs.find(function (item) {
-    return item.value === lang;
-  });
+export const getSelectedLangOption = lang => {
+  const langs = genCodeLangs();
+  const selectedLangOption = langs.find(item => item.value === lang);
   return selectedLangOption || langs[0];
 };
-export var getValidLang = function getValidLang(lang) {
-  var langOption = getSelectedLangOption(lang);
+export const getValidLang = lang => {
+  const langOption = getSelectedLangOption(lang);
   return langOption.value;
 };

package/dist/basic-sdk/extension/plugins/code-block/hover-menu/index.js

@@ -1,4 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React, { useCallback, useEffect, useState } from 'react';
 import { Input } from 'reactstrap';
 import { withTranslation } from 'react-i18next';
@@ -7,53 +6,44 @@ import { ElementPopover } from '../../../commons/';
 import { genCodeLangs } from '../prismjs';
 import { getSelectedLangOption } from '../helpers';
 import './index.css';
-var CodeBlockHoverMenu = function CodeBlockHoverMenu(_ref) {
-  var style = _ref.style,
-    language = _ref.language,
-    menuPosition = _ref.menuPosition,
-    onChangeLanguage = _ref.onChangeLanguage,
-    onChangeAutoLineWrap = _ref.onChangeAutoLineWrap,
-    onCopyCodeBlock = _ref.onCopyCodeBlock,
-    onDeleteCodeBlock = _ref.onDeleteCodeBlock,
-    t = _ref.t;
-  var _style$white_space = style.white_space,
-    white_space = _style$white_space === void 0 ? 'nowrap' : _style$white_space;
-  var _useState = useState(false),
-    _useState2 = _slicedToArray(_useState, 2),
-    isShowlangsList = _useState2[0],
-    setIsShowlangsList = _useState2[1];
-  var _useState3 = useState(''),
-    _useState4 = _slicedToArray(_useState3, 2),
-    selectedLanguageText = _useState4[0],
-    setSelectedLanguageText = _useState4[1];
-  var _useState5 = useState(genCodeLangs()),
-    _useState6 = _slicedToArray(_useState5, 2),
-    langsData = _useState6[0],
-    setLangsData = _useState6[1];
-  var _useState7 = useState(false),
-    _useState8 = _slicedToArray(_useState7, 2),
-    isShowTooltip = _useState8[0],
-    setIsShowTooltip = _useState8[1];
-  var onHiddenLangsList = useCallback(function (e) {
+const CodeBlockHoverMenu = _ref => {
+  let {
+    style,
+    language,
+    menuPosition,
+    onChangeLanguage,
+    onChangeAutoLineWrap,
+    onCopyCodeBlock,
+    onDeleteCodeBlock,
+    t
+  } = _ref;
+  const {
+    white_space = 'nowrap'
+  } = style;
+  const [isShowlangsList, setIsShowlangsList] = useState(false);
+  const [selectedLanguageText, setSelectedLanguageText] = useState('');
+  const [langsData, setLangsData] = useState(genCodeLangs());
+  const [isShowTooltip, setIsShowTooltip] = useState(false);
+  const onHiddenLangsList = useCallback(e => {
     if (!e.target.parentNode.className.includes('sdoc-search-langs')) {
       setIsShowlangsList(false);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  useEffect(function () {
+  useEffect(() => {
     setIsShowTooltip(true);
     window.addEventListener('click', onHiddenLangsList);
-    return function () {
+    return () => {
       window.removeEventListener('click', onHiddenLangsList);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  var onShowLangs = useCallback(function (e) {
+  const onShowLangs = useCallback(e => {
     e.stopPropagation();
     setIsShowlangsList(!isShowlangsList);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [isShowlangsList]);
-  var onAutoLineWrap = useCallback(function () {
+  const onAutoLineWrap = useCallback(() => {
     if (white_space === 'normal') {
       onChangeAutoLineWrap('nowrap');
     } else {
@@ -61,36 +51,38 @@ var CodeBlockHoverMenu = function CodeBlockHoverMenu(_ref) {
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [white_space]);
-  var onDelete = useCallback(function () {
+  const onDelete = useCallback(() => {
     onDeleteCodeBlock();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  var onSelectLang = useCallback(function (lang) {
-    var text = lang.text;
+  const onSelectLang = useCallback(lang => {
+    const {
+      text
+    } = lang;
     setSelectedLanguageText(text);
     onChangeLanguage(lang);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  useEffect(function () {
+  useEffect(() => {
     // Compatible with legacy code
-    var selectedLanguage = language;
+    let selectedLanguage = language;
     if (language === 'text') {
       selectedLanguage = 'plaintext';
     }
-    var selectedLanguageOption = getSelectedLangOption(selectedLanguage);
+    const selectedLanguageOption = getSelectedLangOption(selectedLanguage);
     setSelectedLanguageText(selectedLanguageOption.text);
   }, [language]);
-  var onChange = useCallback(function (e) {
-    var filterData = [];
-    var restData = [];
-    genCodeLangs().forEach(function (item) {
+  const onChange = useCallback(e => {
+    const filterData = [];
+    const restData = [];
+    genCodeLangs().forEach(item => {
       if (item.value.startsWith(e.currentTarget.value.toLowerCase())) {
         filterData.push(item);
       } else {
         restData.push(item);
       }
     });
-    setLangsData([].concat(filterData, restData));
+    setLangsData([...filterData, ...restData]);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
   return /*#__PURE__*/React.createElement(ElementPopover, null, /*#__PURE__*/React.createElement("div", {
@@ -160,12 +152,12 @@ var CodeBlockHoverMenu = function CodeBlockHoverMenu(_ref) {
     onChange: onChange
   })), /*#__PURE__*/React.createElement("ul", {
     className: "langs-list-ul"
-  }, langsData.map(function (item) {
+  }, langsData.map(item => {
     return /*#__PURE__*/React.createElement("li", {
       className: "langs-list-li ".concat(selectedLanguageText === item.text ? 'active' : ''),
       id: item.value,
       key: item.value,
-      onClick: function onClick() {
+      onClick: () => {
         onSelectLang(item);
       }
     }, item.text, /*#__PURE__*/React.createElement("span", {

package/dist/basic-sdk/extension/plugins/code-block/index.js

@@ -2,7 +2,7 @@ import { CODE_BLOCK } from '../../constants';
 import CodeBlockMenu from './menu';
 import withCodeBlock from './plugin';
 import { renderCodeBlock, renderCodeLine } from './render-elem';
-var CodeBlockPlugin = {
+const CodeBlockPlugin = {
   type: CODE_BLOCK,
   nodeType: 'element',
   editorMenus: [CodeBlockMenu],

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

@@ -3,13 +3,15 @@ import { focusEditor } from '../../../core';
 import { MENUS_CONFIG_MAP, ELEMENT_TYPE, INSERT_POSITION } from '../../../constants';
 import { isMenuDisabled, changeToCodeBlock } from '../helpers';
 import DropdownMenuItem from '../../../commons/dropdown-menu-item';
-var CodeBlockMenu = function CodeBlockMenu(_ref) {
-  var editor = _ref.editor,
-    readonly = _ref.readonly,
-    toggle = _ref.toggle;
-  var disabled = isMenuDisabled(editor, readonly);
-  var menuConfig = MENUS_CONFIG_MAP[ELEMENT_TYPE.CODE_BLOCK];
-  var insertCodeBlock = useCallback(function () {
+const CodeBlockMenu = _ref => {
+  let {
+    editor,
+    readonly,
+    toggle
+  } = _ref;
+  const disabled = isMenuDisabled(editor, readonly);
+  const menuConfig = MENUS_CONFIG_MAP[ELEMENT_TYPE.CODE_BLOCK];
+  const insertCodeBlock = useCallback(() => {
     changeToCodeBlock(editor, 'plaintext', INSERT_POSITION.CURRENT);
     toggle && toggle();
     focusEditor(editor);

package/dist/basic-sdk/extension/plugins/code-block/model.js

@@ -1,11 +1,10 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import { BLOCKQUOTE } from '../../constants';
-var Blockquote = /*#__PURE__*/_createClass(function Blockquote(options) {
-  _classCallCheck(this, Blockquote);
-  this.type = options.type || BLOCKQUOTE;
-  this.children = options.children || [{
-    text: ''
-  }];
-});
+class Blockquote {
+  constructor(options) {
+    this.type = options.type || BLOCKQUOTE;
+    this.children = options.children || [{
+      text: ''
+    }];
+  }
+}
 export default Blockquote;

package/dist/basic-sdk/extension/plugins/code-block/plugin.js

@@ -1,6 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _toArray from "@babel/runtime/helpers/esm/toArray";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import slugid from 'slugid';
 import isHotkey from 'is-hotkey';
@@ -8,55 +5,57 @@ import { Transforms, Node, Range, Editor } from '@seafile/slate';
 import { getNodeType, isLastNode, getSelectedNodeByType, generateEmptyElement, isSelectionAtBlockStart } from '../../core';
 import { deleteBackwardByLength } from './helpers';
 import { CODE_BLOCK, PARAGRAPH, CODE_LINE, BLOCKQUOTE } from '../../constants';
-var withCodeBlock = function withCodeBlock(editor) {
-  var normalizeNode = editor.normalizeNode,
-    insertFragment = editor.insertFragment,
-    insertText = editor.insertText,
-    insertBreak = editor.insertBreak,
-    insertData = editor.insertData,
-    deleteBackward = editor.deleteBackward;
-  var newEditor = editor;
+const withCodeBlock = editor => {
+  const {
+    normalizeNode,
+    insertFragment,
+    insertText,
+    insertBreak,
+    insertData,
+    deleteBackward
+  } = editor;
+  const newEditor = editor;
 
   // If you enter two Spaces in quick succession, a period and a space appear （Default Settings for mac）
-  newEditor.insertText = function (data) {
+  newEditor.insertText = data => {
     if (data === '. ') {
       return insertText('  ');
     }
     return insertText(data);
   };
-  newEditor.deleteBackward = function (unit) {
-    var node = getSelectedNodeByType(editor, CODE_BLOCK);
+  newEditor.deleteBackward = unit => {
+    const node = getSelectedNodeByType(editor, CODE_BLOCK);
     if (node) {
       if (isSelectionAtBlockStart(editor)) return;
     }
     deleteBackward(unit);
   };
-  newEditor.insertData = function (data) {
+  newEditor.insertData = data => {
     // Paste a single code block element somewhere other than a code block
     if (data.types.includes('text/code-block') && !getSelectedNodeByType(editor, CODE_BLOCK)) {
-      var options = {};
+      const options = {};
       // Paste into quote block
       if (getSelectedNodeByType(newEditor, BLOCKQUOTE)) {
-        var path = Editor.path(newEditor, newEditor.selection);
+        const path = Editor.path(newEditor, newEditor.selection);
         options['at'] = [path[0]];
       }
-      var codeBlockNode = JSON.parse(data.getData('text/code-block'));
+      const codeBlockNode = JSON.parse(data.getData('text/code-block'));
       return Transforms.insertNodes(newEditor, codeBlockNode, _objectSpread({}, options));
     }
     insertData(data);
   };
-  newEditor.insertFragment = function (data) {
+  newEditor.insertFragment = data => {
     // Only selected code block content
     if (data.length === 1 && data[0].type === CODE_BLOCK && !getSelectedNodeByType(editor, CODE_BLOCK)) {
-      data.forEach(function (node, index) {
+      data.forEach((node, index) => {
         if (node.type === CODE_BLOCK) {
-          var newBlock = node.children.map(function (line) {
-            var text = Node.string(line);
-            var p = generateEmptyElement(PARAGRAPH);
+          const newBlock = node.children.map(line => {
+            const text = Node.string(line);
+            const p = generateEmptyElement(PARAGRAPH);
             p.children[0].text = text;
             return p;
           });
-          data.splice.apply(data, [index, 1].concat(_toConsumableArray(newBlock)));
+          data.splice(index, 1, ...newBlock);
         }
       });
       return insertFragment(data);
@@ -64,17 +63,15 @@ var withCodeBlock = function withCodeBlock(editor) {
       // Paste into code block
       if (getSelectedNodeByType(editor, CODE_BLOCK)) {
         // Pasted data is code block split with code-line
-        data.forEach(function (node, index) {
+        data.forEach((node, index) => {
           if (node.type === CODE_BLOCK) {
-            var codeLineArr = node.children.map(function (line) {
-              return line;
-            });
-            data.splice.apply(data, [index, 1].concat(_toConsumableArray(codeLineArr)));
+            const codeLineArr = node.children.map(line => line);
+            data.splice(index, 1, ...codeLineArr);
           }
         });
-        var newData = data.map(function (node) {
-          var text = Node.string(node);
-          var codeLine = {
+        const newData = data.map(node => {
+          const text = Node.string(node);
+          const codeLine = {
             id: slugid.nice(),
             type: CODE_LINE,
             children: [{
@@ -86,12 +83,10 @@ var withCodeBlock = function withCodeBlock(editor) {
         });
 
         // current focus code-line string not empty
-        var string = Editor.string(newEditor, newEditor.selection.focus.path);
+        const string = Editor.string(newEditor, newEditor.selection.focus.path);
         if (string.length !== 0 && Range.isCollapsed(newEditor.selection)) {
-          var _newData = _toArray(newData),
-            node = _newData[0],
-            restNode = _newData.slice(1);
-          var text = Node.string(node);
+          const [node, ...restNode] = newData;
+          const text = Node.string(node);
           insertText(text);
           if (restNode.length !== 0) {
             insertBreak();
@@ -108,11 +103,9 @@ var withCodeBlock = function withCodeBlock(editor) {
   };
 
   // Rewrite normalizeNode
-  newEditor.normalizeNode = function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      node = _ref2[0],
-      path = _ref2[1];
-    var type = getNodeType(node);
+  newEditor.normalizeNode = _ref => {
+    let [node, path] = _ref;
+    const type = getNodeType(node);
     if (type === CODE_LINE && path.length <= 1) {
       Transforms.setNodes(newEditor, {
         type: PARAGRAPH
@@ -130,9 +123,9 @@ var withCodeBlock = function withCodeBlock(editor) {
       }
 
       // code-block is the last node in the editor and needs to be followed by a p node
-      var isLast = isLastNode(newEditor, node);
+      const isLast = isLastNode(newEditor, node);
       if (isLast) {
-        var paragraph = generateEmptyElement(PARAGRAPH);
+        const paragraph = generateEmptyElement(PARAGRAPH);
         Transforms.insertNodes(newEditor, paragraph, {
           at: [path[0] + 1]
         });
@@ -148,12 +141,12 @@ var withCodeBlock = function withCodeBlock(editor) {
         });
       }
       if (node.children.length > 1) {
-        node.children.forEach(function (child, index) {
+        node.children.forEach((child, index) => {
           if (child.type !== CODE_LINE) {
             Transforms.setNodes(newEditor, {
               type: CODE_LINE
             }, {
-              at: [].concat(_toConsumableArray(path), [index])
+              at: [...path, index]
             });
           }
         });
@@ -163,11 +156,11 @@ var withCodeBlock = function withCodeBlock(editor) {
     // Perform default behavior
     return normalizeNode([node, path]);
   };
-  newEditor.codeBlockOnKeyDown = function (event) {
+  newEditor.codeBlockOnKeyDown = event => {
     if (isHotkey(['command+enter', 'ctrl+enter'], event)) {
       if (newEditor.selection && !Range.isExpanded(newEditor.selection)) {
-        var path = Editor.path(newEditor, newEditor.selection);
-        var p = generateEmptyElement(PARAGRAPH);
+        const path = Editor.path(newEditor, newEditor.selection);
+        const p = generateEmptyElement(PARAGRAPH);
         Transforms.insertNodes(newEditor, p, {
           at: [path[0] + 1]
         });
@@ -178,14 +171,14 @@ var withCodeBlock = function withCodeBlock(editor) {
       newEditor.insertText('    ');
     }
     if (isHotkey('shift+tab', event)) {
-      var range = {
+      const range = {
         anchor: {
           offset: 0,
           path: newEditor.selection.focus.path
         },
         focus: _objectSpread({}, newEditor.selection.focus)
       };
-      var str = Editor.string(newEditor, range);
+      const str = Editor.string(newEditor, range);
       if (str.trim() === '') {
         deleteBackwardByLength(newEditor, str.length);
       }