dtable-ui-component 0.1.61 → 0.1.65

package/es/components/cell-formatter/long-text-formatter.js

@@ -67,7 +67,21 @@ var LongTextFormatter = /*#__PURE__*/function (_React$Component) {
       var valueType = Object.prototype.toString.call(value);
 
       if (valueType === '[object String]') {
-        return getPreviewContent(value);
+        var _getPreviewContent = getPreviewContent(value),
+            previewText = _getPreviewContent.previewText,
+            images = _getPreviewContent.images,
+            links = _getPreviewContent.links,
+            checklist = _getPreviewContent.checklist;
+
+        var validValue = Object.assign({}, {
+          text: value,
+          preview: previewText,
+          images: images,
+          links: links,
+          checklist: checklist
+        });
+        console.log(validValue);
+        return validValue;
       }
 
       if (valueType === '[object Object]') {

package/es/utils/normalize-long-text-value.js

@@ -1,68 +1,95 @@
-var hrefReg = /\[.+\]\(\S+\)|<img src=(\S+).+\/>|!\[\]\(\S+\)|<\S+>/g,
-    imageReg1 = /^<img src="(\S+)" .+\/>/,
-    imageReg2 = /^!\[\]\((\S+)\)/,
-    linkReg1 = /^\[.+\]\(\S+\)/,
-    linkReg2 = /^<\S+>$/;
-
-var getLinks = function getLinks(hrefList) {
-  var hrefObj = {
+import { Node } from 'slate';
+import { deserialize } from './slate2markdown';
+
+var getPreviewContent = function getPreviewContent(value) {
+  console.log('longText Source: ', value);
+  var content = deserialize(value);
+  var previewContent = {
+    previewText: '',
+    images: [],
     links: [],
-    images: []
+    checklist: {
+      total: 0,
+      completed: 0
+    }
   };
-  hrefList.forEach(function (href) {
-    if (href.search(linkReg1) >= 0 || href.search(linkReg2) >= 0) {
-      hrefObj.links.push(href);
-    } else {
-      var imageSrcList = href.match(imageReg1);
-      var imageSrcList1 = href.match(imageReg2);
+  getPreviewInfo(content, previewContent);
+  getPreviewText(content, previewContent);
+  console.log('previewContent: ', previewContent);
+  return previewContent;
+};
+
+var getPreviewInfo = function getPreviewInfo(nodes, previewContent) {
+  var nodeIndex = 0;
+
+  while (nodes && nodeIndex <= nodes.length - 1) {
+    var currentNode = nodes[nodeIndex];
 
-      if (imageSrcList) {
-        hrefObj.images.push(imageSrcList[1]);
-      } else if (imageSrcList1) {
-        hrefObj.images.push(imageSrcList1[1]);
+    if (currentNode.type === 'link') {
+      previewContent.links.push(currentNode.data.href);
+    } else if (currentNode.type === 'image') {
+      previewContent.images.push(currentNode.data.src);
+    } else if (currentNode.type === 'list_item' && currentNode.data) {
+      var data = currentNode.data;
+
+      if (data.hasOwnProperty('checked')) {
+        previewContent.checklist.total += 1;
+
+        if (data.checked) {
+          previewContent.checklist.completed++;
+        }
       }
+
+      getPreviewInfo(currentNode.children, previewContent);
+    } else {
+      getPreviewInfo(currentNode.children, previewContent);
     }
-  });
-  return hrefObj;
+
+    nodeIndex++;
+  }
 };
 
-var getPreviewContent = function getPreviewContent(markdownContent) {
-  var preview = '';
-  var newMarkdownContent = markdownContent.replace(hrefReg, '');
+var getTextOfNode = function getTextOfNode(node) {
+  var text = '';
 
-  for (var index = 0; index < newMarkdownContent.length; index++) {
-    if (newMarkdownContent[index] === '#') {
-      continue;
-    } else if (newMarkdownContent[index] === '\n') {
-      preview += ' ';
-    } else {
-      preview += newMarkdownContent[index];
-    }
+  for (var index = 0; index < node.children.length; index++) {
+    var currentNode = node.children[index];
+    var data = currentNode.data;
+    var type = currentNode.type;
 
-    if (preview.length === 30) {
-      break;
+    if (type === 'link') {
+      text += '';
+    } else if (type === 'list_item') {
+      if (data && data.hasOwnProperty('checked')) {
+        text += '';
+      } else {
+        text += Node.text(currentNode) + ' ';
+      }
+    } else {
+      if (currentNode.hasOwnProperty('text')) {
+        text += currentNode.text;
+      } else {
+        text += Node.text(currentNode) + ' ';
+      }
     }
   }
 
-  var hrefList = markdownContent.match(hrefReg);
+  return text;
+};
+
+var getPreviewText = function getPreviewText(content, previewContent) {
+  var previewText = '';
 
-  if (hrefList) {
-    var _getLinks = getLinks(hrefList),
-        images = _getLinks.images,
-        links = _getLinks.links;
+  for (var index = 0; index < content.length; index++) {
+    previewText += getTextOfNode(content[index]) + ' ';
+    var textLength = previewText.length;
 
-    return {
-      preview: preview,
-      images: images,
-      links: links
-    };
+    if (textLength >= 150) {
+      break;
+    }
   }
 
-  return {
-    preview: preview,
-    images: [],
-    links: []
-  };
+  previewContent.previewText = previewText;
 };
 
 export default getPreviewContent;

package/es/utils/slate2markdown/core.js

@@ -0,0 +1,172 @@
+'use strict';
+
+var path = require('path');
+
+var replace = require('replace-ext');
+
+var buffer = require('is-buffer');
+
+module.exports = VFile;
+var own = {}.hasOwnProperty;
+var proto = VFile.prototype;
+proto.toString = toString;
+/* Order of setting (least specific to most), we need this because
+ * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path
+ * is needed before a stem can be set. */
+
+var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
+/* Construct a new file. */
+
+function VFile(options) {
+  var prop;
+  var index;
+  var length;
+
+  if (typeof options === 'number') {
+    options = options.toString();
+  }
+
+  if (!options) {
+    options = {};
+  } else if (typeof options === 'string' || buffer(options)) {
+    options = {
+      contents: options
+    };
+  } else if ('message' in options && 'messages' in options) {
+    return options;
+  }
+
+  if (!(this instanceof VFile)) {
+    return new VFile(options);
+  }
+
+  this.data = {};
+  this.messages = [];
+  this.history = [];
+  this.cwd = process.cwd();
+  /* Set path related properties in the correct order. */
+
+  index = -1;
+  length = order.length;
+
+  while (++index < length) {
+    prop = order[index];
+
+    if (own.call(options, prop)) {
+      this[prop] = options[prop];
+    }
+  }
+  /* Set non-path related properties. */
+
+
+  for (prop in options) {
+    if (order.indexOf(prop) === -1) {
+      this[prop] = options[prop];
+    }
+  }
+}
+/* Access full path (`~/index.min.js`). */
+
+
+Object.defineProperty(proto, 'path', {
+  get: function get() {
+    return this.history[this.history.length - 1];
+  },
+  set: function set(path) {
+    assertNonEmpty(path, 'path');
+
+    if (path !== this.path) {
+      this.history.push(path);
+    }
+  }
+});
+/* Access parent path (`~`). */
+
+Object.defineProperty(proto, 'dirname', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.dirname(this.path) : undefined;
+  },
+  set: function set(dirname) {
+    assertPath(this.path, 'dirname');
+    this.path = path.join(dirname || '', this.basename);
+  }
+});
+/* Access basename (`index.min.js`). */
+
+Object.defineProperty(proto, 'basename', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.basename(this.path) : undefined;
+  },
+  set: function set(basename) {
+    assertNonEmpty(basename, 'basename');
+    assertPart(basename, 'basename');
+    this.path = path.join(this.dirname || '', basename);
+  }
+});
+/* Access extname (`.js`). */
+
+Object.defineProperty(proto, 'extname', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.extname(this.path) : undefined;
+  },
+  set: function set(extname) {
+    var ext = extname || '';
+    assertPart(ext, 'extname');
+    assertPath(this.path, 'extname');
+
+    if (ext) {
+      if (ext.charAt(0) !== '.') {
+        throw new Error('`extname` must start with `.`');
+      }
+
+      if (ext.indexOf('.', 1) !== -1) {
+        throw new Error('`extname` cannot contain multiple dots');
+      }
+    }
+
+    this.path = replace(this.path, ext);
+  }
+});
+/* Access stem (`index.min`). */
+
+Object.defineProperty(proto, 'stem', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;
+  },
+  set: function set(stem) {
+    assertNonEmpty(stem, 'stem');
+    assertPart(stem, 'stem');
+    this.path = path.join(this.dirname || '', stem + (this.extname || ''));
+  }
+});
+/* Get the value of the file. */
+
+function toString(encoding) {
+  var value = this.contents || '';
+  return buffer(value) ? value.toString(encoding) : String(value);
+}
+/* Assert that `part` is not a path (i.e., does
+ * not contain `path.sep`). */
+
+
+function assertPart(part, name) {
+  if (part.indexOf(path.sep) !== -1) {
+    throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');
+  }
+}
+/* Assert that `part` is not empty. */
+
+
+function assertNonEmpty(part, name) {
+  if (!part) {
+    throw new Error('`' + name + '` cannot be empty');
+  }
+}
+/* Assert `path` exists. */
+
+
+function assertPath(path, name) {
+  if (!path) {
+    throw new Error('Setting `' + name + '` requires `path` to be set too');
+  }
+}