@seafile/seafile-editor 0.3.76

package/dist/editor/editor-utils/selection-utils.js

@@ -0,0 +1,33 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Editor, Range } from 'slate';
+/** Triple-click can set the selection focus point to
+ *  the start of the following block node.
+ *  Use this function to reset the selection focus point to the end of the previous block node
+ *  */
+
+export var normailizeSelection = function normailizeSelection(editor) {
+  var selection = editor.selection;
+  if (!selection) return false;
+  var anchor = selection.anchor,
+      focus = selection.focus;
+  if (Range.isCollapsed(selection)) return;
+  if (focus.offset !== 0) return;
+
+  var _Editor$nodes = Editor.nodes(editor, {
+    match: 'block',
+    at: focus
+  }),
+      _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+      node = _Editor$nodes2[0];
+
+  if (!node) return;
+
+  if (Editor.isStart(editor, focus, node[1])) {
+    var newFocusNode = Editor.before(editor, focus);
+    var newSelection = {
+      anchor: anchor,
+      focus: newFocusNode
+    };
+    Editor.select(editor, newSelection);
+  }
+};

package/dist/editor/editor-utils/text-utils.js

@@ -0,0 +1,130 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import { Editor, Path } from 'slate';
+var BOLDITALICREG = /\*\*\*(\S+)\*\*\*|\_\_\_(\S+)\_\_\_|\*\_\_(\S+)\_\_\*|\_\*\*(\S+)\*\*\_|\_\_\*(\S+)\*\_\_|\*\*\_(\S+)_\*\*/;
+var BOLDREG = /\*\*(\S+)\*\*|\_\_(\S+)\_\_/;
+var ITALICREG = /\*(\S+)\*|_(\S+)_/;
+var CODEREG = /\`(\S+)\`/;
+
+var TextUtils = function TextUtils(_editor) {
+  var _this = this;
+
+  _classCallCheck(this, TextUtils);
+
+  this.getTextInfoBeforeSelection = function () {
+    var editor = _this.editor;
+    var selection = _this.editor.selection;
+    var anchor = selection.anchor;
+
+    var _Editor$nodes = Editor.nodes(editor, {
+      match: 'block'
+    }),
+        _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+        block = _Editor$nodes2[0];
+
+    var path = block ? block[1] : [];
+    var start = Editor.start(editor, path);
+    var range = {
+      anchor: anchor,
+      focus: start
+    };
+    var beforeText = Editor.text(editor, range);
+    return {
+      range: range,
+      beforeText: beforeText,
+      block: block
+    };
+  };
+
+  this.setTextMarkByShortCut = function (exec, command) {
+    var editor = _this.editor;
+    var selection = editor.selection;
+
+    var _Editor$node = Editor.node(editor, selection),
+        _Editor$node2 = _slicedToArray(_Editor$node, 2),
+        textNode = _Editor$node2[0],
+        textPath = _Editor$node2[1];
+
+    var text = textNode.text;
+    var offset = selection.anchor.offset;
+    var lastChart = text[offset - 1];
+    var marks, markText, startOffset;
+    var matched;
+
+    if (lastChart === '_' || lastChart === '`' || lastChart === '*') {
+      if (matched = text.match(BOLDITALICREG)) {
+        startOffset = matched.index;
+        marks = {
+          BOLD: true,
+          ITALIC: true
+        };
+      } else if (matched = text.match(BOLDREG)) {
+        startOffset = matched.index;
+        marks = {
+          BOLD: true
+        };
+      } else if (matched = text.match(ITALICREG)) {
+        startOffset = matched.index;
+        marks = {
+          ITALIC: true
+        };
+      } else if (matched = text.match(CODEREG)) {
+        startOffset = matched.index;
+        marks = {
+          CODE: true
+        };
+      }
+
+      if (matched) {
+        for (var index = 1; index < matched.length; index++) {
+          if (matched[index]) {
+            markText = matched[index];
+            break;
+          }
+        }
+
+        marks = Object.assign({
+          BOLD: false,
+          ITALIC: false,
+          CODE: false
+        }, marks);
+        Editor.select(editor, {
+          anchor: {
+            path: textPath,
+            offset: startOffset
+          },
+          focus: {
+            path: textPath,
+            offset: offset
+          }
+        });
+        Editor.delete(editor, editor.selection); // insert a space before mark
+
+        Editor.insertText(editor, ' ');
+        Editor.insertNodes(editor, [_objectSpread({
+          text: markText
+        }, marks), {
+          text: ' '
+        }]);
+        var selectedPath = Path.next(Path.next(textPath)); // select the next empty text node to escape the mark
+
+        Editor.select(editor, selectedPath);
+        Editor.collapse(editor, {
+          edge: 'end'
+        });
+        return;
+      }
+    }
+
+    exec(command);
+  };
+
+  this.editor = _editor;
+} // Get text related variables before current selection
+// block: Parent of current text node
+// range: From start of block to current selection
+// beforeText: The text of block from start to selection
+;
+
+export default TextUtils;

package/dist/editor/editor.js

@@ -0,0 +1,66 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import SimpleEditor from './simple-editor';
+import SeafileEditor from './seafile-editor';
+import LoadScript from './load-script';
+
+var SimpleEditorWithErrorBoundary = /*#__PURE__*/function (_React$Component) {
+  _inherits(SimpleEditorWithErrorBoundary, _React$Component);
+
+  var _super = _createSuper(SimpleEditorWithErrorBoundary);
+
+  function SimpleEditorWithErrorBoundary() {
+    _classCallCheck(this, SimpleEditorWithErrorBoundary);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(SimpleEditorWithErrorBoundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error) {
+      console.error(error);
+      this.forceUpdate();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(SimpleEditor, this.props);
+    }
+  }]);
+
+  return SimpleEditorWithErrorBoundary;
+}(React.Component);
+
+var SeafileEditorWithErrorBundary = /*#__PURE__*/function (_React$Component2) {
+  _inherits(SeafileEditorWithErrorBundary, _React$Component2);
+
+  var _super2 = _createSuper(SeafileEditorWithErrorBundary);
+
+  function SeafileEditorWithErrorBundary() {
+    _classCallCheck(this, SeafileEditorWithErrorBundary);
+
+    return _super2.apply(this, arguments);
+  }
+
+  _createClass(SeafileEditorWithErrorBundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error) {
+      console.error(error);
+      this.forceUpdate();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(LoadScript, {
+        scriptSource: this.props.scriptSource
+      }, /*#__PURE__*/React.createElement(SeafileEditor, this.props));
+    }
+  }]);
+
+  return SeafileEditorWithErrorBundary;
+}(React.Component);
+
+export { SimpleEditorWithErrorBoundary as SimpleEditor, SeafileEditorWithErrorBundary as SeafileEditor };

package/dist/editor/element-model/blockquote.js

@@ -0,0 +1,16 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+
+var Blockquote = function Blockquote(options) {
+  _classCallCheck(this, Blockquote);
+
+  this.type = options.type || 'blockquote';
+  this.children = options.children || [{
+    text: ''
+  }];
+};
+
+var generateBlockquote = function generateBlockquote(options) {
+  return Object.assign({}, new Blockquote(options));
+};
+
+export default generateBlockquote;

package/dist/editor/element-model/image.js

@@ -0,0 +1,19 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+
+var Image = function Image(options) {
+  _classCallCheck(this, Image);
+
+  this.type = options.type || 'image';
+  this.data = options.data || {
+    src: ''
+  };
+  this.children = options.children || [{
+    text: ''
+  }];
+};
+
+var generateImage = function generateImage(options) {
+  return Object.assign({}, new Image(options));
+};
+
+export default generateImage;

package/dist/editor/element-model/link.js

@@ -0,0 +1,19 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+
+var Link = function Link(options) {
+  _classCallCheck(this, Link);
+
+  this.type = options.type || 'link';
+  this.children = options.children || [{
+    text: ''
+  }];
+  this.data = options.data || {
+    href: ''
+  };
+};
+
+var generateLinkElement = function generateLinkElement(options) {
+  return Object.assign({}, new Link(options));
+};
+
+export default generateLinkElement;

package/dist/editor/element-model/table.js

@@ -0,0 +1,50 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+
+var Table = function Table() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  _classCallCheck(this, Table);
+
+  this.type = options.type || 'table';
+  this.children = options.children || [generateTableRow(), generateTableRow()];
+};
+
+var TableRow = function TableRow() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  _classCallCheck(this, TableRow);
+
+  this.type = options.type || 'table_row';
+  this.children = options.children || [generateTableCell(), generateTableCell()];
+};
+
+var TableCell = function TableCell() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  _classCallCheck(this, TableCell);
+
+  this.type = options.type || 'table_cell';
+  this.children = options.children || [{
+    type: 'paragraph',
+    children: [{
+      text: ''
+    }]
+  }];
+  this.data = options.data || {
+    align: 'left'
+  };
+};
+
+var generateTable = function generateTable(options) {
+  return Object.assign({}, new Table(options));
+};
+
+var generateTableRow = function generateTableRow(options) {
+  return Object.assign({}, new TableRow(options));
+};
+
+var generateTableCell = function generateTableCell(options) {
+  return Object.assign({}, new TableCell(options));
+};
+
+export { generateTable, generateTableRow, generateTableCell };

package/dist/editor/element-model/text.js

@@ -0,0 +1,13 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+
+var Text = function Text(options) {
+  _classCallCheck(this, Text);
+
+  this.text = options.text || '';
+};
+
+var generateTextElement = function generateTextElement(options) {
+  return Object.assign({}, new Text(options));
+};
+
+export default generateTextElement;

package/dist/editor/load-script.js

@@ -0,0 +1,83 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import Loading from '../components/loading'; // load mathjax.js first before show editor
+
+var LoadScript = /*#__PURE__*/function (_React$Component) {
+  _inherits(LoadScript, _React$Component);
+
+  var _super = _createSuper(LoadScript);
+
+  function LoadScript(props) {
+    var _this;
+
+    _classCallCheck(this, LoadScript);
+
+    _this = _super.call(this, props);
+
+    _this.loadScript = function () {
+      if (!_this.props.scriptSource) return;
+
+      if (!document.querySelector('#mathjax')) {
+        var script = document.createElement('script');
+        script.src = _this.props.scriptSource;
+        script.id = 'mathjax';
+        document.body.appendChild(script);
+
+        script.onload = function () {
+          _this.setState({
+            isScriptLoaded: true
+          });
+        };
+      }
+    };
+
+    if (!props.scriptSource || window.MathJax) {
+      _this.state = {
+        isScriptLoaded: true
+      };
+      return _possibleConstructorReturn(_this);
+    }
+
+    window.canInsertFormula = true;
+
+    if (!window.MathJax) {
+      // config mathjax
+      window.MathJax = {
+        options: {
+          enableMenu: false
+        },
+        tex: {
+          inlineMath: [['$', '$']],
+          displayMath: [['$$', '$$']]
+        },
+        svg: {
+          fontCache: 'global'
+        }
+      };
+      _this.state = {
+        isScriptLoaded: false
+      };
+
+      _this.loadScript();
+    }
+
+    return _this;
+  } // load mathjax 
+
+
+  _createClass(LoadScript, [{
+    key: "render",
+    value: function render() {
+      var isScriptLoaded = this.state.isScriptLoaded;
+      return isScriptLoaded ? this.props.children : /*#__PURE__*/React.createElement(Loading, null);
+    }
+  }]);
+
+  return LoadScript;
+}(React.Component);
+
+export default LoadScript;