@seafile/seafile-editor 1.0.0 → 1.0.2

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

@@ -0,0 +1,326 @@
+"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.formatMdToSlate = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _core = require("../../extension/core");
+var _elementTypes = require("../../extension/constants/element-types");
+var INLINE_KEY_MAP = {
+  strong: 'bold',
+  emphasis: 'italic'
+};
+
+// <strong><em>aa<em>bb<em></strong>
+var applyMarkForInlineItem = function applyMarkForInlineItem(result, item) {
+  var textNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var type = item.type,
+    children = item.children,
+    value = item.value;
+  if (type === _elementTypes.LINK) {
+    var child = children.length === 0 ? {
+      type: 'text',
+      value: ''
+    } : children[0];
+    var linkChildren = [{
+      id: _slugid.default.nice(),
+      text: child.value
+    }];
+    var 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) {
+    var data = (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({
+      src: item.url
+    }, item.title && {
+      title: item.title
+    }), item.alt && {
+      alt: item.alt
+    }), item.width && {
+      width: item.width
+    }), item.height && {
+      height: item.height
+    });
+    var 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') {
+    var nodes = transformHtml(item);
+    result.push(nodes);
+    return result;
+  }
+  if (type === 'text') {
+    textNode['text'] = value || '';
+    result.push(textNode);
+    return;
+  }
+  if (type === 'inlineCode') {
+    textNode['code'] = true;
+    textNode['text'] = value || '';
+    result.push(textNode);
+    return;
+  }
+  var attr_key = INLINE_KEY_MAP[type];
+  if (!Array.isArray(children) || children.length === 0 || !attr_key) {
+    textNode['text'] = value || '';
+    result.push(textNode);
+    return;
+  }
+  textNode[attr_key] = true;
+  children.forEach(function (item) {
+    applyMarkForInlineItem(result, item, textNode);
+  });
+};
+var transformNodeWithInlineChildren = function transformNodeWithInlineChildren(node) {
+  var children = node.children;
+  var defaultChildren = [(0, _core.generateDefaultText)()];
+  if (!children || !Array.isArray(children) || children.length === 0) {
+    return defaultChildren;
+  }
+  var result = [];
+  children.forEach(function (item) {
+    return applyMarkForInlineItem(result, item);
+  });
+  return result.flat();
+};
+var transformHeader = exports.transformHeader = function transformHeader(node) {
+  var depth = node.depth;
+  var type = "".concat(_elementTypes.HEADER).concat(depth);
+  return {
+    id: _slugid.default.nice(),
+    type: type,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformParagraph = exports.transformParagraph = function transformParagraph(node) {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformBlockquote = exports.transformBlockquote = function transformBlockquote(node) {
+  var children = node.children;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.BLOCKQUOTE,
+    children: children.map(function (child) {
+      var handler = elementHandlers[child.type];
+      return handler(child);
+    }).flat() // flat
+  };
+};
+
+var transformListContent = exports.transformListContent = function transformListContent(node) {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformListItem = exports.transformListItem = function transformListItem(node) {
+  var children = node.children;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.LIST_ITEM,
+    // eslint-disable-next-line array-callback-return
+    children: children.map(function (child) {
+      if (child.type === _elementTypes.PARAGRAPH) {
+        return transformListContent(child);
+      } else {
+        return transformList(child);
+      }
+    })
+  };
+};
+var transformOrderedList = exports.transformOrderedList = function transformOrderedList(node) {
+  var children = node.children;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.ORDERED_LIST,
+    children: children.map(function (child) {
+      return transformListItem(child);
+    })
+  };
+};
+var transformUnorderedList = exports.transformUnorderedList = function transformUnorderedList(node) {
+  var children = node.children;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.UNORDERED_LIST,
+    children: children.map(function (child) {
+      return transformListItem(child);
+    })
+  };
+};
+var transformCheckListItem = exports.transformCheckListItem = function transformCheckListItem(node) {
+  var children = node.children,
+    checked = node.checked;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.CHECK_LIST_ITEM,
+    checked: checked,
+    children: children.map(function (child) {
+      return transformNodeWithInlineChildren(child);
+    }).flat()
+  };
+};
+var transformCheckList = exports.transformCheckList = function transformCheckList(node) {
+  var children = node.children;
+  return children.map(function (child) {
+    return transformCheckListItem(child);
+  });
+};
+var transformList = exports.transformList = function transformList(node) {
+  var ordered = node.ordered,
+    children = node.children;
+  var firstChild = children[0];
+  if (ordered === true) {
+    return transformOrderedList(node);
+  }
+  if (ordered === false && firstChild.checked === null) {
+    return transformUnorderedList(node);
+  }
+  return transformCheckList(node);
+};
+var transformTableCell = exports.transformTableCell = function transformTableCell(cell, align) {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.TABLE_CELL,
+    align: align || null,
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+var transformTableRow = exports.transformTableRow = function transformTableRow(row, align) {
+  var cells = row.children;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.TABLE_ROW,
+    children: cells.map(function (cell) {
+      return transformTableCell(cell, align);
+    })
+  };
+};
+var transformTable = exports.transformTable = function transformTable(node) {
+  var rows = node.children,
+    _node$align = node.align,
+    align = _node$align === void 0 ? [] : _node$align;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.TABLE,
+    children: rows.map(function (row, index) {
+      return transformTableRow(row, align[index]);
+    })
+  };
+};
+var transformCodeLine = exports.transformCodeLine = function transformCodeLine(text) {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.CODE_LINE,
+    children: [{
+      id: _slugid.default.nice(),
+      text: text
+    }]
+  };
+};
+var transformCodeBlock = exports.transformCodeBlock = function transformCodeBlock(node) {
+  var lang = node.lang,
+    value = node.value;
+  var children = value.split('\n');
+  return {
+    id: _slugid.default.nice(),
+    type: _elementTypes.CODE_BLOCK,
+    lang: lang,
+    children: children.map(function (text) {
+      return transformCodeLine(text);
+    })
+  };
+};
+var transformHr = exports.transformHr = function transformHr(node) {
+  return {
+    id: _slugid.default.nice(),
+    type: 'hr',
+    children: [(0, _core.generateDefaultText)()]
+  };
+};
+var transformHtml = exports.transformHtml = function transformHtml(node) {
+  var defaultTextNode = (0, _core.generateDefaultText)();
+  if (node.value.slice(0, 4).toLowerCase() === '<img') {
+    var _DOMParser$parseFromS = new DOMParser().parseFromString(node.value, 'text/html'),
+      body = _DOMParser$parseFromS.body;
+    var img = body.firstChild;
+    var src = img.getAttribute('src');
+    if (src) return defaultTextNode;
+    var alt = img.getAttribute('alt');
+    var title = img.getAttribute('title');
+    var width = img.getAttribute('width');
+    var height = img.getAttribute('height');
+    var data = (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({
+      src: src
+    }, alt && {
+      alt: alt
+    }), title && {
+      title: title
+    }), !isNaN(width) && width > 0 && {
+      width: width
+    }), !isNaN(height) && height > 0 && {
+      height: height
+    });
+    var image = {
+      id: _slugid.default.nice(),
+      data: data,
+      type: _elementTypes.IMAGE,
+      children: [(0, _core.generateDefaultText)()]
+    };
+    return [defaultTextNode, image, defaultTextNode];
+  }
+  return defaultTextNode;
+};
+var transformMath = exports.transformMath = function transformMath(node) {
+  return {
+    id: _slugid.default.nice(),
+    type: 'formula',
+    data: {
+      formula: node.value
+    },
+    children: [(0, _core.generateDefaultText)()]
+  };
+};
+var elementHandlers = {
+  'paragraph': transformParagraph,
+  'heading': transformHeader,
+  'blockquote': transformBlockquote,
+  'table': transformTable,
+  'list': transformList,
+  // ordered_list | unordered_list | check_list_item
+  'code': transformCodeBlock,
+  'thematicBreak': transformHr,
+  'math': transformMath
+};
+var formatMdToSlate = exports.formatMdToSlate = function formatMdToSlate(children) {
+  var validChildren = children.filter(function (child) {
+    return elementHandlers[child.type];
+  });
+  return validChildren.map(function (child) {
+    var handler = elementHandlers[child.type];
+    return handler(child);
+  }).flat();
+};

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

@@ -0,0 +1,43 @@
+"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 _remarkStringify = _interopRequireDefault(require("remark-stringify"));
+var _remarkMath = _interopRequireDefault(require("remark-math"));
+var _transform = require("./transform");
+var isContentValid = function isContentValid(value) {
+  if (!value || !Array.isArray(value)) return false;
+  return true;
+};
+
+// slateNode -> mdast -> mdString
+var slateToMdString = function slateToMdString(value) {
+  if (!isContentValid(value)) return '';
+  // slateNode -> mdast
+  // https://github.com/syntax-tree/mdast#phrasingcontent
+  var mdASTNodes = (0, _transform.formatSlateToMd)(value);
+  var root = {
+    type: 'root',
+    children: mdASTNodes
+  };
+
+  // convert slate value to md
+  var stringifyOptions = {
+    rule: '-',
+    ruleSpaces: false,
+    bullet: '*',
+    commonmarks: true,
+    fences: true
+  };
+  var res = (0, _unified.unified)().use(_remarkParse.default).use(_remarkGfm.default).use(_remarkStringify.default, stringifyOptions).use(_remarkMath.default).stringify(root);
+  return res;
+};
+
+// transform rules: https://github.com/syntax-tree/mdast
+var _default = exports.default = slateToMdString;

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

@@ -0,0 +1,269 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatSlateToMd = void 0;
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var generateDefaultText = function generateDefaultText() {
+  return {
+    type: 'text',
+    value: ''
+  };
+};
+var transformTextNode = function transformTextNode(textNode) {
+  var mdNode = {
+    type: 'text',
+    value: textNode.text
+  };
+
+  // code = true, override text type
+  if (textNode['code']) {
+    mdNode = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, mdNode), {}, {
+      type: 'inlineCode'
+    });
+  }
+
+  // blob = true, add strong parent
+  if (textNode['bold']) {
+    mdNode = {
+      type: 'strong',
+      children: [mdNode]
+    };
+  }
+
+  // italic = true, add emphasis parent
+  if (textNode['italic']) {
+    mdNode = {
+      type: 'emphasis',
+      children: [mdNode]
+    };
+  }
+  return mdNode;
+};
+var transformInlineChildren = function transformInlineChildren(result, item) {
+  // image
+  if (item.type && item.type === 'image') {
+    var data = item.data;
+    var image = {
+      type: 'image',
+      url: data.src,
+      alt: data.alt || null,
+      title: data.title || null
+    };
+    if (data.height || data.width) {
+      image = {
+        type: 'html',
+        value: "<img src=\"".concat(data.src, "\" alt=\"").concat(data.alt, "\" title=\"").concat(data.title, "\" width=\"").concat(data.width, "\" height=\"").concat(data.height, "\" />")
+      };
+    }
+    result.push(image);
+    return result;
+  }
+
+  // link
+  if (item.type && item.type === 'link') {
+    var link = {
+      type: 'link',
+      url: item.url,
+      title: item.title || null,
+      children: [transformTextNode(item.children[0])]
+    };
+    result.push(link);
+    return result;
+  }
+
+  // text
+  var nodes = transformTextNode(item);
+  result.push(nodes);
+  return result;
+};
+var transformNodeWithInlineChildren = function transformNodeWithInlineChildren(node) {
+  var children = node.children;
+  var defaultChildren = [generateDefaultText()];
+  if (!children || !Array.isArray(children) || children.length === 0) {
+    return defaultChildren;
+  }
+  var result = [];
+  children.forEach(function (item) {
+    return transformInlineChildren(result, item);
+  });
+  return result.flat();
+};
+var transformHeader = function transformHeader(node) {
+  var level = node.type.replace('header', '');
+  return {
+    type: 'heading',
+    depth: parseInt(level),
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformParagraph = function transformParagraph(node) {
+  return {
+    type: 'paragraph',
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+var transformBlockquote = function transformBlockquote(node) {
+  var children = node.children;
+  return {
+    type: 'blockquote',
+    children: children.map(function (child) {
+      var handler = elementHandlers[child.type];
+      return handler(child);
+    }).flat() // flat
+  };
+};
+
+var transformCheckList = function transformCheckList(node) {
+  return {
+    type: 'list',
+    ordered: false,
+    start: null,
+    spread: false,
+    children: [{
+      type: 'listItem',
+      spread: false,
+      checked: node.checked,
+      children: [transformParagraph(node)]
+    }]
+  };
+};
+var transformListContent = function transformListContent(node) {
+  return transformParagraph(node);
+};
+var transformListItem = function transformListItem(node) {
+  var loose = false;
+  var children = node.children;
+  // eslint-disable-next-line array-callback-return
+  var newChildren = children.map(function (child) {
+    if (child.type === 'paragraph') {
+      return transformListContent(child);
+    }
+    if (child.type === 'unordered_list' || child.type === 'ordered_list') {
+      return transformList(child);
+    }
+  });
+  if (newChildren.length === 1) {
+    loose = false;
+  } else if (newChildren.length === 2 && newChildren[1].type === 'list') {
+    loose = true;
+  } else {
+    loose = true;
+  }
+  return {
+    type: 'listItem',
+    loose: loose,
+    checked: null,
+    children: newChildren
+  };
+};
+var transformList = function transformList(node) {
+  var children = node.children;
+  var newChildren = children.map(function (child) {
+    return transformListItem(child);
+  });
+  var loose = false;
+  var _iterator = (0, _createForOfIteratorHelper2.default)(newChildren),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _node = _step.value;
+      if (_node.loose === true) {
+        loose = true;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    type: 'list',
+    ordered: node.type === 'ordered_list',
+    // ordered_list | unordered_list
+    start: 1,
+    loose: loose,
+    children: newChildren
+  };
+};
+var transformTableCell = function transformTableCell(cell) {
+  return {
+    type: 'tableCell',
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+var transformTableRow = function transformTableRow(row) {
+  var cells = row.children;
+  return {
+    type: 'tableRow',
+    children: cells.map(function (cell) {
+      return transformTableCell(cell);
+    })
+  };
+};
+var transformTable = function transformTable(node) {
+  var rows = node.children;
+  var align = rows.map(function (row) {
+    var _cells$;
+    var cells = row.children;
+    return ((_cells$ = cells[0]) === null || _cells$ === void 0 ? void 0 : _cells$.align) || null;
+  });
+  return {
+    type: 'table',
+    align: align,
+    children: rows.map(function (row) {
+      return transformTableRow(row);
+    })
+  };
+};
+var transformCodeLine = function transformCodeLine(node) {
+  var _node$children$;
+  var text = ((_node$children$ = node.children[0]) === null || _node$children$ === void 0 ? void 0 : _node$children$.text) || '';
+  return text;
+};
+var transformCodeBlock = function transformCodeBlock(node) {
+  var children = node.children;
+  return {
+    type: 'code',
+    lang: node.lang ? node.lang : null,
+    value: children.map(function (child) {
+      return transformCodeLine(child);
+    }).join('\n')
+  };
+};
+var transformFormula = function transformFormula(node) {
+  var data = node.data;
+  return {
+    type: 'math',
+    value: data.formula
+  };
+};
+var elementHandlers = {
+  'paragraph': transformParagraph,
+  'header1': transformHeader,
+  'header2': transformHeader,
+  'header3': transformHeader,
+  'header4': transformHeader,
+  'header5': transformHeader,
+  'header6': transformHeader,
+  'blockquote': transformBlockquote,
+  'table': transformTable,
+  'check_list_item': transformCheckList,
+  'ordered_list': transformList,
+  'unordered_list': transformList,
+  'code_block': transformCodeBlock,
+  'formula': transformFormula
+};
+var formatSlateToMd = exports.formatSlateToMd = function formatSlateToMd(children) {
+  var validChildren = children.filter(function (child) {
+    return elementHandlers[child.type];
+  });
+  return validChildren.map(function (child) {
+    var handler = elementHandlers[child.type];
+    return handler(child);
+  }).flat();
+};

package/dist/utils/common.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isUrl = exports.isMac = exports.isImage = exports.IMAGE_TYPES = void 0;
+var _isUrl = _interopRequireDefault(require("is-url"));
+var isMac = exports.isMac = function isMac() {
+  var platform = navigator.platform;
+  return platform === 'Mac68K' || platform === 'MacPPC' || platform === 'Macintosh' || platform === 'MacIntel';
+};
+var IMAGE_TYPES = exports.IMAGE_TYPES = ['png', 'jpg', 'gif'];
+var isImage = exports.isImage = function isImage(url) {
+  if (!url) return false;
+  if (!isUrl(url)) return false;
+  var suffix = url.split('.')[1]; // http://xx/mm/*.png
+  if (!suffix) return false;
+  return IMAGE_TYPES.includes(suffix.toLowerCase());
+};
+var isUrl = exports.isUrl = function isUrl(url) {
+  if (!url) return false;
+  if (!url.startsWith('http')) return false;
+  if (!(0, _isUrl.default)(url)) return false;
+  return true;
+};