@seafile/sea-email-editor 0.0.1

package/dist/extension/plugins/list/transforms/transforms-to-list.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformsToList = void 0;
+var _slate = require("slate");
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _constant = require("../constant");
+var _elementTypes = require("../../../constants/element-types");
+var _unwrapList = require("./unwrap-list");
+const wrapLineList = (editor, type) => {
+  const emptyList = (0, _core.generateElement)(type, {
+    childrenOrText: []
+  });
+  _slate.Transforms.wrapNodes(editor, emptyList);
+  const paragraphEntry = (0, _core.getSelectedNodeEntryByType)(editor, _elementTypes.PARAGRAPH);
+  if (!paragraphEntry) return;
+  const [, paragraphPath] = paragraphEntry;
+  const emptyListItem = (0, _core.generateElement)(_elementTypes.LIST_ITEM, {
+    childrenOrText: []
+  });
+  _slate.Transforms.wrapNodes(editor, emptyListItem, {
+    at: paragraphPath
+  });
+};
+const wrapRangeList = (editor, type) => {
+  const [startPoint, endPoint] = _slate.Range.edges(editor.selection);
+  const [commonAncestorNode, commonAncestorPath] = _slate.Node.common(editor, startPoint.path, endPoint.path);
+
+  // If common anchestor is of list,order list, unordered list, list of items,wrap or un wrap it
+  if ([..._constant.LIST_TYPES, _elementTypes.LIST_ITEM].includes(commonAncestorNode.type)) {
+    // Change to another list type, if select different depth of list,set the shallowest depth to the given type
+    if (commonAncestorNode.type !== type) {
+      const options = {
+        at: startPoint,
+        match: {
+          type: _constant.LIST_TYPES
+        },
+        mode: 'lowest'
+      };
+      const startListEntry = (0, _core.findNode)(editor, options);
+      const endListEntry = (0, _core.findNode)(editor, {
+        ...options,
+        at: endPoint
+      });
+      const selectDepth = Math.min(startListEntry[1].length, endListEntry[1].length);
+      _slate.Transforms.setNodes(editor, {
+        type
+      }, {
+        match: (node, path) => _slate.Element.isElement(node) && _constant.LIST_TYPES.includes(node.type) && path.length >= selectDepth,
+        mode: 'all'
+      });
+    } else {
+      (0, _unwrapList.unwrapList)(editor);
+    }
+    return;
+  }
+  const commonAncestorDepth = commonAncestorPath.length;
+  const selectedNodeEntries = _slate.Editor.nodes(editor, {
+    mode: 'all'
+  });
+  // Filter out all the child node of selected node.
+  const nodeEntryList = Array.from(selectedNodeEntries).filter(_ref => {
+    let [node, path] = _ref;
+    return path.length === commonAncestorDepth + 1;
+  });
+  nodeEntryList.forEach(_ref2 => {
+    let [node, path] = _ref2;
+    if (_constant.LIST_TYPES.includes(node.type)) {
+      _slate.Transforms.setNodes(editor, {
+        type
+      }, {
+        at: path,
+        match: n => _slate.Element.isElement(n) && _elementTypes.LIST_ITEM.includes(n.type),
+        mode: 'all'
+      });
+    } else {
+      const emptyListItem = (0, _core.generateElement)(_elementTypes.LIST_ITEM, {
+        childrenOrText: []
+      });
+      _slate.Transforms.wrapNodes(editor, emptyListItem, {
+        at: path
+      });
+      const emptyList = (0, _core.generateElement)(type, {
+        childrenOrText: []
+      });
+      _slate.Transforms.wrapNodes(editor, emptyList, {
+        at: path
+      });
+    }
+  });
+};
+
+/**
+ * @param {object} editor
+ * @param {keyof LIST_TYPES} type
+ */
+const transformsToList = (editor, type) => {
+  _slate.Editor.withoutNormalizing(editor, () => {
+    const {
+      selection
+    } = editor;
+    if (!selection) return false;
+    if (_slate.Range.isCollapsed(selection) || !(0, _core.isRangeAcrossBlocks)(editor)) {
+      const res = (0, _queries.getListItemEntry)(editor);
+      // Unwrap list if `res` exist which means selected in list,or wrap it
+      if (res) {
+        const {
+          list
+        } = res;
+        const setListType = (editor, type) => _slate.Transforms.setNodes(editor, {
+          type
+        }, {
+          match: node => _constant.LIST_TYPES.includes((0, _core.getNodeType)(node)),
+          mode: 'lowest',
+          at: editor.selection
+        });
+        // Change list type to another, if list type is different from the given type
+        list[0].type !== type ? setListType(editor, type) : (0, _unwrapList.unwrapList)(editor);
+      } else {
+        wrapLineList(editor, type);
+      }
+      return;
+    }
+    // Selection is a range
+    wrapRangeList(editor, type);
+  });
+};
+exports.transformsToList = transformsToList;

package/dist/extension/plugins/list/transforms/unwrap-list.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unwrapList = void 0;
+var _slate = require("slate");
+var _core = require("../../../core");
+var _constant = require("../constant");
+var _elementTypes = require("../../../constants/element-types");
+const unwrapList = function (editor) {
+  let {
+    at
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const ancestorListTypeCheck = () => {
+    if ((0, _core.getAboveNode)(editor, {
+      match: {
+        type: _constant.LIST_TYPES
+      }
+    })) {
+      return true;
+    }
+
+    // The selection's common node might be a list type
+    if (!at && editor.selection) {
+      const commonNode = _slate.Node.common(editor, editor.selection.anchor.path, editor.selection.focus.path);
+      if (_slate.Element.isElement(commonNode[0]) && _constant.LIST_TYPES.includes(commonNode[0].type)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  _slate.Editor.withoutNormalizing(editor, () => {
+    do {
+      _slate.Transforms.unwrapNodes(editor, {
+        at,
+        match: n => (0, _core.getNodeType)(n) === _elementTypes.LIST_ITEM,
+        split: true
+      });
+      _slate.Transforms.unwrapNodes(editor, {
+        at,
+        match: n => _constant.LIST_TYPES.includes((0, _core.getNodeType)(n)),
+        split: true
+      });
+    } while (ancestorListTypeCheck());
+  });
+};
+exports.unwrapList = unwrapList;

package/dist/extension/plugins/markdown/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _plugin = _interopRequireDefault(require("./plugin"));
+const MarkDownPlugin = {
+  editorPlugin: _plugin.default
+};
+var _default = exports.default = MarkDownPlugin;

package/dist/extension/plugins/markdown/plugin.js

@@ -0,0 +1,257 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _transforms = require("../list/transforms");
+var _core = require("../../core");
+var _constants = require("../../constants");
+var _elementTypes = require("../../constants/element-types");
+var _helpers = require("../blockquote/helpers");
+var _helpers2 = require("../code-block/helpers");
+const KEY_TO_TYPE_FOR_SPACE = {
+  // Title shortcut
+  '#': _elementTypes.HEADER1,
+  '##': _elementTypes.HEADER2,
+  '###': _elementTypes.HEADER3,
+  '####': _elementTypes.HEADER4,
+  '#####': _elementTypes.HEADER5,
+  '######': _elementTypes.HEADER6,
+  // List shortcut
+  '*': _elementTypes.UNORDERED_LIST,
+  '-': _elementTypes.UNORDERED_LIST,
+  // Reference shortcut key
+  '>': _elementTypes.BLOCKQUOTE,
+  '```': _elementTypes.CODE_BLOCK
+};
+const KEY_TO_INLINE_TYPE_FOR_SPACE = {
+  // Inline shortcut keys
+  '**': _constants.TEXT_STYLE_MAP.BOLD,
+  '*': _constants.TEXT_STYLE_MAP.ITALIC,
+  '***': _constants.TEXT_STYLE_MAP.BOLD_ITALIC,
+  '__': _constants.TEXT_STYLE_MAP.BOLD,
+  '_': _constants.TEXT_STYLE_MAP.ITALIC,
+  '___': _constants.TEXT_STYLE_MAP.BOLD_ITALIC,
+  '`': _constants.TEXT_STYLE_MAP.CODE
+};
+const getBeforeText = editor => {
+  const {
+    selection
+  } = editor;
+  if (selection == null) return {
+    beforeText: '',
+    range: null
+  };
+  const {
+    anchor
+  } = selection;
+  const range = {
+    anchor,
+    focus: {
+      path: selection.focus.path,
+      offset: 0
+    }
+  };
+  const beforeText = _slate.Editor.string(editor, range) || '';
+  return {
+    beforeText,
+    range
+  };
+};
+const withMarkDown = editor => {
+  const {
+    insertText
+  } = editor;
+  const newEditor = editor;
+
+  // When entering a space, convert markdown
+  newEditor.insertText = text => {
+    const {
+      selection
+    } = editor;
+    if (selection == null) return insertText(text);
+    if (_slate.Range.isExpanded(selection)) return insertText(text);
+    if ((0, _core.getSelectedNodeByType)(editor, _elementTypes.PARAGRAPH) == null) return insertText(text); // It must be in paragraph
+    if (text !== ' ') return insertText(text); // The value must be an input space
+
+    // Gets the text before the space
+    const {
+      beforeText,
+      range
+    } = getBeforeText(editor);
+    if (!beforeText || !range) return insertText(text);
+
+    // Based on the keyword, find the type of element you want to convert
+    const type = KEY_TO_TYPE_FOR_SPACE[beforeText.trim()];
+    const italicAndBoldType = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-3)];
+    const boldType = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-2)];
+    const italicType = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-1)];
+    const inlineCode = KEY_TO_INLINE_TYPE_FOR_SPACE[beforeText.slice(-1)];
+    if (!type && !boldType && !italicType && !italicAndBoldType) return insertText(text);
+    if (italicAndBoldType === _constants.TEXT_STYLE_MAP.BOLD_ITALIC) {
+      const SYMBOL = beforeText.slice(-3);
+      const restStr = beforeText === null || beforeText === void 0 ? void 0 : beforeText.slice(0, beforeText.length - 3);
+      const startOffset = restStr === null || restStr === void 0 ? void 0 : restStr.lastIndexOf(SYMBOL);
+      const endOffset = (beforeText === null || beforeText === void 0 ? void 0 : beforeText.lastIndexOf(SYMBOL)) + 3;
+      if (startOffset === -1) {
+        return insertText(text);
+      }
+      if (startOffset !== -3) {
+        _slate.Transforms.delete(editor, {
+          at: {
+            anchor: {
+              path: range.focus.path,
+              offset: startOffset
+            },
+            focus: {
+              ...selection.focus
+            }
+          },
+          voids: true
+        });
+        const newText = beforeText.slice(startOffset + 3, endOffset - 3);
+        _slate.Editor.addMark(editor, _constants.TEXT_STYLE_MAP.BOLD, true);
+        _slate.Editor.addMark(editor, _constants.TEXT_STYLE_MAP.ITALIC, true);
+        insertText(newText);
+        _slate.Editor.removeMark(editor, _constants.TEXT_STYLE_MAP.BOLD);
+        _slate.Editor.removeMark(editor, _constants.TEXT_STYLE_MAP.ITALIC);
+        return;
+      }
+      return;
+    }
+    if (boldType === _constants.TEXT_STYLE_MAP.BOLD) {
+      const SYMBOL = beforeText.slice(-2);
+      const restStr = beforeText.slice(0, beforeText.length - 2);
+      const startOffset = restStr.lastIndexOf(SYMBOL);
+      const endOffset = beforeText.lastIndexOf(SYMBOL) + 2;
+      if (startOffset === -1) {
+        return insertText(text);
+      }
+      _slate.Transforms.delete(editor, {
+        at: {
+          anchor: {
+            path: range.focus.path,
+            offset: startOffset
+          },
+          focus: {
+            ...selection.focus
+          }
+        },
+        voids: true
+      });
+      const newType = boldType.toLowerCase();
+      const newText = beforeText.slice(startOffset + 2, endOffset - 2);
+      _slate.Editor.addMark(editor, newType, true);
+      insertText(newText);
+      _slate.Editor.removeMark(editor, newType);
+      return;
+    }
+
+    // demos
+    // 1 '*'
+    // 2 'acd * add *'
+    if (italicType === _constants.TEXT_STYLE_MAP.ITALIC) {
+      const SYMBOL = beforeText.slice(-1);
+      const restStr = beforeText === null || beforeText === void 0 ? void 0 : beforeText.slice(0, beforeText.length - 1);
+      const startOffset = restStr === null || restStr === void 0 ? void 0 : restStr.lastIndexOf(SYMBOL);
+      const endOffset = (beforeText === null || beforeText === void 0 ? void 0 : beforeText.lastIndexOf(SYMBOL)) + 1;
+
+      // start: restStr =  '`' | '   `'
+      if (restStr === '' || restStr === '_') {
+        return insertText(text);
+      }
+
+      // end: restStr = '   _' | 'aaaaa_'
+      if (startOffset + 1 === restStr.length) {
+        return insertText(text);
+      }
+      if (startOffset === -1 && restStr.length > 0) {
+        return insertText(text);
+      }
+      if (startOffset !== -1) {
+        _slate.Transforms.delete(editor, {
+          at: {
+            anchor: {
+              path: range.focus.path,
+              offset: startOffset
+            },
+            focus: {
+              ...selection.focus
+            }
+          },
+          voids: true
+        });
+        const newType = italicType.toLowerCase();
+        const newText = beforeText.slice(startOffset + 1, endOffset - 1);
+        _slate.Editor.addMark(editor, newType, true);
+        insertText(newText);
+        _slate.Editor.removeMark(editor, newType);
+        return;
+      }
+    }
+    if (type !== _elementTypes.CODE_BLOCK && inlineCode === _constants.TEXT_STYLE_MAP.CODE) {
+      const restStr = beforeText === null || beforeText === void 0 ? void 0 : beforeText.slice(0, beforeText.length - 1);
+      const startOffset = restStr === null || restStr === void 0 ? void 0 : restStr.lastIndexOf('`');
+      const endOffset = (beforeText === null || beforeText === void 0 ? void 0 : beforeText.lastIndexOf('`')) + 1;
+
+      // start: restStr =  '`' | '   `'
+      if (restStr === '' || restStr === '`') {
+        return insertText(text);
+      }
+
+      // end: restStr = '   `' | 'aaaaa`'
+      if (startOffset + 1 === restStr.length) {
+        return insertText(text);
+      }
+      if (startOffset === -1 && restStr.length > 0) {
+        return insertText(text);
+      }
+      if (startOffset !== -1) {
+        _slate.Transforms.delete(editor, {
+          at: {
+            anchor: {
+              path: range.focus.path,
+              offset: startOffset
+            },
+            focus: {
+              ...selection.focus
+            }
+          },
+          voids: true
+        });
+        const newType = inlineCode.toLowerCase();
+        const newText = beforeText.slice(startOffset + 1, endOffset - 1);
+        _slate.Editor.addMark(editor, newType, true);
+        insertText(newText);
+
+        // add space with inline code
+        _slate.Editor.removeMark(editor, newType);
+        insertText(' ');
+        return;
+      }
+    }
+
+    // Delete element
+    _slate.Transforms.select(editor, range);
+    _slate.Transforms.delete(editor);
+    if (type === _elementTypes.UNORDERED_LIST) {
+      (0, _transforms.transformsToList)(editor, type);
+      return;
+    }
+    if (type === _elementTypes.BLOCKQUOTE) {
+      (0, _helpers.setBlockQuoteType)(editor, false);
+      return;
+    }
+    if (type === _elementTypes.CODE_BLOCK) {
+      (0, _helpers2.transformToCodeBlock)(editor);
+      return;
+    }
+    _slate.Transforms.setNodes(editor, {
+      type
+    });
+  };
+  return newEditor;
+};
+var _default = exports.default = withMarkDown;

package/dist/extension/plugins/node-id/constants.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SPLIT_NODE = exports.SET_SELECTION = exports.SET_NODE = exports.REMOVE_TEXT = exports.REMOVE_NODE = exports.MOVE_NODE = exports.MERGE_NODE = exports.INSERT_TEXT = exports.INSERT_NODE = void 0;
+// insert_node & remove_node
+const INSERT_TEXT = exports.INSERT_TEXT = 'insert_text';
+const REMOVE_TEXT = exports.REMOVE_TEXT = 'remove_text';
+
+// insert_node & remove_node
+const INSERT_NODE = exports.INSERT_NODE = 'insert_node';
+const REMOVE_NODE = exports.REMOVE_NODE = 'remove_node';
+
+// merge_node  & split_node
+const MERGE_NODE = exports.MERGE_NODE = 'merge_node';
+const SPLIT_NODE = exports.SPLIT_NODE = 'split_node';
+
+// set_node & move_node
+const SET_NODE = exports.SET_NODE = 'set_node';
+const MOVE_NODE = exports.MOVE_NODE = 'move_node';
+
+// set_selection
+const SET_SELECTION = exports.SET_SELECTION = 'set_selection';

package/dist/extension/plugins/node-id/helpers.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replacePastedDataId = exports.replaceNodeId = exports.decorateOperation = void 0;
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var OPERATION = _interopRequireWildcard(require("./constants"));
+var _objectUtils = _interopRequireDefault(require("../../../utils/object-utils"));
+const decorateOperation = operation => {
+  let newOperation = (0, _deepCopy.default)(operation);
+  const {
+    type
+  } = newOperation;
+  switch (type) {
+    case OPERATION.INSERT_NODE:
+      {
+        let {
+          node
+        } = newOperation;
+        if (!node.id) node.id = _slugid.default.nice(); // generate an id for insert node
+        break;
+      }
+    case OPERATION.SPLIT_NODE:
+      {
+        // child: split [7, 0] -> [[7, 0],[7, 1]]
+        // parent: split [[7, 0], [7, 1]] -> [[7], [8]]
+        const {
+          properties = {}
+        } = newOperation;
+        // need generate a new id for new node
+        properties.id = _slugid.default.nice();
+        break;
+      }
+    default:
+      {
+        break;
+      }
+  }
+  return newOperation;
+};
+exports.decorateOperation = decorateOperation;
+const replaceNodeId = node => {
+  if (!_objectUtils.default.isObject(node)) return node;
+  if (_objectUtils.default.hasProperty(node, 'children')) {
+    return {
+      ...node,
+      id: _slugid.default.nice(),
+      children: replacePastedDataId(node.children)
+    };
+  }
+  return {
+    ...node,
+    id: _slugid.default.nice()
+  };
+};
+exports.replaceNodeId = replaceNodeId;
+const replacePastedDataId = pastedData => {
+  // If children is malformed, return a list of correct child nodes
+  if (_objectUtils.default.isObject(pastedData)) {
+    return replaceNodeId(pastedData);
+  }
+  if (!Array.isArray(pastedData)) return [{
+    id: _slugid.default.nice(),
+    text: ''
+  }];
+  return pastedData.map(item => {
+    item.id = _slugid.default.nice();
+    if (item.children) {
+      item.children = replacePastedDataId(item.children);
+    }
+    return item;
+  });
+};
+exports.replacePastedDataId = replacePastedDataId;

package/dist/extension/plugins/node-id/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _withNodeId = _interopRequireDefault(require("./with-node-id"));
+const NodeIdPlugin = {
+  editorPlugin: _withNodeId.default
+};
+var _default = exports.default = NodeIdPlugin;

package/dist/extension/plugins/node-id/with-node-id.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helpers = require("./helpers");
+const catchSlateFragment = /data-slate-fragment="(.+?)"/m;
+const getSlateFragmentAttribute = dataTransfer => {
+  const htmlData = dataTransfer.getData('text/html');
+  const [, fragment] = htmlData.match(catchSlateFragment) || [];
+  return fragment;
+};
+const withNodeId = editor => {
+  const {
+    apply
+  } = editor;
+  const newEditor = editor;
+  newEditor.apply = op => {
+    const newOp = (0, _helpers.decorateOperation)(op);
+    apply(newOp);
+  };
+
+  // rewrite insert fragment data
+  newEditor.insertFragmentData = data => {
+    const fragment = data.getData('application/x-slate-fragment') || getSlateFragmentAttribute(data);
+    if (fragment) {
+      const decoded = decodeURIComponent(window.atob(fragment));
+      const parsed = JSON.parse(decoded);
+      const newData = (0, _helpers.replacePastedDataId)(parsed);
+      newEditor.insertFragment(newData);
+      return newEditor;
+    }
+  };
+  return newEditor;
+};
+var _default = exports.default = withNodeId;

package/dist/extension/plugins/p/helper.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformToParagraph = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../../constants/element-types");
+var _core = require("../../core");
+const transformToParagraph = (editor, focusLocation) => {
+  if (!editor.selection) return;
+  _slate.Transforms.setNodes(editor, {
+    type: _elementTypes.PARAGRAPH
+  });
+  (0, _core.focusEditor)(editor, focusLocation);
+};
+exports.transformToParagraph = transformToParagraph;

package/dist/extension/plugins/p/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elementTypes = require("../../constants/element-types");
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireDefault(require("./render-elem"));
+const PPlugin = {
+  type: _elementTypes.P,
+  nodeType: 'element',
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default]
+};
+var _default = exports.default = PPlugin;