@seafile/seafile-editor 0.3.76

package/dist/editor-api.js

@@ -0,0 +1,261 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { SeafileAPI } from 'seafile-js';
+import { serverConfig } from './config';
+var serviceUrl = serverConfig.serviceUrl,
+    username = serverConfig.username,
+    password = serverConfig.password;
+var seafileAPI = new SeafileAPI();
+seafileAPI.init({
+  server: serviceUrl,
+  username: username,
+  password: password
+});
+
+function getImageFileNameWithTimestamp(file) {
+  var d = Date.now();
+  return 'image-' + d.toString() + file.name.slice(file.name.lastIndexOf('.'));
+}
+
+var EditorApi = /*#__PURE__*/function () {
+  function EditorApi(repoID, fileName, dirPath, name, filePath, serviceUrl, username, contact_email, repoName) {
+    var _this = this;
+
+    _classCallCheck(this, EditorApi);
+
+    this.uploadLocalImage = function (imageFile) {
+      return _this.seafileAPI.getUploadLink(_this.repoID, '/').then(function (res) {
+        var uploadLink = res.data + '?ret-json=1';
+        var newFile = new File([imageFile], getImageFileNameWithTimestamp(imageFile), {
+          type: imageFile.type
+        });
+        var formData = new FormData();
+        formData.append('parent_dir', '/');
+        formData.append('relative_path', 'images/auto-upload');
+        formData.append('file', newFile);
+        return _this.seafileAPI.uploadImage(uploadLink, formData);
+      }).then(function (res) {
+        return _this._getImageURL(res.data[0].name);
+      });
+    };
+
+    this.getDraftKey = function () {
+      return _this.repoID + _this.filePath;
+    };
+
+    this.addFileParticipants = function (emails) {
+      return _this.seafileAPI.addFileParticipants(_this.repoID, _this.filePath, emails);
+    };
+
+    this.seafileAPI = seafileAPI;
+    this.repoID = repoID;
+    this.filePath = filePath;
+    this.serviceUrl = serviceUrl;
+    this.dirPath = dirPath;
+    this.fileName = fileName;
+    this.userName = username;
+    this.contact_email = contact_email;
+    this.name = name;
+    this.repoName = repoName;
+  }
+
+  _createClass(EditorApi, [{
+    key: "login",
+    value: function login() {
+      return this.seafileAPI.login();
+    }
+  }, {
+    key: "saveContent",
+    value: function saveContent(content) {
+      var _this2 = this;
+
+      return this.seafileAPI.getUpdateLink(this.repoID, this.dirPath).then(function (res) {
+        var uploadLink = res.data;
+        return _this2.seafileAPI.updateFile(uploadLink, _this2.filePath, _this2.fileName, content);
+      });
+    }
+  }, {
+    key: "unStarItem",
+    value: function unStarItem() {
+      return this.seafileAPI.unstarItem(this.repoID, this.filePath);
+    }
+  }, {
+    key: "starItem",
+    value: function starItem() {
+      return this.seafileAPI.starItem(this.repoID, this.filePath);
+    }
+  }, {
+    key: "createShareLink",
+    value: function createShareLink(userPassword, userValidDays) {
+      return this.seafileAPI.createShareLink(this.repoID, this.filePath, userPassword, userValidDays);
+    }
+  }, {
+    key: "getShareLink",
+    value: function getShareLink() {
+      return this.seafileAPI.getShareLink(this.repoID, this.filePath);
+    }
+  }, {
+    key: "deleteShareLink",
+    value: function deleteShareLink(token) {
+      return this.seafileAPI.deleteShareLink(token);
+    }
+  }, {
+    key: "getCommentsNumber",
+    value: function getCommentsNumber() {
+      return this.seafileAPI.getCommentsNumber(this.repoID, this.filePath);
+    }
+  }, {
+    key: "postComment",
+    value: function postComment(comment, detail) {
+      return this.seafileAPI.postComment(this.repoID, this.filePath, comment, detail);
+    }
+  }, {
+    key: "listComments",
+    value: function listComments() {
+      return this.seafileAPI.listComments(this.repoID, this.filePath);
+    }
+  }, {
+    key: "updateComment",
+    value: function updateComment(commentID, resolved, detail, newComment) {
+      return this.seafileAPI.updateComment(this.repoID, commentID, resolved, detail, newComment);
+    }
+  }, {
+    key: "deleteComment",
+    value: function deleteComment(commentID) {
+      return this.seafileAPI.deleteComment(this.repoID, commentID);
+    }
+  }, {
+    key: "getUserAvatar",
+    value: function getUserAvatar(size) {
+      return this.seafileAPI.getUserAvatar(this.userName, size);
+    }
+  }, {
+    key: "getParentDectionaryUrl",
+    value: function getParentDectionaryUrl() {
+      return this.serviceUrl + '/#common/lib/' + this.repoID + '/';
+    }
+  }, {
+    key: "_getImageURL",
+    value: function _getImageURL(fileName) {
+      var url = this.serviceUrl + '/lib/' + this.repoID + '/file/images/auto-upload/' + fileName + '?raw=1';
+      return url;
+    }
+  }, {
+    key: "getFileContent",
+    value: function getFileContent(url) {
+      return this.seafileAPI.getFileContent(url);
+    }
+  }, {
+    key: "getFileURL",
+    value: function getFileURL(fileNode) {
+      var url;
+
+      if (fileNode.type === 'file') {
+        if (fileNode.isImage()) {
+          url = this.serviceUrl + '/lib/' + this.repoID + '/file' + encodeURIComponent(fileNode.path()) + '?raw=1';
+        } else {
+          url = this.serviceUrl + '/lib/' + this.repoID + '/file' + encodeURIComponent(fileNode.path());
+        }
+      } else {
+        url = this.serviceUrl + '/#common/lib/' + this.repoID + encodeURIComponent(fileNode.path());
+      }
+
+      return url;
+    }
+  }, {
+    key: "isInternalFileLink",
+    value: function isInternalFileLink(url) {
+      var re = new RegExp("".concat(this.serviceUrl, "/lib/[0-9a-f-]{36}/file.*"));
+      return re.test(url);
+    }
+  }, {
+    key: "listFileHistoryRecords",
+    value: function listFileHistoryRecords(page, perPage) {
+      return this.seafileAPI.listFileHistoryRecords(this.repoID, this.filePath, page, perPage);
+    }
+  }, {
+    key: "getFileHistoryVersion",
+    value: function getFileHistoryVersion(commitID) {
+      return this.seafileAPI.getFileRevision(this.repoID, commitID, this.filePath);
+    }
+  }, {
+    key: "getFileInfo",
+    value: function getFileInfo() {
+      return this.seafileAPI.getFileInfo(this.repoID, this.filePath);
+    }
+  }, {
+    key: "isInternalDirLink",
+    value: function isInternalDirLink(url) {
+      var re = new RegExp("".concat(this.serviceUrl, "/#[a-z-]*?/lib/[0-9a-f-]{36}.*"));
+      return re.test(url);
+    }
+  }, {
+    key: "getFiles",
+    value: function getFiles() {
+      // return promise
+      return this.seafileAPI.listDir(this.repoID, this.dirPath, {
+        recursive: true
+      }).then(function (response) {
+        var files = response.data.map(function (item) {
+          return {
+            name: item.name,
+            type: item.type === 'dir' ? 'dir' : 'file',
+            parent_path: item.parent_dir
+          };
+        });
+        return files;
+      });
+    }
+  }, {
+    key: "getInternalLink",
+    value: function getInternalLink() {
+      return this.seafileAPI.getInternalLink(this.repoID, this.filePath);
+    }
+  }, {
+    key: "getFileDownloadLink",
+    value: function getFileDownloadLink(repoID, filePath) {
+      return this.seafileAPI.getFileDownloadLink(repoID, filePath);
+    }
+  }, {
+    key: "fileMetaData",
+    value: function fileMetaData() {
+      return this.seafileAPI.fileMetaData(this.repoID, this.filePath);
+    }
+  }, {
+    key: "listFileTags",
+    value: function listFileTags() {
+      return this.seafileAPI.listFileTags(this.repoID, this.filePath);
+    }
+  }, {
+    key: "listRelatedFiles",
+    value: function listRelatedFiles() {
+      return this.seafileAPI.listRelatedFiles(this.repoID, this.filePath);
+    }
+  }, {
+    key: "markdownLint",
+    value: function markdownLint(slateValue) {
+      return this.seafileAPI.markdownLint(slateValue);
+    }
+  }, {
+    key: "searchUsers",
+    value: function searchUsers(searchParam) {
+      return this.seafileAPI.searchUsers(searchParam);
+    }
+  }, {
+    key: "listRepoRelatedUsers",
+    value: function listRepoRelatedUsers() {
+      return this.seafileAPI.listRepoRelatedUsers(this.repoID);
+    }
+  }]);
+
+  return EditorApi;
+}();
+
+var repoID = serverConfig.repoID,
+    fileName = serverConfig.fileName,
+    dirPath = serverConfig.dirPath,
+    name = serverConfig.name,
+    filePath = serverConfig.filePath,
+    contact_email = serverConfig.contact_email;
+var editorApi = new EditorApi(repoID, fileName, dirPath, name, filePath, serviceUrl, username, contact_email);
+export default editorApi;

package/dist/index.css

@@ -0,0 +1,97 @@
+* {
+  margin: 0;
+  padding: 0;
+}
+html,
+input,
+textarea {
+  font-family: 'Roboto', sans-serif;
+  line-height: 1.4;
+  background: #eee;
+}
+
+body {
+  overflow-y: hidden;
+}
+
+p {
+  margin: 0;
+}
+
+:not(pre) > code {
+  font-family: monospace;
+  background-color: #eee;
+  padding: 3px;
+}
+
+img {
+  max-width: 100%;
+}
+
+img.active {
+  box-shadow: 0 0 0 2px blue;
+}
+
+input {
+  box-sizing: border-box;
+  font-size: 0.85em;
+  width: 100%;
+  padding: 0.5em;
+  border: 2px solid #ddd;
+  background: #fafafa;
+}
+
+input:focus {
+  outline: 0;
+  border-color: blue;
+}
+input[type="checkbox"] {
+  width: auto;
+}
+
+
+.lds-ripple {
+  display: inline-block;
+  position: relative;
+  width: 64px;
+  height: 64px;
+}
+.lds-ripple div {
+  position: absolute;
+  border: 4px solid #eb8205;
+  opacity: 1;
+  border-radius: 50%;
+  animation: lds-ripple 1s cubic-bezier(0, 0.2, 0.8, 1) infinite;
+}
+.lds-ripple div:nth-child(2) {
+  animation-delay: -0.5s;
+}
+@keyframes lds-ripple {
+  0% {
+    top: 28px;
+    left: 28px;
+    width: 0;
+    height: 0;
+    opacity: 1;
+  }
+  100% {
+    top: -1px;
+    left: -1px;
+    width: 58px;
+    height: 58px;
+    opacity: 0;
+  }
+}
+.empty-loading-page {
+  position: fixed;
+  height: 100%;
+  width: 100%;
+}
+
+.page-centered {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  /* bring your own prefixes */
+  transform: translate(-50%, -50%);
+}

package/dist/lib/slate-hyperscript/creators.js

@@ -0,0 +1,263 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { Element, Node, Range, Text, createEditor as makeEditor } from 'slate';
+import { AnchorToken, FocusToken, Token, addAnchorToken, addFocusToken, getAnchorOffset, getFocusOffset } from './tokens';
+/**
+ * Resolve the descedants of a node by normalizing the children that can be
+ * passed into a hyperscript creator function.
+ */
+
+var STRINGS = new WeakSet();
+
+var resolveDescendants = function resolveDescendants(children) {
+  var nodes = [];
+
+  var addChild = function addChild(child) {
+    if (child == null) {
+      return;
+    }
+
+    var prev = nodes[nodes.length - 1];
+
+    if (typeof child === 'string') {
+      var text = {
+        text: child
+      };
+      STRINGS.add(text);
+      child = text;
+    }
+
+    if (Text.isText(child)) {
+      var c = child; // HACK: fix typescript complaining
+
+      if (Text.isText(prev) && STRINGS.has(prev) && STRINGS.has(c) && Text.equals(prev, c, {
+        loose: true
+      })) {
+        prev.text += c.text;
+      } else {
+        nodes.push(c);
+      }
+    } else if (Element.isElement(child)) {
+      nodes.push(child);
+    } else if (child instanceof Token) {
+      var n = nodes[nodes.length - 1];
+
+      if (!Text.isText(n)) {
+        addChild('');
+        n = nodes[nodes.length - 1];
+      }
+
+      if (child instanceof AnchorToken) {
+        addAnchorToken(n, child);
+      } else if (child instanceof FocusToken) {
+        addFocusToken(n, child);
+      }
+    } else {
+      throw new Error("Unexpected hyperscript child object: ".concat(child));
+    }
+  };
+
+  var _iterator = _createForOfIteratorHelper(children.flat(Infinity)),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var child = _step.value;
+      addChild(child);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return nodes;
+};
+/**
+ * Create an anchor token.
+ */
+
+
+export function createAnchor(tagName, attributes, children) {
+  return new AnchorToken(attributes);
+}
+/**
+ * Create an anchor and a focus token.
+ */
+
+export function createCursor(tagName, attributes, children) {
+  return [new AnchorToken(attributes), new FocusToken(attributes)];
+}
+/**
+ * Create an `Element` object.
+ */
+
+export function createElement(tagName, attributes, children) {
+  return _objectSpread(_objectSpread({}, attributes), {}, {
+    children: resolveDescendants(children)
+  });
+}
+/**
+ * Create a focus token.
+ */
+
+export function createFocus(tagName, attributes, children) {
+  return new FocusToken(attributes);
+}
+/**
+ * Create a fragment.
+ */
+
+export function createFragment(tagName, attributes, children) {
+  return resolveDescendants(children);
+}
+/**
+ * Create a `Selection` object.
+ */
+
+export function createSelection(tagName, attributes, children) {
+  var anchor = children.find(function (c) {
+    return c instanceof AnchorToken;
+  });
+  var focus = children.find(function (c) {
+    return c instanceof FocusToken;
+  });
+
+  if (!anchor || !anchor.offset || !anchor.path) {
+    throw new Error('The <selection> hyperscript tag must have an <anchor> tag as a child with \`path\` and \`offset\` attributes defined.');
+  }
+
+  if (!focus || !focus.offset || !focus.path) {
+    throw new Error('The <selection> hyperscript tag must have a <focus> tag as a child with \`path\` and \`offset\` attributes defined.');
+  }
+
+  return _objectSpread({
+    anchor: {
+      offset: anchor.offset,
+      path: anchor.path
+    },
+    focus: {
+      offset: focus.offset,
+      path: focus.path
+    }
+  }, attributes);
+}
+/**
+ * Create a `Text` object.
+ */
+
+export function createText(tagName, attributes, children) {
+  var nodes = resolveDescendants(children);
+
+  if (nodes.length > 1) {
+    throw new Error('The <text> hyperscript tag must only contain a single nodes worth of children.');
+  }
+
+  var _nodes = _slicedToArray(nodes, 1),
+      node = _nodes[0];
+
+  if (node == null) {
+    node = {
+      text: ''
+    };
+  }
+
+  if (!Text.isText(node)) {
+    throw new Error('The <text> hyperscript tag can only contain text content as children.');
+  } // COMPAT: If they used the <text> tag we want to guarantee that it won't be
+  // merge with other string children.
+
+
+  STRINGS.delete(node);
+  Object.assign(node, attributes);
+  return node;
+}
+/**
+ * Create a top-level `Editor` object.
+ */
+
+export function createEditor(tagName, attributes, children) {
+  var otherChildren = [];
+  var selectionChild;
+
+  var _iterator2 = _createForOfIteratorHelper(children),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var child = _step2.value;
+
+      if (Range.isRange(child)) {
+        selectionChild = child;
+      } else {
+        otherChildren.push(child);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  var descendants = resolveDescendants(otherChildren);
+  var selection = {};
+  var editor = makeEditor();
+  Object.assign(editor, attributes);
+  editor.children = descendants; // Search the document's texts to see if any of them have tokens associated
+  // that need incorporated into the selection.
+
+  var _iterator3 = _createForOfIteratorHelper(Node.texts(editor)),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = _slicedToArray(_step3.value, 2),
+          node = _step3$value[0],
+          path = _step3$value[1];
+
+      var anchor = getAnchorOffset(node);
+      var focus = getFocusOffset(node);
+
+      if (anchor != null) {
+        var _anchor = _slicedToArray(anchor, 1),
+            offset = _anchor[0];
+
+        selection.anchor = {
+          path: path,
+          offset: offset
+        };
+      }
+
+      if (focus != null) {
+        var _focus = _slicedToArray(focus, 1),
+            _offset = _focus[0];
+
+        selection.focus = {
+          path: path,
+          offset: _offset
+        };
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  if (selection.anchor && !selection.focus) {
+    throw new Error('Slate hyperscript ranges must have both \`<anchor />\` and \`<focus />\` defined if one is defined, but you only defined \`<anchor />\`. For collapsed selections, use \`<cursor />\` instead.');
+  }
+
+  if (!selection.anchor && selection.focus) {
+    throw new Error('Slate hyperscript ranges must have both \`<anchor />\` and \`<focus />\` defined if one is defined, but you only defined \`<focus />\`. For collapsed selections, use \`<cursor />\` instead.');
+  }
+
+  if (selectionChild != null) {
+    editor.selection = selectionChild;
+  } else if (Range.isRange(selection)) {
+    editor.selection = selection;
+  }
+
+  return editor;
+}

package/dist/lib/slate-hyperscript/hyperscript.js

@@ -0,0 +1,92 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import isPlainObject from 'is-plain-object';
+import { createAnchor, createCursor, createEditor, createElement, createFocus, createFragment, createSelection, createText } from './creators';
+/**
+ * The default creators for Slate objects.
+ */
+
+var DEFAULT_CREATORS = {
+  anchor: createAnchor,
+  cursor: createCursor,
+  editor: createEditor,
+  element: createElement,
+  focus: createFocus,
+  fragment: createFragment,
+  selection: createSelection,
+  text: createText
+};
+
+var createHyperscript = function createHyperscript() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$elements = options.elements,
+      elements = _options$elements === void 0 ? {} : _options$elements;
+  var elementCreators = normalizeElements(elements);
+
+  var creators = _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_CREATORS), elementCreators), options.creators);
+
+  var jsx = createFactory(creators);
+  return jsx;
+};
+/**
+ * Create a Slate hyperscript function with `options`.
+ */
+
+
+var createFactory = function createFactory(creators) {
+  var jsx = function jsx(tagName, attributes) {
+    for (var _len = arguments.length, children = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      children[_key - 2] = arguments[_key];
+    }
+
+    var creator = creators[tagName];
+
+    if (!creator) {
+      throw new Error("No hyperscript creator found for tag: <".concat(tagName, ">"));
+    }
+
+    if (attributes == null) {
+      attributes = {};
+    }
+
+    if (!isPlainObject(attributes)) {
+      children = [attributes].concat(children);
+      attributes = {};
+    }
+
+    children = children.filter(function (child) {
+      return Boolean(child);
+    }).flat();
+    var ret = creator(tagName, attributes, children);
+    return ret;
+  };
+
+  return jsx;
+};
+/**
+ * Normalize a dictionary of element shorthands into creator functions.
+ */
+
+
+var normalizeElements = function normalizeElements(elements) {
+  var creators = {};
+
+  var _loop = function _loop(tagName) {
+    var props = elements[tagName];
+
+    if (typeof props !== 'object') {
+      throw new Error("Properties specified for a hyperscript shorthand should be an object, but for the custom element <".concat(tagName, ">  tag you passed: ").concat(props));
+    }
+
+    creators[tagName] = function (tagName, attributes, children) {
+      return createElement('element', _objectSpread(_objectSpread({}, props), attributes), children);
+    };
+  };
+
+  for (var tagName in elements) {
+    _loop(tagName);
+  }
+
+  return creators;
+};
+
+export { createHyperscript };

package/dist/lib/slate-hyperscript/index.js

@@ -0,0 +1,3 @@
+import { createHyperscript } from './hyperscript';
+var jsx = createHyperscript();
+export { jsx };