dtable-ui-component 0.1.75-beta → 0.1.75-beta1

package/lib/utils/cell-value-validator.js

@@ -0,0 +1,41 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var CellType = _interopRequireWildcard(require("../constants/cell-types"));
+
+var _constants = require("../constants");
+
+var _validators;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var numberValidator = function numberValidator(value) {
+  return (value || value === 0) && Object.prototype.toString.call(value) === '[object Number]';
+};
+
+var textValidator = function textValidator(value) {
+  return !!value;
+};
+
+var checkboxValidator = function checkboxValidator(value) {
+  return typeof value === 'boolean';
+};
+
+var validators = (_validators = {}, _validators[CellType.NUMBER] = numberValidator, _validators[CellType.RATE] = numberValidator, _validators[CellType.DURATION] = numberValidator, _validators[CellType.CHECKBOX] = checkboxValidator, _validators[CellType.TEXT] = textValidator, _validators[CellType.DATE] = textValidator, _validators[CellType.CTIME] = textValidator, _validators[CellType.MTIME] = textValidator, _validators[CellType.GEOLOCATION] = textValidator, _validators[CellType.AUTO_NUMBER] = textValidator, _validators[CellType.URL] = textValidator, _validators[CellType.EMAIL] = textValidator, _validators[_constants.FORMULA_RESULT_TYPE.DATE] = textValidator, _validators[_constants.FORMULA_RESULT_TYPE.STRING] = textValidator, _validators[_constants.FORMULA_RESULT_TYPE.NUMBER] = numberValidator, _validators[_constants.FORMULA_RESULT_TYPE.BOOL] = checkboxValidator, _validators);
+
+var cellValueValidator = function cellValueValidator(cellValue, type) {
+  var validator = validators[type];
+
+  if (validator) {
+    return validator(cellValue);
+  }
+
+  return true;
+};
+
+var _default = cellValueValidator;
+exports.default = _default;

package/lib/utils/column-utils.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isArrayFormalColumn = isArrayFormalColumn;
+exports.isSimpleCellFormatter = isSimpleCellFormatter;
+
+var _constants = require("../constants");
+
+function isSimpleCellFormatter(type) {
+  return _constants.SIMPLE_CELL_COLUMNS.includes(type) || _constants.SIMPLE_CELL_FORMULA_RESULTS.includes(type);
+}
+
+function isArrayFormalColumn(columnType) {
+  return _constants.ARRAY_FORMAL_COLUMNS.includes(columnType);
+}

package/lib/utils/editor-utils.js

@@ -0,0 +1,81 @@
+"use strict";
+
+exports.__esModule = true;
+exports.initDateEditorLanguage = exports.getSelectOptionItem = void 0;
+
+var zhCN = require('@seafile/seafile-calendar/lib/locale/zh_CN');
+
+var zhTW = require('@seafile/seafile-calendar/lib/locale/zh_TW');
+
+var enUS = require('@seafile/seafile-calendar/lib/locale/en_US');
+
+var frFR = require('@seafile/seafile-calendar/lib/locale/fr_FR');
+
+var deDE = require('@seafile/seafile-calendar/lib/locale/de_DE');
+
+var esES = require('@seafile/seafile-calendar/lib/locale/es_ES');
+
+var plPL = require('@seafile/seafile-calendar/lib/locale/pl_PL');
+
+var csCZ = require('@seafile/seafile-calendar/lib/locale/cs_CZ');
+
+var initDateEditorLanguage = function initDateEditorLanguage(lang) {
+  var language;
+
+  switch (lang) {
+    case 'zh-cn':
+      language = zhCN;
+      break;
+
+    case 'zh-tw':
+      language = zhTW;
+      break;
+
+    case 'en':
+      language = enUS;
+      break;
+
+    case 'fr':
+      language = frFR;
+      break;
+
+    case 'de':
+      language = deDE;
+      break;
+
+    case 'es':
+      language = esES;
+      break;
+
+    case 'es-ar':
+      language = esES;
+      break;
+
+    case 'es-mx':
+      language = esES;
+      break;
+
+    case 'pl':
+      language = plPL;
+      break;
+
+    case 'cs':
+      language = csCZ;
+      break;
+
+    default:
+      language = zhCN;
+  }
+
+  return language;
+};
+
+exports.initDateEditorLanguage = initDateEditorLanguage;
+
+var getSelectOptionItem = function getSelectOptionItem(options, optionId) {
+  return options.find(function (option) {
+    return option.id === optionId;
+  });
+};
+
+exports.getSelectOptionItem = getSelectOptionItem;

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,181 @@
+"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) {
+      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;