@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/socket/with-socket-io.js

@@ -1,55 +1,63 @@
 import { generateCursorData } from '../cursor/helper';
 import EventBus from '../utils/event-bus';
 import SocketManager from './socket-manager';
-var withSocketIO = function withSocketIO(editor, options) {
-  var onChange = editor.onChange;
-  var newEditor = editor;
-  var socketManager = null;
-  var user = options.config.user;
+const withSocketIO = (editor, options) => {
+  const {
+    onChange
+  } = editor;
+  const newEditor = editor;
+  let socketManager = null;
+  const {
+    user
+  } = options.config;
   newEditor.user = user;
-  newEditor.openConnection = function () {
-    var document = options.document,
-      config = options.config;
-    var cursorData = generateCursorData(options.config);
+  newEditor.openConnection = () => {
+    const {
+      document,
+      config
+    } = options;
+    const cursorData = generateCursorData(options.config);
     config['cursorData'] = cursorData;
     socketManager = SocketManager.getInstance(newEditor, document, config);
   };
-  newEditor.closeConnection = function () {
+  newEditor.closeConnection = () => {
     socketManager && socketManager.closeSocketConnect();
     SocketManager.destroy();
   };
-  newEditor.onChange = function () {
-    var document = options.document,
-      config = options.config;
-    var operations = newEditor.operations;
+  newEditor.onChange = () => {
+    const {
+      document,
+      config
+    } = options;
+    let operations = newEditor.operations;
     if (!newEditor.isRemote && operations.length > 0) {
-      var isAllSetSelection = operations.every(function (operation) {
-        return operation.type === 'set_selection';
-      });
-      var _socketManager = SocketManager.getInstance(newEditor, document, config);
+      const isAllSetSelection = operations.every(operation => operation.type === 'set_selection');
+      const socketManager = SocketManager.getInstance(newEditor, document, config);
       if (!isAllSetSelection) {
         // get update content value operations
-        var updateOperations = operations.filter(function (operation) {
-          return operation.type !== 'set_selection';
-        });
-        _socketManager.onReceiveLocalOperations(updateOperations);
+        const updateOperations = operations.filter(operation => operation.type !== 'set_selection');
+        socketManager.onReceiveLocalOperations(updateOperations);
       }
-      _socketManager.sendCursorLocation(editor.selection);
+      socketManager.sendCursorLocation(editor.selection);
     }
 
     // dispatch editor change event
-    var eventBus = EventBus.getInstance(newEditor, document, config);
+    const eventBus = EventBus.getInstance(newEditor, document, config);
     eventBus.dispatch('change');
     onChange();
   };
-  newEditor.rebaseContent = function (document, originFileVersion) {
-    var config = options.config;
-    var socketManager = SocketManager.getInstance(newEditor, document, config);
+  newEditor.rebaseContent = (document, originFileVersion) => {
+    const {
+      config
+    } = options;
+    const socketManager = SocketManager.getInstance(newEditor, document, config);
     socketManager.sendRebaseContent(document, originFileVersion);
   };
-  newEditor.updateDocumentVersion = function (document) {
-    var config = options.config;
-    var socketManager = SocketManager.getInstance(newEditor, document, config);
+  newEditor.updateDocumentVersion = document => {
+    const {
+      config
+    } = options;
+    const socketManager = SocketManager.getInstance(newEditor, document, config);
     socketManager.updateDocumentVersion(document);
   };
   return newEditor;

package/dist/basic-sdk/utils/debug.js

@@ -1,14 +1,14 @@
 import Debug from 'debug';
-var stateDebug = Debug('sdoc:state-change');
+const stateDebug = Debug('sdoc:state-change');
 stateDebug.enabled = true;
 stateDebug.log = console.log;
-var clientDebug = Debug('sdoc:socket-client');
+const clientDebug = Debug('sdoc:socket-client');
 clientDebug.enabled = true;
 clientDebug.log = console.log;
-var serverDebug = Debug('sdoc:socket-server');
+const serverDebug = Debug('sdoc:socket-server');
 serverDebug.enabled = true;
 serverDebug.log = console.log;
-var conflictDebug = Debug('sdoc:sdoc-conflict');
+const conflictDebug = Debug('sdoc:sdoc-conflict');
 conflictDebug.enabled = true;
 conflictDebug.log = console.log;
 export { stateDebug, clientDebug, serverDebug, conflictDebug };

package/dist/basic-sdk/utils/diff-text.js

@@ -1,19 +1,17 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import ObjectUtils from './object-utils';
-var buildValues = function buildValues(diff, components, newString, oldString, valueType, useLongestToken) {
-  var componentPos = 0;
-  var componentLen = components.length;
-  var newPos = 0;
-  var oldPos = 0;
+const buildValues = (diff, components, newString, oldString, valueType, useLongestToken) => {
+  let componentPos = 0;
+  let componentLen = components.length;
+  let newPos = 0;
+  let oldPos = 0;
   for (; componentPos < componentLen; componentPos++) {
-    var component = components[componentPos];
+    let component = components[componentPos];
     if (!component.removed) {
       if (!component.added && useLongestToken) {
-        var value = newString.slice(newPos, newPos + component.count);
+        let value = newString.slice(newPos, newPos + component.count);
         // eslint-disable-next-line no-loop-func
-        value = value.map(function (value, i) {
-          var oldValue = oldString[oldPos + i];
+        value = value.map((value, i) => {
+          let oldValue = oldString[oldPos + i];
           return oldValue.length > value.length ? oldValue : value;
         });
         component.value = diff.join(value, valueType);
@@ -34,7 +32,7 @@ var buildValues = function buildValues(diff, components, newString, oldString, v
       // The diffing algorithm is tied to add then remove output and this is the simplest
       // route to get the desired output with minimal overhead.
       if (componentPos && components[componentPos - 1].added) {
-        var tmp = components[componentPos - 1];
+        let tmp = components[componentPos - 1];
         components[componentPos - 1] = components[componentPos];
         components[componentPos] = tmp;
       }
@@ -44,212 +42,212 @@ var buildValues = function buildValues(diff, components, newString, oldString, v
   // Special case handle for when one terminal is ignored (i.e. whitespace).
   // For this case we merge the terminal into the prior string and drop the change.
   // This is only available for string mode.
-  var lastComponent = components[componentLen - 1];
+  let lastComponent = components[componentLen - 1];
   if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
     components[componentLen - 2].value += lastComponent.value;
     components.pop();
   }
   return components;
 };
-var clonePath = function clonePath(path) {
+const clonePath = path => {
   return {
     newPos: path.newPos,
     components: path.components.slice(0)
   };
 };
-var DiffText = /*#__PURE__*/_createClass(function DiffText(oldValue, newValue) {
-  var _this = this;
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  _classCallCheck(this, DiffText);
-  this.done = function (value) {
-    if (_this.callback) {
+class DiffText {
+  constructor(oldValue, newValue) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    this.done = value => {
+      if (this.callback) {
+        setTimeout(function () {
+          this.callback(undefined, value);
+        }, 0);
+        return true;
+      }
+      return value;
+    };
+    // Main worker method. checks all permutations of a given edit length for acceptance.
+    this.execCompareLength = bestPath => {
+      for (let diagonalPath = -1 * this.comparePath; diagonalPath <= this.comparePath; diagonalPath += 2) {
+        let basePath;
+        let addPath = bestPath[diagonalPath - 1];
+        let removePath = bestPath[diagonalPath + 1];
+        let oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+        if (addPath) {
+          // No one else is going to attempt to use this value, clear it
+          bestPath[diagonalPath - 1] = undefined;
+        }
+        let canAdd = addPath && addPath.newPos + 1 < this.newLen;
+        let canRemove = removePath && 0 <= oldPos && oldPos < this.oldLen;
+        if (!canAdd && !canRemove) {
+          // If this path is a terminal then prune
+          bestPath[diagonalPath] = undefined;
+          continue;
+        }
+
+        // Select the diagonal that we want to branch from. We select the prior
+        // path whose position in the new string is the farthest from the origin
+        // and does not pass the bounds of the diff graph
+        if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
+          basePath = clonePath(removePath);
+          this.pushComponent(basePath.components, undefined, true);
+        } else {
+          basePath = addPath; // No need to clone, we've pulled it from the list
+          basePath.newPos++;
+          this.pushComponent(basePath.components, true, undefined);
+        }
+        oldPos = this.extractCommon(basePath, this.newValue, this.oldValue, diagonalPath);
+
+        // If we have hit the end of both strings, then we are done
+        if (basePath.newPos + 1 >= this.newLen && oldPos + 1 >= this.oldLen) {
+          return this.done(buildValues(this, basePath.components, this.newValue, this.oldValue, this.valueType, this.useLongestToken));
+        } else {
+          // Otherwise track this path as a potential candidate and continue.
+          bestPath[diagonalPath] = basePath;
+        }
+      }
+      this.comparePath++;
+    };
+    this.exec = bestPath => {
       setTimeout(function () {
-        this.callback(undefined, value);
+        if (this.comparePath > this.maxEditLength) {
+          return this.callback();
+        }
+        if (!this.execCompareLength(bestPath)) {
+          this.exec(bestPath);
+        }
       }, 0);
-      return true;
-    }
-    return value;
-  };
-  // Main worker method. checks all permutations of a given edit length for acceptance.
-  this.execCompareLength = function (bestPath) {
-    for (var diagonalPath = -1 * _this.comparePath; diagonalPath <= _this.comparePath; diagonalPath += 2) {
-      var basePath = void 0;
-      var addPath = bestPath[diagonalPath - 1];
-      var removePath = bestPath[diagonalPath + 1];
-      var oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
-      if (addPath) {
-        // No one else is going to attempt to use this value, clear it
-        bestPath[diagonalPath - 1] = undefined;
+    };
+    this.pushComponent = (components, added, removed) => {
+      let last = components[components.length - 1];
+      if (last && last.added === added && last.removed === removed) {
+        // We need to clone here as the component clone operation is just
+        // as shallow array clone
+        components[components.length - 1] = {
+          count: last.count + 1,
+          added: added,
+          removed: removed
+        };
+      } else {
+        components.push({
+          count: 1,
+          added: added,
+          removed: removed
+        });
       }
-      var canAdd = addPath && addPath.newPos + 1 < _this.newLen;
-      var canRemove = removePath && 0 <= oldPos && oldPos < _this.oldLen;
-      if (!canAdd && !canRemove) {
-        // If this path is a terminal then prune
-        bestPath[diagonalPath] = undefined;
-        continue;
+    };
+    this.extractCommon = (basePath, newString, oldString, diagonalPath) => {
+      let newLen = newString.length;
+      let oldLen = oldString.length;
+      let newPos = basePath.newPos;
+      let oldPos = newPos - diagonalPath;
+      let commonCount = 0;
+      while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+        newPos++;
+        oldPos++;
+        commonCount++;
       }
-
-      // Select the diagonal that we want to branch from. We select the prior
-      // path whose position in the new string is the farthest from the origin
-      // and does not pass the bounds of the diff graph
-      if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
-        basePath = clonePath(removePath);
-        _this.pushComponent(basePath.components, undefined, true);
-      } else {
-        basePath = addPath; // No need to clone, we've pulled it from the list
-        basePath.newPos++;
-        _this.pushComponent(basePath.components, true, undefined);
+      if (commonCount) {
+        basePath.components.push({
+          count: commonCount
+        });
       }
-      oldPos = _this.extractCommon(basePath, _this.newValue, _this.oldValue, diagonalPath);
-
-      // If we have hit the end of both strings, then we are done
-      if (basePath.newPos + 1 >= _this.newLen && oldPos + 1 >= _this.oldLen) {
-        return _this.done(buildValues(_this, basePath.components, _this.newValue, _this.oldValue, _this.valueType, _this.useLongestToken));
+      basePath.newPos = newPos;
+      return oldPos;
+    };
+    this.equals = (left, right) => {
+      if (this.options.comparator) {
+        return this.options.comparator(left, right);
       } else {
-        // Otherwise track this path as a potential candidate and continue.
-        bestPath[diagonalPath] = basePath;
+        return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
       }
-    }
-    _this.comparePath++;
-  };
-  this.exec = function (bestPath) {
-    setTimeout(function () {
-      if (this.comparePath > this.maxEditLength) {
-        return this.callback();
+    };
+    this.removeEmpty = (array, type) => {
+      if (type === 'Array') return array;
+      let ret = [];
+      for (let i = 0; i < array.length; i++) {
+        if (array[i]) {
+          ret.push(array[i]);
+        }
       }
-      if (!this.execCompareLength(bestPath)) {
-        this.exec(bestPath);
+      return ret;
+    };
+    this.tokenize = (value, valueType) => {
+      if (valueType === 'Array') return value.slice();
+      return value.split('');
+    };
+    this.join = (value, valueType) => {
+      if (valueType === 'Array') return value;
+      return value.join('');
+    };
+    this.getDiffs = () => {
+      if (!this.canCompare) {
+        return [{
+          value: this.oldValue,
+          removed: true
+        }, {
+          value: this.newValue,
+          added: true
+        }];
       }
-    }, 0);
-  };
-  this.pushComponent = function (components, added, removed) {
-    var last = components[components.length - 1];
-    if (last && last.added === added && last.removed === removed) {
-      // We need to clone here as the component clone operation is just
-      // as shallow array clone
-      components[components.length - 1] = {
-        count: last.count + 1,
-        added: added,
-        removed: removed
-      };
-    } else {
-      components.push({
-        count: 1,
-        added: added,
-        removed: removed
-      });
-    }
-  };
-  this.extractCommon = function (basePath, newString, oldString, diagonalPath) {
-    var newLen = newString.length;
-    var oldLen = oldString.length;
-    var newPos = basePath.newPos;
-    var oldPos = newPos - diagonalPath;
-    var commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && _this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-    }
-    if (commonCount) {
-      basePath.components.push({
-        count: commonCount
-      });
-    }
-    basePath.newPos = newPos;
-    return oldPos;
-  };
-  this.equals = function (left, right) {
-    if (_this.options.comparator) {
-      return _this.options.comparator(left, right);
-    } else {
-      return left === right || _this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  };
-  this.removeEmpty = function (array, type) {
-    if (type === 'Array') return array;
-    var ret = [];
-    for (var i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  };
-  this.tokenize = function (value, valueType) {
-    if (valueType === 'Array') return value.slice();
-    return value.split('');
-  };
-  this.join = function (value, valueType) {
-    if (valueType === 'Array') return value;
-    return value.join('');
-  };
-  this.getDiffs = function () {
-    if (!_this.canCompare) {
-      return [{
-        value: _this.oldValue,
-        removed: true
-      }, {
-        value: _this.newValue,
-        added: true
+      let bestPath = [{
+        newPos: -1,
+        components: []
       }];
-    }
-    var bestPath = [{
-      newPos: -1,
-      components: []
-    }];
 
-    // Seed editLength = 0, i.e. the content starts with the same values
-    var oldPos = _this.extractCommon(bestPath[0], _this.newValue, _this.oldValue, 0);
-    if (bestPath[0].newPos + 1 >= _this.newLen && oldPos + 1 >= _this.oldLen) {
-      // Identity per the equality and tokenizer
-      return _this.done([{
-        value: _this.join(_this.newValue, _this.valueType),
-        count: _this.oldValue.length
-      }]);
-    }
+      // Seed editLength = 0, i.e. the content starts with the same values
+      let oldPos = this.extractCommon(bestPath[0], this.newValue, this.oldValue, 0);
+      if (bestPath[0].newPos + 1 >= this.newLen && oldPos + 1 >= this.oldLen) {
+        // Identity per the equality and tokenizer
+        return this.done([{
+          value: this.join(this.newValue, this.valueType),
+          count: this.oldValue.length
+        }]);
+      }
 
-    // Performs the length of edit iteration. Is a bit fugly as this has to support the
-    // sync and async mode which is never fun. Loops over execCompareLength until a value
-    // is produced, or until the edit length exceeds options.maxEditLength (if given),
-    // in which case it will return undefined.
-    if (_this.callback) {
-      _this.exec(bestPath);
-    } else {
-      while (_this.comparePath <= _this.maxEditLength) {
-        var ret = _this.execCompareLength(bestPath);
-        if (ret) {
-          return ret;
+      // Performs the length of edit iteration. Is a bit fugly as this has to support the
+      // sync and async mode which is never fun. Loops over execCompareLength until a value
+      // is produced, or until the edit length exceeds options.maxEditLength (if given),
+      // in which case it will return undefined.
+      if (this.callback) {
+        this.exec(bestPath);
+      } else {
+        while (this.comparePath <= this.maxEditLength) {
+          let ret = this.execCompareLength(bestPath);
+          if (ret) {
+            return ret;
+          }
         }
       }
+    };
+    this.oldValue = oldValue;
+    this.newValue = newValue;
+    const oldValueType = ObjectUtils.getDataType(oldValue);
+    const newValueType = ObjectUtils.getDataType(newValue);
+    this.canCompare = true;
+    if (oldValueType !== newValueType) {
+      this.canCompare = false;
+      return;
+    }
+    this.valueType = newValueType;
+    this.callback = options.callback;
+    const optionsType = ObjectUtils.getDataType(options);
+    if (optionsType === 'function') {
+      this.callback = options;
+      this.options = {};
+    } else {
+      this.options = {};
+    }
+    this.comparePath = 1;
+    this.oldValue = this.removeEmpty(this.tokenize(oldValue, oldValueType), oldValueType);
+    this.oldLen = this.oldValue.length;
+    this.newValue = this.removeEmpty(this.tokenize(newValue, newValueType), newValueType);
+    this.newLen = this.newValue.length;
+    this.maxEditLength = this.newLen + this.oldLen;
+    if (this.options.maxEditLength) {
+      this.maxEditLength = Math.min(this.maxEditLength, this.options.maxEditLength);
     }
-  };
-  this.oldValue = oldValue;
-  this.newValue = newValue;
-  var oldValueType = ObjectUtils.getDataType(oldValue);
-  var newValueType = ObjectUtils.getDataType(newValue);
-  this.canCompare = true;
-  if (oldValueType !== newValueType) {
-    this.canCompare = false;
-    return;
-  }
-  this.valueType = newValueType;
-  this.callback = options.callback;
-  var optionsType = ObjectUtils.getDataType(options);
-  if (optionsType === 'function') {
-    this.callback = options;
-    this.options = {};
-  } else {
-    this.options = {};
-  }
-  this.comparePath = 1;
-  this.oldValue = this.removeEmpty(this.tokenize(oldValue, oldValueType), oldValueType);
-  this.oldLen = this.oldValue.length;
-  this.newValue = this.removeEmpty(this.tokenize(newValue, newValueType), newValueType);
-  this.newLen = this.newValue.length;
-  this.maxEditLength = this.newLen + this.oldLen;
-  if (this.options.maxEditLength) {
-    this.maxEditLength = Math.min(this.maxEditLength, this.options.maxEditLength);
   }
-});
+}
 export default DiffText;