@seafile/sdoc-editor 1.0.54 → 1.0.55

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

@@ -1,10 +1,17 @@
-import slugid from 'slugid';
-import isHotkey from 'is-hotkey';
-import { Transforms, Node, Range, Editor } from '@seafile/slate';
-import { ReactEditor } from '@seafile/slate-react';
-import { getNodeType, isLastNode, getSelectedNodeByType, generateEmptyElement, isSelectionAtBlockStart, getSelectedElems } from '../../core';
-import { deleteBackwardByLength } from './helpers';
-import { CODE_BLOCK, PARAGRAPH, CODE_LINE, BLOCKQUOTE } from '../../constants';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _core = require("../../core");
+var _helpers = require("./helpers");
+var _constants = require("../../constants");
 const withCodeBlock = editor => {
   const {
     normalizeNode,
@@ -24,23 +31,23 @@ const withCodeBlock = editor => {
     return insertText(data);
   };
   newEditor.deleteBackward = unit => {
-    const node = getSelectedNodeByType(editor, CODE_BLOCK);
+    const node = (0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK);
     if (node) {
-      if (isSelectionAtBlockStart(editor)) return;
+      if ((0, _core.isSelectionAtBlockStart)(editor)) return;
     }
     deleteBackward(unit);
   };
   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)) {
+    if (data.types.includes('text/code-block') && !(0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK)) {
       const options = {};
       // Paste into quote block
-      if (getSelectedNodeByType(newEditor, BLOCKQUOTE)) {
-        const path = Editor.path(newEditor, newEditor.selection);
+      if ((0, _core.getSelectedNodeByType)(newEditor, _constants.BLOCKQUOTE)) {
+        const path = _slate.Editor.path(newEditor, newEditor.selection);
         options['at'] = [path[0]];
       }
       const codeBlockNode = JSON.parse(data.getData('text/code-block'));
-      return Transforms.insertNodes(newEditor, codeBlockNode, {
+      return _slate.Transforms.insertNodes(newEditor, codeBlockNode, {
         ...options
       });
     }
@@ -48,12 +55,12 @@ const withCodeBlock = editor => {
   };
   newEditor.insertFragment = data => {
     // Only selected code block content
-    if (data.length === 1 && data[0].type === CODE_BLOCK && !getSelectedNodeByType(editor, CODE_BLOCK)) {
+    if (data.length === 1 && data[0].type === _constants.CODE_BLOCK && !(0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK)) {
       data.forEach((node, index) => {
-        if (node.type === CODE_BLOCK) {
+        if (node.type === _constants.CODE_BLOCK) {
           const newBlock = node.children.map(line => {
-            const text = Node.string(line);
-            const p = generateEmptyElement(PARAGRAPH);
+            const text = _slate.Node.string(line);
+            const p = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
             p.children[0].text = text;
             return p;
           });
@@ -63,32 +70,32 @@ const withCodeBlock = editor => {
       return insertFragment(data);
     } else {
       // Paste into code block
-      if (getSelectedNodeByType(editor, CODE_BLOCK)) {
+      if ((0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK)) {
         // Pasted data is code block split with code-line
         data.forEach((node, index) => {
-          if (node.type === CODE_BLOCK) {
+          if (node.type === _constants.CODE_BLOCK) {
             const codeLineArr = node.children.map(line => line);
             data.splice(index, 1, ...codeLineArr);
           }
         });
         const newData = data.map(node => {
-          const text = Node.string(node);
+          const text = _slate.Node.string(node);
           const codeLine = {
-            id: slugid.nice(),
-            type: CODE_LINE,
+            id: _slugid.default.nice(),
+            type: _constants.CODE_LINE,
             children: [{
               text: text,
-              id: slugid.nice()
+              id: _slugid.default.nice()
             }]
           };
           return codeLine;
         });
 
         // current focus code-line string not empty
-        const string = Editor.string(newEditor, newEditor.selection.focus.path);
-        if (string.length !== 0 && Range.isCollapsed(newEditor.selection)) {
+        const string = _slate.Editor.string(newEditor, newEditor.selection.focus.path);
+        if (string.length !== 0 && _slate.Range.isCollapsed(newEditor.selection)) {
           const [node, ...restNode] = newData;
-          const text = Node.string(node);
+          const text = _slate.Node.string(node);
           insertText(text);
           if (restNode.length !== 0) {
             insertBreak();
@@ -107,46 +114,46 @@ const withCodeBlock = editor => {
   // Rewrite normalizeNode
   newEditor.normalizeNode = _ref => {
     let [node, path] = _ref;
-    const type = getNodeType(node);
-    if (type === CODE_LINE && path.length <= 1) {
-      Transforms.setNodes(newEditor, {
-        type: PARAGRAPH
+    const type = (0, _core.getNodeType)(node);
+    if (type === _constants.CODE_LINE && path.length <= 1) {
+      _slate.Transforms.setNodes(newEditor, {
+        type: _constants.PARAGRAPH
       }, {
         at: path
       });
       return;
     }
-    if (type === CODE_BLOCK) {
+    if (type === _constants.CODE_BLOCK) {
       if (node.children.length === 0) {
-        Transforms.delete(newEditor, {
+        _slate.Transforms.delete(newEditor, {
           at: path
         });
         return;
       }
 
       // code-block is the last node in the editor and needs to be followed by a p node
-      const isLast = isLastNode(newEditor, node);
+      const isLast = (0, _core.isLastNode)(newEditor, node);
       if (isLast) {
-        const paragraph = generateEmptyElement(PARAGRAPH);
-        Transforms.insertNodes(newEditor, paragraph, {
+        const paragraph = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, paragraph, {
           at: [path[0] + 1]
         });
       }
 
       // There must be a code node below code-block
-      if (getNodeType(node.children[0]) !== CODE_LINE) {
-        Transforms.unwrapNodes(newEditor);
-        Transforms.setNodes(newEditor, {
-          type: PARAGRAPH
+      if ((0, _core.getNodeType)(node.children[0]) !== _constants.CODE_LINE) {
+        _slate.Transforms.unwrapNodes(newEditor);
+        _slate.Transforms.setNodes(newEditor, {
+          type: _constants.PARAGRAPH
         }, {
           mode: 'highest'
         });
       }
       if (node.children.length > 1) {
         node.children.forEach((child, index) => {
-          if (child.type !== CODE_LINE) {
-            Transforms.setNodes(newEditor, {
-              type: CODE_LINE
+          if (child.type !== _constants.CODE_LINE) {
+            _slate.Transforms.setNodes(newEditor, {
+              type: _constants.CODE_LINE
             }, {
               at: [...path, index]
             });
@@ -159,38 +166,38 @@ const withCodeBlock = editor => {
     return normalizeNode([node, path]);
   };
   newEditor.codeBlockOnKeyDown = event => {
-    if (isHotkey(['command+enter', 'ctrl+enter'], event)) {
-      if (newEditor.selection && !Range.isExpanded(newEditor.selection)) {
-        const path = Editor.path(newEditor, newEditor.selection);
-        const p = generateEmptyElement(PARAGRAPH);
-        Transforms.insertNodes(newEditor, p, {
+    if ((0, _isHotkey.default)(['command+enter', 'ctrl+enter'], event)) {
+      if (newEditor.selection && !_slate.Range.isExpanded(newEditor.selection)) {
+        const path = _slate.Editor.path(newEditor, newEditor.selection);
+        const p = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, p, {
           at: [path[0] + 1]
         });
-        Transforms.select(newEditor, [path[0] + 1]);
+        _slate.Transforms.select(newEditor, [path[0] + 1]);
       }
     }
-    if (isHotkey('tab', event)) {
+    if ((0, _isHotkey.default)('tab', event)) {
       const {
         selection
       } = newEditor;
       event.preventDefault();
       // By default, tab key will insert 4 spaces
       const indent = ' '.repeat(4);
-      if (Range.isCollapsed(selection)) {
+      if (_slate.Range.isCollapsed(selection)) {
         newEditor.insertText(indent);
       } else {
-        const selectedElements = getSelectedElems(newEditor);
+        const selectedElements = (0, _core.getSelectedElems)(newEditor);
         selectedElements.forEach(elem => {
-          if (elem.type !== CODE_LINE) return;
-          const text = indent + Node.string(elem);
-          const insertPoint = ReactEditor.findPath(newEditor, elem);
-          Transforms.insertText(editor, text, {
+          if (elem.type !== _constants.CODE_LINE) return;
+          const text = indent + _slate.Node.string(elem);
+          const insertPoint = _slateReact.ReactEditor.findPath(newEditor, elem);
+          _slate.Transforms.insertText(editor, text, {
             at: insertPoint
           });
         });
       }
     }
-    if (isHotkey('shift+tab', event)) {
+    if ((0, _isHotkey.default)('shift+tab', event)) {
       const range = {
         anchor: {
           offset: 0,
@@ -200,12 +207,12 @@ const withCodeBlock = editor => {
           ...newEditor.selection.focus
         }
       };
-      const str = Editor.string(newEditor, range);
+      const str = _slate.Editor.string(newEditor, range);
       if (str.trim() === '') {
-        deleteBackwardByLength(newEditor, str.length);
+        (0, _helpers.deleteBackwardByLength)(newEditor, str.length);
       }
     }
   };
   return newEditor;
 };
-export default withCodeBlock;
+var _default = exports.default = withCodeBlock;

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

@@ -1,24 +1,31 @@
-import Prism from 'prismjs';
-import 'prismjs/themes/prism.css';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeTokensByLanguageType = exports.normalizeTokens = exports.genCodeLangs = exports.default = void 0;
+var _prismjs = _interopRequireDefault(require("prismjs"));
+require("prismjs/themes/prism.css");
+require("prismjs/components/prism-javascript");
+require("prismjs/components/prism-typescript");
+require("prismjs/components/prism-markup");
+require("prismjs/components/prism-go");
+require("prismjs/components/prism-php");
+require("prismjs/components/prism-c");
+require("prismjs/components/prism-python");
+require("prismjs/components/prism-java");
+require("prismjs/components/prism-cpp");
+require("prismjs/components/prism-csharp");
+require("prismjs/components/prism-sql");
+require("prismjs/components/prism-ruby");
+require("prismjs/components/prism-swift");
+require("prismjs/components/prism-bash");
+require("prismjs/components/prism-lua");
 // languages
-import 'prismjs/components/prism-javascript';
-import 'prismjs/components/prism-typescript';
-import 'prismjs/components/prism-markup';
-import 'prismjs/components/prism-go';
-import 'prismjs/components/prism-php';
-import 'prismjs/components/prism-c';
-import 'prismjs/components/prism-python';
-import 'prismjs/components/prism-java';
-import 'prismjs/components/prism-cpp';
-import 'prismjs/components/prism-csharp';
-import 'prismjs/components/prism-sql';
-import 'prismjs/components/prism-ruby';
-import 'prismjs/components/prism-swift';
-import 'prismjs/components/prism-bash';
-import 'prismjs/components/prism-lua';
+
 const newlineRe = /\r\n|\r|\n/;
-export const genCodeLangs = () => {
+const genCodeLangs = () => {
   return [{
     text: 'Plain Text',
     value: 'plaintext'
@@ -72,7 +79,8 @@ export const genCodeLangs = () => {
     value: 'xml'
   }];
 };
-export const normalizeTokensByLanguageType = {
+exports.genCodeLangs = genCodeLangs;
+const normalizeTokensByLanguageType = exports.normalizeTokensByLanguageType = {
   'php': tokens => {
     tokens.forEach(token => {
       if (['<?', '?>'].includes(token.content)) {
@@ -102,7 +110,7 @@ const appendTypes = (types, add) => {
   }
   return types.concat(add);
 };
-export const normalizeTokens = tokens => {
+const normalizeTokens = tokens => {
   const typeArrStack = [[]];
   const tokenArrStack = [tokens];
   const tokenArrIndexStack = [0];
@@ -169,4 +177,5 @@ export const normalizeTokens = tokens => {
   normalizeEmptyLines(currentLine);
   return acc;
 };
-export default Prism;
+exports.normalizeTokens = normalizeTokens;
+var _default = exports.default = _prismjs.default;

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

@@ -1,13 +1,21 @@
-import React, { useCallback, useEffect, useState, useRef } from 'react';
-import { ReactEditor, useReadOnly } from '@seafile/slate-react';
-import { Transforms } from '@seafile/slate';
-import EventBus from '../../../utils/event-bus';
-import { focusEditor } from '../../core';
-import { useScrollContext } from '../../../hooks/use-scroll-context';
-import CodeBlockHoverMenu from './hover-menu';
-import { setClipboardCodeBlockData } from './helpers';
-import { INTERNAL_EVENT } from '../../../constants';
-import '../../../assets/css/code-block.css';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderCodeLine = exports.renderCodeBlock = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _slateReact = require("@seafile/slate-react");
+var _slate = require("@seafile/slate");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _core = require("../../core");
+var _useScrollContext = require("../../../hooks/use-scroll-context");
+var _hoverMenu = _interopRequireDefault(require("./hover-menu"));
+var _helpers = require("./helpers");
+var _constants = require("../../../constants");
+require("../../../assets/css/code-block.css");
 const CodeBlock = _ref => {
   let {
     attributes,
@@ -15,9 +23,9 @@ const CodeBlock = _ref => {
     element,
     editor
   } = _ref;
-  const readOnly = useReadOnly();
-  const codeBlockRef = useRef();
-  const scrollRef = useScrollContext();
+  const readOnly = (0, _slateReact.useReadOnly)();
+  const codeBlockRef = (0, _react.useRef)();
+  const scrollRef = (0, _useScrollContext.useScrollContext)();
   const {
     style = {
       white_space: 'nowrap'
@@ -26,49 +34,49 @@ const CodeBlock = _ref => {
   const {
     white_space
   } = style;
-  const [menuPosition, setMenuPosition] = useState({
+  const [menuPosition, setMenuPosition] = (0, _react.useState)({
     top: '',
     left: ''
   });
-  const [showHoverMenu, setShowHoverMenu] = useState(false);
-  const onChangeLanguage = useCallback(lang => {
+  const [showHoverMenu, setShowHoverMenu] = (0, _react.useState)(false);
+  const onChangeLanguage = (0, _react.useCallback)(lang => {
     const {
       value: language
     } = lang;
-    const path = ReactEditor.findPath(editor, element);
-    Transforms.setNodes(editor, {
+    const path = _slateReact.ReactEditor.findPath(editor, element);
+    _slate.Transforms.setNodes(editor, {
       language
     }, {
       at: path
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const onChangeAutoLineWrap = useCallback(autoWrap => {
-    const path = ReactEditor.findPath(editor, element);
+  const onChangeAutoLineWrap = (0, _react.useCallback)(autoWrap => {
+    const path = _slateReact.ReactEditor.findPath(editor, element);
     const newStyle = {
       ...style,
       white_space: autoWrap
     };
-    Transforms.setNodes(editor, {
+    _slate.Transforms.setNodes(editor, {
       style: newStyle
     }, {
       at: path
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const onCopyCodeBlock = useCallback(() => {
-    setClipboardCodeBlockData(element);
+  const onCopyCodeBlock = (0, _react.useCallback)(() => {
+    (0, _helpers.setClipboardCodeBlockData)(element);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [element]);
-  const onDeleteCodeBlock = useCallback(() => {
-    const path = ReactEditor.findPath(editor, element);
-    Transforms.removeNodes(editor, {
+  const onDeleteCodeBlock = (0, _react.useCallback)(() => {
+    const path = _slateReact.ReactEditor.findPath(editor, element);
+    _slate.Transforms.removeNodes(editor, {
       at: path
     });
-    focusEditor(editor);
-    Transforms.select(editor, editor.selection);
+    (0, _core.focusEditor)(editor);
+    _slate.Transforms.select(editor, editor.selection);
   }, [editor, element]);
-  const onFocusCodeBlock = useCallback(e => {
+  const onFocusCodeBlock = (0, _react.useCallback)(e => {
     if (readOnly) return;
     if (codeBlockRef.current) {
       const {
@@ -80,18 +88,17 @@ const CodeBlock = _ref => {
         top: menuTop,
         left: left // left = code-block left distance
       };
-
       setMenuPosition(newMenuPosition);
     }
     setShowHoverMenu(true);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const onMouseLeave = useCallback(e => {
+  const onMouseLeave = (0, _react.useCallback)(e => {
     if (readOnly) return;
     setShowHoverMenu(false);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const onScroll = useCallback(e => {
+  const onScroll = (0, _react.useCallback)(e => {
     if (readOnly) return;
     if (!showHoverMenu) return;
     if (e.currentTarget.scrollTop) {
@@ -104,11 +111,10 @@ const CodeBlock = _ref => {
         top: menuTop,
         left: left // left = code-block left distance
       };
-
       setMenuPosition(newMenuPosition);
     }
   }, [readOnly, showHoverMenu]);
-  useEffect(() => {
+  (0, _react.useEffect)(() => {
     if (readOnly) return;
     let observerRefValue = null;
     if (scrollRef.current) {
@@ -119,32 +125,32 @@ const CodeBlock = _ref => {
       observerRefValue.removeEventListener('scroll', onScroll);
     };
   }, [onScroll, readOnly, scrollRef]);
-  const onHiddenHoverMenu = useCallback(() => {
+  const onHiddenHoverMenu = (0, _react.useCallback)(() => {
     if (codeBlockRef.current) {
       setShowHoverMenu(false);
     }
   }, []);
-  useEffect(() => {
-    const eventBus = EventBus.getInstance();
-    eventBus.subscribe(INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU, onHiddenHoverMenu);
+  (0, _react.useEffect)(() => {
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.subscribe(_constants.INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU, onHiddenHoverMenu);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
   const handleScroll = () => {
-    EventBus.getInstance().dispatch(INTERNAL_EVENT.UPDATE_SEARCH_REPLACE_HIGHLIGHT);
+    _eventBus.default.getInstance().dispatch(_constants.INTERNAL_EVENT.UPDATE_SEARCH_REPLACE_HIGHLIGHT);
   };
-  return /*#__PURE__*/React.createElement("div", Object.assign({
+  return /*#__PURE__*/_react.default.createElement("div", Object.assign({
     "data-id": element.id
   }, attributes, {
-    className: "sdoc-code-block-container ".concat(attributes.className),
+    className: `sdoc-code-block-container ${attributes.className}`,
     onClick: onFocusCodeBlock,
     onMouseLeave: onMouseLeave
-  }), /*#__PURE__*/React.createElement("pre", {
+  }), /*#__PURE__*/_react.default.createElement("pre", {
     onScroll: handleScroll,
     className: 'sdoc-code-block-pre',
     ref: codeBlockRef
-  }, /*#__PURE__*/React.createElement("code", {
-    className: "sdoc-code-block-code ".concat(white_space === 'nowrap' ? 'sdoc-code-no-wrap' : '')
-  }, children)), showHoverMenu && /*#__PURE__*/React.createElement(CodeBlockHoverMenu, {
+  }, /*#__PURE__*/_react.default.createElement("code", {
+    className: `sdoc-code-block-code ${white_space === 'nowrap' ? 'sdoc-code-no-wrap' : ''}`
+  }, children)), showHoverMenu && /*#__PURE__*/_react.default.createElement(_hoverMenu.default, {
     menuPosition: menuPosition,
     onChangeLanguage: onChangeLanguage,
     language: element.language,
@@ -156,20 +162,22 @@ const CodeBlock = _ref => {
     onDeleteCodeBlock: onDeleteCodeBlock
   }));
 };
-export const renderCodeBlock = (props, editor) => {
-  return /*#__PURE__*/React.createElement(CodeBlock, Object.assign({}, props, {
+const renderCodeBlock = (props, editor) => {
+  return /*#__PURE__*/_react.default.createElement(CodeBlock, Object.assign({}, props, {
     editor: editor
   }));
 };
-export const renderCodeLine = (props, editor) => {
+exports.renderCodeBlock = renderCodeBlock;
+const renderCodeLine = (props, editor) => {
   const {
     element,
     attributes,
     children
   } = props;
-  return /*#__PURE__*/React.createElement("div", Object.assign({
+  return /*#__PURE__*/_react.default.createElement("div", Object.assign({
     "data-id": element.id
   }, attributes, {
     className: 'sdoc-code-line'
   }), children);
-};
+};
+exports.renderCodeLine = renderCodeLine;

package/dist/basic-sdk/extension/plugins/file-link/constants/index.js

@@ -1,9 +1,15 @@
-export const FILE_LINK_TYPE = {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FILE_LINK_TYPE_CONFIG = exports.FILE_LINK_TYPES = exports.FILE_LINK_TYPE = void 0;
+const FILE_LINK_TYPE = exports.FILE_LINK_TYPE = {
   TEXT_LINK: 'text_link',
   ICON_LINK: 'icon_link',
   CARD_LINK: 'card_link'
 };
-export const FILE_LINK_TYPE_CONFIG = {
+const FILE_LINK_TYPE_CONFIG = exports.FILE_LINK_TYPE_CONFIG = {
   [FILE_LINK_TYPE.TEXT_LINK]: {
     icon: 'sdocfont sdoc-text-link',
     text: 'Text_link'
@@ -17,4 +23,4 @@ export const FILE_LINK_TYPE_CONFIG = {
     text: 'Card'
   }
 };
-export const FILE_LINK_TYPES = [FILE_LINK_TYPE.TEXT_LINK, FILE_LINK_TYPE.ICON_LINK, FILE_LINK_TYPE.CARD_LINK];
+const FILE_LINK_TYPES = exports.FILE_LINK_TYPES = [FILE_LINK_TYPE.TEXT_LINK, FILE_LINK_TYPE.ICON_LINK, FILE_LINK_TYPE.CARD_LINK];