@seafile/sdoc-editor 2.0.82 → 2.0.83

package/dist/slate-convert/slate-to-md/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _remarkGfm = _interopRequireDefault(require("remark-gfm"));
+var _remarkMath = _interopRequireDefault(require("remark-math"));
+var _remarkParse = _interopRequireDefault(require("remark-parse"));
+var _remarkStringify = _interopRequireDefault(require("remark-stringify"));
+var _unified = require("unified");
+var _transform = require("./transform");
+var isContentValid = function isContentValid(value) {
+  if (!value || !Array.isArray(value)) return false;
+  return true;
+};
+
+// slateNode -> mdast -> mdString
+var slateToMdString = function slateToMdString(value) {
+  if (!isContentValid(value)) return '';
+  // slateNode -> mdast
+  // https://github.com/syntax-tree/mdast#phrasingcontent
+  var mdASTNodes = (0, _transform.formatSlateToMd)(value);
+  var root = {
+    type: 'root',
+    children: mdASTNodes
+  };
+
+  // convert slate value to md
+  var stringifyOptions = {
+    rule: '-',
+    ruleSpaces: false,
+    bullet: '*',
+    commonmarks: true,
+    fences: true
+  };
+  var res = (0, _unified.unified)().use(_remarkParse["default"]).use(_remarkGfm["default"]).use(_remarkStringify["default"], stringifyOptions).use(_remarkMath["default"]).stringify(root);
+  return res;
+};
+
+// transform rules: https://github.com/syntax-tree/mdast
+var _default = exports["default"] = slateToMdString;

package/dist/slate-convert/slate-to-md/transform.js

@@ -0,0 +1,347 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatSlateToMd = void 0;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _isPunctuationMark = _interopRequireDefault(require("../../utils/is-punctuation-mark"));
+var generateDefaultText = function generateDefaultText(value) {
+  return {
+    type: 'text',
+    value: value || ''
+  };
+};
+var transformTextNode = function transformTextNode(textNode) {
+  var mdNode = {
+    type: 'text',
+    value: textNode.text
+  };
+
+  // code = true, override text type
+  if (textNode['code']) {
+    mdNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, mdNode), {}, {
+      type: 'inlineCode'
+    });
+  }
+
+  // blob = true, add strong parent
+  if (textNode['bold']) {
+    mdNode['value'] = mdNode.value ? mdNode.value.trim() : '';
+    if ((0, _isPunctuationMark["default"])(mdNode.value)) {
+      // https://symbl.cc/en/200B/
+      mdNode['value'] = mdNode.value + '​';
+    }
+    mdNode = {
+      type: 'strong',
+      children: [mdNode]
+    };
+  }
+
+  // italic = true, add emphasis parent
+  if (textNode['italic'] && mdNode.type === 'strong') {
+    mdNode = {
+      type: 'emphasis',
+      children: [mdNode]
+    };
+  } else if (textNode['italic']) {
+    mdNode['value'] = mdNode.value ? mdNode.value.trim() : '';
+    if ((0, _isPunctuationMark["default"])(mdNode.value)) {
+      // https://symbl.cc/en/200B/
+      mdNode['value'] = mdNode.value + '​';
+    }
+    mdNode = {
+      type: 'emphasis',
+      children: [mdNode]
+    };
+  }
+  return mdNode;
+};
+var transformInlineChildren = function transformInlineChildren(result, item) {
+  // image
+  if (item.type && item.type === 'image') {
+    var data = item.data;
+    var image = {
+      type: 'image',
+      url: data.src,
+      alt: data.alt || null,
+      title: data.title || null
+    };
+    if (data.height || data.width) {
+      image = {
+        type: 'html',
+        value: "<img src=\"".concat(data.src, "\" alt=\"").concat(data.alt, "\" title=\"").concat(data.title, "\" width=\"").concat(data.width, "\" height=\"").concat(data.height, "\" />")
+      };
+    }
+    result.push(image);
+    return result;
+  }
+
+  // link
+  if (item.type && item.type === 'link') {
+    var link = {
+      type: 'link',
+      url: item.href,
+      title: item.title || null,
+      children: [transformTextNode(item.children[0])]
+    };
+    result.push(link);
+    return result;
+  }
+
+  // mention
+  if (item.type && item.type === 'mention') {
+    result.push({
+      type: 'text',
+      value: item.children[0].text + ' '
+    });
+    return result;
+  }
+
+  // TODO: seatable
+  if (item.type && item.type === 'seatable_column') {
+    var _data = item.data;
+    var newNode = {
+      text: "{".concat(_data.name, "}")
+    };
+    var column = transformTextNode(newNode);
+    result.push(column);
+    return result;
+  }
+
+  // text
+  var nodes = transformTextNode(item);
+  result.push(nodes);
+  return result;
+};
+var transformNodeWithInlineChildren = function transformNodeWithInlineChildren(node) {
+  var children = node.children;
+  var defaultChildren = [generateDefaultText()];
+  if (!children || !Array.isArray(children) || children.length === 0) {
+    return defaultChildren;
+  }
+  var result = [];
+  children.forEach(function (item) {
+    return transformInlineChildren(result, item);
+  });
+  return result.flat();
+};
+var transformHeader = function transformHeader(node) {
+  var level = node.type.replace('header', '');
+  return {
+    type: 'heading',
+    depth: parseInt(level),
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformParagraph = function transformParagraph(node) {
+  var children = node.children;
+  if (!Array.isArray(children) || children.length === 0) {
+    return {
+      type: 'paragraph',
+      children: transformNodeWithInlineChildren(node)
+    };
+  }
+
+  // TODO: seatable
+  var voidNodeTypes = ['image', 'seatable_column', 'formula'];
+  var hasBlock = children.some(function (item) {
+    return voidNodeTypes.includes(item.type);
+  });
+  if (!hasBlock && _slate.Node.string(node).length === 0) {
+    return {
+      type: 'paragraph',
+      children: [
+      // https://symbl.cc/en/200B/
+      generateDefaultText('​')]
+    };
+  }
+  return {
+    type: 'paragraph',
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformBlockquote = function transformBlockquote(node) {
+  var children = node.children;
+  return {
+    type: 'blockquote',
+    children: children.map(function (child) {
+      var handler = elementHandlers[child.type];
+      return handler(child);
+    }).flat() // flat
+  };
+};
+var transformCheckList = function transformCheckList(node) {
+  return {
+    type: 'list',
+    ordered: false,
+    start: null,
+    spread: false,
+    children: [{
+      type: 'listItem',
+      spread: false,
+      checked: node.checked ? true : false,
+      children: [transformParagraph(node)]
+    }]
+  };
+};
+var transformListContent = function transformListContent(node) {
+  return transformParagraph(node);
+};
+var transformListItem = function transformListItem(node) {
+  var loose = false;
+  var children = node.children;
+  // eslint-disable-next-line array-callback-return
+  var newChildren = children.map(function (child) {
+    if (child.type === 'paragraph') {
+      return transformListContent(child);
+    }
+    if (child.type === 'code_block') {
+      return transformCodeBlock(child);
+    }
+    if (child.type === 'blockquote') {
+      return transformBlockquote(child);
+    }
+    if (child.type === 'unordered_list' || child.type === 'ordered_list') {
+      return transformList(child);
+    }
+  });
+  if (newChildren.length === 1) {
+    loose = false;
+  } else if (newChildren.length === 2 && newChildren[1].type === 'list') {
+    loose = true;
+  } else {
+    loose = true;
+  }
+  return {
+    type: 'listItem',
+    loose: loose,
+    checked: null,
+    children: newChildren
+  };
+};
+var transformList = function transformList(node) {
+  var children = node.children;
+  var newChildren = children.map(function (child) {
+    return transformListItem(child);
+  });
+  var loose = false;
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(newChildren),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _node = _step.value;
+      if (_node.loose === true) {
+        loose = true;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    type: 'list',
+    ordered: node.type === 'ordered_list',
+    // ordered_list | unordered_list
+    start: 1,
+    loose: loose,
+    children: newChildren
+  };
+};
+var transformTableCell = function transformTableCell(cell) {
+  return {
+    type: 'tableCell',
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+var transformTableRow = function transformTableRow(row) {
+  var cells = row.children;
+  return {
+    type: 'tableRow',
+    children: cells.map(function (cell) {
+      return transformTableCell(cell);
+    })
+  };
+};
+var transformTable = function transformTable(node) {
+  var rows = node.children;
+  var align = rows.map(function (row) {
+    var _cells$;
+    var cells = row.children;
+    return ((_cells$ = cells[0]) === null || _cells$ === void 0 ? void 0 : _cells$.align) || null;
+  });
+  return {
+    type: 'table',
+    align: align,
+    children: rows.map(function (row) {
+      return transformTableRow(row);
+    })
+  };
+};
+var transformCodeLine = function transformCodeLine(node) {
+  var _node$children$;
+  var text = ((_node$children$ = node.children[0]) === null || _node$children$ === void 0 ? void 0 : _node$children$.text) || '';
+  return text;
+};
+var transformCodeBlock = function transformCodeBlock(node) {
+  var children = node.children;
+  return {
+    type: 'code',
+    lang: node.lang ? node.lang : null,
+    value: children.map(function (child) {
+      return transformCodeLine(child);
+    }).join('\n')
+  };
+};
+var transformFormula = function transformFormula(node) {
+  var data = node.data;
+  return {
+    type: 'math',
+    value: data.formula
+  };
+};
+var transformMention = function transformMention(node) {
+  var data = node.data;
+  return {
+    type: 'mention',
+    value: data.value
+  };
+};
+var transformImageBlock = function transformImageBlock(node) {
+  return {
+    type: 'paragraph',
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var elementHandlers = {
+  'paragraph': transformParagraph,
+  'header1': transformHeader,
+  'header2': transformHeader,
+  'header3': transformHeader,
+  'header4': transformHeader,
+  'header5': transformHeader,
+  'header6': transformHeader,
+  'blockquote': transformBlockquote,
+  'table': transformTable,
+  'check_list_item': transformCheckList,
+  'ordered_list': transformList,
+  'unordered_list': transformList,
+  'code_block': transformCodeBlock,
+  'formula': transformFormula,
+  'mention': transformMention,
+  'image_block': transformImageBlock
+};
+var formatSlateToMd = exports.formatSlateToMd = function formatSlateToMd(children) {
+  var validChildren = children.filter(function (child) {
+    return elementHandlers[child.type];
+  });
+  return validChildren.map(function (child) {
+    var handler = elementHandlers[child.type];
+    return handler(child);
+  }).flat();
+};

package/dist/socket/helpers.js

@@ -0,0 +1,282 @@
+"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.validateOperation = exports.syncRemoteOperations = exports.syncRemoteCursorLocation = exports.revertOperationList = exports.reExecRevertOperationList = exports.getRevertOperationList = exports.getNodePathById = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slate = require("@seafile/slate");
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _helper = require("../cursor/helper");
+var _core = require("../extension/core");
+var OPERATION = _interopRequireWildcard(require("../node-id/constants"));
+var _getNodePathById = exports.getNodePathById = function getNodePathById(rootNode, nodeId) {
+  var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  if (rootNode.id === nodeId) return path;
+  var _rootNode$children = rootNode.children,
+    children = _rootNode$children === void 0 ? [] : _rootNode$children;
+  for (var i = 0; i < children.length; i++) {
+    var child = children[i];
+    path.push(i);
+    var nodePath = _getNodePathById(child, nodeId, path);
+    if (nodePath) return nodePath;
+    path.pop();
+  }
+  return null;
+};
+var validateOperation = exports.validateOperation = function validateOperation(editor, operation) {
+  var isValid = false;
+  var newOperation = (0, _deepCopy["default"])(operation);
+  var type = newOperation.type;
+  switch (type) {
+    case OPERATION.INSERT_TEXT:
+    case OPERATION.REMOVE_TEXT:
+      {
+        var node_id = newOperation.node_id,
+          path = newOperation.path;
+        var node = (0, _core.getNode)(editor, path);
+        // node is exist and node path is not changed
+        if (node && node.id === node_id) {
+          isValid = true;
+          break;
+        }
+
+        // node is exist but node path is changed
+        var nodePath = _getNodePathById(editor, node_id);
+        if (nodePath) {
+          isValid = true;
+          newOperation.path = nodePath;
+          break;
+        }
+        // node is not exist
+        isValid = false;
+        break;
+      }
+    case OPERATION.INSERT_NODE:
+      {
+        var parent_node_id = newOperation.parent_node_id,
+          _path = newOperation.path;
+        var parentNodePath = _getNodePathById(editor, parent_node_id);
+        if (!parentNodePath) {
+          isValid = false;
+          break;
+        }
+        var parentPath = _path.slice(0, _path.length - 1);
+        if (parentPath.join() === parentNodePath.join()) {
+          isValid = true;
+          break;
+        }
+
+        // reset insert node path
+        var parentNode = (0, _core.getNode)(editor, _path);
+        if (parentNode) {
+          var childLength = parentNode.children.length;
+          var index = Math.min(_path[_path.length - 1], childLength);
+          newOperation.path = parentNodePath.concat([index]);
+          isValid = true;
+        }
+        break;
+      }
+    case OPERATION.REMOVE_NODE:
+      {
+        var _node_id = newOperation.node_id,
+          _path2 = newOperation.path;
+        var _node = (0, _core.getNode)(editor, _path2);
+        // node is exist and node path is not changed
+        if (_node && _node.id === _node_id) {
+          isValid = true;
+          break;
+        }
+
+        // node is exist but node path is changed
+        var _nodePath = _getNodePathById(editor, _node_id);
+        if (_nodePath) {
+          isValid = true;
+          newOperation.path = _nodePath;
+          break;
+        }
+
+        // node is not exist
+        isValid = false;
+        break;
+      }
+    case OPERATION.MERGE_NODE:
+      {
+        // merge next node into prev node
+        var _node_id2 = newOperation.node_id,
+          _path3 = newOperation.path;
+        var _node2 = (0, _core.getNode)(editor, _path3);
+        // node is exist and node path is not changed
+        if (_node2 && _node2.id === _node_id2) {
+          isValid = true;
+          break;
+        }
+
+        // node is exist but node path is changed
+        var _nodePath2 = _getNodePathById(editor, _node_id2);
+        if (_nodePath2) {
+          isValid = true;
+          newOperation.path = _nodePath2;
+          break;
+        }
+
+        // node is not exist
+        isValid = false;
+        break;
+      }
+    case OPERATION.SPLIT_NODE:
+      {
+        var _node_id3 = newOperation.node_id,
+          _path4 = newOperation.path;
+        var _node3 = (0, _core.getNode)(editor, _path4);
+        // node is exist and node path is not changed
+        if (_node3 && _node3.id === _node_id3) {
+          isValid = true;
+          break;
+        }
+
+        // node is exist but node path is changed
+        var _nodePath3 = _getNodePathById(editor, _node_id3);
+        if (_nodePath3) {
+          isValid = true;
+          newOperation.path = _nodePath3;
+          break;
+        }
+
+        // node is not exist
+        isValid = false;
+        break;
+      }
+    case OPERATION.SET_NODE:
+      {
+        var _node_id4 = newOperation.node_id,
+          _path5 = newOperation.path,
+          properties = newOperation.properties;
+        var _node4 = (0, _core.getNode)(editor, _path5);
+        // node is exist and node path is not changed
+        if (_node4 && _node4.id === _node_id4) {
+          isValid = true;
+          newOperation.properties = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, properties), {}, {
+            type: _node4.type
+          });
+          break;
+        }
+
+        // node is exist but node path is changed
+        var _nodePath4 = _getNodePathById(editor, _node_id4);
+        if (_nodePath4) {
+          isValid = true;
+          var _node5 = (0, _core.getNode)(editor, _nodePath4);
+          newOperation.properties = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, properties), {}, {
+            type: _node5.type
+          });
+          newOperation.path = _nodePath4;
+          break;
+        }
+
+        // node is not exist
+        isValid = false;
+        break;
+      }
+    case OPERATION.MOVE_NODE:
+      {
+        var _node_id5 = newOperation.node_id,
+          _path6 = newOperation.path;
+        var _node6 = (0, _core.getNode)(editor, _path6);
+        // node is exist and node path is not changed
+        if (_node6 && _node6.id === _node_id5) {
+          isValid = true;
+          break;
+        }
+
+        // TODO: newPath can not calculate by nodePath
+        // node is exist but node path is changed
+        // const nodePath = getNodePathById(editor, node_id);
+        // if (nodePath) {}
+
+        // node is not exist
+        isValid = false;
+        break;
+      }
+    default:
+      {
+        // set_selection
+        break;
+      }
+  }
+  if (isValid) return newOperation;
+  return isValid;
+};
+var getRevertOperationList = exports.getRevertOperationList = function getRevertOperationList(operationList) {
+  if (operationList.length === 0) return [];
+
+  // Generate a duplicate operationList, The original value cannot be modified here
+  var revertOperationList = (0, _deepCopy["default"])(operationList);
+  revertOperationList = revertOperationList.reverse();
+  return revertOperationList.map(function (operations) {
+    var ops = operations.reverse();
+    return ops.map(function (item) {
+      return _slate.Operation.inverse(item);
+    });
+  });
+};
+var revertOperationList = exports.revertOperationList = function revertOperationList(editor, operationList) {
+  if (operationList.length === 0) return [];
+  var revertOperationList = getRevertOperationList(operationList);
+
+  // Cancel locale execute operations
+  var _loop = function _loop() {
+    var operations = revertOperationList[i];
+    _slate.Editor.withoutNormalizing(editor, function () {
+      for (var j = 0; j < operations.length; j++) {
+        var op = operations[j];
+        editor.apply(op);
+      }
+    });
+  };
+  for (var i = 0; i < revertOperationList.length; i++) {
+    _loop();
+  }
+};
+var reExecRevertOperationList = exports.reExecRevertOperationList = function reExecRevertOperationList(editor, revertOperationList) {
+  if (revertOperationList.length === 0) return;
+
+  // Re-execute revert operations
+  var _loop2 = function _loop2() {
+    var operations = revertOperationList[i];
+    _slate.Editor.withoutNormalizing(editor, function () {
+      for (var j = 0; j < operations.length; j++) {
+        var op = validateOperation(editor, operations[j]);
+        if (op) {
+          editor.apply(op);
+        }
+      }
+    });
+  };
+  for (var i = 0; i < revertOperationList.length; i++) {
+    _loop2();
+  }
+};
+var syncRemoteOperations = exports.syncRemoteOperations = function syncRemoteOperations(editor, remoteOperations) {
+  if (remoteOperations.length === 0) return;
+  _slate.Editor.withoutNormalizing(editor, function () {
+    for (var i = 0; i < remoteOperations.length; i++) {
+      var op = remoteOperations[i];
+      if (op.type === 'set_selection') {
+        continue;
+      }
+      editor.apply(op);
+    }
+  });
+};
+var syncRemoteCursorLocation = exports.syncRemoteCursorLocation = function syncRemoteCursorLocation(editor, user, location, cursorData) {
+  var currentUser = editor.user;
+  if (user && user.username !== currentUser.username) {
+    (0, _helper.setCursor)(editor, user, location, cursorData);
+
+    // sync cursor position
+    editor.onCursor && editor.onCursor(editor.cursors);
+  }
+};

package/dist/socket/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SocketManager", {
+  enumerable: true,
+  get: function get() {
+    return _socketManager["default"];
+  }
+});
+Object.defineProperty(exports, "withSocketIO", {
+  enumerable: true,
+  get: function get() {
+    return _withSocketIo["default"];
+  }
+});
+var _socketManager = _interopRequireDefault(require("./socket-manager"));
+var _withSocketIo = _interopRequireDefault(require("./with-socket-io"));