@seafile/sdoc-editor 0.1.0 → 0.1.2

package/dist/utils/diff/index.js

@@ -1,2 +0,0 @@
-import { Diff, Diff3, equalityFunctionForSlate, SlateDiff } from './diff';
-export { Diff, Diff3, equalityFunctionForSlate, SlateDiff };

package/dist/utils/seafile-markdown2html.js

@@ -1,52 +0,0 @@
-var unified = require('unified');
-var markdown = require('remark-parse');
-var slug = require('remark-slug');
-var breaks = require('remark-breaks');
-var remark2rehype = require('remark-rehype');
-var format = require('rehype-format');
-var raw = require('rehype-raw');
-var xtend = require('xtend');
-var toHTML = require('hast-util-to-html');
-var sanitize = require('hast-util-sanitize');
-var gh = require('hast-util-sanitize/lib/github');
-var deepmerge = require('deepmerge').default;
-var mathjax = require('rehype-mathjax/browser');
-var math = require('remark-math/block');
-function stringify(config) {
-  var settings = xtend(config, this.data('settings'));
-  var schema = deepmerge(gh, {
-    'tagNames': ['input', 'code', 'span', 'div', 'blockquote', 'pre'],
-    'attributes': {
-      'input': ['type'],
-      'li': ['className'],
-      'code': ['className'],
-      'span': ['className'],
-      'div': ['className']
-    },
-    'protocols': {
-      'src': ['http', 'https', 'cid']
-    }
-  });
-  this.Compiler = compiler;
-  function compiler(tree) {
-    // use sanity to remove dangerous html, the default is
-    // GitHub style sanitation
-    var hast = sanitize(tree, schema);
-    return toHTML(hast, settings);
-  }
-}
-
-// markdown -> mdast -> html AST -> html
-var processor = unified().use(markdown, {
-  commonmark: true
-}).use(math).use(breaks).use(slug).use(remark2rehype, {
-  allowDangerousHTML: true
-}).use(mathjax, {
-  displayMath: ['$$', '$$']
-}).use(raw).use(format).use(stringify);
-
-// var processorGetAST = unified()
-//   .use(markdown, {commonmark: true})
-//   .use(slug);
-
-export { processor };

package/dist/utils/slate2markdown/deserialize.js

@@ -1,588 +0,0 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import { Text } from 'slate';
-import { generateTable } from '../../containers/element-model/table';
-import { isEmptyParagraph } from '../utils';
-var unified = require('unified');
-var markdown = require('remark-parse');
-var math = require('remark-math/block');
-var definitions = require('mdast-util-definitions');
-function getProcessor() {
-  var processor = unified().use(markdown, {
-    commonmark: true
-  });
-  // Parse formula md string to slate node when editor can insert formula
-  if (window.canInsertFormula) {
-    processor.use(math);
-  }
-  return processor;
-}
-
-// transform code value: a function used to tranform code value of markdown format to slate document
-function mdCodeNodeToSlate(codeValue) {
-  // statement an array : filled width code value splited by '\n'
-  var codeValueArr = codeValue.split(/\n/g);
-  var slateText, slateBlock;
-  // map codeValueArr item to slate document 'code_line'
-  var slate_code_arr = codeValueArr.map(function (text) {
-    // transform string to slateText object
-    slateText = {
-      text: text
-    };
-    // transform slateText to Block object
-    slateBlock = {
-      children: [slateText],
-      type: 'code_line'
-    };
-    return slateBlock;
-  });
-  return slate_code_arr;
-}
-
-// deserialize mdTable to SlateNode
-function mdTableToSlateTable(tableNode, opts) {
-  // get align array
-  var tableAlignArr = tableNode.align;
-  // get all table_rows, return：array
-  var tableRows = tableNode.children;
-  // slate table_row Node into it
-  var tableRowsArr = [];
-  // traverse table_rows
-  for (var rowIndex = 0; rowIndex < tableRows.length; rowIndex++) {
-    // slate table_cell Node into it
-    var tableCellsArr = [];
-    /*
-     * traverse every table_cells of an table_rows,
-     * the length of every table_rows is equal to tableAlign array
-     * */
-    for (var columnsIndex = 0; columnsIndex < tableAlignArr.length; columnsIndex++) {
-      // get table_cell and tranlate it to slate Node: table_cell
-      var tableCell = tableRows[rowIndex].children[columnsIndex];
-      if (!tableCell) {
-        tableCell = {
-          type: 'tableCell',
-          children: [{
-            type: 'paragraph',
-            children: [{
-              text: ''
-            }]
-          }],
-          data: {
-            align: 'left'
-          }
-        };
-      }
-      var children = parseChildren(tableCell, opts);
-      if (children.length === 0) {
-        children.push({
-          text: ''
-        });
-      }
-      tableCell = {
-        type: 'table_cell',
-        children: [{
-          type: 'paragraph',
-          children: children
-        }],
-        data: {
-          align: tableAlignArr[columnsIndex]
-        }
-      };
-      tableCellsArr.push(tableCell);
-    }
-    // push add table_rows into tableRowsArr
-    tableRowsArr.push({
-      type: 'table_row',
-      children: tableCellsArr
-    });
-  }
-  return tableRowsArr;
-}
-function mdImageToSlate(node, opts) {
-  var _DOMParser$parseFromS = new DOMParser().parseFromString(node.value, 'text/html'),
-    body = _DOMParser$parseFromS.body;
-  var img = body.firstChild;
-  var data = {};
-  data['src'] = img.getAttribute('src');
-  if (!isNaN(img.getAttribute('width')) && img.getAttribute('width') > 0) {
-    data['width'] = img.getAttribute('width');
-  }
-  if (!isNaN(img.getAttribute('height')) && img.getAttribute('height') > 0) {
-    data['height'] = img.getAttribute('height');
-  }
-  if (img.getAttribute('alt')) {
-    data['alt'] = img.getAttribute('alt');
-  }
-  if (img.getAttribute('title')) {
-    data['title'] = img.getAttribute('title');
-  }
-  if (data['src']) {
-    return [{
-      text: ''
-    }, {
-      type: 'image',
-      data: data,
-      children: [{
-        text: ''
-      }]
-    }, {
-      text: ''
-    }];
-  }
-}
-function _applyMark(childNodeOrNodes, mark) {
-  if (childNodeOrNodes instanceof Array) {
-    return childNodeOrNodes.map(function (item) {
-      return _applyMark(item, mark);
-    });
-  } else if (childNodeOrNodes.text) {
-    childNodeOrNodes[mark] = true;
-    return childNodeOrNodes;
-  } else {
-    return childNodeOrNodes;
-  }
-}
-function addChildNodeOrNodes(children, childNodeOrNodes) {
-  if (childNodeOrNodes instanceof Array) {
-    childNodeOrNodes.map(function (item) {
-      return children.push(item);
-    });
-  } else {
-    if (childNodeOrNodes !== undefined) children.push(childNodeOrNodes);
-  }
-}
-function parseMark(node, markString, opts) {
-  var mark = markString;
-  var children = [];
-  var _iterator = _createForOfIteratorHelper(node.children),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var child = _step.value;
-      var childNodeOrNodes = _nodeToSlate(child, opts);
-      // ignore unrecognized node type
-      if (!childNodeOrNodes) continue;
-      childNodeOrNodes = _applyMark(childNodeOrNodes, mark);
-      addChildNodeOrNodes(children, childNodeOrNodes);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  return children;
-}
-function parseChildren(node, opts) {
-  var children = [];
-  var _iterator2 = _createForOfIteratorHelper(node.children),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var child = _step2.value;
-      var ret = _nodeToSlate(child, opts);
-      addChildNodeOrNodes(children, ret);
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
-  return children;
-}
-function _nodeToSlate(node, opts) {
-  var children = [];
-  var definition = opts.definition;
-  switch (node.type) {
-    case 'heading':
-      var header_string;
-      children = parseChildren(node, opts);
-      if (children && children.length === 0) {
-        children.push({
-          text: ''
-        });
-      }
-      switch (node.depth) {
-        case 1:
-          header_string = 'header_one';
-          break;
-        case 2:
-          header_string = 'header_two';
-          break;
-        case 3:
-          header_string = 'header_three';
-          break;
-        case 4:
-          header_string = 'header_four';
-          break;
-        case 5:
-          header_string = 'header_five';
-          break;
-        case 6:
-          header_string = 'header_six';
-          break;
-        default:
-          console.log('Invalid depth: ' + node.depth);
-          header_string = 'header_one';
-          break;
-      }
-      return {
-        type: header_string,
-        children: children
-      };
-    case 'paragraph':
-      children = parseChildren(node, opts);
-      if (children.length === 0) {
-        children.push({
-          text: ''
-        });
-      }
-      return {
-        type: 'paragraph',
-        children: children
-      };
-    case 'blockquote':
-      children = parseChildren(node, opts);
-      if (children.length === 0) {
-        children.push({
-          type: 'paragraph',
-          children: [{
-            text: ''
-          }]
-        });
-      }
-      return {
-        type: 'blockquote',
-        children: children
-      };
-    case 'list':
-      opts.loose = node.loose;
-      children = parseChildren(node, opts);
-      if (children.length === 0) {
-        children.push({
-          type: 'list_item',
-          children: [{
-            type: 'paragraph',
-            children: [{
-              text: ''
-            }]
-          }]
-        });
-      }
-      if (node.ordered) {
-        return {
-          type: 'ordered_list',
-          children: children
-        };
-      } else {
-        return {
-          type: 'unordered_list',
-          children: children
-        };
-      }
-    case 'listItem':
-      children = parseChildren(node, opts);
-      if (children.length === 0) {
-        /**
-        * if children is an empty array push an empy paragaph to it
-        */
-        children.push({
-          type: 'paragraph',
-          children: [{
-            text: ''
-          }]
-        });
-      }
-      var data = {};
-      if (node.checked !== null) {
-        data.checked = node.checked;
-      }
-      return {
-        type: 'list_item',
-        data: data,
-        children: children
-      };
-    case 'code':
-      var data = {};
-      if (node.lang) {
-        data.syntax = node.lang;
-      }
-      var slate_code_arr = mdCodeNodeToSlate(node.value);
-      if (slate_code_arr.length === 0) {
-        slate_code_arr.push({
-          type: 'code_line',
-          children: [{
-            text: ''
-          }]
-        });
-      }
-      return {
-        type: 'code_block',
-        data: data,
-        children: slate_code_arr
-      };
-    case 'strong':
-      return parseMark(node, 'BOLD', opts);
-    case 'emphasis':
-      return parseMark(node, 'ITALIC', opts);
-    case 'inlineCode':
-      // Inline code need to be handled differently
-      return {
-        text: node.value,
-        'CODE': true
-      };
-    case 'text':
-      // A plain text in markdown
-      // text is the botton node in Markdown AST
-      return {
-        text: node.value
-      };
-    case 'thematicBreak':
-      return {
-        type: 'hr',
-        children: [{
-          text: ''
-        }]
-      };
-    case 'table':
-      // get all children of table by mdTableToSlateTable
-      children = mdTableToSlateTable(node, opts);
-      if (children.length === 0) {
-        return generateTable();
-      }
-      return {
-        type: 'table',
-        children: children,
-        data: {
-          align: node.align
-        }
-      };
-    case 'html':
-      if (node.value.slice(0, 4).toLowerCase() === '<img') {
-        return mdImageToSlate(node, opts);
-      } else {
-        return {
-          text: ''
-        };
-      }
-    case 'link':
-      children = parseChildren(node, opts);
-      if (children.length === 0) return {
-        text: ''
-      };
-      var data = {
-        href: node.url
-      };
-      if (node.title) {
-        data.title = node.title;
-      }
-      return [{
-        text: ''
-      }, {
-        type: 'link',
-        data: data,
-        children: children
-      }, {
-        text: ''
-      }];
-    case 'image':
-      var data = {
-        src: node.url
-      };
-      if (node.title) {
-        data.title = node.title;
-      }
-      if (node.alt) {
-        data.alt = node.alt;
-      }
-      if (node.width) {
-        data.width = node.width;
-      }
-      if (node.height) {
-        data.height = node.height;
-      }
-      return [{
-        text: ''
-      }, {
-        type: 'image',
-        data: data,
-        children: [{
-          text: ''
-        }]
-      }, {
-        text: ''
-      }];
-    case 'linkReference':
-      children = parseChildren(node, opts);
-      var def = definition(node.identifier);
-      var data = {};
-      if (def) {
-        data.href = def.url;
-        if (def.title) {
-          data.title = def.title;
-        }
-        return {
-          type: 'link',
-          data: data,
-          children: children
-        };
-      } else {
-        return {
-          text: '[' + node.identifier + ']'
-        };
-      }
-    case 'imageReference':
-      var def = definition(node.identifier);
-      var data = {};
-      if (def) {
-        data.src = def.url;
-        if (def.title) {
-          data.title = def.title;
-        }
-        if (node.alt) {
-          data.alt = node.alt;
-        }
-        return {
-          type: 'image',
-          data: data,
-          children: [{
-            text: ''
-          }]
-        };
-      } else {
-        return {
-          text: '![' + node.alt + ']'
-        };
-      }
-    case 'math':
-      {
-        return {
-          type: 'formula',
-          children: [{
-            text: ''
-          }],
-          data: {
-            formula: node.value
-          }
-        };
-      }
-    case 'definition':
-      return;
-    default:
-      console.log('unrecognized type: ' + node.type);
-      return;
-  }
-}
-function fixValue(nodes) {
-  var c = [];
-  var _iterator3 = _createForOfIteratorHelper(nodes),
-    _step3;
-  try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var node = _step3.value;
-      // if node is image node, wrap it into paragraph node
-      if (node.type === 'image') {
-        var data = {};
-        data['src'] = node.data.src;
-        data['width'] = node.data.width || null;
-        data['height'] = node.data.height || null;
-        if (node.data.alt) {
-          data['alt'] = node.data.alt;
-        }
-        if (node.data.title) {
-          data['title'] = node.data.title;
-        }
-        var nodeNew = {
-          type: 'paragraph',
-          children: [{
-            text: ''
-          }, {
-            type: 'image',
-            data: data,
-            children: [{
-              text: '',
-              marks: []
-            }]
-          }, {
-            text: ''
-          }]
-        };
-        c.push(nodeNew);
-      } else if (node.type === 'html_block') {
-        // convert from inline to block
-        node = {
-          type: 'html_block',
-          data: {
-            html: node.get('data').get('html')
-          },
-          children: node.nodes
-        };
-        c.push(node);
-      } else if (!Text.isText(node)) {
-        c.push(node);
-      }
-    }
-  } catch (err) {
-    _iterator3.e(err);
-  } finally {
-    _iterator3.f();
-  }
-  return c;
-}
-function deserialize(content) {
-  // valid input content, maybe a number
-  if (!isNaN(content)) {
-    content = content.toString();
-  }
-  var processor = getProcessor();
-  var root = processor.parse(content);
-  var definition = definitions(root);
-  var nodes = [];
-  var _iterator4 = _createForOfIteratorHelper(root.children),
-    _step4;
-  try {
-    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-      var child = _step4.value;
-      addChildNodeOrNodes(nodes, _nodeToSlate(child, {
-        definition: definition
-      }));
-    }
-  } catch (err) {
-    _iterator4.e(err);
-  } finally {
-    _iterator4.f();
-  }
-  if (nodes.length === 0) {
-    // add default paragraph
-    var node = {
-      type: 'paragraph',
-      children: [{
-        text: ''
-      }]
-    };
-    nodes.push(node);
-  }
-
-  // handle image and html_block
-  var c = fixValue(nodes);
-  var firstBlockType = c[0] && c[0].type;
-  if (firstBlockType === 'table' || firstBlockType === 'code_block' || firstBlockType === 'blockquote') {
-    c.unshift({
-      type: 'paragraph',
-      children: [{
-        text: ''
-      }]
-    });
-  }
-
-  // Do not add an empty paragraph in if the article has only an empty paragraph
-  if (c.length === 1 && isEmptyParagraph(c[0])) {
-    return c;
-  }
-  c.push({
-    type: 'paragraph',
-    children: [{
-      text: ''
-    }]
-  });
-  return c;
-}
-export { deserialize };

package/dist/utils/slate2markdown/index.js

@@ -1,3 +0,0 @@
-import { serialize } from './serialize';
-import { deserialize } from './deserialize';
-export { serialize, deserialize };