dtable-ui-component 0.1.74 → 0.1.75-beta3

package/lib/utils/markdown2html.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.processorGetAST = exports.processor = void 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, {
+    'attributes': {
+      'input': ['type'],
+      'li': ['className'],
+      'code': ['className'],
+      'span': ['className'],
+      'div': ['className']
+    },
+    'tagNames': ['input', 'code', 'span', 'div']
+  });
+  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);
+exports.processor = processor;
+var processorGetAST = unified().use(markdown, {
+  commonmark: true
+}).use(slug);
+exports.processorGetAST = processorGetAST;

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

@@ -0,0 +1,74 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var hrefReg = /\[.+\]\(\S+\)|<img src=(\S+).+\/>|!\[\]\(\S+\)|<\S+>/g;
+var imageReg1 = /^<img( width=[\\|/|"](\d)+[\\|/|"])? src="(\S+)" .?\/>/;
+var imageReg2 = /^!\[\]\((\S+)\)/;
+var linkReg1 = /^\[.+\]\(\S+\)/;
+var linkReg2 = /^<\S+>$/;
+
+var getLinks = function getLinks(hrefList) {
+  var hrefObj = {
+    links: [],
+    images: []
+  };
+  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);
+
+      if (imageSrcList) {
+        hrefObj.images.push(imageSrcList[1]);
+      } else if (imageSrcList1) {
+        hrefObj.images.push(imageSrcList1[1]);
+      }
+    }
+  });
+  return hrefObj;
+};
+
+var getPreviewContent = function getPreviewContent(markdownContent) {
+  var preview = '';
+  var newMarkdownContent = markdownContent.replace(hrefReg, '');
+
+  for (var index = 0; index < newMarkdownContent.length; index++) {
+    if (newMarkdownContent[index] === '#') {
+      continue;
+    } else if (newMarkdownContent[index] === '\n') {
+      preview += ' ';
+    } else {
+      preview += newMarkdownContent[index];
+    }
+
+    if (preview.length === 150) {
+      break;
+    }
+  }
+
+  var hrefList = markdownContent.match(hrefReg);
+
+  if (hrefList) {
+    var _getLinks = getLinks(hrefList),
+        images = _getLinks.images,
+        links = _getLinks.links;
+
+    return {
+      preview: preview,
+      images: images,
+      links: links
+    };
+  }
+
+  return {
+    preview: preview,
+    images: [],
+    links: [],
+    text: markdownContent
+  };
+};
+
+var _default = getPreviewContent;
+exports.default = _default;

package/lib/utils/number-precision.js

@@ -0,0 +1,182 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+exports.digitLength = digitLength;
+exports.divide = divide;
+exports.enableBoundaryChecking = enableBoundaryChecking;
+exports.float2Fixed = float2Fixed;
+exports.minus = minus;
+exports.plus = plus;
+exports.round = round;
+exports.strip = strip;
+exports.times = times;
+
+/**
+ * @desc Solve the problem of floating calculation, avoid multiple digits after the decimal point and loss of calculation accuracy.
+ * example: 3 + 2.4 = 4.699999999999999，1.0 - 0.9 = 0.09999999999999998
+ */
+
+/**
+ * Correct wrong data
+ * strip(0.09999999999999998)=0.1
+ */
+function strip(num, precision) {
+  if (precision === void 0) {
+    precision = 12;
+  }
+
+  return +parseFloat(num.toPrecision(precision));
+}
+/**
+ * Return digits length of a number
+ * @param {*number} num Input number
+ */
+
+
+function digitLength(num) {
+  // Get digit length of e
+  var eSplit = num.toString().split(/[eE]/);
+  var len = (eSplit[0].split('.')[1] || '').length - +(eSplit[1] || 0);
+  return len > 0 ? len : 0;
+}
+/**
+ * Convert decimals to integers and support scientific notation. If it is a decimal, it is enlarged to an integer
+ * @param {*number} num Number of inputs
+ */
+
+
+function float2Fixed(num) {
+  if (num.toString().indexOf('e') === -1) {
+    return Number(num.toString().replace('.', ''));
+  }
+
+  var dLen = digitLength(num);
+  return dLen > 0 ? strip(num * Math.pow(10, dLen)) : num;
+}
+/**
+ * Check whether the number is out of range, and give a prompt if it is out of range
+ * @param {*number} num Number of inputs
+ */
+
+
+function checkBoundary(num) {
+  if (_boundaryCheckingState) {
+    if (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) {
+      // eslint-disable-next-line no-console
+      console.warn(num + " is beyond boundary when transfer to integer, the results may not be accurate");
+    }
+  }
+}
+/**
+ * Exact multiplication
+ */
+
+
+function times(num1, num2) {
+  for (var _len = arguments.length, others = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    others[_key - 2] = arguments[_key];
+  }
+
+  if (others.length > 0) {
+    return times.apply(void 0, [times(num1, num2), others[0]].concat(others.slice(1)));
+  }
+
+  var num1Changed = float2Fixed(num1);
+  var num2Changed = float2Fixed(num2);
+  var baseNum = digitLength(num1) + digitLength(num2);
+  var leftValue = num1Changed * num2Changed;
+  checkBoundary(leftValue);
+  return leftValue / Math.pow(10, baseNum);
+}
+/**
+ * Exact addition
+ */
+
+
+function plus(num1, num2) {
+  for (var _len2 = arguments.length, others = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+    others[_key2 - 2] = arguments[_key2];
+  }
+
+  if (others.length > 0) {
+    return plus.apply(void 0, [plus(num1, num2), others[0]].concat(others.slice(1)));
+  }
+
+  var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));
+  return (times(num1, baseNum) + times(num2, baseNum)) / baseNum;
+}
+/**
+ * Exact subtraction
+ */
+
+
+function minus(num1, num2) {
+  for (var _len3 = arguments.length, others = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+    others[_key3 - 2] = arguments[_key3];
+  }
+
+  if (others.length > 0) {
+    return minus.apply(void 0, [minus(num1, num2), others[0]].concat(others.slice(1)));
+  }
+
+  var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));
+  return (times(num1, baseNum) - times(num2, baseNum)) / baseNum;
+}
+/**
+ * Exact division
+ */
+
+
+function divide(num1, num2) {
+  for (var _len4 = arguments.length, others = new Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
+    others[_key4 - 2] = arguments[_key4];
+  }
+
+  if (others.length > 0) {
+    return divide.apply(void 0, [divide(num1, num2), others[0]].concat(others.slice(1)));
+  }
+
+  var num1Changed = float2Fixed(num1);
+  var num2Changed = float2Fixed(num2);
+  checkBoundary(num1Changed);
+  checkBoundary(num2Changed); // fix: Similar to 10 ** -4 is 0.00009999999999999999, strip correction
+
+  return times(num1Changed / num2Changed, strip(Math.pow(10, digitLength(num2) - digitLength(num1))));
+}
+/**
+ * rounding
+ */
+
+
+function round(num, ratio) {
+  var base = Math.pow(10, ratio);
+  return divide(Math.round(times(num, base)), base);
+}
+
+var _boundaryCheckingState = true;
+/**
+ * Whether to perform boundary check, default true
+ * @param flag Mark switch, true is on, false is off, default is true
+ */
+
+function enableBoundaryChecking(flag) {
+  if (flag === void 0) {
+    flag = true;
+  }
+
+  _boundaryCheckingState = flag;
+}
+
+var _default = {
+  strip: strip,
+  plus: plus,
+  minus: minus,
+  times: times,
+  divide: divide,
+  round: round,
+  digitLength: digitLength,
+  float2Fixed: float2Fixed,
+  enableBoundaryChecking: enableBoundaryChecking
+};
+exports.default = _default;