@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/utils/is-punctuation-mark.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const isChPunctuation = char => {
+  // \u2014|\u2018|\u2019|\u201c|\u201d|
+  // \u2026|
+  // \u2039｜\u203a
+  // \u3001|\u3002|\u3008|\u3009|\u300a|\u300b|\u300c|\u300d|\u300e|\u300f
+  // \u3010|\u3011|\u3014|\u3015|\u301c|\u301d|\u301e
+  // \ufe43|\ufe44|\ufe4f
+  // \uffe5 (¥)
+  const reg = /[\u2014|\u2018|\u2019|\u201c|\u201d|\u2026|\u2039|\u203a|\u3001|\u3002|\u3008|\u3009|\u300a|\u300b|\u300c|\u300d|\u300e|\u300f|\u3010|\u3011|\u3014|\u3015|\u301c|\u301d|\u301e]/;
+  if (reg.test(char)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+function isEnHalfWidthPunctuation(char) {
+  // Distribution of half-width punctuation points in unicode: 0x0021~0x007e
+  // https://en.wikibooks.org/wiki/Unicode/Character_reference/0000-0FFF
+  const reg = /[\x21-\x2f\x3a-\x40\x5b-\x60\x7B-\x7F]/;
+  if (reg.test(char)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function isEnFullWidthPunctuation(char) {
+  // 0xff01~0xff5e
+  // https://en.wikibooks.org/wiki/Unicode/Character_reference/F000-FFFF
+  const reg = /[\uff01-\uff0f\uff1a-\uff1f\uff20\uff3b-\uff3f\uff40\uff5b-\uff5f]/;
+  if (reg.test(char)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+const isLastCharPunctuation = value => {
+  if (typeof value !== 'string' || !value) return false;
+  const lastChar = value.slice(-1);
+  if (isChPunctuation(lastChar)) return true;
+  if (isEnHalfWidthPunctuation(lastChar)) return true;
+  if (isEnFullWidthPunctuation(lastChar)) return true;
+  return false;
+};
+var _default = exports.default = isLastCharPunctuation;

package/dist/basic-sdk/utils/local-storage-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class LocalStorage {
+  static setItem(key, value) {
+    let savedValue;
+    const valueType = typeof value;
+    if (valueType === 'string') {
+      savedValue = value;
+    } else if (valueType === 'number') {
+      savedValue = value + '';
+    } else {
+      savedValue = JSON.stringify(value);
+    }
+    return window.localStorage.setItem(key, savedValue);
+  }
+  static getItem(key, defaultValue) {
+    const value = window.localStorage.getItem(key);
+    try {
+      return JSON.parse(value) || defaultValue;
+    } catch {
+      return value || defaultValue;
+    }
+  }
+  static removeItem(key) {
+    return window.localStorage.removeItem(key);
+  }
+
+  // The setExpire and getExpire methods used to satisfy some cases that need to be updated regularly
+  static setExpire(key, value, expire) {
+    let obj = {
+      data: value,
+      time: Date.now(),
+      expire: expire
+    };
+    this.setItem(key, JSON.stringify(obj));
+  }
+  static getExpire(key) {
+    let val = this.getItem(key);
+    if (!val) return val;
+    val = JSON.parse(val);
+    if (Date.now() - val.time > val.expire) {
+      this.removeItem(key);
+      return null;
+    }
+    return val.data;
+  }
+}
+var _default = exports.default = LocalStorage;

package/dist/basic-sdk/utils/mouse-event.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unregisterResizeEvents = exports.registerResizeEvents = exports.getMouseMoveInfo = exports.getMouseDownInfo = exports.eventStopPropagation = exports.createObjectWithProperties = void 0;
+const eventStopPropagation = event => {
+  if (!event) return;
+  event.stopPropagation();
+  event.nativeEvent && event.nativeEvent.stopImmediatePropagation && event.nativeEvent.stopImmediatePropagation();
+};
+exports.eventStopPropagation = eventStopPropagation;
+const registerResizeEvents = function () {
+  let eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  for (let key in eventsMap) {
+    document.addEventListener(key, eventsMap[key]);
+  }
+};
+exports.registerResizeEvents = registerResizeEvents;
+const unregisterResizeEvents = function () {
+  let eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  for (let key in eventsMap) {
+    document.removeEventListener(key, eventsMap[key]);
+  }
+};
+exports.unregisterResizeEvents = unregisterResizeEvents;
+const getMouseDownInfo = (event, scrollContainer) => {
+  let positionX = 0;
+  let positionY = 0;
+  let scrollLeft = 0;
+  let scrollTop = 0;
+  if (event) {
+    positionX = event.clientX;
+    positionY = event.clientY;
+  }
+  if (scrollContainer) {
+    scrollLeft = scrollContainer.scrollLeft;
+    scrollTop = scrollContainer.scrollTop;
+  }
+  return {
+    positionX,
+    positionY,
+    scrollLeft,
+    scrollTop
+  };
+};
+exports.getMouseDownInfo = getMouseDownInfo;
+const getMouseMoveInfo = (event, mouseDownInfo, scrollContainer) => {
+  let displacementX = 0;
+  let displacementY = 0;
+  if (!event) return {
+    displacementX,
+    displacementY
+  };
+  const {
+    clientX: currPositionX,
+    clientY: currPositionY
+  } = event;
+  let scrollLeft = 0;
+  let scrollTop = 0;
+  if (scrollContainer) {
+    scrollLeft = scrollContainer.scrollLeft || 0;
+    scrollTop = scrollContainer.scrollTop || 0;
+  }
+  displacementX = currPositionX - mouseDownInfo.positionX + scrollLeft - (mouseDownInfo.scrollLeft || 0);
+  displacementY = currPositionY - mouseDownInfo.positionY + scrollTop - (mouseDownInfo.scrollTop || 0);
+  return {
+    displacementX,
+    displacementY
+  };
+};
+exports.getMouseMoveInfo = getMouseMoveInfo;
+const createObjectWithProperties = (originalObj, properties) => {
+  return properties.reduce((result, property) => {
+    if (property in originalObj) {
+      result[property] = originalObj[property];
+    }
+    return result;
+  }, {});
+};
+exports.createObjectWithProperties = createObjectWithProperties;

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

@@ -0,0 +1,58 @@
+"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;
+class ObjectUtils {
+  static getDataType(data) {
+    let type = typeof data;
+    if (type !== 'object') {
+      return type;
+    }
+    return Object.prototype.toString.call(data).replace(/^\[object (\S+)\]$/, '$1');
+  }
+  static iterable(data) {
+    return ['Object', 'Array'].includes(this.getDataType(data));
+  }
+  static isObjectChanged(source, comparison, notIncludeKeys) {
+    if (!this.iterable(source)) {
+      throw new Error(`source should be a Object or Array , but got ${this.getDataType(source)}`);
+    }
+    if (this.getDataType(source) !== this.getDataType(comparison)) {
+      return true;
+    }
+    const sourceKeys = Object.keys(source);
+    const comparisonKeys = Object.keys({
+      ...source,
+      ...comparison
+    }).filter(key => !notIncludeKeys.includes(key));
+    if (sourceKeys.length !== comparisonKeys.length) {
+      return true;
+    }
+    return comparisonKeys.some(key => {
+      if (this.iterable(source[key])) {
+        return this.isObjectChanged(source[key], comparison[key], notIncludeKeys);
+      } else {
+        return source[key] !== comparison[key];
+      }
+    });
+  }
+  static isSameObject(source, comparison) {
+    let notIncludeKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    if (!source || !comparison) return false;
+    return !this.isObjectChanged(source, comparison, notIncludeKeys);
+  }
+}
+_ObjectUtils = ObjectUtils;
+(0, _defineProperty2.default)(ObjectUtils, "isObject", data => {
+  return _ObjectUtils.getDataType(data) === 'Object';
+});
+(0, _defineProperty2.default)(ObjectUtils, "hasProperty", (obj, prop) => {
+  if (!obj) return false;
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+});
+var _default = exports.default = ObjectUtils;

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

@@ -0,0 +1,309 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRebase = exports.canMerge = void 0;
+var _constants = require("../constants");
+var _constants2 = require("../extension/constants");
+var _helpers = require("../node-id/helpers");
+var _diff = require("./diff");
+var _objectUtils = _interopRequireDefault(require("./object-utils"));
+const expandGroup = content => {
+  if ([_constants2.ELEMENT_TYPE.UNORDERED_LIST, _constants2.ELEMENT_TYPE.ORDERED_LIST].includes(content.type)) {
+    return [{
+      ...content,
+      children: content.children.map(item => {
+        if (item.type === _constants2.ELEMENT_TYPE.GROUP) {
+          return expandGroup(item);
+        }
+        return item;
+      }).flat(1)
+    }];
+  }
+  return content.type === _constants2.ELEMENT_TYPE.GROUP ? content.children : [content];
+};
+const mergeChanges = changes => {
+  if (!Array.isArray(changes) || changes.length === 0) return changes;
+  let value = [];
+  let i = 0;
+  while (i < changes.length) {
+    const change = changes[i];
+    const lastChange = value[value.length - 1];
+    if (change && lastChange && change[_constants.REBASE_MARK_KEY.MODIFY_TYPE] === _constants.MODIFY_TYPE.ADD && lastChange[_constants.REBASE_MARK_KEY.MODIFY_TYPE] === _constants.MODIFY_TYPE.DELETE) {
+      value = value.slice(0, value.length - 1);
+      lastChange[_constants.REBASE_MARK_KEY.MODIFY_TYPE] && delete lastChange[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+      change[_constants.REBASE_MARK_KEY.MODIFY_TYPE] && delete change[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+      value.push({
+        id: change.id.endsWith('_group') ? change.id : change.id + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP,
+        [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.MODIFY,
+        children: expandGroup(change),
+        [_constants.REBASE_MARK_KEY.OLD_ELEMENT]: {
+          id: lastChange.id.endsWith('_group') ? lastChange.id : lastChange.id + '_group',
+          type: _constants2.ELEMENT_TYPE.GROUP,
+          children: expandGroup(lastChange)
+        }
+      });
+    } else {
+      value.push(change);
+    }
+    i++;
+  }
+  return value;
+};
+const getChanges = function (masterContent, revisionContent) {
+  let childrenName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
+  const {
+    map: masterContentMap,
+    ids: masterIds
+  } = (0, _diff.generateIdMapAndIds)(masterContent[childrenName]);
+  const {
+    map: currentContentMap,
+    ids: currentIds
+  } = (0, _diff.generateIdMapAndIds)(revisionContent[childrenName]);
+  const idDiffs = (0, _diff.getIdDiffs)(masterIds, currentIds);
+  let content = [];
+  idDiffs.forEach(idDiff => {
+    const {
+      value,
+      added,
+      removed
+    } = idDiff;
+    if (added) {
+      // merge consecutive identical operations
+      content.push({
+        id: value[0] + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP,
+        [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.ADD,
+        children: value.map(item => currentContentMap[item])
+      });
+    } else if (removed) {
+      // merge consecutive identical operations
+      content.push({
+        id: value[0] + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP,
+        [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.DELETE,
+        children: value.map(item => masterContentMap[item])
+      });
+    } else {
+      value.forEach(elementId => {
+        if (_objectUtils.default.isSameObject(masterContentMap[elementId], currentContentMap[elementId])) {
+          content.push(currentContentMap[elementId]);
+        } else {
+          const oldElement = masterContentMap[elementId];
+          const currentElement = currentContentMap[elementId];
+          let newElement = {
+            ...currentElement,
+            [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.MODIFY,
+            [_constants.REBASE_MARK_KEY.OLD_ELEMENT]: oldElement
+          };
+          if (currentElement.type === oldElement.type) {
+            const elementType = currentElement.type;
+            if ([_constants2.ELEMENT_TYPE.UNORDERED_LIST, _constants2.ELEMENT_TYPE.ORDERED_LIST].includes(elementType)) {
+              const listContent = getChanges(oldElement, currentElement);
+              newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE] = _constants.MODIFY_TYPE.CHILDREN_MODIFY;
+              newElement['children'] = listContent;
+            }
+          }
+          content.push(newElement);
+        }
+      });
+    }
+  });
+  return mergeChanges(content);
+};
+const getMergeElement = (diffElement, baseElement) => {
+  const modifyType = diffElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+  const newElement = {
+    ...diffElement
+  };
+  newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE] && delete newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+
+  // revision does not have this element, master has this element
+  if (modifyType === _constants.MODIFY_TYPE.DELETE) {
+    // base content does not have this element, indicating that it is newly added by master and needs to be retained, and will not be counted as a conflict.
+    if (!baseElement) return expandGroup(newElement);
+
+    // base content has this element, master modified it, indicating that revision deleted it, and the user manually selected the conflict
+    if (!_objectUtils.default.isSameObject(baseElement, diffElement, [_constants.REBASE_MARK_KEY.MODIFY_TYPE])) {
+      newElement[_constants.REBASE_MARK_KEY.REBASE_TYPE] = _constants.REBASE_TYPE.MODIFY_DELETE;
+      return [newElement];
+    }
+
+    // base content has this element, but master has not modified it. It means that revision has deleted it and the program has deleted it. The conflict will not be counted.
+    return [];
+  }
+
+  // revision has this element, master does not have this element
+  if (modifyType === _constants.MODIFY_TYPE.ADD) {
+    // base content does not have this element, indicating that it is newly added by revision and needs to be retained, and will not be counted as a conflict.
+    if (!baseElement) return expandGroup(newElement);
+
+    // master deleted it, revision modified it, and the user manually selected the conflict
+    if (!_objectUtils.default.isSameObject(baseElement, diffElement, [_constants.REBASE_MARK_KEY.MODIFY_TYPE])) {
+      newElement[_constants.REBASE_MARK_KEY.REBASE_TYPE] = _constants.REBASE_TYPE.DELETE_MODIFY;
+      return [newElement];
+    }
+
+    // master deleted it, revision did not modify it, the program deleted it, and the conflict is not counted.
+    return [];
+  }
+
+  // Elements that differ between revision and master
+  if (modifyType === _constants.MODIFY_TYPE.MODIFY) {
+    const masterElement = {
+      ...diffElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT]
+    };
+    delete newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
+
+    // revision and master both add a new element, but the content is different. ===》 At present, this situation does not exist, it only exists in the theoretical stage.
+    if (!baseElement) {
+      return [{
+        ...(0, _helpers.replaceNodeId)(masterElement),
+        [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+        [_constants.REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
+        [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.OTHER
+      }, {
+        ...newElement,
+        [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+        [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.MY
+      }];
+    }
+
+    // master is the same as base, indicating that revision has modified the content
+    if (_objectUtils.default.isSameObject(masterElement, baseElement)) return [newElement];
+
+    // revision is the same as base, indicating that master has modified the content
+    if (_objectUtils.default.isSameObject(newElement, baseElement)) return [masterElement];
+
+    // They are all different. Revision and master were modified at the same time. If there is a conflict, the conflict needs to be resolved manually.
+    return [{
+      ...(0, _helpers.replaceNodeId)(masterElement),
+      [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+      [_constants.REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
+      [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.OTHER
+    }, {
+      ...newElement,
+      [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+      [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.MY
+    }];
+  }
+  if (modifyType === _constants.MODIFY_TYPE.CHILDREN_MODIFY) {
+    const masterElement = {
+      ...diffElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT]
+    };
+    delete newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
+
+    // revision and master both add a new element, but the content is different. ===》 At present, this situation does not exist, it only exists in the theoretical stage.
+    if (!baseElement) {
+      return [{
+        ...(0, _helpers.replaceNodeId)(masterElement),
+        [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+        [_constants.REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
+        [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.OTHER
+      }, {
+        ...newElement,
+        [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+        [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.MY
+      }];
+    }
+    if (_objectUtils.default.isSameObject(masterElement, baseElement)) return expandGroup(newElement);
+    if (_objectUtils.default.isSameObject(newElement, baseElement)) return [masterElement];
+    if (_objectUtils.default.isSameObject(masterElement, newElement, ['type'])) {
+      if (_objectUtils.default.isSameObject(masterElement, baseElement, ['type'])) return expandGroup(newElement);
+      if (_objectUtils.default.isSameObject(newElement, baseElement, ['type'])) return [masterElement];
+    }
+
+    // The content of the subnode has changed and needs to be solved manually.
+    const childrenContent = getMergeContent(baseElement, diffElement.children);
+    return [{
+      ...newElement,
+      children: childrenContent
+    }];
+  }
+  newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT] && delete newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
+  return expandGroup(newElement);
+};
+const getMergeContent = function (baseContent, diffChanges) {
+  let childrenName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
+  const {
+    map: diffChangesContentMap,
+    ids: diffChangesContentIds
+  } = (0, _diff.generateIdMapAndIds)(diffChanges);
+  const {
+    map: baseContentMap
+  } = (0, _diff.generateIdMapAndIds)(baseContent[childrenName]);
+  let content = [];
+  diffChangesContentIds.forEach(elementId => {
+    const diffElement = diffChangesContentMap[elementId];
+    const baseElement = baseContentMap[elementId];
+    const mergeElements = getMergeElement(diffElement, baseElement);
+    content.push(...mergeElements);
+  });
+  return content;
+};
+const canMerge = (content, reference) => {
+  if (!Array.isArray(reference) || reference.length === 0) return true;
+  const {
+    map: referenceMap
+  } = (0, _diff.generateIdMapAndIds)(reference);
+  let flag = true;
+  for (let i = 0; i < content.length; i++) {
+    const element = content[i];
+    let referenceElement = referenceMap[element.id];
+    if (!referenceElement) {
+      flag = false;
+      break;
+    }
+    flag = canMerge(element.children, referenceElement.children);
+    if (flag === false) {
+      break;
+    }
+  }
+  return flag;
+};
+exports.canMerge = canMerge;
+const updateContentToFormatVersion4 = content => {
+  if (content.format_version === 4) return;
+  content.format_version = 4;
+  content.elements = content.children;
+  delete content['children'];
+};
+
+// Only the data in baseContent needs to be formatted.
+// The data in the other two does not need to be formatted. They are directly obtained from sdoc-server.
+const getRebase = (masterContent, baseContent, revisionContent) => {
+  updateContentToFormatVersion4(baseContent);
+
+  // master no changes, merged directly
+  if (masterContent.version === baseContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: true,
+      value: revisionContent
+    };
+  }
+
+  // The revision content has not changed
+  if (baseContent.version === revisionContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: false,
+      value: masterContent
+    };
+  }
+  const diffChanges = getChanges(masterContent, revisionContent, 'elements');
+  const content = getMergeContent(baseContent, diffChanges, 'elements');
+  return {
+    canMerge: canMerge(content, revisionContent.elements),
+    isNeedReplaceMaster: true,
+    value: {
+      ...revisionContent,
+      elements: content,
+      version: Math.max(masterContent.version, revisionContent.version) + 1
+    }
+  };
+};
+exports.getRebase = getRebase;

package/dist/components/error-boundary/error-page.css

@@ -0,0 +1,16 @@
+.error-page {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  overflow: hidden;
+}
+
+.error-page .error-tip {
+  color: red;
+}
+
+.error-page .error-button {
+  margin-top: 20px;
+}

package/dist/components/error-boundary/error-page.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactI18next = require("react-i18next");
+var _reactstrap = require("reactstrap");
+var _basicSdk = require("../../basic-sdk");
+require("./error-page.css");
+function ErrorPage(_ref) {
+  let {
+    t
+  } = _ref;
+  const normalizeSdoc = (0, _react.useCallback)(async () => {
+    const res = await _basicSdk.context.normalizeSdocContent();
+    const {
+      success
+    } = res.data;
+    if (success) {
+      // eslint-disable-next-line no-restricted-globals
+      location.reload(true);
+    }
+  }, []);
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: "error-page"
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    className: "error-tip"
+  }, t('Sdoc_error_tip')), /*#__PURE__*/_react.default.createElement(_reactstrap.Button, {
+    className: "error-button",
+    onClick: () => normalizeSdoc()
+  }, t('Repair')));
+}
+var _default = exports.default = (0, _reactI18next.withTranslation)('sdoc-editor')(ErrorPage);

package/dist/components/error-boundary/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _errorPage = _interopRequireDefault(require("./error-page"));
+class ErrorBoundary extends _react.PureComponent {
+  constructor(props) {
+    super(props);
+    this.state = {
+      hasError: false
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.log(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      return /*#__PURE__*/_react.default.createElement(_errorPage.default, null);
+    }
+    return this.props.children;
+  }
+}
+exports.default = ErrorBoundary;

package/dist/components/modal-header/index.css

@@ -0,0 +1,18 @@
+.sdoc-add-link-close-icon {
+  border-radius: 3px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  height: 28px;
+  width: 28px;
+}
+
+.sdoc-add-link-close-icon .sdocfont {
+  font-size: 18px;
+  font-weight: 600;
+  color: #666;
+}
+
+.sdoc-add-link-close-icon:hover {
+  background-color: #efefef;
+}

package/dist/components/modal-header/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = SdocModalHeader;
+var _react = _interopRequireDefault(require("react"));
+var _reactstrap = require("reactstrap");
+require("./index.css");
+function SdocModalHeader(_ref) {
+  let {
+    toggle,
+    children
+  } = _ref;
+  let close = null;
+  if (toggle) {
+    close = /*#__PURE__*/_react.default.createElement("span", {
+      className: "sdoc-add-link-close-icon",
+      onClick: toggle
+    }, /*#__PURE__*/_react.default.createElement("i", {
+      className: "sdocfont sdoc-sm-close",
+      "aria-hidden": "true"
+    }));
+  }
+  return /*#__PURE__*/_react.default.createElement(_reactstrap.ModalHeader, {
+    close: close
+  }, children);
+}