@seafile/sea-email-editor 0.0.5 → 0.0.7

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

@@ -0,0 +1,23 @@
+"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");
+const hrRule = element => {
+  if (element.nodeName === 'HR') {
+    return {
+      id: _slugid.default.nice(),
+      type: _constants.DIVIDER,
+      children: [{
+        id: _slugid.default.nice(),
+        text: ''
+      }]
+    };
+  }
+  return;
+};
+var _default = exports.default = hrRule;

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

@@ -16,5 +16,6 @@ var _table = _interopRequireDefault(require("./table"));
 var _text = _interopRequireDefault(require("./text"));
 var _br = _interopRequireDefault(require("./br"));
 var _p = _interopRequireDefault(require("./p"));
-const rules = [_blockquote.default, _codeBlock.default, _header.default, _image.default, _link.default, _list.default, _table.default, _paragraph.default, _text.default, _br.default, _p.default];
+var _hr = _interopRequireDefault(require("./hr"));
+const rules = [_blockquote.default, _codeBlock.default, _header.default, _image.default, _link.default, _list.default, _table.default, _paragraph.default, _text.default, _br.default, _p.default, _hr.default];
 var _default = exports.default = rules;

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

@@ -33,23 +33,49 @@ const listRule = (element, parseChild) => {
     };
     return (0, _helper.mergeElementOther2SlateNode)(element, node);
   }
-  if (nodeName === 'LI' && firstChild && PARAGRAPH_TAGS.includes(firstChild.nodeName)) {
-    const node = {
-      id: _slugid.default.nice(),
-      type: _constants.LIST_ITEM,
-      children: parseChild(childNodes)
+  if (nodeName === 'LI') {
+    const parsedChildren = parseChild(childNodes);
+    const normalizedChildren = Array.isArray(parsedChildren) ? parsedChildren : parsedChildren ? [parsedChildren] : [];
+    const listItemChildren = [];
+    let inlineChildren = [];
+    const appendInlineParagraph = () => {
+      if (inlineChildren.length === 0) return;
+      listItemChildren.push({
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: inlineChildren
+      });
+      inlineChildren = [];
     };
-    return (0, _helper.mergeElementOther2SlateNode)(element, node);
-  }
-  if (nodeName === 'LI' && firstChild && !PARAGRAPH_TAGS.includes(firstChild.nodeName)) {
+    normalizedChildren.forEach(child => {
+      if (!child) return;
+      const isInlineNode = !child.type || _constants.INLINE_LEVEL_TYPES.includes(child.type);
+      if (isInlineNode) {
+        inlineChildren.push(child);
+        return;
+      }
+      appendInlineParagraph();
+      listItemChildren.push(child);
+    });
+    appendInlineParagraph();
+    if (listItemChildren.length === 0) {
+      listItemChildren.push({
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: [(0, _core.generateDefaultText)()]
+      });
+    } else if ([_constants.UNORDERED_LIST, _constants.ORDERED_LIST].includes(listItemChildren[0].type)) {
+      // Ensure nested list item content starts with a paragraph.
+      listItemChildren.unshift({
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: [(0, _core.generateDefaultText)()]
+      });
+    }
     const node = {
       id: _slugid.default.nice(),
       type: _constants.LIST_ITEM,
-      children: [{
-        id: _slugid.default.nice(),
-        type: _constants.PARAGRAPH,
-        children: parseChild(childNodes)
-      }]
+      children: listItemChildren
     };
     return (0, _helper.mergeElementOther2SlateNode)(element, node);
   }

package/dist/slate-convert/index.js

@@ -10,6 +10,12 @@ Object.defineProperty(exports, "deserializeHtml", {
     return _htmlToSlate.default;
   }
 });
+Object.defineProperty(exports, "mdStringToSlate", {
+  enumerable: true,
+  get: function () {
+    return _mdToSlate.default;
+  }
+});
 Object.defineProperty(exports, "slateToHtml", {
   enumerable: true,
   get: function () {
@@ -17,4 +23,5 @@ Object.defineProperty(exports, "slateToHtml", {
   }
 });
 var _slateToHtml = _interopRequireDefault(require("./slate-to-html"));
-var _htmlToSlate = _interopRequireDefault(require("./html-to-slate"));
+var _htmlToSlate = _interopRequireDefault(require("./html-to-slate"));
+var _mdToSlate = _interopRequireDefault(require("./md-to-slate"));

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

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _unified = require("unified");
+var _remarkParse = _interopRequireDefault(require("remark-parse"));
+var _remarkGfm = _interopRequireDefault(require("remark-gfm"));
+var _remarkMath = _interopRequireDefault(require("remark-math"));
+var _core = require("../../extension/core");
+var _transform = require("./transform");
+// md string -> md ast
+const getProcessor = () => {
+  const processor = (0, _unified.unified)().use(_remarkParse.default) // Handles markdown basic syntax
+  .use(_remarkGfm.default) // Handle markdown extension syntax
+  .use(_remarkMath.default); // Handles markdown math formulas
+
+  return processor;
+};
+const reconciledSlateNodes = nodes => {
+  return nodes;
+};
+
+// md string --> md ast --> slate ast
+// https://github.com/syntax-tree/mdast
+const mdStringToSlate = mdString => {
+  if (!mdString) return [(0, _core.generateDefaultParagraph)()];
+  let content = mdString;
+  if (typeof mdString === 'number') {
+    content = mdString + '';
+  }
+
+  // md string --> md ast
+  const root = getProcessor().parse(content);
+
+  // the mdString is '\r\n'
+  if (root.children.length === 0) {
+    return [(0, _core.generateDefaultParagraph)()];
+  }
+
+  // md ast --> slate ast
+  const slateNodes = (0, _transform.formatMdToSlate)(root.children);
+
+  // Format the document
+  return reconciledSlateNodes(slateNodes);
+};
+var _default = exports.default = mdStringToSlate;

package/dist/slate-convert/md-to-slate/transform.js

@@ -0,0 +1,451 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformUnorderedList = exports.transformTableRow = exports.transformTableCell = exports.transformTable = exports.transformParagraph = exports.transformOrderedList = exports.transformMath = exports.transformListItem = exports.transformListContent = exports.transformList = exports.transformHtml = exports.transformHr = exports.transformHeader = exports.transformCodeLine = exports.transformCodeBlock = exports.transformCheckListItem = exports.transformCheckList = exports.transformBlockquote = exports.transformBlockHtml = exports.formatMdToSlate = void 0;
+var _slugid = _interopRequireDefault(require("slugid"));
+var _core = require("../../extension/core");
+var _elementTypes = require("../../extension/constants/element-types");
+var _htmlToSlate = _interopRequireDefault(require("../html-to-slate"));
+const INLINE_KEY_MAP = {
+  strong: 'bold',
+  emphasis: 'italic'
+};
+
+// <strong><em>aa<em>bb<em></strong>
+const applyMarkForInlineItem = function (result, item) {
+  let textNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+    type,
+    children,
+    value
+  } = item;
+  if (type === _elementTypes.LINK) {
+    const child = children.length === 0 ? {
+      type: 'text',
+      value: ''
+    } : children[0];
+    const linkChildren = [{
+      id: _slugid.default.nice(),
+      text: child.value || ''
+    }];
+    const link = {
+      id: _slugid.default.nice(),
+      type: _elementTypes.LINK,
+      url: item.url,
+      title: item.title,
+      children: linkChildren
+    };
+    result.push([(0, _core.generateDefaultText)(), link, (0, _core.generateDefaultText)()]);
+    return result;
+  }
+  if (type === _elementTypes.IMAGE) {
+    const data = {
+      src: item.url,
+      ...(item.title && {
+        title: item.title
+      }),
+      ...(item.alt && {
+        alt: item.alt
+      }),
+      ...(item.width && {
+        width: item.width
+      }),
+      ...(item.height && {
+        height: item.height
+      })
+    };
+    const image = {
+      id: _slugid.default.nice(),
+      data: data,
+      type: _elementTypes.IMAGE,
+      children: [(0, _core.generateDefaultText)()]
+    };
+    result.push([(0, _core.generateDefaultText)(), image, (0, _core.generateDefaultText)()]);
+    return result;
+  }
+
+  // Handle special images
+  if (type === 'html') {
+    const nodes = transformHtml(item);
+    result.push(nodes);
+    return result;
+  }
+  if (!textNode.id) {
+    textNode['id'] = _slugid.default.nice();
+  }
+  if (type === 'text') {
+    // https://symbl.cc/en/200B/
+    const formatValue = value && value !== '​' ? value : '';
+    textNode['text'] = formatValue;
+    result.push({
+      ...textNode
+    });
+
+    // reset testNode
+    textNode = {};
+    return;
+  }
+  if (type === 'inlineCode') {
+    textNode['code'] = true;
+    textNode['text'] = value || '';
+    result.push({
+      ...textNode
+    });
+
+    // reset testNode
+    textNode = {};
+    return;
+  }
+  const attr_key = INLINE_KEY_MAP[type];
+  if (!Array.isArray(children) || children.length === 0 || !attr_key) {
+    textNode['text'] = value || '';
+    result.push({
+      ...textNode
+    });
+
+    // reset testNode
+    textNode = {};
+    return;
+  }
+  textNode[attr_key] = true;
+  children.forEach(item => {
+    applyMarkForInlineItem(result, item, {
+      ...textNode
+    });
+  });
+};
+const transformNodeWithInlineChildren = node => {
+  const {
+    children
+  } = node;
+  const defaultChildren = [(0, _core.generateDefaultText)()];
+  if (!children || !Array.isArray(children) || children.length === 0) {
+    return defaultChildren;
+  }
+  const result = [];
+  children.forEach(item => applyMarkForInlineItem(result, item));
+  return result.flat();
+};
+const transformHeader = node => {
+  const {
+    depth
+  } = node;
+  const type = `${_elementTypes.HEADER}${depth}`;
+  return {
+    id: _slugid.default.nice(),
+    type: type,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+exports.transformHeader = transformHeader;
+const transformParagraph = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+exports.transformParagraph = transformParagraph;
+const transformBlockquote = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.BLOCKQUOTE,
+    children: Array.isArray(children) && children.length > 0 ? children.map(child => {
+      const handler = elementHandlers[child.type];
+      return handler(child); // flat
+    }).flat() : [{
+      id: _slugid.default.nice(),
+      type: _elementTypes.PARAGRAPH,
+      children: [{
+        id: _slugid.default.nice(),
+        text: ''
+      }]
+    }]
+  };
+};
+exports.transformBlockquote = transformBlockquote;
+const transformListContent = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+exports.transformListContent = transformListContent;
+const transformListItem = node => {
+  const {
+    children
+  } = node;
+  if (children.length === 0) {
+    return {
+      id: _slugid.default.nice(),
+      type: _elementTypes.LIST_ITEM,
+      // eslint-disable-next-line array-callback-return
+      children: [transformListContent({})]
+    };
+  }
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.LIST_ITEM,
+    // eslint-disable-next-line array-callback-return
+    children: children.map(child => {
+      if (child.type === _elementTypes.PARAGRAPH) {
+        return transformListContent(child);
+      } else if (child.type === 'code') {
+        return transformCodeBlock(child);
+      } else if (child.type === 'blockquote') {
+        return transformBlockquote(child);
+      } else if (child.type === 'list') {
+        const hasParent = true;
+        return transformList(child, hasParent);
+      } else if (child.type === 'heading') {
+        return transformParagraph(child);
+      } else if (child.type === 'html') {
+        // patch
+        return transformBlockHtml(child);
+      } else if (child.type === 'thematicBreak') {
+        // patch
+        return transformParagraph(child);
+      } else {
+        console.warn('Unhandled child type in list item:', child);
+        return (0, _core.generateDefaultParagraph)();
+      }
+    }).flat()
+  };
+};
+exports.transformListItem = transformListItem;
+const transformOrderedList = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.ORDERED_LIST,
+    children: children.map(child => transformListItem(child))
+  };
+};
+exports.transformOrderedList = transformOrderedList;
+const transformUnorderedList = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.UNORDERED_LIST,
+    children: children.map(child => transformListItem(child))
+  };
+};
+exports.transformUnorderedList = transformUnorderedList;
+const transformCheckListItem = node => {
+  const {
+    children,
+    checked
+  } = node;
+  if (children.length === 0) {
+    return {
+      id: _slugid.default.nice(),
+      type: _elementTypes.CHECK_LIST_ITEM,
+      checked: checked ? true : false,
+      children: transformNodeWithInlineChildren({})
+    };
+  }
+  if (children.length === 1) {
+    return {
+      id: _slugid.default.nice(),
+      type: _elementTypes.CHECK_LIST_ITEM,
+      checked: checked ? true : false,
+      children: children.map(child => transformNodeWithInlineChildren(child)).flat()
+    };
+  }
+  const [child, ...reset] = children;
+  const firstChild = {
+    id: _slugid.default.nice(),
+    type: _elementTypes.CHECK_LIST_ITEM,
+    checked: checked,
+    children: transformNodeWithInlineChildren(child)
+  };
+  const resetChildren = formatMdToSlate(reset);
+  return [firstChild, ...resetChildren];
+};
+exports.transformCheckListItem = transformCheckListItem;
+const transformCheckList = node => {
+  const {
+    children
+  } = node;
+  return children.map(child => transformCheckListItem(child)).flat();
+};
+exports.transformCheckList = transformCheckList;
+const transformList = (node, hasParent) => {
+  const {
+    ordered,
+    children
+  } = node;
+  const firstChild = children[0];
+  if (ordered === true) {
+    return transformOrderedList(node);
+  }
+  if (ordered === false && firstChild.checked === null) {
+    return transformUnorderedList(node);
+  }
+  // patch tasklist in list
+  if (hasParent) {
+    return transformUnorderedList(node);
+  }
+  return transformCheckList(node);
+};
+exports.transformList = transformList;
+const transformTableCell = (cell, align) => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.TABLE_CELL,
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+exports.transformTableCell = transformTableCell;
+const transformTableRow = row => {
+  const {
+    children: cells
+  } = row;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.TABLE_ROW,
+    children: cells.map(cell => transformTableCell(cell))
+  };
+};
+exports.transformTableRow = transformTableRow;
+const transformTable = node => {
+  const {
+    children: rows,
+    align = []
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.TABLE,
+    align: align,
+    children: rows.map((row, index) => transformTableRow(row))
+  };
+};
+exports.transformTable = transformTable;
+const transformCodeLine = text => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.CODE_LINE,
+    children: [{
+      id: _slugid.default.nice(),
+      text: text
+    }]
+  };
+};
+exports.transformCodeLine = transformCodeLine;
+const transformCodeBlock = node => {
+  const {
+    lang,
+    value
+  } = node;
+  let children = value.split('\n');
+  if (children.length === 0) {
+    children = [''];
+  }
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.CODE_BLOCK,
+    lang: lang,
+    children: children.map(text => transformCodeLine(text))
+  };
+};
+exports.transformCodeBlock = transformCodeBlock;
+const transformHr = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.DIVIDER,
+    children: [(0, _core.generateDefaultText)()]
+  };
+};
+exports.transformHr = transformHr;
+const transformHtml = node => {
+  const defaultTextNode = (0, _core.generateDefaultText)();
+  if (node.value.slice(0, 4).toLowerCase() === '<img') {
+    const {
+      body
+    } = new DOMParser().parseFromString(node.value, 'text/html');
+    const img = body.firstChild;
+    const src = img.getAttribute('src');
+    if (!src) return [defaultTextNode];
+    const alt = img.getAttribute('alt');
+    const title = img.getAttribute('title');
+    const width = img.getAttribute('width');
+    const height = img.getAttribute('height');
+    const data = {
+      src: src,
+      ...(alt && {
+        alt
+      }),
+      ...(title && {
+        title
+      }),
+      ...(!isNaN(width) && width > 0 && {
+        width
+      }),
+      ...(!isNaN(height) && height > 0 && {
+        height
+      })
+    };
+    const image = {
+      id: _slugid.default.nice(),
+      data: data,
+      type: _elementTypes.IMAGE,
+      children: [(0, _core.generateDefaultText)()]
+    };
+    return [(0, _core.generateDefaultText)(), image, (0, _core.generateDefaultText)()];
+  }
+  return [defaultTextNode];
+};
+exports.transformHtml = transformHtml;
+const transformBlockHtml = node => {
+  if (node.value.slice(0, 4).toLowerCase() === '<img') {
+    return {
+      id: _slugid.default.nice(),
+      type: _elementTypes.PARAGRAPH,
+      children: transformHtml(node)
+    };
+  }
+  return (0, _htmlToSlate.default)(node.value);
+};
+exports.transformBlockHtml = transformBlockHtml;
+const transformMath = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: 'formula',
+    data: {
+      formula: node.value
+    },
+    children: [(0, _core.generateDefaultText)()]
+  };
+};
+exports.transformMath = transformMath;
+const elementHandlers = {
+  'paragraph': transformParagraph,
+  'heading': transformHeader,
+  'blockquote': transformBlockquote,
+  'table': transformTable,
+  'list': transformList,
+  // ordered_list | unordered_list | check_list_item
+  'code': transformCodeBlock,
+  'thematicBreak': transformHr,
+  'math': transformMath,
+  'html': transformBlockHtml
+};
+const formatMdToSlate = children => {
+  const validChildren = children.filter(child => elementHandlers[child.type]);
+  return validChildren.map(child => {
+    const handler = elementHandlers[child.type];
+    return handler(child);
+  }).flat();
+};
+exports.formatMdToSlate = formatMdToSlate;

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

@@ -70,7 +70,8 @@ const ELEMENT_HTML_TAG = {
   [_constants.ElementTypes.LINK]: 'a',
   [_constants.ElementTypes.TABLE]: 'table',
   [_constants.ElementTypes.TABLE_ROW]: 'tr',
-  [_constants.ElementTypes.TABLE_CELL]: 'td'
+  [_constants.ElementTypes.TABLE_CELL]: 'td',
+  [_constants.ElementTypes.DIVIDER]: 'div'
 };
 const findElementByPath = (value, path) => {
   return path.reduce((element, pathIndex, currentIndex) => currentIndex === 0 ? element[pathIndex] : element === null || element === void 0 ? void 0 : element.children[pathIndex], value);
@@ -86,10 +87,13 @@ const element2Html = (value, element, path) => {
     style,
     children
   } = translateElement(value, element, path);
-  if (tag === 'img') {
+  if (type === _constants.ElementTypes.IMAGE) {
     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 (type === _constants.ElementTypes.DIVIDER) {
+    return `<div ${className}${style}><div style="width: 100%; height: 1px; background-color: #ccc; margin: 5px 0;"></div></div>`;
+  }
   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}>`;
@@ -143,7 +147,6 @@ const slateToHtml = value => {
   value.forEach((element, index) => {
     html += element2Html(value, element, [index]);
   });
-  console.log(html);
   return html;
 };
 var _default = exports.default = slateToHtml;

package/dist/utils/common.js

@@ -15,6 +15,7 @@ exports.isMac = isMac;
 const IMAGE_TYPES = exports.IMAGE_TYPES = ['png', 'jpg', 'gif'];
 const isImage = url => {
   if (!url) return false;
+  if (url.startsWith('data:image')) return true;
   if (!isUrl(url)) return false;
   const fileName = url.slice(url.lastIndexOf('/') + 1); // http://xx/mm/*.png
   const suffix = fileName.split('.')[1];

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@seafile/sea-email-editor",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "main": "dist/index.js",
   "dependencies": {
-    "@seafile/react-image-lightbox": "4.0.2",
+   "@seafile/react-image-lightbox": "^5.0.4",
     "classnames": "2.3.2",
     "copy-to-clipboard": "3.3.1",
     "deep-copy": "1.4.2",