@seafile/sdoc-editor 0.4.35 → 0.4.37

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

@@ -0,0 +1,360 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import slugid from 'slugid';
+import { generateDefaultText } from '../../basic-sdk/extension/core';
+import { BLOCKQUOTE, HEADER, IMAGE, LINK, PARAGRAPH, TABLE, CODE_BLOCK, LIST_ITEM, ORDERED_LIST, UNORDERED_LIST, CHECK_LIST_ITEM, CODE_LINE, TABLE_ROW, TABLE_CELL } from '../../basic-sdk/extension/constants/element-type';
+import deserializeHtml from '../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 === LINK) {
+    const child = children.length === 0 ? {
+      type: 'text',
+      value: ''
+    } : children[0];
+    const linkChildren = [{
+      id: slugid.nice(),
+      text: child.value
+    }];
+    const link = {
+      id: slugid.nice(),
+      type: LINK,
+      url: item.url,
+      title: item.title,
+      children: linkChildren
+    };
+    result.push([generateDefaultText(), link, generateDefaultText()]);
+    return result;
+  }
+  if (type === IMAGE) {
+    const data = _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+      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.nice(),
+      data: data,
+      type: IMAGE,
+      children: [generateDefaultText()]
+    };
+    result.push([generateDefaultText(), image, generateDefaultText()]);
+    return result;
+  }
+
+  // Handle special images
+  if (type === 'html') {
+    const nodes = transformHtml(item);
+    result.push(nodes);
+    return result;
+  }
+  if (!textNode.id) {
+    textNode['id'] = slugid.nice();
+  }
+  if (type === 'text') {
+    textNode['text'] = value || '';
+    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 = [generateDefaultText()];
+  if (!children || !Array.isArray(children) || children.length === 0) {
+    return defaultChildren;
+  }
+  const result = [];
+  children.forEach(item => applyMarkForInlineItem(result, item));
+  return result.flat();
+};
+export const transformHeader = node => {
+  const {
+    depth
+  } = node;
+  const type = "".concat(HEADER).concat(depth);
+  return {
+    id: slugid.nice(),
+    type: type,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+export const transformParagraph = node => {
+  return {
+    id: slugid.nice(),
+    type: PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+export const transformBlockquote = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: slugid.nice(),
+    type: BLOCKQUOTE,
+    children: children.map(child => {
+      const handler = elementHandlers[child.type];
+      return handler(child);
+    }).flat() // flat
+  };
+};
+
+export const transformListContent = node => {
+  return {
+    id: slugid.nice(),
+    type: PARAGRAPH,
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+export const transformListItem = node => {
+  const {
+    children
+  } = node;
+  if (children.length === 0) {
+    return {
+      id: slugid.nice(),
+      type: LIST_ITEM,
+      // eslint-disable-next-line array-callback-return
+      children: [transformListContent({})]
+    };
+  }
+  return {
+    id: slugid.nice(),
+    type: LIST_ITEM,
+    // eslint-disable-next-line array-callback-return
+    children: children.map(child => {
+      if (child.type === 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 === 'html') {
+        // patch
+        return transformBlockHtml(child);
+      }
+    }).flat()
+  };
+};
+export const transformOrderedList = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: slugid.nice(),
+    type: ORDERED_LIST,
+    children: children.map(child => transformListItem(child))
+  };
+};
+export const transformUnorderedList = node => {
+  const {
+    children
+  } = node;
+  return {
+    id: slugid.nice(),
+    type: UNORDERED_LIST,
+    children: children.map(child => transformListItem(child))
+  };
+};
+export const transformCheckListItem = node => {
+  const {
+    children,
+    checked
+  } = node;
+  return {
+    id: slugid.nice(),
+    type: CHECK_LIST_ITEM,
+    checked: checked,
+    children: children.map(child => transformNodeWithInlineChildren(child)).flat()
+  };
+};
+export const transformCheckList = node => {
+  const {
+    children
+  } = node;
+  return children.map(child => transformCheckListItem(child));
+};
+export 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);
+};
+export const transformTableCell = (cell, align) => {
+  return {
+    id: slugid.nice(),
+    type: TABLE_CELL,
+    align: align || null,
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+export const transformTableRow = (row, align) => {
+  const {
+    children: cells
+  } = row;
+  return {
+    id: slugid.nice(),
+    type: TABLE_ROW,
+    children: cells.map(cell => transformTableCell(cell, align))
+  };
+};
+export const transformTable = node => {
+  const {
+    children: rows,
+    align = []
+  } = node;
+  return {
+    id: slugid.nice(),
+    type: TABLE,
+    children: rows.map((row, index) => transformTableRow(row, align[index]))
+  };
+};
+export const transformCodeLine = text => {
+  return {
+    id: slugid.nice(),
+    type: CODE_LINE,
+    children: [{
+      id: slugid.nice(),
+      text: text
+    }]
+  };
+};
+export const transformCodeBlock = node => {
+  const {
+    lang,
+    value
+  } = node;
+  let children = value.split('\n').filter(Boolean);
+  if (children.length === 0) {
+    children = [''];
+  }
+  return {
+    id: slugid.nice(),
+    type: CODE_BLOCK,
+    lang: lang,
+    children: children.map(text => transformCodeLine(text))
+  };
+};
+export const transformHr = node => {
+  return {
+    id: slugid.nice(),
+    type: 'hr',
+    children: [generateDefaultText()]
+  };
+};
+export const transformHtml = node => {
+  const defaultTextNode = 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 = _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+      src: src
+    }, alt && {
+      alt
+    }), title && {
+      title
+    }), !isNaN(width) && width > 0 && {
+      width
+    }), !isNaN(height) && height > 0 && {
+      height
+    });
+    const image = {
+      id: slugid.nice(),
+      data: data,
+      type: IMAGE,
+      children: [generateDefaultText()]
+    };
+    return [generateDefaultText(), image, generateDefaultText()];
+  }
+  return [defaultTextNode];
+};
+export const transformBlockHtml = node => {
+  if (node.value.slice(0, 4).toLowerCase() === '<img') {
+    return {
+      id: slugid.nice(),
+      type: PARAGRAPH,
+      children: transformHtml(node)
+    };
+  }
+  return deserializeHtml(node.value);
+};
+export const transformMath = node => {
+  return {
+    id: slugid.nice(),
+    type: 'formula',
+    data: {
+      formula: node.value
+    },
+    children: [generateDefaultText()]
+  };
+};
+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
+};
+export const formatMdToSlate = children => {
+  const validChildren = children.filter(child => elementHandlers[child.type]);
+  return validChildren.map(child => {
+    const handler = elementHandlers[child.type];
+    return handler(child);
+  }).flat();
+};

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

@@ -0,0 +1,37 @@
+import { unified } from 'unified';
+import markdown from 'remark-parse';
+import gfm from 'remark-gfm';
+import remarkStringify from 'remark-stringify';
+import remarkMath from 'remark-math';
+import { formatSlateToMd } from './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 = 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 = unified().use(markdown).use(gfm).use(remarkStringify, stringifyOptions).use(remarkMath).stringify(root);
+  return res;
+};
+
+// transform rules: https://github.com/syntax-tree/mdast
+
+export default slateToMdString;

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

@@ -0,0 +1,311 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import isLastCharPunctuation from '../../utils/is-punctuation-mark';
+const generateDefaultText = () => {
+  return {
+    type: 'text',
+    value: ''
+  };
+};
+const transformTextNode = textNode => {
+  let mdNode = {
+    type: 'text',
+    value: textNode.text
+  };
+
+  // code = true, override text type
+  if (textNode['code']) {
+    mdNode = _objectSpread(_objectSpread({}, mdNode), {}, {
+      type: 'inlineCode'
+    });
+  }
+
+  // blob = true, add strong parent
+  if (textNode['bold']) {
+    mdNode['value'] = mdNode.value ? mdNode.value.trim() : '';
+    if (isLastCharPunctuation(mdNode.value)) {
+      const value = mdNode.value;
+      const mdNode1 = _objectSpread(_objectSpread({}, mdNode), {}, {
+        value: value.substring(0, value.length - 1)
+      });
+      const mdNode2 = {
+        type: 'text',
+        value: value.substring(value.length - 1)
+      };
+      mdNode = [{
+        type: 'strong',
+        children: [mdNode1]
+      }, mdNode2];
+    } else {
+      mdNode = {
+        type: 'strong',
+        children: [mdNode]
+      };
+    }
+  }
+
+  // italic = true, add emphasis parent
+  if (textNode['italic'] && mdNode.type === 'strong') {
+    mdNode = {
+      type: 'emphasis',
+      children: [mdNode]
+    };
+  } else if (textNode['italic']) {
+    mdNode['value'] = mdNode.value ? mdNode.value.trim() : '';
+    if (isLastCharPunctuation(mdNode.value)) {
+      const value = mdNode.value;
+      const mdNode1 = _objectSpread(_objectSpread({}, mdNode), {}, {
+        value: value.substring(0, value.length - 1)
+      });
+      const mdNode2 = {
+        type: 'text',
+        value: value.substring(value.length - 1)
+      };
+      mdNode = [{
+        type: 'emphasis',
+        children: [mdNode1]
+      }, mdNode2];
+    } else {
+      mdNode = {
+        type: 'emphasis',
+        children: [mdNode]
+      };
+    }
+  }
+  return mdNode;
+};
+const transformInlineChildren = (result, item) => {
+  // image
+  if (item.type && item.type === 'image') {
+    const {
+      data
+    } = item;
+    let 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') {
+    const link = {
+      type: 'link',
+      url: item.url,
+      title: item.title || null,
+      children: [transformTextNode(item.children[0])]
+    };
+    result.push(link);
+    return result;
+  }
+  if (item.type && item.type === 'column') {
+    const data = item.data;
+    const newNode = {
+      text: "{".concat(data.name, "}")
+    };
+    const column = transformTextNode(newNode);
+    result.push(column);
+    return result;
+  }
+
+  // text
+  const nodes = transformTextNode(item);
+  result.push(nodes);
+  return result;
+};
+const transformNodeWithInlineChildren = node => {
+  const {
+    children
+  } = node;
+  const defaultChildren = [generateDefaultText()];
+  if (!children || !Array.isArray(children) || children.length === 0) {
+    return defaultChildren;
+  }
+  const result = [];
+  children.forEach(item => transformInlineChildren(result, item));
+  return result.flat();
+};
+const transformHeader = node => {
+  const level = node.type.replace('header', '');
+  return {
+    type: 'heading',
+    depth: parseInt(level),
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+const transformParagraph = node => {
+  return {
+    type: 'paragraph',
+    children: transformNodeWithInlineChildren(node)
+  };
+};
+const transformBlockquote = node => {
+  const {
+    children
+  } = node;
+  return {
+    type: 'blockquote',
+    children: children.map(child => {
+      const handler = elementHandlers[child.type];
+      return handler(child);
+    }).flat() // flat
+  };
+};
+
+const transformCheckList = node => {
+  return {
+    type: 'list',
+    ordered: false,
+    start: null,
+    spread: false,
+    children: [{
+      type: 'listItem',
+      spread: false,
+      checked: node.checked,
+      children: [transformParagraph(node)]
+    }]
+  };
+};
+const transformListContent = node => {
+  return transformParagraph(node);
+};
+const transformListItem = node => {
+  let loose = false;
+  const {
+    children
+  } = node;
+  // eslint-disable-next-line array-callback-return
+  const newChildren = children.map(child => {
+    if (child.type === 'paragraph') {
+      return transformListContent(child);
+    }
+    if (child.type === 'code_block') {
+      return transformCodeBlock(child);
+    }
+    if (child.type === 'blockquote') {
+      return transformBlockquote(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
+  };
+};
+const transformList = node => {
+  const {
+    children
+  } = node;
+  const newChildren = children.map(child => transformListItem(child));
+  let loose = false;
+  for (let node of newChildren) {
+    if (node.loose === true) {
+      loose = true;
+      break;
+    }
+  }
+  return {
+    type: 'list',
+    ordered: node.type === 'ordered_list',
+    // ordered_list | unordered_list
+    start: 1,
+    loose: loose,
+    children: newChildren
+  };
+};
+const transformTableCell = cell => {
+  return {
+    type: 'tableCell',
+    children: transformNodeWithInlineChildren(cell)
+  };
+};
+const transformTableRow = row => {
+  const {
+    children: cells
+  } = row;
+  return {
+    type: 'tableRow',
+    children: cells.map(cell => transformTableCell(cell))
+  };
+};
+const transformTable = node => {
+  const {
+    children: rows
+  } = node;
+  const align = rows.map(row => {
+    var _cells$;
+    const {
+      children: cells
+    } = row;
+    return ((_cells$ = cells[0]) === null || _cells$ === void 0 ? void 0 : _cells$.align) || null;
+  });
+  return {
+    type: 'table',
+    align: align,
+    children: rows.map(row => transformTableRow(row))
+  };
+};
+const transformCodeLine = node => {
+  var _node$children$;
+  const text = ((_node$children$ = node.children[0]) === null || _node$children$ === void 0 ? void 0 : _node$children$.text) || '';
+  return text;
+};
+const transformCodeBlock = node => {
+  const {
+    children
+  } = node;
+  return {
+    type: 'code',
+    lang: node.lang ? node.lang : null,
+    value: children.map(child => transformCodeLine(child)).join('\n')
+  };
+};
+const transformFormula = node => {
+  const data = node.data;
+  return {
+    type: 'math',
+    value: data.formula
+  };
+};
+const 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
+};
+export const formatSlateToMd = children => {
+  const validChildren = children.filter(child => elementHandlers[child.type]);
+  return validChildren.map(child => {
+    const handler = elementHandlers[child.type];
+    return handler(child);
+  }).flat();
+};

package/dist/utils/get-event-transfer.js

@@ -4,7 +4,9 @@ const {
   TEXT
 } = TransferTypes;
 function getEventTransfer(event) {
-  let html, text, files;
+  let html;
+  let text;
+  let files;
   if (window.isMobile) {
     if (window.dtableTransfer) {
       text = window.dtableTransfer['TEXT'];