@seafile/sdoc-editor 2.0.81 → 2.0.83

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

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var _helpers = require("./helpers");
+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;
+
+  // If you enter two Spaces in quick succession, a period and a space appear （Default Settings for mac）
+  newEditor.insertText = function (data) {
+    if (data === '. ') {
+      return insertText('  ');
+    }
+    return insertText(data);
+  };
+  newEditor.deleteBackward = function (unit) {
+    var node = (0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK);
+    if (node) {
+      if ((0, _core.isSelectionAtBlockStart)(editor)) return;
+    }
+    deleteBackward(unit);
+  };
+  newEditor.insertData = function (data) {
+    // Paste a single code block element somewhere other than a code block
+    if (data.types.includes('text/code-block') && !(0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK)) {
+      var options = {};
+      // Paste into quote block
+      if ((0, _core.getSelectedNodeByType)(newEditor, _constants.BLOCKQUOTE)) {
+        var path = _slate.Editor.path(newEditor, newEditor.selection);
+        options['at'] = [path[0]];
+      }
+      var codeBlockNode = JSON.parse(data.getData('text/code-block'));
+      return _slate.Transforms.insertNodes(newEditor, codeBlockNode, (0, _objectSpread2["default"])({}, options));
+    }
+    insertData(data);
+  };
+  newEditor.insertFragment = function (data) {
+    // Only selected code block content
+    if (data.length === 1 && data[0].type === _constants.CODE_BLOCK && !(0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK)) {
+      data.forEach(function (node, index) {
+        if (node.type === _constants.CODE_BLOCK) {
+          var newBlock = node.children.map(function (line) {
+            var text = _slate.Node.string(line);
+            var p = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+            p.children[0].text = text;
+            return p;
+          });
+          data.splice.apply(data, [index, 1].concat((0, _toConsumableArray2["default"])(newBlock)));
+        }
+      });
+      return insertFragment(data);
+    }
+
+    // Paste into code block
+    if ((0, _core.getSelectedNodeByType)(editor, _constants.CODE_BLOCK)) {
+      // Pasted data is code block split with code-line
+      data.forEach(function (node, index) {
+        if (node.type === _constants.CODE_BLOCK) {
+          var codeLineArr = node.children.map(function (line) {
+            return line;
+          });
+          data.splice.apply(data, [index, 1].concat((0, _toConsumableArray2["default"])(codeLineArr)));
+        }
+      });
+      var newData = data.map(function (node) {
+        var text = _slate.Node.string(node);
+        var codeLine = {
+          id: _slugid["default"].nice(),
+          type: _constants.CODE_LINE,
+          children: [{
+            text: text,
+            id: _slugid["default"].nice()
+          }]
+        };
+        return codeLine;
+      });
+
+      // current focus code-line string not empty
+      var string = _slate.Editor.string(newEditor, newEditor.selection.focus.path);
+      if (string.length !== 0 && _slate.Range.isCollapsed(newEditor.selection)) {
+        var _newData = (0, _toArray2["default"])(newData),
+          node = _newData[0],
+          restNode = _newData.slice(1);
+        var text = _slate.Node.string(node);
+        insertText(text);
+        if (restNode.length !== 0) {
+          insertBreak();
+          insertFragment(restNode);
+        }
+        return;
+      }
+      return insertFragment(newData);
+    }
+
+    // Paste into not a code block
+    return insertFragment(data);
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = function (_ref) {
+    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      node = _ref2[0],
+      path = _ref2[1];
+    var 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 === _constants.CODE_BLOCK) {
+      if (node.children.length === 0) {
+        _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
+      var isLast = (0, _core.isLastNode)(newEditor, node);
+      if (isLast) {
+        var 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 ((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(function (child, index) {
+          if (child.type !== _constants.CODE_LINE) {
+            _slate.Transforms.setNodes(newEditor, {
+              type: _constants.CODE_LINE
+            }, {
+              at: [].concat((0, _toConsumableArray2["default"])(path), [index])
+            });
+          }
+        });
+      }
+    }
+
+    // Perform default behavior
+    return normalizeNode([node, path]);
+  };
+  newEditor.codeBlockOnKeyDown = function (event) {
+    if ((0, _isHotkey["default"])(['command+enter', 'ctrl+enter'], event)) {
+      if (newEditor.selection && !_slate.Range.isExpanded(newEditor.selection)) {
+        var path = _slate.Editor.path(newEditor, newEditor.selection);
+        var p = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, p, {
+          at: [path[0] + 1]
+        });
+        _slate.Transforms.select(newEditor, [path[0] + 1]);
+      }
+    }
+    if ((0, _isHotkey["default"])('tab', event)) {
+      var selection = newEditor.selection;
+      event.preventDefault();
+      // By default, tab key will insert 4 spaces
+      var indent = ' '.repeat(4);
+      if (_slate.Range.isCollapsed(selection)) {
+        newEditor.insertText(indent);
+      } else {
+        var selectedElements = (0, _core.getSelectedElems)(newEditor);
+        selectedElements.forEach(function (elem) {
+          if (elem.type !== _constants.CODE_LINE) return;
+          var text = indent + _slate.Node.string(elem);
+          var insertPoint = _slateReact.ReactEditor.findPath(newEditor, elem);
+          _slate.Transforms.insertText(editor, text, {
+            at: insertPoint
+          });
+        });
+      }
+    }
+    if ((0, _isHotkey["default"])('shift+tab', event)) {
+      var range = {
+        anchor: {
+          offset: 0,
+          path: newEditor.selection.focus.path
+        },
+        focus: (0, _objectSpread2["default"])({}, newEditor.selection.focus)
+      };
+      var str = _slate.Editor.string(newEditor, range);
+      if (str.trim() === '') {
+        (0, _helpers.deleteBackwardByLength)(newEditor, str.length);
+      }
+    }
+  };
+  newEditor.insertBreak = function () {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.CODE_LINE);
+    if (selectedNode != null && (0, _core.isCursorAtBlockStart)(newEditor)) {
+      var line = (0, _core.generateEmptyElement)(_constants.CODE_LINE);
+      _slate.Transforms.insertNodes(editor, line, {
+        at: selectedNode[1]
+      });
+      return;
+    }
+    insertBreak();
+  };
+  return newEditor;
+};
+var _default = exports["default"] = withCodeBlock;

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

@@ -0,0 +1,187 @@
+"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");
+require("prismjs/components/prism-json.js");
+require("prismjs/components/prism-yaml");
+// languages
+
+var newlineRe = /\r\n|\r|\n/;
+var genCodeLangs = exports.genCodeLangs = function genCodeLangs() {
+  return [{
+    text: 'Plain Text',
+    value: 'plaintext'
+  }, {
+    text: 'Bash',
+    value: 'bash'
+  }, {
+    text: 'CSS',
+    value: 'css'
+  }, {
+    text: 'C',
+    value: 'c'
+  }, {
+    text: 'C++',
+    value: 'cpp'
+  }, {
+    text: 'C#',
+    value: 'csharp'
+  }, {
+    text: 'Go',
+    value: 'go'
+  }, {
+    text: 'HTML',
+    value: 'html'
+  }, {
+    text: 'Javascript',
+    value: 'javascript'
+  }, {
+    text: 'Java',
+    value: 'java'
+  }, {
+    text: 'JSON',
+    value: 'json'
+  }, {
+    text: 'PHP',
+    value: 'php'
+  }, {
+    text: 'Python',
+    value: 'python'
+  }, {
+    text: 'Ruby',
+    value: 'ruby'
+  }, {
+    text: 'SQL',
+    value: 'sql'
+  }, {
+    text: 'Swift',
+    value: 'swift'
+  }, {
+    text: 'Typescript',
+    value: 'typescript'
+  }, {
+    text: 'XML',
+    value: 'xml'
+  }, {
+    text: 'YAML',
+    value: 'yaml'
+  }];
+};
+var normalizeTokensByLanguageType = exports.normalizeTokensByLanguageType = {
+  'php': function php(tokens) {
+    tokens.forEach(function (token) {
+      if (['<?', '?>'].includes(token.content)) {
+        token.type = 'operator';
+        token.alias = '';
+      }
+    });
+    return tokens;
+  }
+};
+var normalizeEmptyLines = function normalizeEmptyLines(line) {
+  if (line.length === 0) {
+    line.push({
+      types: ['plain'],
+      content: '\n',
+      empty: true
+    });
+  } else if (line.length === 1 && line[0].content === '') {
+    line[0].content = '\n';
+    line[0].empty = true;
+  }
+};
+var appendTypes = function appendTypes(types, add) {
+  var typesSize = types.length;
+  if (typesSize > 0 && types[typesSize - 1] === add) {
+    return types;
+  }
+  return types.concat(add);
+};
+var normalizeTokens = exports.normalizeTokens = function normalizeTokens(tokens) {
+  var typeArrStack = [[]];
+  var tokenArrStack = [tokens];
+  var tokenArrIndexStack = [0];
+  var tokenArrSizeStack = [tokens.length];
+  var i = 0;
+  var stackIndex = 0;
+  var currentLine = [];
+  var acc = [currentLine];
+  while (stackIndex > -1) {
+    while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {
+      var content = void 0;
+      var types = typeArrStack[stackIndex];
+      var tokenArr = tokenArrStack[stackIndex];
+      var token = tokenArr[i];
+
+      // Determine content and append type to types if necessary
+      if (typeof token === 'string') {
+        types = stackIndex > 0 ? types : ['plain'];
+        content = token;
+      } else {
+        types = appendTypes(types, token.type);
+        if (token.alias) {
+          types = appendTypes(types, token.alias);
+        }
+        content = token.content;
+      }
+
+      // If token.content is an array, increase the stack depth and repeat this while-loop
+      if (typeof content !== 'string') {
+        stackIndex++;
+        typeArrStack.push(types);
+        tokenArrStack.push(content);
+        tokenArrIndexStack.push(0);
+        tokenArrSizeStack.push(content.length);
+        continue;
+      }
+
+      // Split by newlines
+      var splitByNewlines = content.split(newlineRe);
+      var newlineCount = splitByNewlines.length;
+      currentLine.push({
+        types: types,
+        content: splitByNewlines[0]
+      });
+
+      // Create a new line for each string on a new line
+      for (var _i = 1; _i < newlineCount; _i++) {
+        normalizeEmptyLines(currentLine);
+        acc.push(currentLine = []);
+        currentLine.push({
+          types: types,
+          content: splitByNewlines[_i]
+        });
+      }
+    }
+
+    // Decreate the stack depth
+    stackIndex--;
+    typeArrStack.pop();
+    tokenArrStack.pop();
+    tokenArrIndexStack.pop();
+    tokenArrSizeStack.pop();
+  }
+  normalizeEmptyLines(currentLine);
+  return acc;
+};
+var _default = exports["default"] = _prismjs["default"];

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

@@ -0,0 +1,176 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderCodeLine = exports.renderCodeBlock = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _constants = require("../../../constants");
+var _useScrollContext = require("../../../hooks/use-scroll-context");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _core = require("../../core");
+var _helpers = require("./helpers");
+var _hoverMenu = _interopRequireDefault(require("./hover-menu"));
+var CodeBlock = function CodeBlock(_ref) {
+  var attributes = _ref.attributes,
+    children = _ref.children,
+    element = _ref.element,
+    editor = _ref.editor;
+  var readOnly = (0, _slateReact.useReadOnly)();
+  var codeBlockRef = (0, _react.useRef)();
+  var scrollRef = (0, _useScrollContext.useScrollContext)();
+  var _element$style = element.style,
+    style = _element$style === void 0 ? {
+      white_space: 'nowrap'
+    } : _element$style;
+  var white_space = style.white_space;
+  var _useState = (0, _react.useState)({
+      top: '',
+      left: ''
+    }),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    menuPosition = _useState2[0],
+    setMenuPosition = _useState2[1];
+  var _useState3 = (0, _react.useState)(false),
+    _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+    showHoverMenu = _useState4[0],
+    setShowHoverMenu = _useState4[1];
+  var onChangeLanguage = (0, _react.useCallback)(function (lang) {
+    var language = lang.value;
+    var path = _slateReact.ReactEditor.findPath(editor, element);
+    _slate.Transforms.setNodes(editor, {
+      language: language
+    }, {
+      at: path
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var onChangeAutoLineWrap = (0, _react.useCallback)(function (autoWrap) {
+    var path = _slateReact.ReactEditor.findPath(editor, element);
+    var newStyle = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, style), {}, {
+      white_space: autoWrap
+    });
+    _slate.Transforms.setNodes(editor, {
+      style: newStyle
+    }, {
+      at: path
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var onCopyCodeBlock = (0, _react.useCallback)(function () {
+    (0, _helpers.setClipboardCodeBlockData)(element);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [element]);
+  var onDeleteCodeBlock = (0, _react.useCallback)(function () {
+    var path = _slateReact.ReactEditor.findPath(editor, element);
+    _slate.Transforms.removeNodes(editor, {
+      at: path
+    });
+    (0, _core.focusEditor)(editor);
+    _slate.Transforms.select(editor, editor.selection);
+  }, [editor, element]);
+  var onFocusCodeBlock = (0, _react.useCallback)(function (e) {
+    if (readOnly) return;
+    if (codeBlockRef.current) {
+      var _codeBlockRef$current = codeBlockRef.current.getBoundingClientRect(),
+        top = _codeBlockRef$current.top,
+        left = _codeBlockRef$current.left;
+      var menuTop = top - 42; // top = top distance - menu height
+      var newMenuPosition = {
+        top: menuTop,
+        left: left // left = code-block left distance
+      };
+      setMenuPosition(newMenuPosition);
+    }
+    setShowHoverMenu(true);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var onMouseLeave = (0, _react.useCallback)(function (e) {
+    if (readOnly) return;
+    setShowHoverMenu(false);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var onScroll = (0, _react.useCallback)(function (e) {
+    if (readOnly) return;
+    if (!showHoverMenu) return;
+    if (e.currentTarget.scrollTop) {
+      var _codeBlockRef$current2 = codeBlockRef.current.getBoundingClientRect(),
+        top = _codeBlockRef$current2.top,
+        left = _codeBlockRef$current2.left;
+      var menuTop = top - 42; // top = top distance - menu height
+      var newMenuPosition = {
+        top: menuTop,
+        left: left // left = code-block left distance
+      };
+      setMenuPosition(newMenuPosition);
+    }
+  }, [readOnly, showHoverMenu]);
+  (0, _react.useEffect)(function () {
+    if (readOnly) return;
+    var observerRefValue = null;
+    if (scrollRef.current) {
+      scrollRef.current.addEventListener('scroll', onScroll);
+      observerRefValue = scrollRef.current;
+    }
+    return function () {
+      observerRefValue.removeEventListener('scroll', onScroll);
+    };
+  }, [onScroll, readOnly, scrollRef]);
+  var onHiddenHoverMenu = (0, _react.useCallback)(function () {
+    if (codeBlockRef.current) {
+      setShowHoverMenu(false);
+    }
+  }, []);
+  (0, _react.useEffect)(function () {
+    var eventBus = _eventBus["default"].getInstance();
+    eventBus.subscribe(_constants.INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU, onHiddenHoverMenu);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var handleScroll = function handleScroll() {
+    _eventBus["default"].getInstance().dispatch(_constants.INTERNAL_EVENT.UPDATE_SEARCH_REPLACE_HIGHLIGHT);
+  };
+  return /*#__PURE__*/_react["default"].createElement("div", Object.assign({
+    "data-id": element.id
+  }, attributes, {
+    className: "sdoc-code-block-container ".concat(attributes.className),
+    onClick: onFocusCodeBlock,
+    onMouseLeave: onMouseLeave
+  }), /*#__PURE__*/_react["default"].createElement("pre", {
+    onScroll: handleScroll,
+    className: 'sdoc-code-block-pre',
+    ref: codeBlockRef
+  }, /*#__PURE__*/_react["default"].createElement("code", {
+    className: "sdoc-code-block-code ".concat(white_space === 'nowrap' ? 'sdoc-code-no-wrap' : '')
+  }, children)), showHoverMenu && /*#__PURE__*/_react["default"].createElement(_hoverMenu["default"], {
+    menuPosition: menuPosition,
+    onChangeLanguage: onChangeLanguage,
+    language: element.language,
+    style: element.style || {
+      white_space: 'nowrap'
+    },
+    onChangeAutoLineWrap: onChangeAutoLineWrap,
+    onCopyCodeBlock: onCopyCodeBlock,
+    onDeleteCodeBlock: onDeleteCodeBlock
+  }));
+};
+var renderCodeBlock = exports.renderCodeBlock = function renderCodeBlock(props, editor) {
+  return /*#__PURE__*/_react["default"].createElement(CodeBlock, Object.assign({}, props, {
+    editor: editor
+  }));
+};
+var renderCodeLine = exports.renderCodeLine = function renderCodeLine(props, editor) {
+  var element = props.element,
+    attributes = props.attributes,
+    children = props.children;
+  return /*#__PURE__*/_react["default"].createElement("div", Object.assign({
+    "data-id": element.id
+  }, attributes, {
+    className: 'sdoc-code-line'
+  }), children);
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FILE_LINK_TYPE_CONFIG = exports.FILE_LINK_TYPES = exports.FILE_LINK_TYPE = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var FILE_LINK_TYPE = exports.FILE_LINK_TYPE = {
+  TEXT_LINK: 'text_link',
+  ICON_LINK: 'icon_link',
+  CARD_LINK: 'card_link'
+};
+var FILE_LINK_TYPE_CONFIG = exports.FILE_LINK_TYPE_CONFIG = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, FILE_LINK_TYPE.TEXT_LINK, {
+  icon: 'sdocfont sdoc-text-link',
+  text: 'Text_Link'
+}), FILE_LINK_TYPE.ICON_LINK, {
+  icon: 'sdocfont sdoc-inline-link',
+  text: 'Icon_and_text_Link'
+}), FILE_LINK_TYPE.CARD_LINK, {
+  icon: 'sdocfont sdoc-card-link',
+  text: 'Card'
+});
+var FILE_LINK_TYPES = exports.FILE_LINK_TYPES = [FILE_LINK_TYPE.TEXT_LINK, FILE_LINK_TYPE.ICON_LINK, FILE_LINK_TYPE.CARD_LINK];