dtable-ui-component 0.3.2-alpha4 → 0.3.2-alpha6

package/lib/RowExpandLinkFormatter/index.js

@@ -0,0 +1,174 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React, { Component } from 'react';
+import { CellType } from 'dtable-store';
+import { MultipleSelectFormatter, DateFormatter, CTimeFormatter, MTimeFormatter } from '../index';
+import CollaboratorItemFormatter from './collaborator-item-formatter';
+import { getFormulaArrayValue, isArrayFormalColumn } from './utils';
+import { getCellDisplayValue } from './value-display-utils';
+import './index.css';
+
+var RowExpandLinkFormatter = /*#__PURE__*/function (_Component) {
+  _inherits(RowExpandLinkFormatter, _Component);
+
+  var _super = _createSuper(RowExpandLinkFormatter);
+
+  function RowExpandLinkFormatter() {
+    _classCallCheck(this, RowExpandLinkFormatter);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(RowExpandLinkFormatter, [{
+    key: "render",
+    value: function render() {
+      var props = this.props;
+      var column = props.column,
+          value = props.value,
+          containerClassName = props.containerClassName,
+          collaborators = props.collaborators;
+      var data = column.data;
+
+      if (!Array.isArray(value) || value.length === 0) {
+        return props.renderEmpty();
+      }
+
+      var _ref = data || {},
+          displayColumn = _ref.display_column;
+
+      if (!displayColumn) {
+        return props.renderEmpty();
+      }
+
+      var displayColumnType = displayColumn.type,
+          displayColumnData = displayColumn.data;
+      var cellValue = getFormulaArrayValue(value, !isArrayFormalColumn(displayColumnType));
+
+      if (!Array.isArray(cellValue) || cellValue.length === 0) {
+        return props.renderEmpty();
+      }
+
+      switch (displayColumnType) {
+        case CellType.TEXT:
+        case CellType.AUTO_NUMBER:
+        case CellType.EMAIL:
+        case CellType.URL:
+        case CellType.DURATION:
+        case CellType.NUMBER:
+          {
+            return /*#__PURE__*/React.createElement("div", {
+              className: containerClassName
+            }, cellValue.map(function (value, index) {
+              if (!value) return null;
+              return /*#__PURE__*/React.createElement("div", {
+                key: "link-".concat(displayColumnType, "-").concat(index),
+                className: "row-expand-link-item"
+              }, value);
+            }));
+          }
+
+        case CellType.DATE:
+          {
+            return /*#__PURE__*/React.createElement("div", {
+              className: containerClassName
+            }, cellValue.map(function (value, index) {
+              if (!value || typeof value !== 'string') return null;
+
+              var _ref2 = displayColumnData || {},
+                  format = _ref2.format;
+
+              return /*#__PURE__*/React.createElement(DateFormatter, {
+                key: "link-".concat(displayColumnType, "-").concat(index),
+                value: value.replace('T', ' ').replace('Z', ''),
+                format: format,
+                containerClassName: "row-expand-link-item"
+              });
+            }));
+          }
+
+        case CellType.CTIME:
+          {
+            return /*#__PURE__*/React.createElement("div", {
+              className: containerClassName
+            }, cellValue.map(function (value, index) {
+              if (!value) return null;
+              return /*#__PURE__*/React.createElement(CTimeFormatter, {
+                key: "link-".concat(displayColumnType, "-").concat(index),
+                value: value,
+                containerClassName: "row-expand-link-item"
+              });
+            }));
+          }
+
+        case CellType.MTIME:
+          {
+            return /*#__PURE__*/React.createElement("div", {
+              className: containerClassName
+            }, cellValue.map(function (value, index) {
+              if (!value) return null;
+              return /*#__PURE__*/React.createElement(MTimeFormatter, {
+                key: "link-".concat(displayColumnType, "-").concat(index),
+                value: value,
+                containerClassName: "row-expand-link-item"
+              });
+            }));
+          }
+
+        case CellType.CREATOR:
+        case CellType.LAST_MODIFIER:
+          {
+            return /*#__PURE__*/React.createElement("div", {
+              className: "dtable-ui cell-formatter-container collaborator-formatter sql-query-collaborator-formatter"
+            }, cellValue.map(function (value, index) {
+              if (!value) return null;
+              return /*#__PURE__*/React.createElement(CollaboratorItemFormatter, {
+                key: "link-".concat(displayColumnType, "-").concat(index),
+                cellValue: value,
+                collaborators: collaborators,
+                context: props.context,
+                renderEmpty: props.renderEmpty
+              });
+            }));
+          }
+
+        case CellType.SINGLE_SELECT:
+          {
+            if (!cellValue || cellValue.length === 0) {
+              return props.renderEmpty();
+            }
+
+            var options = displayColumnData && Array.isArray(displayColumnData.options) ? displayColumnData.options : [];
+            return /*#__PURE__*/React.createElement(MultipleSelectFormatter, {
+              value: cellValue,
+              options: options || []
+            });
+          }
+
+        case CellType.FORMULA:
+          {
+            return /*#__PURE__*/React.createElement("div", {
+              className: containerClassName
+            }, cellValue.map(function (value, index) {
+              if (!value) return null;
+              return /*#__PURE__*/React.createElement("div", {
+                key: "link-".concat(displayColumnType, "-").concat(index),
+                className: "row-expand-link-item"
+              }, getCellDisplayValue(_defineProperty({}, displayColumn.key, value), displayColumn, collaborators));
+            }));
+          }
+
+        default:
+          {
+            return props.renderEmpty();
+          }
+      }
+    }
+  }]);
+
+  return RowExpandLinkFormatter;
+}(Component);
+
+export { RowExpandLinkFormatter as default };

package/lib/RowExpandLinkFormatter/number-precision.js

@@ -0,0 +1,116 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+
+function strip(num) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 12;
+  return +parseFloat(num.toPrecision(precision));
+}
+
+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;
+}
+
+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;
+}
+
+function checkBoundary(num) {
+  if (_boundaryCheckingState) {
+    if (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) {
+      // eslint-disable-next-line no-console
+      console.warn("".concat(num, " is beyond boundary when transfer to integer, the results may not be accurate"));
+    }
+  }
+}
+
+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(_toConsumableArray(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);
+}
+
+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(_toConsumableArray(others.slice(1))));
+  }
+
+  var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));
+  return (times(num1, baseNum) + times(num2, baseNum)) / baseNum;
+}
+
+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(_toConsumableArray(others.slice(1))));
+  }
+
+  var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));
+  return (times(num1, baseNum) - times(num2, baseNum)) / baseNum;
+}
+
+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(_toConsumableArray(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))));
+}
+
+function round(num, ratio) {
+  var base = Math.pow(10, ratio);
+  return divide(Math.round(times(num, base)), base);
+}
+
+var _boundaryCheckingState = true;
+
+function enableBoundaryChecking() {
+  var flag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  _boundaryCheckingState = flag;
+}
+
+export { strip, plus, minus, times, divide, round, digitLength, float2Fixed, enableBoundaryChecking };
+export default {
+  strip: strip,
+  plus: plus,
+  minus: minus,
+  times: times,
+  divide: divide,
+  round: round,
+  digitLength: digitLength,
+  float2Fixed: float2Fixed,
+  enableBoundaryChecking: enableBoundaryChecking
+};

package/lib/RowExpandLinkFormatter/utils.js

@@ -0,0 +1,58 @@
+import { CellType } from 'dtable-store';
+export var isValidCellValue = function isValidCellValue(value) {
+  if (value === undefined) return false;
+  if (value === null) return false;
+  if (value === '') return false;
+  if (JSON.stringify(value) === '{}') return false;
+  if (JSON.stringify(value) === '[]') return false;
+  return true;
+};
+export var getFormulaArrayValue = function getFormulaArrayValue(value) {
+  var isFlat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!Array.isArray(value)) return [];
+  if (!isFlat) return getTwoDimensionArrayValue(value);
+  return value.map(function (item) {
+    if (Object.prototype.toString.call(item) !== '[object Object]') {
+      return item;
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(item, 'display_value')) return item;
+    var display_value = item.display_value;
+    if (!Array.isArray(display_value) || display_value.length === 0) return display_value;
+    return display_value.map(function (i) {
+      if (Object.prototype.toString.call(i) === '[object Object]') {
+        if (!Object.prototype.hasOwnProperty.call(i, 'display_value')) return i;
+        var _display_value = i.display_value;
+        return _display_value;
+      }
+
+      return i;
+    });
+  }).flat().filter(function (item) {
+    return isValidCellValue(item);
+  });
+};
+export var getTwoDimensionArrayValue = function getTwoDimensionArrayValue(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(function (item) {
+    if (Object.prototype.toString.call(item) !== '[object Object]') {
+      return item;
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(item, 'display_value')) return item;
+    var display_value = item.display_value;
+    if (!Array.isArray(display_value) || display_value.length === 0) return display_value;
+    return display_value.map(function (i) {
+      if (Object.prototype.toString.call(i) === '[object Object]') {
+        if (!Object.prototype.hasOwnProperty.call(i, 'display_value')) return i;
+        var _display_value2 = i.display_value;
+        return _display_value2;
+      }
+
+      return i;
+    });
+  });
+};
+export function isArrayFormalColumn(columnType) {
+  return [CellType.IMAGE, CellType.FILE, CellType.MULTIPLE_SELECT, CellType.COLLABORATOR].includes(columnType);
+}