@seafile/comment-editor 0.0.1-alpha.0

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

@@ -0,0 +1,328 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIdDiffs = exports.getDiff = exports.generateIdMapAndIds = void 0;
+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
+const IGNORE_KEYS = ['BOLD', 'ITALIC', 'bold', 'italic', 'columns', 'minHeight', 'min_height', 'language', 'white_space'];
+const generatorDiffTextElement = function (textElement, diffType) {
+  let style = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!textElement) return null;
+  if (!diffType) return textElement;
+  const id = textElement.id;
+  return {
+    ...textElement,
+    id: id || _slugid.default.nice(),
+    [diffType]: true,
+    ...style
+  };
+};
+
+// Depth facilitates each child node, adding diffType to each end node
+const generatorDiffElement = function (element, diffType) {
+  let 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 {
+    ...element,
+    [diffType]: true,
+    children: element.children.map(item => generatorDiffElement(item, diffType, style))
+  };
+};
+const generateIdMapAndIds = elements => {
+  let map = {};
+  let ids = [];
+  if (!Array.isArray(elements) || elements.length === 0) return {
+    map,
+    ids
+  };
+  elements.forEach(element => {
+    ids.push(element.id);
+    map[element.id] = element;
+  });
+  return {
+    map,
+    ids
+  };
+};
+exports.generateIdMapAndIds = generateIdMapAndIds;
+const hasChildren = element => {
+  if (!element) return false;
+  if (!Array.isArray(element.children) || element.children.length === 0) return false;
+  return true;
+};
+
+// id diffs
+const getIdDiffs = (oldIds, newIds) => {
+  const diff = new _diffText.default(oldIds, newIds);
+  return diff.getDiffs();
+};
+
+// text diffs
+exports.getIdDiffs = getIdDiffs;
+const getTextDiff = (element, oldElement, diff) => {
+  const newText = element.text;
+  const oldText = oldElement.text;
+  const textDiff = new _diffText.default(oldText || '', newText || '');
+  const textDiffs = textDiff.getDiffs();
+  let newChildren = [];
+  textDiffs.forEach((item, index) => {
+    const id = `${element.id || _slugid.default.nice()}-${index}`;
+    let elementItem = {
+      id,
+      text: item.value
+    };
+    if (item.added) {
+      diff.changes.push(id);
+      const commonChild = generatorDiffTextElement(elementItem, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE);
+      newChildren.push(commonChild);
+    } else if (item.removed) {
+      diff.changes.push(id);
+      const commonChild = generatorDiffTextElement(elementItem, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE);
+      newChildren.push(commonChild);
+    } else {
+      const commonChild = generatorDiffTextElement(elementItem);
+      newChildren.push(commonChild);
+    }
+  });
+  return newChildren;
+};
+const getCommonDiff = (element, oldElement, diff) => {
+  if (!hasChildren(element) && !hasChildren(oldElement)) {
+    const newChildren = getTextDiff(element, oldElement, diff);
+    return [{
+      ...element,
+      children: newChildren
+    }];
+  }
+  if (!hasChildren(element) || !hasChildren(oldElement)) {
+    const elementId = element.id || _slugid.default.nice();
+    diff.changes.push(`${elementId}_delete`);
+    return [generatorDiffElement({
+      ...oldElement,
+      id: `${elementId}_delete`
+    }, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE), generatorDiffElement({
+      ...element,
+      id: `${elementId}_add`
+    }, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE)];
+  }
+
+  // Content does not change
+  if (_objectUtils.default.isSameObject(element, oldElement, [...IGNORE_KEYS, 'type'])) {
+    return [element];
+  }
+
+  // Compare content
+  const {
+    children: currentChildren
+  } = element;
+  const {
+    children: oldChildren
+  } = oldElement;
+  const {
+    map: currentMap,
+    ids: currentIds
+  } = generateIdMapAndIds(currentChildren);
+  const {
+    map: oldMap,
+    ids: oldIds
+  } = generateIdMapAndIds(oldChildren);
+  const idDiffs = getIdDiffs(oldIds, currentIds);
+  let newChildren = [];
+  idDiffs.forEach(idDiff => {
+    const ids = idDiff.value;
+    const isAdded = idDiff.added;
+    const isDelete = idDiff.removed;
+    ids.forEach(id => {
+      const newChildrenElement = currentMap[id];
+      const 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) {
+              const textDiffs = getTextDiff(newChildrenElement, oldChildrenElement, diff);
+              newChildren.push(...textDiffs);
+            } else if (newChildrenElement.type === _constants.ELEMENT_TYPE.IMAGE) {
+              if (newChildrenElement.data.src === oldChildrenElement.data.src) {
+                newChildren.push(newChildrenElement);
+              } else {
+                newChildren.push(generatorDiffTextElement({
+                  ...element,
+                  id: element.id + '_add'
+                }, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE));
+                newChildren.push(generatorDiffTextElement({
+                  ...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) {
+                const diffElements = getCommonDiff(newChildrenElement, oldChildrenElement, diff);
+                newChildren.push(...diffElements);
+              } else if (newChildrenElement.href !== oldChildrenElement.href) {
+                diff.changes.push(oldChildrenElement.id + '_delete');
+                newChildren.push(generatorDiffTextElement({
+                  ...oldChildrenElement,
+                  id: oldChildrenElement.id + '_delete'
+                }, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE));
+                newChildren.push(generatorDiffTextElement({
+                  ...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) {
+              const newRows = getCommonDiff(newChildrenElement, oldChildrenElement, diff);
+              newChildren.push(...newRows);
+            } else {
+              const commonDiffs = getCommonDiff(newChildrenElement, oldChildrenElement, diff);
+              newChildren.push(...commonDiffs);
+            }
+          } else {
+            diff.changes.push(oldChildrenElement.id + '_delete');
+            newChildren.push(generatorDiffTextElement({
+              ...oldChildrenElement,
+              id: oldChildrenElement.id + '_delete'
+            }, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE));
+            newChildren.push(generatorDiffTextElement({
+              ...newChildrenElement,
+              id: newChildrenElement.id + '_add'
+            }, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE));
+          }
+        }
+      }
+    });
+  });
+  return [{
+    ...element,
+    children: newChildren
+  }];
+};
+const updateDiffValue = (diff, element, oldElement) => {
+  if (!diff || !element || !oldElement) return;
+  if (_objectUtils.default.isSameObject(element, oldElement, IGNORE_KEYS)) {
+    diff.value.push(element);
+    return;
+  }
+  const elements = getCommonDiff(element, oldElement, diff);
+  elements.forEach(item => {
+    // Changing empty characters to other characters
+    if (!item.add && item.children.find(child => child.add === true)) {
+      item.add = true;
+    }
+    diff.value.push(item);
+  });
+};
+
+/**
+ * params:
+    * currentValue: current version document content
+    * oldValue: last version document content
+ * return { value: [], change: [] }
+*/
+const getElementDiffValue = (currentContent, oldContent) => {
+  // init
+  let diff = {
+    value: [],
+    changes: []
+  };
+  const {
+    map: currentContentMap,
+    ids: currentIds
+  } = generateIdMapAndIds(currentContent);
+  const {
+    map: oldContentMap,
+    ids: oldIds
+  } = generateIdMapAndIds(oldContent);
+  const diffs = getIdDiffs(oldIds, currentIds);
+  diffs.forEach(diffItem => {
+    const elementIds = diffItem.value;
+    if (diffItem.removed) {
+      elementIds.forEach(elementId => {
+        diff.changes.push(elementId);
+        const element = oldContentMap[elementId];
+        const diffElement = generatorDiffElement(element, _constants.TEXT_STYLE_MAP.DELETE, _constants.DELETED_STYLE);
+        diff.value.push(diffElement);
+      });
+    } else if (diffItem.added) {
+      elementIds.forEach(elementId => {
+        diff.changes.push(elementId);
+        const element = currentContentMap[elementId];
+        const diffElement = generatorDiffElement(element, _constants.TEXT_STYLE_MAP.ADD, _constants.ADDED_STYLE);
+        diff.value.push(diffElement);
+      });
+    } else {
+      elementIds.forEach(elementId => {
+        const element = currentContentMap[elementId];
+        updateDiffValue(diff, element, oldContentMap[element.id]);
+      });
+    }
+  });
+  return diff;
+};
+
+/**
+ * params:
+    * currentValue: current version document
+    * oldValue: last version document
+ * return { value: [], change: [] }
+*/
+const getDiff = function () {
+  let currentValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+    elements: []
+  };
+  let 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: []
+  };
+  const {
+    version: currentVersion,
+    elements: currentContent
+  } = {
+    ...currentValue,
+    elements: (0, _documentUtils.normalizeChildren)(currentValue.elements)
+  };
+  const {
+    version: oldVersion,
+    elements: oldContent
+  } = {
+    ...oldValue,
+    elements: (0, _documentUtils.normalizeChildren)(oldValue.elements)
+  };
+  if (currentVersion === oldVersion) return {
+    value: currentContent,
+    changes: []
+  };
+  return getElementDiffValue(currentContent, oldContent);
+};
+exports.getDiff = getDiff;
+window.getIdDiffs = getIdDiffs;

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

@@ -0,0 +1,81 @@
+"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 _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"));
+const normalizeChildren = children => {
+  // text
+  if (!Array.isArray(children)) return children;
+
+  // element
+  if (Array.isArray(children) && children.length === 0) return [(0, _index.generateDefaultText)()];
+  return children.map(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;
+  });
+};
+exports.normalizeChildren = normalizeChildren;
+const normalizeCopyNodes = (editor, elements) => {
+  if (!Array.isArray(elements) || elements.length === 0) return [];
+  return elements.map(element => {
+    if (element.type === _constants.ELEMENT_TYPE.TABLE) {
+      return (0, _helpers.normalizeTableELement)(editor, element);
+    }
+    return element;
+  });
+};
+exports.normalizeCopyNodes = normalizeCopyNodes;
+const setOriginSdocKey = event => {
+  const docUuid = _context.default.getSetting('docUuid');
+  event.clipboardData.setData(`text/${_constants.CLIPBOARD_ORIGIN_SDOC_KEY}`, docUuid);
+};
+exports.setOriginSdocKey = setOriginSdocKey;
+const getSlateFragmentAttribute = dataTransfer => {
+  const catchSlateFragment = /data-slate-fragment="(.+?)"/m;
+  const htmlData = dataTransfer.getData('text/html');
+  const [, fragment] = htmlData.match(catchSlateFragment) || [];
+  return fragment;
+};
+exports.getSlateFragmentAttribute = getSlateFragmentAttribute;
+const generateDefaultDocContent = () => {
+  const defaultValue = {
+    version: 0,
+    elements: [{
+      id: 'aaaa',
+      type: 'paragraph',
+      children: [{
+        text: ''
+      }]
+    }]
+  };
+  return defaultValue;
+};
+
+// patch: update children to elements
+exports.generateDefaultDocContent = generateDefaultDocContent;
+const formatSdocContent = content => {
+  return {
+    ...content,
+    ...(!content.elements && {
+      elements: content.children
+    })
+  };
+};
+exports.formatSdocContent = formatSdocContent;

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class EventBus {
+  constructor() {
+    this.instance = null;
+    this.subscribers = {};
+  }
+  static getInstance() {
+    if (this.instance) return this.instance;
+    this.instance = new EventBus();
+    return this.instance;
+  }
+  subscribe(type, handler) {
+    if (!this.subscribers[type]) {
+      this.subscribers[type] = [];
+    }
+    const handlers = this.subscribers[type];
+    handlers.push(handler);
+    return () => {
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+      }
+    };
+  }
+  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];
+    }
+    const handlers = this.subscribers[type];
+    if (Array.isArray(handlers)) {
+      handlers.forEach(handler => handler(...data));
+    }
+  }
+}
+var _default = exports.default = EventBus;

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

@@ -0,0 +1,131 @@
+"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 _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../constants");
+var _constants2 = require("../extension/constants");
+var _queries = require("../extension/core/queries/");
+var _eventBus = _interopRequireDefault(require("../utils/event-bus"));
+var _documentUtils = require("./document-utils");
+class EventProxy {
+  constructor(_editor) {
+    (0, _defineProperty2.default)(this, "onKeyDown", event => {
+      const editor = this.editor;
+      if (editor.onHotKeyDown) {
+        const 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();
+        const {
+          history
+        } = editor;
+        if (history.redos.length === 0) {
+          return false;
+        }
+        editor.redo();
+      }
+
+      // undo
+      if ((0, _isHotkey.default)('mod+z', event)) {
+        event.preventDefault();
+        const {
+          history
+        } = editor;
+        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();
+        const eventBus = _eventBus.default.getInstance();
+        eventBus.dispatch(_constants.INTERNAL_EVENT.ON_PRINT);
+      }
+      const node = (0, _queries.getSelectedNodeByType)(editor, _constants2.ELEMENT_TYPE.TABLE);
+      if (node) {
+        this.editor.tableOnKeyDown(event);
+      }
+      const 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);
+        const eventBus = _eventBus.default.getInstance();
+        eventBus.dispatch(_constants.INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU);
+      }
+    });
+    (0, _defineProperty2.default)(this, "onCopy", event => {
+      if (this.editor.onCopy) this.editor.onCopy(event);
+      (0, _documentUtils.setOriginSdocKey)(event);
+    });
+    (0, _defineProperty2.default)(this, "onCut", event => {
+      (0, _documentUtils.setOriginSdocKey)(event);
+      if (this.editor.cut) {
+        this.editor.cut(event);
+      }
+    });
+    (0, _defineProperty2.default)(this, "onPaste", event => {});
+    (0, _defineProperty2.default)(this, "onCompositionStart", event => {
+      const editor = this.editor;
+      if (editor.onCompositionStart) {
+        const isHandled = editor.onCompositionStart(event);
+        if (isHandled) return;
+      }
+    });
+    (0, _defineProperty2.default)(this, "onCompositionUpdate", event => {
+      const editor = this.editor;
+      if (editor.onCompositionUpdate) {
+        const isHandled = editor.onCompositionUpdate(event);
+        if (isHandled) return;
+      }
+    });
+    (0, _defineProperty2.default)(this, "onCompositionEnd", event => {
+      const editor = this.editor;
+      if (editor.onCompositionEnd) {
+        const isHandled = editor.onCompositionEnd(event);
+        if (isHandled) return;
+      }
+    });
+    this.editor = _editor;
+  }
+}
+var _default = exports.default = EventProxy;

package/dist/basic-sdk/utils/full-width-mode.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStyleByFullWidthMode = exports.getContentStyleByFullModeStyle = void 0;
+var _constants = require("../constants");
+var _localStorageUtils = _interopRequireDefault(require("./local-storage-utils"));
+const getStyleByFullWidthMode = (scrollRef, editor) => {
+  const sdocStorage = _localStorageUtils.default.getItem(_constants.SDOC_STORAGE) || {};
+  const {
+    outlineOpen: isShowOutline
+  } = sdocStorage;
+  let containerStyle = {};
+  containerStyle['width'] = _constants.ARTICLE_FULL_WIDTH;
+  containerStyle['minWidth'] = _constants.ARTICLE_FULL_MIN_WIDTH;
+
+  // Has outline
+  if (isShowOutline && (editor === null || editor === void 0 ? void 0 : editor.editorType) !== _constants.WIKI_EDITOR) {
+    containerStyle['marginLeft'] = `${_constants.LEFT_OUTLINE_WIDTH}px`;
+    const adjustWidth = ` - ${_constants.LEFT_OUTLINE_WIDTH - 50}px`; // One side is 50
+    containerStyle['width'] = containerStyle['width'].slice(0, -1) + adjustWidth;
+  }
+  return containerStyle;
+};
+exports.getStyleByFullWidthMode = getStyleByFullWidthMode;
+const getContentStyleByFullModeStyle = () => {
+  if (_localStorageUtils.default.getItem(_constants.FULL_WIDTH_MODE)) {
+    return {
+      'minWidth': `${Number(_constants.ARTICLE_FULL_MIN_WIDTH.slice(0, -2))}px`
+    };
+  }
+  return {};
+};
+exports.getContentStyleByFullModeStyle = getContentStyleByFullModeStyle;