@seafile/sdoc-editor 2.0.81 → 2.0.83

package/dist/utils/diff.js

@@ -0,0 +1,351 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTopLevelChanges = exports.getMergedChanges = exports.getIdDiffs = exports.getDiff = exports.generateIdMapAndIds = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _objectSpread4 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../extension/constants");
+var _diffText = _interopRequireDefault(require("./diff-text"));
+var _documentUtils = require("./document-utils");
+var _objectUtils = _interopRequireDefault(require("./object-utils"));
+// ignore
+var IGNORE_KEYS = ['BOLD', 'ITALIC', 'bold', 'italic', 'columns', 'minHeight', 'min_height', 'language', 'white_space'];
+var generatorDiffTextElement = function generatorDiffTextElement(textElement, diffType) {
+  var style = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!textElement) return null;
+  if (!diffType) return textElement;
+  var id = textElement.id;
+  return (0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, textElement), {}, (0, _defineProperty2["default"])({
+    id: id || _slugid["default"].nice()
+  }, diffType, true), style);
+};
+var getTopLevelChanges = exports.getTopLevelChanges = function getTopLevelChanges(changes) {
+  var topLevelChanges = [];
+  var articleEl = document.getElementById('sdoc-editor');
+  changes.forEach(function (item) {
+    var dom = document.querySelectorAll("[data-id=\"".concat(item, "\"]"))[0];
+    if (!dom) return [];
+    while (((_dom = dom) === null || _dom === void 0 ? void 0 : (_dom$dataset = _dom.dataset) === null || _dom$dataset === void 0 ? void 0 : _dom$dataset.root) !== 'true' || ((_dom2 = dom) === null || _dom2 === void 0 ? void 0 : _dom2.parentNode) !== articleEl) {
+      var _dom, _dom$dataset, _dom2, _dom3;
+      if (!((_dom3 = dom) !== null && _dom3 !== void 0 && _dom3.parentNode) || dom instanceof Document) break;
+      var parentNode = dom.parentNode;
+      if (parentNode instanceof Document) {
+        break;
+      } else {
+        var _dom4, _dom4$dataset;
+        dom = parentNode;
+        if ((_dom4 = dom) !== null && _dom4 !== void 0 && (_dom4$dataset = _dom4.dataset) !== null && _dom4$dataset !== void 0 && _dom4$dataset.id && !dom.classList.contains('table-cell')) break;
+      }
+    }
+    topLevelChanges.push(dom.dataset.id);
+  });
+  return Array.from(new Set(topLevelChanges));
+};
+
+// Merge consecutive added areas or deleted areas
+var getMergedChanges = exports.getMergedChanges = function getMergedChanges(topLevelChanges, diffValue) {
+  var topLevelChangesValue = [];
+  var changes = [];
+  diffValue.forEach(function (item) {
+    if (topLevelChanges.includes(item.id)) {
+      var obj = {
+        id: item.id,
+        value: item
+      };
+      topLevelChangesValue.push(obj);
+    }
+  });
+  topLevelChangesValue.forEach(function (item) {
+    var _changes;
+    var preChange = (_changes = changes[changes.length - 1]) === null || _changes === void 0 ? void 0 : _changes.value;
+    var curChange = item.value;
+    if (curChange !== null && curChange !== void 0 && curChange.add && preChange !== null && preChange !== void 0 && preChange.add) return;
+    if (curChange !== null && curChange !== void 0 && curChange["delete"] && preChange !== null && preChange !== void 0 && preChange["delete"]) return;
+    changes.push(item);
+  });
+  return changes.map(function (item) {
+    return item.id;
+  });
+};
+
+// Depth facilitates each child node, adding diffType to each end node
+var _generatorDiffElement = function generatorDiffElement(element, diffType) {
+  var style = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!element) return null;
+  if (!Array.isArray(element.children) || element.children.length === 0) {
+    return generatorDiffTextElement(element, diffType, style);
+  }
+  return (0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, element), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, diffType, true), "children", element.children.map(function (item) {
+    return _generatorDiffElement(item, diffType, style);
+  })));
+};
+var generateIdMapAndIds = exports.generateIdMapAndIds = function generateIdMapAndIds(elements) {
+  var map = {};
+  var ids = [];
+  if (!Array.isArray(elements) || elements.length === 0) return {
+    map: map,
+    ids: ids
+  };
+  elements.forEach(function (element) {
+    ids.push(element.id);
+    map[element.id] = element;
+  });
+  return {
+    map: map,
+    ids: ids
+  };
+};
+var hasChildren = function hasChildren(element) {
+  if (!element) return false;
+  if (!Array.isArray(element.children) || element.children.length === 0) return false;
+  return true;
+};
+
+// id diffs
+var getIdDiffs = exports.getIdDiffs = function getIdDiffs(oldIds, newIds) {
+  var diff = new _diffText["default"](oldIds, newIds);
+  return diff.getDiffs();
+};
+
+// text diffs
+var getTextDiff = function getTextDiff(element, oldElement, diff) {
+  var newText = element.text;
+  var oldText = oldElement.text;
+  var textDiff = new _diffText["default"](oldText || '', newText || '');
+  var textDiffs = textDiff.getDiffs();
+  var newChildren = [];
+  textDiffs.forEach(function (item, index) {
+    var id = "".concat(element.id || _slugid["default"].nice(), "-").concat(index);
+    var elementItem = {
+      id: id,
+      text: item.value
+    };
+    if (item.added) {
+      diff.changes.push(id);
+      var commonChild = generatorDiffTextElement(elementItem, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE);
+      newChildren.push(commonChild);
+    } else if (item.removed) {
+      diff.changes.push(id);
+      var _commonChild = generatorDiffTextElement(elementItem, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE);
+      newChildren.push(_commonChild);
+    } else {
+      var _commonChild2 = generatorDiffTextElement(elementItem);
+      newChildren.push(_commonChild2);
+    }
+  });
+  return newChildren;
+};
+var _getCommonDiff = function getCommonDiff(element, oldElement, diff) {
+  if (!hasChildren(element) && !hasChildren(oldElement)) {
+    var _newChildren = getTextDiff(element, oldElement, diff);
+    return [(0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, element), {}, {
+      children: _newChildren
+    })];
+  }
+  if (!hasChildren(element) || !hasChildren(oldElement)) {
+    var elementId = element.id || _slugid["default"].nice();
+    diff.changes.push("".concat(elementId, "_delete"));
+    return [_generatorDiffElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, oldElement), {}, {
+      id: "".concat(elementId, "_delete")
+    }), _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE), _generatorDiffElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, element), {}, {
+      id: "".concat(elementId, "_add")
+    }), _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE)];
+  }
+
+  // Content does not change
+  if (_objectUtils["default"].isSameObject(element, oldElement, [].concat(IGNORE_KEYS, ['type']))) {
+    return [element];
+  }
+
+  // Compare content
+  var currentChildren = element.children;
+  var oldChildren = oldElement.children;
+  var _generateIdMapAndIds = generateIdMapAndIds(currentChildren),
+    currentMap = _generateIdMapAndIds.map,
+    currentIds = _generateIdMapAndIds.ids;
+  var _generateIdMapAndIds2 = generateIdMapAndIds(oldChildren),
+    oldMap = _generateIdMapAndIds2.map,
+    oldIds = _generateIdMapAndIds2.ids;
+  var idDiffs = getIdDiffs(oldIds, currentIds);
+  var newChildren = [];
+  idDiffs.forEach(function (idDiff) {
+    var ids = idDiff.value;
+    var isAdded = idDiff.added;
+    var isDelete = idDiff.removed;
+    ids.forEach(function (id) {
+      var newChildrenElement = currentMap[id];
+      var oldChildrenElement = oldMap[id];
+      if (isAdded) {
+        diff.changes.push(id);
+        newChildren.push(_generatorDiffElement(newChildrenElement, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE));
+      } else if (isDelete) {
+        diff.changes.push(id);
+        newChildren.push(_generatorDiffElement(oldChildrenElement, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE));
+      } else {
+        if (_objectUtils["default"].isSameObject(newChildrenElement, oldChildrenElement, IGNORE_KEYS)) {
+          newChildren.push(newChildrenElement);
+        } else {
+          if (newChildrenElement.type === oldChildrenElement.type) {
+            if (!newChildrenElement.type) {
+              var textDiffs = getTextDiff(newChildrenElement, oldChildrenElement, diff);
+              newChildren.push.apply(newChildren, (0, _toConsumableArray2["default"])(textDiffs));
+            } else if (newChildrenElement.type === _constants.ELEMENT_TYPE.IMAGE) {
+              if (newChildrenElement.data.src === oldChildrenElement.data.src) {
+                newChildren.push(newChildrenElement);
+              } else {
+                newChildren.push(generatorDiffTextElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, element), {}, {
+                  id: element.id + '_add'
+                }), _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE));
+                newChildren.push(generatorDiffTextElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, oldChildrenElement), {}, {
+                  id: element.id + '_delete'
+                }), _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE));
+              }
+            } else if (newChildrenElement.type === _constants.ELEMENT_TYPE.LINK) {
+              if (newChildrenElement.title !== oldChildrenElement.title) {
+                var diffElements = _getCommonDiff(newChildrenElement, oldChildrenElement, diff);
+                newChildren.push.apply(newChildren, (0, _toConsumableArray2["default"])(diffElements));
+              } else if (newChildrenElement.href !== oldChildrenElement.href) {
+                diff.changes.push(oldChildrenElement.id + '_delete');
+                newChildren.push(generatorDiffTextElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, oldChildrenElement), {}, {
+                  id: oldChildrenElement.id + '_delete'
+                }), _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE));
+                newChildren.push(generatorDiffTextElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, newChildrenElement), {}, {
+                  id: newChildrenElement.id + '_add'
+                }), _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE));
+              } else {
+                newChildren.push(newChildrenElement);
+              }
+            } else if (newChildrenElement.type === _constants.ELEMENT_TYPE.TABLE_ROW || newChildrenElement.type === _constants.ELEMENT_TYPE.TABLE_CELL) {
+              var newRows = _getCommonDiff(newChildrenElement, oldChildrenElement, diff);
+              newChildren.push.apply(newChildren, (0, _toConsumableArray2["default"])(newRows));
+            } else {
+              var commonDiffs = _getCommonDiff(newChildrenElement, oldChildrenElement, diff);
+              newChildren.push.apply(newChildren, (0, _toConsumableArray2["default"])(commonDiffs));
+            }
+          } else {
+            diff.changes.push(oldChildrenElement.id + '_delete');
+            newChildren.push(generatorDiffTextElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, oldChildrenElement), {}, {
+              id: oldChildrenElement.id + '_delete'
+            }), _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE));
+            newChildren.push(generatorDiffTextElement((0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, newChildrenElement), {}, {
+              id: newChildrenElement.id + '_add'
+            }), _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE));
+          }
+        }
+      }
+    });
+  });
+  return [(0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, element), {}, {
+    children: newChildren
+  })];
+};
+var updateDiffValue = function updateDiffValue(diff, element, oldElement) {
+  if (!diff || !element || !oldElement) return;
+  if (_objectUtils["default"].isSameObject(element, oldElement, IGNORE_KEYS)) {
+    diff.value.push(element);
+    return;
+  }
+  var elements = _getCommonDiff(element, oldElement, diff);
+  elements.forEach(function (item) {
+    // Changing empty characters to other characters
+    if (!item.add && item.children.find(function (child) {
+      return child.add === true;
+    })) {
+      item.add = true;
+    }
+    diff.value.push(item);
+  });
+};
+
+/**
+ * params:
+    * currentValue: current version document content
+    * oldValue: last version document content
+ * return { value: [], change: [] }
+*/
+var getElementDiffValue = function getElementDiffValue(currentContent, oldContent) {
+  // init
+  var diff = {
+    value: [],
+    changes: []
+  };
+  var _generateIdMapAndIds3 = generateIdMapAndIds(currentContent),
+    currentContentMap = _generateIdMapAndIds3.map,
+    currentIds = _generateIdMapAndIds3.ids;
+  var _generateIdMapAndIds4 = generateIdMapAndIds(oldContent),
+    oldContentMap = _generateIdMapAndIds4.map,
+    oldIds = _generateIdMapAndIds4.ids;
+  var diffs = getIdDiffs(oldIds, currentIds);
+  diffs.forEach(function (diffItem) {
+    var elementIds = diffItem.value;
+    if (diffItem.removed) {
+      elementIds.forEach(function (elementId) {
+        diff.changes.push(elementId);
+        var element = oldContentMap[elementId];
+        var diffElement = _generatorDiffElement(element, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE);
+        diff.value.push(diffElement);
+      });
+    } else if (diffItem.added) {
+      elementIds.forEach(function (elementId) {
+        diff.changes.push(elementId);
+        var element = currentContentMap[elementId];
+        var diffElement = _generatorDiffElement(element, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE);
+        diff.value.push(diffElement);
+      });
+    } else {
+      elementIds.forEach(function (elementId) {
+        var element = currentContentMap[elementId];
+        updateDiffValue(diff, element, oldContentMap[element.id]);
+      });
+    }
+  });
+  return diff;
+};
+
+/**
+ * params:
+    * currentValue: current version document
+    * oldValue: last version document
+ * return { value: [], change: [] }
+*/
+var getDiff = exports.getDiff = function getDiff() {
+  var currentValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+    elements: []
+  };
+  var oldValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    elements: []
+  };
+  if (!currentValue && !oldValue) return {
+    value: [],
+    changes: []
+  };
+  if (!currentValue && oldValue) return {
+    value: (0, _documentUtils.normalizeChildren)(oldValue.elements),
+    changes: []
+  };
+  if (currentValue && !oldValue) return {
+    value: (0, _documentUtils.normalizeChildren)(currentValue.elements),
+    changes: []
+  };
+  var _currentValue$element = (0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, currentValue), {}, {
+      elements: (0, _documentUtils.normalizeChildren)(currentValue.elements)
+    }),
+    currentVersion = _currentValue$element.version,
+    currentContent = _currentValue$element.elements;
+  var _oldValue$elements = (0, _objectSpread4["default"])((0, _objectSpread4["default"])({}, oldValue), {}, {
+      elements: (0, _documentUtils.normalizeChildren)(oldValue.elements)
+    }),
+    oldVersion = _oldValue$elements.version,
+    oldContent = _oldValue$elements.elements;
+  if (currentVersion === oldVersion) return {
+    value: currentContent,
+    changes: []
+  };
+  return getElementDiffValue(currentContent, oldContent);
+};
+window.getIdDiffs = getIdDiffs;

package/dist/utils/document-utils.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setOriginSdocKey = exports.normalizeCopyNodes = exports.normalizeChildren = exports.getSlateFragmentAttribute = exports.generateDefaultDocContent = exports.formatSdocContent = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _context = _interopRequireDefault(require("../context"));
+var _constants = require("../extension/constants");
+var _index = require("../extension/core/utils/index");
+var _helpers = require("../extension/plugins/table/helpers");
+var _objectUtils = _interopRequireDefault(require("./object-utils"));
+var _normalizeChildren = exports.normalizeChildren = function normalizeChildren(children) {
+  // text
+  if (!Array.isArray(children)) return children;
+
+  // element
+  if (Array.isArray(children) && children.length === 0) return [(0, _index.generateDefaultText)()];
+  return children.map(function (child) {
+    // child is text
+    if (_objectUtils["default"].hasProperty(child, 'text') && !_objectUtils["default"].hasProperty(child, 'children')) {
+      return child;
+    }
+    // To resolve the issue that the children is not assigned to the new object
+    if (!Object.getOwnPropertyDescriptor(child, 'children').writable) {
+      child = (0, _deepCopy["default"])(child);
+    }
+    // child is element
+    child.children = _normalizeChildren(child.children);
+    return child;
+  });
+};
+var normalizeCopyNodes = exports.normalizeCopyNodes = function normalizeCopyNodes(editor, elements) {
+  if (!Array.isArray(elements) || elements.length === 0) return [];
+  return elements.map(function (element) {
+    if (element.type === _constants.ELEMENT_TYPE.TABLE) {
+      return (0, _helpers.normalizeTableELement)(editor, element);
+    }
+    return element;
+  });
+};
+var setOriginSdocKey = exports.setOriginSdocKey = function setOriginSdocKey(event) {
+  var docUuid = _context["default"].getSetting('docUuid');
+  event.clipboardData.setData("text/".concat(_constants.CLIPBOARD_ORIGIN_SDOC_KEY), docUuid);
+};
+var getSlateFragmentAttribute = exports.getSlateFragmentAttribute = function getSlateFragmentAttribute(dataTransfer) {
+  var catchSlateFragment = /data-slate-fragment="(.+?)"/m;
+  var htmlData = dataTransfer.getData('text/html');
+  var _ref = htmlData.match(catchSlateFragment) || [],
+    _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+    fragment = _ref2[1];
+  return fragment;
+};
+var generateDefaultDocContent = exports.generateDefaultDocContent = function generateDefaultDocContent() {
+  var defaultValue = {
+    version: 0,
+    elements: [{
+      id: 'aaaa',
+      type: 'paragraph',
+      children: [{
+        text: ''
+      }]
+    }]
+  };
+  return defaultValue;
+};
+
+// patch: update children to elements
+var formatSdocContent = exports.formatSdocContent = function formatSdocContent(content) {
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, content), !content.elements && {
+    elements: content.children
+  });
+};

package/dist/utils/dom-utils.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectionRange = exports.getDomMarginTop = exports.getDomHeight = exports.getCursorPosition = void 0;
+var getDomHeight = exports.getDomHeight = function getDomHeight(dom) {
+  var styles = window.getComputedStyle(dom);
+  var rect = dom.getBoundingClientRect();
+  var marginTop = styles['marginTop'];
+  // margin-bottom overlaps margin-top
+  // const marginBottom = styles['marginBottom'];
+  var height = rect.height;
+  return height + parseInt(marginTop);
+};
+var getDomMarginTop = exports.getDomMarginTop = function getDomMarginTop(dom) {
+  var styles = window.getComputedStyle(dom);
+  var marginTop = styles['marginTop'];
+  return parseInt(marginTop);
+};
+var getSelectionRange = exports.getSelectionRange = function getSelectionRange() {
+  if (window.getSelection) {
+    var sel = window.getSelection();
+    if (sel.getRangeAt && sel.rangeCount) {
+      return sel.getRangeAt(0);
+    }
+  } else if (document.selection && document.selection.createRange) {
+    return document.selection.createRange();
+  }
+  return null;
+};
+var getCursorPosition = exports.getCursorPosition = function getCursorPosition() {
+  var isScrollUp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var x = 0;
+  var y = 0;
+  var range = getSelectionRange();
+  if (range) {
+    var rect = range.getBoundingClientRect();
+    var headerHeight = 100;
+    x = rect.x || 0;
+    if (isScrollUp) {
+      y = rect.y - headerHeight;
+    } else {
+      y = rect.y - headerHeight + rect.height;
+    }
+  }
+  return {
+    x: x,
+    y: y
+  };
+};

package/dist/utils/event-bus.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var EventBus = /*#__PURE__*/function () {
+  function EventBus() {
+    (0, _classCallCheck2["default"])(this, EventBus);
+    this.instance = null;
+    this.subscribers = {};
+  }
+  return (0, _createClass2["default"])(EventBus, [{
+    key: "subscribe",
+    value: function subscribe(type, handler) {
+      if (!this.subscribers[type]) {
+        this.subscribers[type] = [];
+      }
+      var handlers = this.subscribers[type];
+      handlers.push(handler);
+      return function () {
+        var index = handlers.indexOf(handler);
+        if (index > -1) {
+          handlers.splice(index, 1);
+        }
+      };
+    }
+  }, {
+    key: "dispatch",
+    value: function dispatch(type) {
+      for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        data[_key - 1] = arguments[_key];
+      }
+      var handlers = this.subscribers[type];
+      if (Array.isArray(handlers)) {
+        handlers.forEach(function (handler) {
+          return handler.apply(void 0, data);
+        });
+      }
+    }
+  }], [{
+    key: "getInstance",
+    value: function getInstance() {
+      if (this.instance) return this.instance;
+      this.instance = new EventBus();
+      return this.instance;
+    }
+  }]);
+}();
+var _default = exports["default"] = EventBus;

package/dist/utils/event-handler.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../constants");
+var _constants2 = require("../extension/constants");
+var _queries = require("../extension/core/queries/");
+var _eventBus2 = _interopRequireDefault(require("../utils/event-bus"));
+var _documentUtils = require("./document-utils");
+var EventProxy = /*#__PURE__*/(0, _createClass2["default"])(function EventProxy(_editor) {
+  var _this = this;
+  (0, _classCallCheck2["default"])(this, EventProxy);
+  (0, _defineProperty2["default"])(this, "onKeyDown", function (event) {
+    var editor = _this.editor;
+    if (editor.onHotKeyDown) {
+      var isHandled = editor.onHotKeyDown(event);
+      if (isHandled) return;
+    }
+
+    // bold
+    if ((0, _isHotkey["default"])('mod+b', event)) {
+      event.preventDefault();
+      editor.toggleTextBold();
+    }
+
+    // italic
+    if ((0, _isHotkey["default"])('mod+i', event)) {
+      event.preventDefault();
+      editor.toggleTextItalic();
+    }
+
+    // font scale
+    if ((0, _isHotkey["default"])('opt+.', event)) {
+      event.preventDefault();
+      editor.increaseFontSize();
+    }
+    if ((0, _isHotkey["default"])('opt+,', event)) {
+      event.preventDefault();
+      editor.reduceFontSize();
+    }
+
+    // disable the default 'save page'
+    if ((0, _isHotkey["default"])('mod+s', event)) {
+      event.preventDefault();
+    }
+
+    // redo
+    if ((0, _isHotkey["default"])('mod+y', event)) {
+      event.preventDefault();
+      var history = editor.history;
+      if (history.redos.length === 0) {
+        return false;
+      }
+      editor.redo();
+    }
+
+    // undo
+    if ((0, _isHotkey["default"])('mod+z', event)) {
+      event.preventDefault();
+      var _history = editor.history;
+      if (_history.undos.length === 0) {
+        return false;
+      }
+      editor.undo();
+    }
+    if ((0, _isHotkey["default"])('tab', event) || (0, _isHotkey["default"])('shift+tab', event)) {
+      editor.handleTab && editor.handleTab(event);
+    }
+    if ((0, _isHotkey["default"])('mod+p', event)) {
+      event.preventDefault();
+      var eventBus = _eventBus2["default"].getInstance();
+      eventBus.dispatch(_constants.INTERNAL_EVENT.ON_PRINT);
+    }
+    var node = (0, _queries.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+    if (node) {
+      _this.editor.tableOnKeyDown(event);
+    }
+    var imageNode = (0, _queries.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.IMAGE);
+    if (imageNode) {
+      _this.editor.imageOnKeyDown(event);
+    }
+    if ((0, _queries.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.CODE_BLOCK)) {
+      _this.editor.codeBlockOnKeyDown(event);
+      var _eventBus = _eventBus2["default"].getInstance();
+      _eventBus.dispatch(_constants.INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU);
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onCopy", function (event) {
+    if (_this.editor.onCopy) _this.editor.onCopy(event);
+    (0, _documentUtils.setOriginSdocKey)(event);
+  });
+  (0, _defineProperty2["default"])(this, "onCut", function (event) {
+    (0, _documentUtils.setOriginSdocKey)(event);
+    if (_this.editor.cut) {
+      _this.editor.cut(event);
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onPaste", function (event) {});
+  (0, _defineProperty2["default"])(this, "onCompositionStart", function (event) {
+    var editor = _this.editor;
+    if (editor.onCompositionStart) {
+      var isHandled = editor.onCompositionStart(event);
+      if (isHandled) return;
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onCompositionUpdate", function (event) {
+    var editor = _this.editor;
+    if (editor.onCompositionUpdate) {
+      var isHandled = editor.onCompositionUpdate(event);
+      if (isHandled) return;
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onCompositionEnd", function (event) {
+    var editor = _this.editor;
+    if (editor.onCompositionEnd) {
+      var isHandled = editor.onCompositionEnd(event);
+      if (isHandled) return;
+    }
+  });
+  this.editor = _editor;
+});
+var _default = exports["default"] = EventProxy;