@seafile/comment-editor 0.0.1-alpha.0

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

@@ -0,0 +1,414 @@
+"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 _elementType = require("../../extension/constants/element-type");
+var _core = require("../../extension/core");
+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 === _elementType.LINK) {
+    var _item$title, _item$title$startsWit;
+    const child = children.length === 0 ? {
+      type: 'text',
+      value: ''
+    } : children[0];
+
+    // Mention node
+    if ((_item$title = item.title) !== null && _item$title !== void 0 && (_item$title$startsWit = _item$title.startsWith) !== null && _item$title$startsWit !== void 0 && _item$title$startsWit.call(_item$title, '__sdoc_mention__username')) {
+      const username = item.title.split('__sdoc_mention__username')[1];
+      const mention = {
+        id: _slugid.default.nice(),
+        username,
+        type: 'mention',
+        children: [{
+          id: _slugid.default.nice(),
+          text: child.value
+        }]
+      };
+      result.push(mention);
+      return result;
+    }
+    const linkChildren = [{
+      id: _slugid.default.nice(),
+      text: child.value || ''
+    }];
+    const link = {
+      id: _slugid.default.nice(),
+      type: _elementType.LINK,
+      url: item.url,
+      title: item.title,
+      children: linkChildren
+    };
+    result.push([(0, _core.generateDefaultText)(), link, (0, _core.generateDefaultText)()]);
+    return result;
+  }
+  if (type === _elementType.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: _elementType.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);
+    return;
+  }
+  if (type === 'inlineCode') {
+    textNode['code'] = true;
+    textNode['text'] = value || '';
+    result.push(textNode);
+    return;
+  }
+  const 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(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 = `${_elementType.HEADER}${depth}`;
+  return {
+    id: _slugid.default.nice(),
+    type: type,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+exports.transformHeader = transformHeader;
+const transformParagraph = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+exports.transformParagraph = transformParagraph;
+const transformBlockquote = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.BLOCKQUOTE,
+    children: children.map(child => {
+      const handler = elementHandlers[child.type];
+      return handler(child);
+    }).flat() // flat
+  };
+};
+exports.transformBlockquote = transformBlockquote;
+const transformListContent = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+exports.transformListContent = transformListContent;
+const transformListItem = node => {
+  const {
+    children
+  } = node;
+  if (children.length === 0) {
+    return {
+      id: _slugid.default.nice(),
+      type: _elementType.LIST_ITEM,
+      // eslint-disable-next-line array-callback-return
+      children: [transformListContent({})]
+    };
+  }
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.LIST_ITEM,
+    // eslint-disable-next-line array-callback-return
+    children: children.map(child => {
+      if (child.type === _elementType.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') {
+        return transformList(child);
+      } else if (child.type === 'heading') {
+        return transformParagraph(child);
+      } else if (child.type === 'html') {
+        // patch
+        return transformBlockHtml(child);
+      }
+    }).flat()
+  };
+};
+exports.transformListItem = transformListItem;
+const transformOrderedList = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.ORDERED_LIST,
+    children: children.map(child => transformListItem(child))
+  };
+};
+exports.transformOrderedList = transformOrderedList;
+const transformUnorderedList = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.UNORDERED_LIST,
+    children: children.map(child => transformListItem(child))
+  };
+};
+exports.transformUnorderedList = transformUnorderedList;
+const transformCheckListItem = node => {
+  const {
+    children,
+    checked
+  } = node;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.CHECK_LIST_ITEM,
+    checked: checked,
+    children: children.map(child => transformNodeWithInlineChildren(child)).flat()
+  };
+};
+exports.transformCheckListItem = transformCheckListItem;
+const transformCheckList = node => {
+  const {
+    children
+  } = node;
+  return children.map(child => transformCheckListItem(child));
+};
+exports.transformCheckList = transformCheckList;
+const transformList = node => {
+  const {
+    ordered,
+    children
+  } = node;
+  const firstChild = children[0];
+  if (ordered === true) {
+    return transformOrderedList(node);
+  }
+  if (ordered === false && firstChild.checked === null) {
+    return transformUnorderedList(node);
+  }
+  return transformCheckList(node);
+};
+exports.transformList = transformList;
+const transformTableCell = (cell, align) => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.TABLE_CELL,
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+exports.transformTableCell = transformTableCell;
+const transformTableRow = row => {
+  const {
+    children: cells
+  } = row;
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.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: _elementType.TABLE,
+    align: align,
+    children: rows.map((row, index) => transformTableRow(row))
+  };
+};
+exports.transformTable = transformTable;
+const transformCodeLine = text => {
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.CODE_LINE,
+    children: [{
+      id: _slugid.default.nice(),
+      text: text
+    }]
+  };
+};
+exports.transformCodeLine = transformCodeLine;
+const transformCodeBlock = node => {
+  const {
+    lang,
+    value
+  } = node;
+  let children = value.split('\n').filter(Boolean);
+  if (children.length === 0) {
+    children = [''];
+  }
+  return {
+    id: _slugid.default.nice(),
+    type: _elementType.CODE_BLOCK,
+    lang: lang,
+    children: children.map(text => transformCodeLine(text))
+  };
+};
+exports.transformCodeBlock = transformCodeBlock;
+const transformHr = node => {
+  return {
+    id: _slugid.default.nice(),
+    type: 'hr',
+    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: _elementType.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: _elementType.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/basic-sdk/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 _remarkGfm = _interopRequireDefault(require("remark-gfm"));
+var _remarkMath = _interopRequireDefault(require("remark-math"));
+var _remarkParse = _interopRequireDefault(require("remark-parse"));
+var _remarkStringify = _interopRequireDefault(require("remark-stringify"));
+var _unified = require("unified");
+var _transform = require("./transform");
+const isContentValid = value => {
+  if (!value || !Array.isArray(value)) return false;
+  return true;
+};
+
+// slateNode -> mdast -> mdString
+const slateToMdString = value => {
+  if (!isContentValid(value)) return '';
+  // slateNode -> mdast
+  // https://github.com/syntax-tree/mdast#phrasingcontent
+  const mdASTNodes = (0, _transform.formatSlateToMd)(value);
+  const root = {
+    type: 'root',
+    children: mdASTNodes
+  };
+
+  // convert slate value to md
+  const stringifyOptions = {
+    rule: '-',
+    ruleSpaces: false,
+    bullet: '*',
+    commonmarks: true,
+    fences: true
+  };
+  const 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;