@seafile/comment-editor 0.0.1 → 0.0.2-alpha.1

package/dist/basic-sdk/socket/helpers.js

@@ -1,312 +0,0 @@
-"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 _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"));
-const getNodePathById = function (rootNode, nodeId) {
-  let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  if (rootNode.id === nodeId) return path;
-  const {
-    children = []
-  } = rootNode;
-  for (let i = 0; i < children.length; i++) {
-    const child = children[i];
-    path.push(i);
-    const nodePath = getNodePathById(child, nodeId, path);
-    if (nodePath) return nodePath;
-    path.pop();
-  }
-  return null;
-};
-exports.getNodePathById = getNodePathById;
-const validateOperation = (editor, operation) => {
-  let isValid = false;
-  let newOperation = (0, _deepCopy.default)(operation);
-  const {
-    type
-  } = newOperation;
-  switch (type) {
-    case OPERATION.INSERT_TEXT:
-    case OPERATION.REMOVE_TEXT:
-      {
-        const {
-          node_id,
-          path
-        } = newOperation;
-        const 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
-        const nodePath = getNodePathById(editor, node_id);
-        if (nodePath) {
-          isValid = true;
-          newOperation.path = nodePath;
-          break;
-        }
-        // node is not exist
-        isValid = false;
-        break;
-      }
-    case OPERATION.INSERT_NODE:
-      {
-        let {
-          parent_node_id,
-          path
-        } = newOperation;
-        const parentNodePath = getNodePathById(editor, parent_node_id);
-        if (!parentNodePath) {
-          isValid = false;
-          break;
-        }
-        const parentPath = path.slice(0, path.length - 1);
-        if (parentPath.join() === parentNodePath.join()) {
-          isValid = true;
-          break;
-        }
-
-        // reset insert node path
-        const parentNode = (0, _core.getNode)(editor, path);
-        if (parentNode) {
-          const childLength = parentNode.children.length;
-          const index = Math.min(path[path.length - 1], childLength);
-          newOperation.path = parentNodePath.concat([index]);
-          isValid = true;
-        }
-        break;
-      }
-    case OPERATION.REMOVE_NODE:
-      {
-        const {
-          node_id,
-          path
-        } = newOperation;
-        const 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
-        const 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
-        const {
-          node_id,
-          path
-        } = newOperation;
-        const 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
-        const nodePath = getNodePathById(editor, node_id);
-        if (nodePath) {
-          isValid = true;
-          newOperation.path = nodePath;
-          break;
-        }
-
-        // node is not exist
-        isValid = false;
-        break;
-      }
-    case OPERATION.SPLIT_NODE:
-      {
-        const {
-          node_id,
-          path
-        } = newOperation;
-        const 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
-        const nodePath = getNodePathById(editor, node_id);
-        if (nodePath) {
-          isValid = true;
-          newOperation.path = nodePath;
-          break;
-        }
-
-        // node is not exist
-        isValid = false;
-        break;
-      }
-    case OPERATION.SET_NODE:
-      {
-        const {
-          node_id,
-          path,
-          properties
-        } = newOperation;
-        const node = (0, _core.getNode)(editor, path);
-        // node is exist and node path is not changed
-        if (node && node.id === node_id) {
-          isValid = true;
-          newOperation.properties = {
-            ...properties,
-            type: node.type
-          };
-          break;
-        }
-
-        // node is exist but node path is changed
-        const nodePath = getNodePathById(editor, node_id);
-        if (nodePath) {
-          isValid = true;
-          const node = (0, _core.getNode)(editor, nodePath);
-          newOperation.properties = {
-            ...properties,
-            type: node.type
-          };
-          newOperation.path = nodePath;
-          break;
-        }
-
-        // node is not exist
-        isValid = false;
-        break;
-      }
-    case OPERATION.MOVE_NODE:
-      {
-        const {
-          node_id,
-          path
-        } = newOperation;
-        const node = (0, _core.getNode)(editor, path);
-        // node is exist and node path is not changed
-        if (node && node.id === node_id) {
-          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;
-};
-exports.validateOperation = validateOperation;
-const getRevertOperationList = operationList => {
-  if (operationList.length === 0) return [];
-
-  // Generate a duplicate operationList, The original value cannot be modified here
-  let revertOperationList = (0, _deepCopy.default)(operationList);
-  revertOperationList = revertOperationList.reverse();
-  return revertOperationList.map(operations => {
-    const ops = operations.reverse();
-    return ops.map(item => _slate.Operation.inverse(item));
-  });
-};
-exports.getRevertOperationList = getRevertOperationList;
-const revertOperationList = (editor, operationList) => {
-  if (operationList.length === 0) return [];
-  const revertOperationList = getRevertOperationList(operationList);
-
-  // Cancel locale execute operations
-  for (let i = 0; i < revertOperationList.length; i++) {
-    const operations = revertOperationList[i];
-    _slate.Editor.withoutNormalizing(editor, () => {
-      for (let j = 0; j < operations.length; j++) {
-        const op = operations[j];
-        editor.apply(op);
-      }
-    });
-  }
-};
-exports.revertOperationList = revertOperationList;
-const reExecRevertOperationList = (editor, revertOperationList) => {
-  if (revertOperationList.length === 0) return;
-
-  // Re-execute revert operations
-  for (let i = 0; i < revertOperationList.length; i++) {
-    const operations = revertOperationList[i];
-    _slate.Editor.withoutNormalizing(editor, () => {
-      for (let j = 0; j < operations.length; j++) {
-        const op = validateOperation(editor, operations[j]);
-        if (op) {
-          editor.apply(op);
-        }
-      }
-    });
-  }
-};
-exports.reExecRevertOperationList = reExecRevertOperationList;
-const syncRemoteOperations = (editor, remoteOperations) => {
-  if (remoteOperations.length === 0) return;
-  _slate.Editor.withoutNormalizing(editor, () => {
-    for (let i = 0; i < remoteOperations.length; i++) {
-      const op = remoteOperations[i];
-      if (op.type === 'set_selection') {
-        continue;
-      }
-      editor.apply(op);
-    }
-  });
-};
-exports.syncRemoteOperations = syncRemoteOperations;
-const syncRemoteCursorLocation = (editor, user, location, cursorData) => {
-  const currentUser = editor.user;
-  if (user && user.username !== currentUser.username) {
-    // Get front Point as cursor
-    const {
-      anchor,
-      focus
-    } = location;
-    let newLocation = location;
-    if (!_slate.Point.equals(anchor, focus)) {
-      const frontPoint = _slate.Editor.start(editor, location);
-      newLocation = {
-        anchor: frontPoint,
-        focus: frontPoint
-      };
-    }
-    (0, _helper.setCursor)(editor, user, newLocation, cursorData);
-
-    // sync cursor position
-    editor.onCursor && editor.onCursor(editor.cursors);
-  }
-};
-exports.syncRemoteCursorLocation = syncRemoteCursorLocation;

package/dist/basic-sdk/utils/Kebab-to-camel.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-const KebabToCamel = str => {
-  return str.replace(/(_[a-z])/g, match => `${match.slice(1).toUpperCase()}`);
-};
-var _default = exports.default = KebabToCamel;

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

@@ -1,20 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-/**
- * @param {Function} fn
- * @param {Number} delay
- */
-const debounce = (fn, delay) => {
-  let timeout = null;
-  return function () {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      fn.apply(this, arguments);
-    }, delay);
-  };
-};
-var _default = exports.default = debounce;

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

@@ -1,20 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stateDebug = exports.serverDebug = exports.conflictDebug = exports.clientDebug = void 0;
-var _debug = _interopRequireDefault(require("debug"));
-const stateDebug = exports.stateDebug = (0, _debug.default)('sdoc:state-change');
-stateDebug.enabled = true;
-stateDebug.log = console.log;
-const clientDebug = exports.clientDebug = (0, _debug.default)('sdoc:socket-client');
-clientDebug.enabled = true;
-clientDebug.log = console.log;
-const serverDebug = exports.serverDebug = (0, _debug.default)('sdoc:socket-server');
-serverDebug.enabled = true;
-serverDebug.log = console.log;
-const conflictDebug = exports.conflictDebug = (0, _debug.default)('sdoc:sdoc-conflict');
-conflictDebug.enabled = true;
-conflictDebug.log = console.log;

package/dist/basic-sdk/utils/default-mode.js

@@ -1,28 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getStyleByDefaultMode = void 0;
-var _constants = require("../constants");
-var _localStorageUtils = _interopRequireDefault(require("./local-storage-utils"));
-const getStyleByDefaultMode = (scrollRef, editor) => {
-  const sdocStorage = _localStorageUtils.default.getItem(_constants.SDOC_STORAGE) || {};
-  const {
-    outlineOpen: isShowOutline
-  } = sdocStorage;
-  const containerStyle = {
-    width: _constants.ARTICLE_DEFAULT_WIDTH
-  };
-
-  // Has outline
-  if (isShowOutline && editor.editorType !== _constants.WIKI_EDITOR) {
-    const rect = scrollRef.current.getBoundingClientRect();
-    if ((rect.width - Number(_constants.ARTICLE_DEFAULT_WIDTH.slice(0, 3))) / 2 < 280) {
-      containerStyle['marginLeft'] = `${_constants.LEFT_OUTLINE_WIDTH}px`;
-    }
-  }
-  return containerStyle;
-};
-exports.getStyleByDefaultMode = getStyleByDefaultMode;

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

@@ -1,297 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
-var _objectUtils = _interopRequireDefault(require("./object-utils"));
-const extendedWordChars = 'a-zA-Z\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}\\u{4e00}-\\u{9fa5}';
-const tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, 'ug');
-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++) {
-    let component = components[componentPos];
-    if (!component.removed) {
-      if (!component.added && useLongestToken) {
-        let value = newString.slice(newPos, newPos + component.count);
-        // eslint-disable-next-line no-loop-func
-        value = value.map((value, i) => {
-          let oldValue = oldString[oldPos + i];
-          return oldValue.length > value.length ? oldValue : value;
-        });
-        component.value = diff.join(value, valueType);
-      } else {
-        component.value = diff.join(newString.slice(newPos, newPos + component.count), valueType);
-      }
-      newPos += component.count;
-
-      // Common case
-      if (!component.added) {
-        oldPos += component.count;
-      }
-    } else {
-      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count), valueType);
-      oldPos += component.count;
-
-      // Reverse add and remove so removes are output first to match common convention
-      // 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) {
-        let tmp = components[componentPos - 1];
-        components[componentPos - 1] = components[componentPos];
-        components[componentPos] = tmp;
-      }
-    }
-  }
-
-  // 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.
-  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;
-};
-const clonePath = path => {
-  return {
-    newPos: path.newPos,
-    components: path.components.slice(0)
-  };
-};
-class DiffText {
-  constructor(oldValue, newValue) {
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    (0, _defineProperty2.default)(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.
-    (0, _defineProperty2.default)(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++;
-    });
-    (0, _defineProperty2.default)(this, "exec", bestPath => {
-      setTimeout(function () {
-        if (this.comparePath > this.maxEditLength) {
-          return this.callback();
-        }
-        if (!this.execCompareLength(bestPath)) {
-          this.exec(bestPath);
-        }
-      }, 0);
-    });
-    (0, _defineProperty2.default)(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
-        });
-      }
-    });
-    (0, _defineProperty2.default)(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++;
-      }
-      if (commonCount) {
-        basePath.components.push({
-          count: commonCount
-        });
-      }
-      basePath.newPos = newPos;
-      return oldPos;
-    });
-    (0, _defineProperty2.default)(this, "equals", (left, right) => {
-      if (this.options.ignoreCase) {
-        left = left.toLowerCase();
-        right = right.toLowerCase();
-      }
-      return left.trim() === right.trim();
-    });
-    (0, _defineProperty2.default)(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]);
-        }
-      }
-      return ret;
-    });
-    (0, _defineProperty2.default)(this, "tokenize", (value, valueType) => {
-      if (valueType === 'Array') {
-        return value.slice();
-      }
-      let parts = value.match(tokenizeIncludingWhitespace) || [];
-      const tokens = [];
-      let prevPart = null;
-      parts.forEach(part => {
-        if (/\s/.test(part)) {
-          if (prevPart == null) {
-            tokens.push(part);
-          } else {
-            tokens.push(tokens.pop() + part);
-          }
-        } else if (/\s/.test(prevPart)) {
-          if (tokens[tokens.length - 1] === prevPart) {
-            tokens.push(tokens.pop() + part);
-          } else {
-            tokens.push(prevPart + part);
-          }
-        } else {
-          tokens.push(part);
-        }
-        prevPart = part;
-      });
-      return tokens;
-    });
-    (0, _defineProperty2.default)(this, "join", (value, valueType) => {
-      if (valueType === 'Array') return value;
-      // Tokens being joined here will always have appeared consecutively in the
-      // same text, so we can simply strip off the leading whitespace from all the
-      // tokens except the first (and except any whitespace-only tokens - but such
-      // a token will always be the first and only token anyway) and then join them
-      // and the whitespace around words and punctuation will end up correct.
-      return value.map((token, i) => {
-        if (i === 0) {
-          return token;
-        } else {
-          return token.replace(/^\s+/, '');
-        }
-      }).join('');
-    });
-    (0, _defineProperty2.default)(this, "getDiffs", () => {
-      if (!this.canCompare) {
-        return [{
-          value: this.oldValue,
-          removed: true
-        }, {
-          value: this.newValue,
-          added: true
-        }];
-      }
-      let bestPath = [{
-        newPos: -1,
-        components: []
-      }];
-
-      // 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) {
-          let ret = this.execCompareLength(bestPath);
-          if (ret) {
-            return ret;
-          }
-        }
-      }
-    });
-    this.oldValue = oldValue;
-    this.newValue = newValue;
-    const oldValueType = _objectUtils.default.getDataType(oldValue);
-    const newValueType = _objectUtils.default.getDataType(newValue);
-    this.canCompare = true;
-    if (oldValueType !== newValueType) {
-      this.canCompare = false;
-      return;
-    }
-    this.valueType = newValueType;
-    this.callback = options.callback;
-    const optionsType = _objectUtils.default.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);
-    }
-  }
-}
-var _default = exports.default = DiffText;