@seafile/sea-email-editor 0.0.1

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

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeElementOther2SlateNode = exports.genCodeLangs = exports.formatInlineNodes = void 0;
+const genCodeLangs = () => {
+  return [{
+    text: 'Plain Text',
+    value: 'plaintext'
+  }, {
+    text: 'Bash',
+    value: 'bash'
+  }, {
+    text: 'CSS',
+    value: 'css'
+  }, {
+    text: 'C',
+    value: 'c'
+  }, {
+    text: 'C++',
+    value: 'cpp'
+  }, {
+    text: 'C#',
+    value: 'csharp'
+  }, {
+    text: 'Go',
+    value: 'go'
+  }, {
+    text: 'HTML',
+    value: 'html'
+  }, {
+    text: 'Javascript',
+    value: 'javascript'
+  }, {
+    text: 'Java',
+    value: 'java'
+  }, {
+    text: 'PHP',
+    value: 'php'
+  }, {
+    text: 'Python',
+    value: 'python'
+  }, {
+    text: 'Ruby',
+    value: 'ruby'
+  }, {
+    text: 'SQL',
+    value: 'sql'
+  }, {
+    text: 'Swift',
+    value: 'swift'
+  }, {
+    text: 'Typescript',
+    value: 'typescript'
+  }, {
+    text: 'XML',
+    value: 'xml'
+  }];
+};
+exports.genCodeLangs = genCodeLangs;
+const formatInlineNodes = inlineNodes => {
+  if (!inlineNodes || !Array.isArray(inlineNodes) || inlineNodes.length === 0) return [];
+  const isAllTextNode = inlineNodes.every(inlineNode => {
+    const keys = Object.keys(inlineNode);
+    return keys.length === 2; // keys length is 2: node is text
+  });
+  if (!isAllTextNode) return inlineNodes;
+
+  // if elements is all text node, combine the elements
+  const newInlineNodes = [{
+    id: inlineNodes[0].id,
+    text: inlineNodes.reduce((ret, item) => ret + item.text, '')
+  }];
+  return newInlineNodes;
+};
+exports.formatInlineNodes = formatInlineNodes;
+const mergeElementOther2SlateNode = (element, slateNode) => {
+  if (!element || !slateNode) return {};
+  let newSlateNode = {
+    ...slateNode
+  };
+  if (element.className) {
+    newSlateNode.className = element.className;
+  }
+  if (element.style) {
+    const validStyles = {};
+    for (let i = 0; i < element.style.length; i++) {
+      const prop = element.style[i];
+      const value = element.style.getPropertyValue(prop);
+      if (value && value !== '' && value !== 'none') {
+        let validProp = prop;
+        let validProps = validProp.split('-');
+        if (validProps.length > 1) {
+          validProp = validProps.map((p, index) => index === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join('');
+        }
+        validStyles[validProp] = value;
+      }
+    }
+    if (Object.keys(validStyles).length > 0) {
+      newSlateNode.style = validStyles;
+    }
+  }
+  return newSlateNode;
+};
+exports.mergeElementOther2SlateNode = mergeElementOther2SlateNode;

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

@@ -0,0 +1,138 @@
+"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 _typeOf = _interopRequireDefault(require("type-of"));
+var _constants = require("./constants");
+var _rules = _interopRequireDefault(require("./rules"));
+var _helper = require("./helper");
+const cruftNewline = element => {
+  return !(element.nodeName === '#text' && element.nodeValue === '\n');
+};
+const deserializeElement = element => {
+  let node;
+  const next = elements => {
+    if (Object.prototype.toString.call(elements) === '[object NodeList]') {
+      elements = Array.from(elements);
+    }
+    switch ((0, _typeOf.default)(elements)) {
+      case 'array':
+        return deserializeElements(elements);
+      case 'object':
+        return deserializeElement(elements);
+      case 'null':
+      case 'undefined':
+        return;
+      default:
+        throw new Error(`The \`next\` argument was called with invalid children: "${elements}".`);
+    }
+  };
+  for (let i = 0; i < _rules.default.length; i++) {
+    const rule = _rules.default[i];
+    if (!rule) continue;
+    const ret = rule(element, next);
+    const type = (0, _typeOf.default)(ret);
+    if (type !== 'array' && type !== 'object' && type !== 'null' && type !== 'undefined') {
+      throw new Error(`A rule returned an invalid deserialized representation: "${node}".`);
+    }
+
+    // Not eligible for current component processing
+    if (ret === undefined) {
+      continue;
+    }
+
+    // Empty tags will be discarded and not converted accordingly
+    if (ret === null) {
+      return null;
+    }
+
+    // Assign the final processing result to node
+    node = ret;
+    break;
+  }
+
+  // If node is undefined, it means that the label is not processed, and continue to process the child nodes of the element
+  return node || next(element.childNodes);
+};
+const deserializeElements = function () {
+  let elements = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let isTopLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  let nodes = [];
+  elements.filter(cruftNewline).forEach(element => {
+    const node = deserializeElement(element);
+    switch ((0, _typeOf.default)(node)) {
+      case 'array':
+        const formatNode = isTopLevel ? formatElementNodes(node) : node;
+        nodes = nodes.concat(formatNode);
+        break;
+      case 'object':
+        nodes.push(node);
+        break;
+      default:
+      // nothing todo
+    }
+  });
+  return (0, _helper.formatInlineNodes)(nodes);
+};
+const formatElementNodes = nodes => {
+  if (nodes.length === 0) {
+    return [{
+      id: _slugid.default.nice(),
+      type: _constants.PARAGRAPH,
+      children: [{
+        text: '',
+        id: _slugid.default.nice()
+      }]
+    }];
+  }
+  nodes = nodes.reduce((memo, node) => {
+    if (_constants.TOP_LEVEL_TYPES.includes(node.type)) {
+      memo.push(node);
+    }
+    if (node.type === _constants.LIST_ITEM) {
+      const newNode = {
+        id: _slugid.default.nice(),
+        type: _constants.UNORDERED_LIST,
+        children: [node]
+      };
+      memo.push(newNode);
+      return memo;
+    }
+
+    // The following types will not appear individually during the pasting process
+    // code_line
+    // table_row | table_cell
+
+    // text | image | link
+    if (!node.type || _constants.INLINE_LEVEL_TYPES.includes(node.type)) {
+      let prevNode = memo[memo.length - 1];
+      if (prevNode && prevNode.type === _constants.PARAGRAPH) {
+        prevNode.children.push(node);
+        return memo;
+      }
+      const newNode = {
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: [node]
+      };
+      memo.push(newNode);
+      return memo;
+    }
+    return memo;
+  }, []);
+  return nodes;
+};
+const deserializeHtml = html => {
+  const parsed = new DOMParser().parseFromString(html, 'text/html');
+  const fragment = parsed.body;
+  const children = Array.from(fragment.childNodes);
+  let nodes = [];
+  nodes = deserializeElements(children, true);
+  nodes = formatElementNodes(nodes);
+  return nodes;
+};
+var _default = exports.default = deserializeHtml;

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

@@ -0,0 +1,26 @@
+"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 blockquoteRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'BLOCKQUOTE') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.BLOCKQUOTE,
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = blockquoteRule;

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

@@ -0,0 +1,29 @@
+"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");
+var _elementTypes = require("../../../extension/constants/element-types");
+const brRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'BR' && childNodes.length === 0) {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _elementTypes.PARAGRAPH,
+      children: [{
+        id: _slugid.default.nice(),
+        text: ''
+      }]
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = brRule;

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

@@ -0,0 +1,29 @@
+"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 checkListRule = (element, parseChild) => {
+  const {
+    nodeName
+  } = element;
+  if (nodeName === 'INPUT' && element.getAttribute('type') === 'checkbox') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.CHECK_LIST_ITEM,
+      checked: element.getAttribute('checked') !== null,
+      children: [{
+        id: _slugid.default.nice(),
+        text: ''
+      }]
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = checkListRule;

package/dist/slate-convert/html-to-slate/rules/code-block.js

@@ -0,0 +1,95 @@
+"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 codeBlockRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'PRE') {
+    const children = Array.from(childNodes).filter(item => item.nodeName === 'CODE');
+    let codeChild = children[0];
+    if (codeChild) {
+      let lang = codeChild.getAttribute('lang');
+      lang = (0, _helper.genCodeLangs)().find(item => item.value === lang) || 'plaintext';
+      const node = {
+        id: _slugid.default.nice(),
+        language: lang,
+        type: _constants.CODE_BLOCK,
+        children: parseChild(children)
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(element, node);
+    } else {
+      const lang = 'plaintext';
+      const content = childNodes[0].textContent;
+      const textArr = content.split('\n').filter(Boolean);
+      const children = textArr.map(text => {
+        return {
+          id: _slugid.default.nice(),
+          type: _constants.CODE_LINE,
+          children: [{
+            id: _slugid.default.nice(),
+            text: text
+          }]
+        };
+      });
+      const node = {
+        id: _slugid.default.nice(),
+        language: lang,
+        type: _constants.CODE_BLOCK,
+        children: children
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(element, node);
+    }
+  }
+  if (nodeName === 'CODE' && element.parentElement.nodeName === 'PRE') {
+    const childIsP = Array.from(childNodes).every(n => n.nodeName === 'P');
+    if (childIsP) {
+      return Array.from(childNodes).map(n => {
+        const node = {
+          id: _slugid.default.nice(),
+          type: _constants.CODE_LINE,
+          children: [{
+            id: _slugid.default.nice(),
+            text: n.textContent
+          }]
+        };
+        return (0, _helper.mergeElementOther2SlateNode)(n, node);
+      });
+    }
+    const content = element.textContent;
+    const hasNewLine = content.indexOf('\n') > -1;
+    if (!hasNewLine) {
+      const node = {
+        id: _slugid.default.nice(),
+        type: _constants.CODE_LINE,
+        children: [{
+          id: _slugid.default.nice(),
+          text: element.textContent
+        }]
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(element, node);
+    }
+    const codes = content.split('\n').filter(Boolean);
+    return codes.map(item => {
+      const node = {
+        id: _slugid.default.nice(),
+        type: _constants.CODE_LINE,
+        children: [{
+          id: _slugid.default.nice(),
+          text: item
+        }]
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(item, node);
+    });
+  }
+  return;
+};
+var _default = exports.default = codeBlockRule;

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

@@ -0,0 +1,26 @@
+"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 headerRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName && _constants.HEADER_LIST.includes(nodeName)) {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.HEADER_TYPE_MAP[nodeName],
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = headerRule;

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

@@ -0,0 +1,31 @@
+"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 imageRule = (element, parseChild) => {
+  const {
+    nodeName
+  } = element;
+  if (nodeName === 'IMG') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.IMAGE,
+      data: {
+        src: element.getAttribute('src')
+      },
+      children: [{
+        text: '',
+        id: _slugid.default.nice()
+      }]
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = imageRule;

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

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _blockquote = _interopRequireDefault(require("./blockquote"));
+var _codeBlock = _interopRequireDefault(require("./code-block"));
+var _header = _interopRequireDefault(require("./header"));
+var _image = _interopRequireDefault(require("./image"));
+var _link = _interopRequireDefault(require("./link"));
+var _list = _interopRequireDefault(require("./list"));
+var _paragraph = _interopRequireDefault(require("./paragraph"));
+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 _default = exports.default = rules;

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

@@ -0,0 +1,31 @@
+"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 linkRule = (element, parseChild) => {
+  const {
+    nodeName
+  } = element;
+  const content = element.textContent || element.getAttribute('title') || element.getAttribute('href');
+  if (nodeName === 'A') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.LINK,
+      url: element.getAttribute('href') || content,
+      title: element.getAttribute('title'),
+      children: [{
+        id: _slugid.default.nice(),
+        text: content
+      }]
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = linkRule;

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

@@ -0,0 +1,74 @@
+"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 _core = require("../../../extension/core");
+var _helper = require("../helper");
+const PARAGRAPH_TAGS = ['DIV', 'P'];
+const listRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes,
+    firstChild,
+    parentElement
+  } = element;
+  if (nodeName === 'UL') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.UNORDERED_LIST,
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (nodeName === 'OL') {
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.ORDERED_LIST,
+      children: parseChild(childNodes)
+    };
+    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)
+    };
+    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: [{
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: parseChild(childNodes)
+      }]
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  if (PARAGRAPH_TAGS.includes(nodeName) && parentElement && parentElement.nodeName === 'LI') {
+    if (Array.from(childNodes).length === 0) {
+      const node = {
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: [(0, _core.generateDefaultText)()]
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(element, node);
+    }
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.PARAGRAPH,
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = listRule;

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

@@ -0,0 +1,37 @@
+"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 pRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'P' && element.parentElement.nodeName !== 'LI') {
+    if (childNodes.length === 0) {
+      const node = {
+        id: _slugid.default.nice(),
+        type: _constants.P,
+        children: [{
+          id: _slugid.default.nice(),
+          text: ''
+        }]
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(element, node);
+    }
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.P,
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = pRule;

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

@@ -0,0 +1,37 @@
+"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 paragraphRule = (element, parseChild) => {
+  const {
+    nodeName,
+    childNodes
+  } = element;
+  if (nodeName === 'DIV' && element.parentElement.nodeName !== 'LI') {
+    if (childNodes.length === 0) {
+      const node = {
+        id: _slugid.default.nice(),
+        type: _constants.PARAGRAPH,
+        children: [{
+          id: _slugid.default.nice(),
+          text: ''
+        }]
+      };
+      return (0, _helper.mergeElementOther2SlateNode)(element, node);
+    }
+    const node = {
+      id: _slugid.default.nice(),
+      type: _constants.PARAGRAPH,
+      children: parseChild(childNodes)
+    };
+    return (0, _helper.mergeElementOther2SlateNode)(element, node);
+  }
+  return;
+};
+var _default = exports.default = paragraphRule;