@seafile/sea-email-editor 0.0.1

package/dist/slate-convert/html-to-slate/rules/table.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../constants");
+var _helper = require("../helper");
+const tableRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'TABLE') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.TABLE,
+      align: [],
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'THEAD' || nodeName === 'TBODY') {
+    return parseChild(childNodes);
+  }
+  if (nodeName === 'TR' && childNodes.length > 0) {
+    // patch
+    const children = Array.from(childNodes);
+    const hasTdOrTh = children.some(item => item.nodeName === 'TH' || item.nodeName === 'TD');
+    if (!hasTdOrTh) return;
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.TABLE_ROW,
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'TH' || nodeName === 'TD') {
+    const children = Array.from(childNodes);
+    const cellChildren = children.flatMap(child => {
+      // Replace paragraph node with text node
+      if (child.nodeName === 'P') {
+        const textContent = Array.from(child.childNodes).map(child => child.textContent).join('');
+        const node = {
+          id: _slugid.default.nice(),
+          type: 'text',
+          text: textContent
+        };
+        return (0, _helper.mergeElementOther2SlateNode)(child, node);
+      }
+      return parseChild([child]);
+    });
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.TABLE_CELL,
+      children: cellChildren
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = tableRule;

package/dist/slate-convert/html-to-slate/rules/text.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _helper = require("../helper");
+const textRule = (element, parseChild) => {
+  const {
+    nodeName,
+    nodeType
+  } = element;
+  if (nodeName === 'SPAN') {
+    const node = {
+      id: _slugid.default.nice(),
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'STRONG' || nodeName === 'B') {
+    const node = {
+      id: _slugid.default.nice(),
+      bold: true,
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'CODE' && element.parentElement.nodeName !== 'PRE') {
+    const node = {
+      id: _slugid.default.nice(),
+      code: true,
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'DEL') {
+    const node = {
+      id: _slugid.default.nice(),
+      delete: true,
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'I') {
+    const node = {
+      id: _slugid.default.nice(),
+      italic: true,
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'INS') {
+    const node = {
+      id: _slugid.default.nice(),
+      add: true,
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeType === 3) {
+    const node = {
+      id: _slugid.default.nice(),
+      text: element.textContent
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = textRule;

package/dist/slate-convert/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "deserializeHtml", {
+  enumerable: true,
+  get: function () {
+    return _htmlToSlate.default;
+  }
+});
+Object.defineProperty(exports, "slateToHtml", {
+  enumerable: true,
+  get: function () {
+    return _slateToHtml.default;
+  }
+});
+var _slateToHtml = _interopRequireDefault(require("./slate-to-html"));
+var _htmlToSlate = _interopRequireDefault(require("./html-to-slate"));

package/dist/slate-convert/slate-to-html/index.js

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _constants = require("../../extension/constants");
+const isContentValid = value => {
+  if (!value || !Array.isArray(value)) return false;
+  return true;
+};
+const isEmptyParagraph = node => {
+  const voidNodeTypes = ['image', 'formula'];
+  if (node.type !== _constants.ElementTypes.PARAGRAPH) return false;
+  if (node.type !== _constants.ElementTypes.P) return false;
+  const hasBlock = node.children.some(item => voidNodeTypes.includes(item.type));
+  const hasHtml = node.children.some(item => item.type === 'html');
+  if (hasBlock) return false;
+  if (hasHtml) return false;
+  if (_slate.Node.string(node).length !== 0) return false;
+  return true;
+};
+const translateElement = (value, element, path) => {
+  const {
+    className,
+    style = {}
+  } = element;
+  let customizeStyle = {
+    ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+    ...(style || {})
+  };
+  if (element.type === _constants.ElementTypes.TABLE_CELL) {
+    const tablePath = path.slice(0, -2);
+    const tableElement = findElementByPath(value, tablePath);
+    const tdIndex = path.at(-1);
+    const align = tableElement.align[tdIndex] || 'left';
+    customizeStyle['textAlign'] = align;
+  }
+  let styleString = Object.keys(customizeStyle).map(styleKey => `${styleKey.split(/(?=[A-Z])/).join('-').toLowerCase()}: ${customizeStyle[styleKey]};`).join('');
+  styleString = styleString ? ` style="${styleString}"` : '';
+  const classNameString = className ? ` class="${className}"` : '';
+  return {
+    ...element,
+    className: classNameString,
+    style: styleString
+  };
+};
+const ELEMENT_HTML_TAG = {
+  [_constants.ElementTypes.PARAGRAPH]: 'div',
+  [_constants.ElementTypes.P]: 'p',
+  [_constants.ElementTypes.BLOCKQUOTE]: 'blockquote',
+  [_constants.ElementTypes.HEADER1]: 'h1',
+  [_constants.ElementTypes.HEADER2]: 'h2',
+  [_constants.ElementTypes.HEADER3]: 'h3',
+  [_constants.ElementTypes.HEADER4]: 'h4',
+  [_constants.ElementTypes.HEADER5]: 'h5',
+  [_constants.ElementTypes.HEADER6]: 'h6',
+  [_constants.ElementTypes.UNORDERED_LIST]: 'ul',
+  [_constants.ElementTypes.ORDERED_LIST]: 'ol',
+  [_constants.ElementTypes.LIST_ITEM]: 'li',
+  [_constants.ElementTypes.CHECK_LIST_ITEM]: 'div',
+  [_constants.ElementTypes.CODE_BLOCK]: 'code',
+  [_constants.ElementTypes.CODE_LINE]: 'div',
+  [_constants.ElementTypes.IMAGE]: 'img',
+  [_constants.ElementTypes.LINK]: 'a',
+  [_constants.ElementTypes.TABLE]: 'table',
+  [_constants.ElementTypes.TABLE_ROW]: 'tr',
+  [_constants.ElementTypes.TABLE_CELL]: 'td'
+};
+const findElementByPath = (value, path) => {
+  return path.reduce((element, pathIndex) => element[pathIndex], value);
+};
+const element2Html = (value, element, path) => {
+  const {
+    type
+  } = element;
+  const tag = ELEMENT_HTML_TAG[type] || '';
+  const {
+    className,
+    style,
+    children
+  } = translateElement(value, element, path);
+  if (tag === 'img') {
+    var _element$data, _element$data2;
+    return `<img src="${element === null || element === void 0 ? void 0 : (_element$data = element.data) === null || _element$data === void 0 ? void 0 : _element$data.src}" width="${element === null || element === void 0 ? void 0 : element.data.width}" height="${element === null || element === void 0 ? void 0 : element.data.height}" alt="${(element === null || element === void 0 ? void 0 : (_element$data2 = element.data) === null || _element$data2 === void 0 ? void 0 : _element$data2.alt) || ''}" />`;
+  }
+  if (Array.isArray(children) && tag) {
+    const childrenDom = children.map((child, index) => element2Html(value, child, [...path, index])).join('');
+    if (tag === 'a') return `<${tag}${className}${style} href="${element.url}">${childrenDom}</${tag}>`;
+    if (tag === 'table') return `<${tag}${className}${style}><tbody>${childrenDom}</tbody></${tag}>`;
+    if (type === _constants.ElementTypes.CHECK_LIST_ITEM) {
+      const {
+        checked = false
+      } = element || {};
+      const inputDom = `<input type="checkbox" style="vertical-align: -2px;" checked=${checked} disabled=true />`;
+      return `<div${className}${style}><span style="margin-right: 6px;">${inputDom}</span><span>${childrenDom}</span></div>`;
+    }
+    if (type === _constants.ElementTypes.CODE_BLOCK) return `<div${className}${style}><pre><code>${childrenDom}</code></pre></div>`;
+    return `<${tag}${className}${style}>${childrenDom}</${tag}>`;
+  }
+  const {
+    text,
+    bold,
+    italic,
+    underline,
+    code
+  } = element;
+  let textDom = text;
+  if (bold) {
+    textDom = `<strong>${textDom}</strong>`;
+  }
+  if (italic) {
+    textDom = `<i>${textDom}</i>`;
+  }
+  if (underline) {
+    textDom = `<span style="text-decoration: underline;">${textDom}</span>`;
+  }
+  if (code) {
+    const {
+      style
+    } = translateElement(value, {
+      type: _constants.ElementTypes.CODE
+    }, path);
+    textDom = `<code${style}>${textDom}</code>`;
+  }
+  return textDom || '';
+};
+
+// slateNode -> html
+const slateToHtml = value => {
+  if (!isContentValid(value)) return '';
+  if (value.length === 0) return '';
+
+  // is only one empty paragraph child
+  if (value.length === 1 && isEmptyParagraph(value[0])) return '';
+  let html = '';
+  value.forEach((element, index) => {
+    html += element2Html(value, element, [index]);
+  });
+  return html;
+};
+var _default = exports.default = slateToHtml;

package/dist/utils/common.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isUrl = exports.isMobile = exports.isMac = exports.isImage = exports.isDocumentEmpty = exports.IMAGE_TYPES = void 0;
+var _isUrl = _interopRequireDefault(require("is-url"));
+var _slate = require("slate");
+const isMac = () => {
+  const platform = navigator.platform;
+  return platform === 'Mac68K' || platform === 'MacPPC' || platform === 'Macintosh' || platform === 'MacIntel';
+};
+exports.isMac = isMac;
+const IMAGE_TYPES = exports.IMAGE_TYPES = ['png', 'jpg', 'gif'];
+const isImage = url => {
+  if (!url) return false;
+  if (!isUrl(url)) return false;
+  const fileName = url.slice(url.lastIndexOf('/') + 1); // http://xx/mm/*.png
+  const suffix = fileName.split('.')[1];
+  if (!suffix) return false;
+  return IMAGE_TYPES.includes(suffix.toLowerCase());
+};
+exports.isImage = isImage;
+const isUrl = url => {
+  if (!url) return false;
+  if (!url.startsWith('http')) return false;
+  if (!(0, _isUrl.default)(url)) return false;
+  return true;
+};
+
+// Check document is empty or only contains void nodes
+exports.isUrl = isUrl;
+const isDocumentEmpty = editor => {
+  const document = editor.children;
+  const [firstChildNode] = document;
+  // Check if document has only one block node
+  const isWrapperEmpty = document.length === 1 && _slate.Node.string(firstChildNode).length === 0;
+  if (!isWrapperEmpty) return false;
+  // Check if the only one block node has only one text node with empty string
+  const hasVoidNode = firstChildNode.children.some(node => _slate.Editor.isVoid(editor, node));
+  if (hasVoidNode) return false;
+  return true;
+};
+exports.isDocumentEmpty = isDocumentEmpty;
+const isMobile = exports.isMobile = typeof window !== 'undefined' && (window.innerWidth < 768 || navigator.userAgent.toLowerCase().match(/(ipod|ipad|iphone|android|coolpad|mmp|smartphone|midp|wap|xoom|symbian|j2me|blackberry|wince)/i) != null);

package/dist/utils/deserialize-html.js

@@ -0,0 +1,219 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.htmlDeserializer = void 0;
+var _slateHyperscript = require("slate-hyperscript");
+var _elementTypes = require("../extension/constants/element-types");
+var _model = require("../extension/plugins/table/model");
+var _core = require("../extension/core");
+const ELEMENT_TAGS = {
+  A: el => ({
+    type: _elementTypes.LINK,
+    data: {
+      href: el.getAttribute('href')
+    }
+  }),
+  BLOCKQUOTE: () => ({
+    type: _elementTypes.BLOCKQUOTE
+  }),
+  H1: () => ({
+    type: _elementTypes.HEADER1
+  }),
+  H2: () => ({
+    type: _elementTypes.HEADER2
+  }),
+  H3: () => ({
+    type: _elementTypes.HEADER3
+  }),
+  H4: () => ({
+    type: _elementTypes.HEADER4
+  }),
+  H5: () => ({
+    type: _elementTypes.HEADER5
+  }),
+  H6: () => ({
+    type: _elementTypes.HEADER6
+  }),
+  IMG: el => ({
+    type: _elementTypes.IMAGE,
+    children: [{
+      text: ''
+    }],
+    data: {
+      src: el.getAttribute('src')
+    }
+  }),
+  LI: () => ({
+    type: _elementTypes.LIST_ITEM,
+    data: {}
+  }),
+  OL: () => ({
+    type: _elementTypes.ORDERED_LIST
+  }),
+  P: () => ({
+    type: _elementTypes.PARAGRAPH
+  }),
+  UL: () => ({
+    type: _elementTypes.UNORDERED_LIST
+  }),
+  TABLE: () => ({
+    type: _elementTypes.TABLE
+  }),
+  BR: () => ({
+    text: ''
+  })
+};
+const HEADER_LIST = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];
+const TEXT_TAGS = {
+  CODE: () => ({
+    CODE: true
+  }),
+  DEL: () => ({
+    DELETE: true
+  }),
+  EM: () => ({
+    ITALIC: true
+  }),
+  I: () => ({
+    ITALIC: true
+  }),
+  STRONG: () => ({
+    BOLD: true
+  }),
+  INS: () => ({
+    INS: true
+  })
+};
+const parseTable = el => {
+  if (el.parentNode.nodeName !== 'BODY') {
+    return null;
+  }
+  let tableWidth = 0;
+  Array.from(el.rows[0].childNodes).forEach((cell, index) => {
+    if (cell.nodeName === 'TD' || cell.nodeName === 'TH') {
+      tableWidth += Number(cell.getAttribute('colspan')) || 1;
+    }
+  });
+  let rowList = [];
+  for (let rowIndex = 0; rowIndex < el.rows.length; rowIndex++) {
+    let cells = el.rows[rowIndex].cells;
+    const cellsList = [];
+    for (let columnIndex = 0; columnIndex < cells.length; columnIndex++) {
+      const cell = cells[columnIndex];
+      cellsList.push((0, _model.generateTableCell)({
+        childrenOrText: [(0, _core.generateElement)(_elementTypes.PARAGRAPH, {
+          childrenOrText: cell.textContent
+        })]
+      }));
+    }
+    if (cellsList.length < tableWidth) {
+      let count = tableWidth - cellsList.length;
+      for (let i = 0; i < count; i++) {
+        cellsList.push((0, _model.generateTableCell)({
+          childrenOrText: [(0, _core.generateElement)(_elementTypes.PARAGRAPH)]
+        }));
+      }
+    }
+    rowList.push((0, _model.generateTableRow)({
+      childrenOrText: cellsList
+    }));
+  }
+  return rowList;
+};
+const deserializeHtml = el => {
+  if (el.nodeType === 3) {
+    // remove \n character
+    if (el.textContent === '\n' || el.textContent === '\r') {
+      return null;
+    }
+    if (el.parentElement.nodeName === 'BODY') {
+      let text = el.textContent.replace(/(\n|\r\n)/g, '');
+      if (text.length === 0) return null;
+      return {
+        type: _elementTypes.PARAGRAPH,
+        children: [{
+          text
+        }]
+      };
+    }
+    return el.textContent;
+  } else if (el.nodeType !== 1) {
+    return null;
+  }
+  const {
+    nodeName
+  } = el;
+  let parent = el;
+  let children = Array.from(parent.childNodes).map(deserializeHtml).flat();
+
+  // deserialize task list
+  if (nodeName === 'LI') {
+    if (el.className && el.className.indexOf('task-list-item') >= 0) {
+      return (0, _slateHyperscript.jsx)('element', {
+        data: {
+          checked: false
+        },
+        type: 'list_item'
+      }, children);
+    }
+  }
+  if (nodeName === 'PRE' && el.childNodes[0] && el.childNodes[0].nodeName === 'CODE') {
+    // deserialize code block
+    const code = el.childNodes[0];
+    const codeChildren = [];
+    code.childNodes.forEach((codeLine, index) => {
+      if (codeLine.innerText) {
+        codeChildren.push({
+          type: 'code_line',
+          children: [{
+            text: codeLine.innerText
+          }]
+        });
+      }
+    });
+    return {
+      data: {
+        syntax: null
+      },
+      children: codeChildren,
+      type: 'code_block'
+    };
+  }
+  if (el.nodeName === 'BODY') {
+    return (0, _slateHyperscript.jsx)('fragment', {}, children);
+  }
+  if (ELEMENT_TAGS[nodeName]) {
+    const attrs = ELEMENT_TAGS[nodeName](el);
+    if (nodeName === 'IMG') {
+      return (0, _slateHyperscript.jsx)('element', attrs, [{
+        text: ''
+      }]);
+    }
+
+    // modify BR into an empty text node
+    if (nodeName === 'BR') {
+      return '';
+    }
+    if (nodeName === 'TABLE') {
+      return (0, _slateHyperscript.jsx)('element', attrs, parseTable(el));
+    }
+    if (nodeName === 'A' || HEADER_LIST.includes(nodeName)) {
+      return (0, _slateHyperscript.jsx)('element', attrs, [{
+        text: el.textContent
+      }]);
+    }
+    return (0, _slateHyperscript.jsx)('element', attrs, children);
+  }
+  if (TEXT_TAGS[nodeName]) {
+    const attrs = TEXT_TAGS[nodeName](el);
+    return children.map(child => (0, _slateHyperscript.jsx)('text', attrs, child));
+  }
+  return children;
+};
+const htmlDeserializer = html => {
+  const parsed = new DOMParser().parseFromString(html, 'text/html');
+  return deserializeHtml(parsed.body);
+};
+exports.htmlDeserializer = htmlDeserializer;

package/dist/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;