dtable-ui-component 0.1.61 → 0.1.65

package/lib/utils/slate2markdown/deserialize.js

@@ -0,0 +1,625 @@
+"use strict";
+
+exports.__esModule = true;
+exports.deserialize = deserialize;
+
+var _slate = require("slate");
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var unified = require('./unified');
+
+var markdown = require('remark-parse');
+
+var definitions = require('mdast-util-definitions');
+
+var processor = unified().use(markdown, {
+  commonmark: true
+}); // 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');
+  var slateTextObj, slateBlockObj; // map codeValueArr item to slate document 'code_line'
+
+  var slate_code_arr = codeValueArr.map(function (text) {
+    // transform string to slateText object
+    slateTextObj = _slate.Text.create({
+      text: text
+    }); // transform slateText to Block object
+
+    slateBlockObj = _slate.Block.create({
+      nodes: [slateTextObj],
+      type: 'code_line'
+    });
+    return slateBlockObj;
+  });
+  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: 'text',
+            value: ''
+          }]
+        };
+      }
+
+      var children = parseChildren(tableCell, opts);
+      tableCell = _slate.Block.create({
+        type: 'table_cell',
+        nodes: [_slate.Block.create({
+          type: 'paragraph',
+          nodes: children
+        })],
+        data: {
+          align: tableAlignArr[columnsIndex]
+        }
+      });
+      tableCellsArr.push(tableCell);
+    } // push add table_rows into tableRowsArr
+
+
+    tableRowsArr.push(_slate.Block.create({
+      type: 'table_row',
+      nodes: 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 _slate.Inline.create({
+      type: 'image',
+      data: data
+    });
+  }
+}
+
+function _applyMark(childNodeOrNodes, mark) {
+  if (childNodeOrNodes instanceof Array) {
+    return childNodeOrNodes.map(function (item) {
+      return _applyMark(item, mark);
+    });
+  } else if (childNodeOrNodes.object == 'text') {
+    var length = childNodeOrNodes.text.length;
+    return childNodeOrNodes.addMark(0, length, mark);
+  } 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);
+  }
+}
+/*
+ parse a mark node.
+ Always return an array.
+
+ Example
+     *fdsfd __fdsf__ fdf*
+*/
+
+
+function parseMark(node, markString, opts) {
+  var mark = _slate.Mark.create({
+    type: markString
+  });
+
+  var children = [];
+
+  for (var _iterator = _createForOfIteratorHelperLoose(node.children), _step; !(_step = _iterator()).done;) {
+    var child = _step.value;
+
+    var childNodeOrNodes = _nodeToSlate(child, opts);
+
+    childNodeOrNodes = _applyMark(childNodeOrNodes, mark);
+    addChildNodeOrNodes(children, childNodeOrNodes);
+  }
+
+  return children;
+}
+
+function parseChildren(node, opts) {
+  var children = [];
+
+  for (var _iterator2 = _createForOfIteratorHelperLoose(node.children), _step2; !(_step2 = _iterator2()).done;) {
+    var child = _step2.value;
+
+    var ret = _nodeToSlate(child, opts);
+
+    addChildNodeOrNodes(children, ret);
+  }
+
+  return children;
+}
+
+function _nodeToSlate(node, opts) {
+  var children = [];
+  var mark;
+  var definition = opts.definition;
+
+  switch (node.type) {
+    case 'heading':
+      var header_string;
+      children = parseChildren(node, opts);
+
+      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 _slate.Block.create({
+        type: header_string,
+        nodes: children
+      });
+
+    case 'paragraph':
+      children = parseChildren(node, opts);
+      return _slate.Block.create({
+        type: 'paragraph',
+        nodes: children
+      });
+
+    case 'blockquote':
+      children = parseChildren(node, opts);
+      return _slate.Block.create({
+        type: 'blockquote',
+        nodes: children
+      });
+
+    case 'list':
+      opts.loose = node.loose;
+      children = parseChildren(node, opts);
+
+      if (node.ordered) {
+        return _slate.Block.create({
+          type: 'ordered_list',
+          nodes: children
+        });
+      } else {
+        return _slate.Block.create({
+          type: 'unordered_list',
+          nodes: 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(_slate.Block.create({
+          type: 'paragraph',
+          nodes: [_slate.Text.create('')]
+        }));
+      }
+
+      var data = {};
+
+      if (node.checked !== null) {
+        data.checked = node.checked;
+      }
+
+      return _slate.Block.create({
+        type: 'list_item',
+        data: data,
+        nodes: children
+      });
+
+    case 'code':
+      var data = {};
+
+      if (node.lang) {
+        data.syntax = node.lang;
+      }
+
+      var slate_code_arr = mdCodeNodeToSlate(node.value);
+      return _slate.Block.create({
+        type: 'code_block',
+        data: data,
+        nodes: 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
+      var mark = _slate.Mark.create({
+        type: 'CODE'
+      });
+
+      return _slate.Text.create({
+        text: node.value,
+        marks: [mark]
+      });
+
+    case 'text':
+      // A plain text in markdown
+      // text is the botton node in Markdown AST
+      return _slate.Text.create({
+        text: node.value
+      });
+
+    case 'break':
+      return _slate.Text.create({
+        text: '\n'
+      });
+
+    case 'thematicBreak':
+      return _slate.Block.create({
+        type: 'hr'
+      });
+
+    case 'table':
+      // get all children of table by mdTableToSlateTable
+      children = mdTableToSlateTable(node, opts);
+      return _slate.Block.create({
+        type: 'table',
+        nodes: children,
+        data: {
+          align: node.align
+        }
+      });
+
+    case 'html':
+      if (node.value.slice(0, 4).toLowerCase() === '<img') {
+        return mdImageToSlate(node, opts);
+      } else {
+        var child = _slate.Text.create({
+          text: ''
+        });
+
+        children.push(child);
+        return _slate.Inline.create({
+          type: 'html_block',
+          data: {
+            html: node.value
+          },
+          nodes: children
+        });
+      }
+
+    case 'link':
+      children = parseChildren(node, opts);
+      var data = {
+        href: node.url
+      };
+
+      if (node.title) {
+        data.title = node.title;
+      }
+
+      return _slate.Inline.create({
+        type: 'link',
+        data: data,
+        nodes: children
+      });
+
+    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 _slate.Inline.create({
+        type: 'image',
+        data: data
+      });
+
+    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 _slate.Inline.create({
+          type: 'link',
+          data: data,
+          nodes: children
+        });
+      } else {
+        return _slate.Text.create({
+          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 _slate.Inline.create({
+          type: 'image',
+          data: data
+        });
+      } else {
+        return _slate.Text.create({
+          text: '![' + node.alt + ']'
+        });
+      }
+
+    case 'definition':
+      return;
+
+    default:
+      console.log('unrecognized type: ' + node.type);
+      return;
+  }
+}
+
+function fixValue(nodes) {
+  var c = [];
+
+  for (var _iterator3 = _createForOfIteratorHelperLoose(nodes), _step3; !(_step3 = _iterator3()).done;) {
+    var node = _step3.value;
+
+    if (node.object === 'inline') {
+      if (node.type === 'image') {
+        var data = {};
+        data['src'] = node.data.get('src');
+        data['width'] = node.data.get('width') || null;
+        data['height'] = node.data.get('height') || null;
+
+        if (node.data.get('alt')) {
+          data['alt'] = node.data.get('alt');
+        }
+
+        if (node.data.get('title')) {
+          data['title'] = node.data.get('title');
+        }
+
+        var nodeNew = _slate.Block.create({
+          type: 'paragraph',
+          nodes: [_slate.Text.create(''), _slate.Inline.create({
+            type: 'image',
+            data: data
+          }), _slate.Text.create('')]
+        });
+
+        c.push(nodeNew);
+      } else {
+        c.push(node);
+      }
+    } else if (node.object === 'block') {
+      if (node.type === 'html_block') {
+        // convert from inline to block
+        node = _slate.Block.create({
+          type: 'html_block',
+          data: {
+            html: node.get('data').get('html')
+          },
+          nodes: node.nodes
+        });
+        c.push(node);
+      } else if (node.type === 'code_block') {
+        c.push(node);
+      } else if (node.type === 'paragraph') {
+        (function () {
+          var nodes = [];
+          var textLeaves = [];
+
+          if (node.nodes.size === 0) {
+            nodes.push(_slate.Text.create(''));
+          } else {
+            node.nodes.forEach(function (node, index, nodesList) {
+              if (node.object === 'text') {
+                textLeaves.push(_slate.Leaf.create({
+                  text: node.text,
+                  marks: node.leaves.get(0).get('marks')
+                }));
+
+                if (index === nodesList.size - 1) {
+                  nodes.push(_slate.Text.create({
+                    leaves: textLeaves
+                  }));
+                  textLeaves = [];
+                }
+              } else {
+                nodes.push(_slate.Text.create({
+                  leaves: textLeaves
+                }));
+                textLeaves = [];
+                var nextNode = nodesList.get(index + 1);
+                nodes.push(node);
+
+                if (!nextNode || nextNode.object !== 'text') {
+                  nodes.push(_slate.Text.create(''));
+                }
+              }
+            });
+          }
+
+          c.push(_slate.Block.create({
+            type: 'paragraph',
+            nodes: nodes
+          }));
+        })();
+      } else {
+        var newNodes = fixValue(node.nodes);
+        c.push(_slate.Block.create({
+          type: node.type,
+          nodes: newNodes,
+          data: node.data
+        }));
+      }
+    } else if (node.object === 'text') {
+      c.push(node);
+    }
+  }
+
+  return c;
+}
+
+function deserialize(content) {
+  var root = processor.parse(content);
+  var definition = definitions(root);
+  var nodes = [];
+
+  for (var _iterator4 = _createForOfIteratorHelperLoose(root.children), _step4; !(_step4 = _iterator4()).done;) {
+    var _child = _step4.value;
+    addChildNodeOrNodes(nodes, _nodeToSlate(_child, {
+      definition: definition
+    }));
+  }
+
+  if (nodes.length === 0) {
+    // add default paragraph
+    var child = _slate.Text.create({
+      text: ''
+    });
+
+    var node = _slate.Block.create({
+      type: 'paragraph',
+      nodes: [child]
+    });
+
+    nodes.push(node);
+  } // handle image and html_block
+
+
+  var c;
+  c = fixValue(nodes);
+  var firstBlockType = c[0].type;
+
+  if (firstBlockType === 'table' || firstBlockType === 'code_block' || firstBlockType === 'blockquote') {
+    c.unshift(_slate.Block.create({
+      type: 'paragraph',
+      nodes: [_slate.Text.create('')]
+    }));
+  }
+
+  var document = _slate.Document.create({
+    nodes: c
+  }); // normalize will cost a lot time, for 40K document, it costs 1.5 seconds
+
+
+  var value = _slate.Value.create({
+    document: document
+  }, {
+    normalize: false
+  });
+
+  return value;
+}

package/lib/utils/slate2markdown/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _serialize = require("./serialize");
+
+exports.serialize = _serialize.serialize;
+
+var _deserialize = require("./deserialize");
+
+exports.deserialize = _deserialize.deserialize;
+
+var _markdown2html = require("./markdown2html");
+
+exports.processor = _markdown2html.processor;
+exports.processorGetAST = _markdown2html.processorGetAST;

package/lib/utils/slate2markdown/markdown2html.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.processorGetAST = exports.processor = void 0;
+
+var _github = _interopRequireDefault(require("hast-util-sanitize/lib/github.json"));
+
+var _unified = _interopRequireDefault(require("./unified"));
+
+var _remarkParse = _interopRequireDefault(require("remark-parse"));
+
+var _remarkSlug = _interopRequireDefault(require("remark-slug"));
+
+var _remarkBreaks = _interopRequireDefault(require("remark-breaks"));
+
+var _remarkRehype = _interopRequireDefault(require("remark-rehype"));
+
+var _rehypeFormat = _interopRequireDefault(require("rehype-format"));
+
+var _rehypeRaw = _interopRequireDefault(require("rehype-raw"));
+
+var _xtend = _interopRequireDefault(require("xtend"));
+
+var _hastUtilToHtml = _interopRequireDefault(require("hast-util-to-html"));
+
+var _hastUtilSanitize = _interopRequireDefault(require("hast-util-sanitize"));
+
+var _deepmerge = _interopRequireDefault(require("deepmerge"));
+
+function stringify(config) {
+  var settings = (0, _xtend.default)(config, this.data('settings'));
+  var schema = (0, _deepmerge.default)(_github.default, {
+    'attributes': {
+      'input': ['type'],
+      'li': ['className'],
+      'code': ['className']
+    },
+    'tagNames': ['input', 'code']
+  });
+  this.Compiler = compiler;
+
+  function compiler(tree) {
+    // use sanity to remove dangerous html, the default is
+    // GitHub style sanitation
+    var hast = (0, _hastUtilSanitize.default)(tree, schema);
+    return (0, _hastUtilToHtml.default)(hast, settings);
+  }
+} // markdown -> mdast -> html AST -> html
+
+
+var processor = (0, _unified.default)().use(_remarkParse.default, {
+  commonmark: true
+}).use(_remarkBreaks.default).use(_remarkSlug.default).use(_remarkRehype.default, {
+  allowDangerousHTML: true
+}).use(_rehypeRaw.default).use(_rehypeFormat.default).use(stringify);
+exports.processor = processor;
+var processorGetAST = (0, _unified.default)().use(_remarkParse.default, {
+  commonmark: true
+}).use(_remarkSlug.default);
+exports.processorGetAST = processorGetAST;