dtable-utils 0.0.3 → 4.2.0

package/es/cell-value-get/option.js

@@ -1,20 +1,44 @@
+import { getColumnOptions } from '../column/option.js';
+
+/**
+ * Get option by id
+ * @param {array} options e.g. [{ id, name, ... }]
+ * @param {string} optionId
+ * @returns option, object
+ */
+var getOption = function getOption(options, optionId) {
+  if (!Array.isArray(options) || !optionId) return null;
+  return options.find(function (option) {
+    return option.id === optionId;
+  });
+};
+
 /**
  * Get option name of the given id
- * @param {array} options e.g. [ { id: '', color: '', name: '' } ]
- * @param {string} targetOptionID option id
+ * @param {array} options e.g. [ { id, color, name, ... } ]
+ * @param {string} targetOptionId option id
  * @returns option name, string
  */
-var getOptionName = function getOptionName(options, targetOptionID) {
-  if (!targetOptionID || !Array.isArray(options)) return '';
-  var targetOption = options.find(function (option) {
-    return option.id === targetOptionID;
-  });
+var getOptionName = function getOptionName(options, targetOptionId) {
+  if (!targetOptionId || !Array.isArray(options)) return '';
+  var targetOption = getOption(options, targetOptionId);
   return targetOption ? targetOption.name : '';
 };
 
+/**
+ * Get column option name by id
+ * @param {object} column e.g. { data: { options, ... }, ... }
+ * @param {string} optionId
+ * @returns option name, string
+ */
+var getColumnOptionNameById = function getColumnOptionNameById(column, optionId) {
+  var options = getColumnOptions(column);
+  return getOptionName(options, optionId);
+};
+
 /**
  * Get concatenated options names of given ids.
- * @param {array} options e.g. [ { id: '', color: '', name: '' }, ... ]
+ * @param {array} options e.g. [ { id, color, name, ... }, ... ]
  * @param {array} targetOptionsIds e.g. [ option.id, ... ]
  * @returns concatenated options names, string. e.g. 'name1, name2'
  */
@@ -29,4 +53,4 @@ var getMultipleOptionName = function getMultipleOptionName(options, targetOption
   }).join(', ');
 };
 
-export { getMultipleOptionName, getOptionName };
+export { getColumnOptionNameById, getMultipleOptionName, getOption, getOptionName };

package/es/cell-value-get/rate.js

@@ -0,0 +1,11 @@
+/**
+ * Get formatted rate
+ * @param {number} value
+ * @returns formatted rate
+ */
+var getRateDisplayString = function getRateDisplayString(value) {
+  if (!value) return '';
+  return String(value);
+};
+
+export { getRateDisplayString };

package/es/cell-value-set/date.js

@@ -0,0 +1,26 @@
+import { DateUtils } from '../date.js';
+import { getFloatNumber } from './number.js';
+
+/**
+ * Parse string to date
+ * @param {string} text
+ * @param {string} format default as "YYYY-MM-DD"
+ * @returns date, string
+ */
+var formatTextToDate = function formatTextToDate(text) {
+  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'YYYY-MM-DD';
+  if (typeof text !== 'string' || !text.trim()) return null;
+  var isAllNumber = /^[0-9]+$/.test(text);
+  var dateObj = {};
+  if (isAllNumber) {
+    dateObj = new Date(getFloatNumber(text));
+  } else {
+    dateObj = DateUtils.parseDateWithFormat(text, format);
+  }
+  if (format.indexOf('HH:mm') < 0) {
+    return DateUtils.format(dateObj, 'YYYY-MM-DD') || null;
+  }
+  return DateUtils.format(dateObj, 'YYYY-MM-DD HH:MM') || null;
+};
+
+export { formatTextToDate };

package/es/cell-value-set/number.js

@@ -1,4 +1,6 @@
 import { NPdivide as divide } from '../helper/number-precision/index.js';
+import { isNumber } from '../number.js';
+import { DURATION_FORMATS_MAP, DURATION_FORMATS } from '../constants/column.js';
 
 /**
  * @param {string} sNumber e.g. '1.23'
@@ -50,4 +52,54 @@ var formatStringToNumber = function formatStringToNumber(sNum, formats) {
   return value;
 };
 
-export { formatStringToNumber, getFloatNumber };
+/**
+ * parse duration to seconds depend on formats
+ * @param {string} duration
+ * @param {object} data { duration_format: '' }
+ * @returns number
+ */
+var formatDurationToNumber = function formatDurationToNumber(duration, data) {
+  if (duration === 0) return 0;
+  if (!duration) return null;
+  var _ref2 = data || {},
+    duration_format = _ref2.duration_format;
+  duration_format = duration_format || DURATION_FORMATS_MAP.H_MM;
+  if (DURATION_FORMATS.findIndex(function (format) {
+    return format.type === duration_format;
+  }) < 0) {
+    return null;
+  }
+  var numericDuration = duration - 0;
+  if (isNumber(numericDuration)) {
+    return duration_format === DURATION_FORMATS_MAP.H_MM ? numericDuration * 60 : numericDuration;
+  }
+  var stringifyDuration = String(duration);
+  var isNegative = stringifyDuration[0] === '-';
+  if (isNegative) {
+    stringifyDuration = stringifyDuration.substring(1);
+  }
+  var timeParts = stringifyDuration.split(/[:：]/); // support ':' and '：'.
+  var timePartsLen = timeParts.length;
+  var hoursIndex;
+  var minutesIndex;
+  var secondsIndex;
+  if (duration_format === DURATION_FORMATS_MAP.H_MM) {
+    hoursIndex = timePartsLen - 2;
+    minutesIndex = timePartsLen - 1;
+  } else {
+    hoursIndex = timePartsLen - 3;
+    minutesIndex = timePartsLen - 2;
+    secondsIndex = timePartsLen - 1;
+  }
+  var hours = timeParts[hoursIndex] - 0;
+  var minutes = timeParts[minutesIndex] - 0;
+  var seconds = timeParts[secondsIndex] - 0;
+  if (!isNumber(hours) && !isNumber(minutes) && !isNumber(seconds)) return null;
+  hours = isNumber(hours) ? hours : 0;
+  minutes = isNumber(minutes) ? minutes : 0;
+  seconds = isNumber(seconds) ? seconds : 0;
+  var result = hours * 3600 + minutes * 60 + seconds;
+  return isNegative ? -result : result;
+};
+
+export { formatDurationToNumber, formatStringToNumber, getFloatNumber };

package/es/color/column-color.js

@@ -0,0 +1,437 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import deepCopy from 'deep-copy';
+import { deleteInvalidFilter, getFormattedFilters } from '../filter/core.js';
+import { filterRows, filterRow } from '../filter/filter-row.js';
+import { ValidateFilter } from '../validate/filter.js';
+import { isNumberColumn } from '../column/number.js';
+import { getRowsByIds } from '../table/row.js';
+import { sortTableRows } from '../sort/sort-row.js';
+import { isTableRows } from '../row/core.js';
+import RowColorUtils from './row-color.js';
+import GradientColorUtils from './gradient-color.js';
+import { CellType } from '../constants/cell-type.js';
+import '../constants/column.js';
+import { FILTER_CONJUNCTION_TYPE } from '../constants/filter/index.js';
+import '../constants/formula.js';
+import '../constants/sort.js';
+import '../constants/group.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var COMPUTED_COLUMN_TYPES = [CellType.LINK, CellType.FORMULA, CellType.LINK_FORMULA];
+var BY_RULES = 'by_rules';
+var BY_NUMERIC_RANGE = 'by_numeric_range';
+var BY_REPEAT_VALUE = 'by_repeat_value';
+var isColumnHasColorRules = function isColumnHasColorRules(column) {
+  var colorbys = column && column.colorbys;
+  if (!colorbys) return false;
+  var type = colorbys.type,
+    colorByRules = colorbys.color_by_rules,
+    rangeSettings = colorbys.range_settings,
+    repeatValueSettings = colorbys.repeat_value_settings;
+  if (type === BY_RULES) {
+    return colorByRules && Array.isArray(colorByRules) && colorByRules.length > 0;
+  }
+  if (type === BY_REPEAT_VALUE) {
+    return repeatValueSettings;
+  }
+
+  // type === BY_NUMERIC_RANGE
+  return rangeSettings && Object.keys(rangeSettings).length > 0;
+};
+var hasRelatedColumnColorRule = function hasRelatedColumnColorRule(columns, updatedColumnKeyMap) {
+  return (
+    // the updated column is one of current table, and the column has color_rules
+    columns.some(function (column) {
+      return updatedColumnKeyMap[column.key] && isColumnHasColorRules(column);
+    })
+  );
+};
+var isColumnColorRulesValid = function isColumnColorRulesValid(column) {
+  var columns = [column];
+  var colorbys = column.colorbys;
+  var type = colorbys.type,
+    colorByRules = colorbys.color_by_rules;
+  if (type === BY_RULES) {
+    var isHasValidColorRule = colorByRules.some(function (rule) {
+      var filters = rule.filters;
+      if (filters.length === 0) return false;
+      return filters.some(function (filter) {
+        return !ValidateFilter.validate(filter, columns).error_message;
+      });
+    });
+    return isHasValidColorRule;
+  }
+  if (type === BY_REPEAT_VALUE) {
+    return true;
+  }
+  if (type === BY_NUMERIC_RANGE) {
+    // gradient color is only used for number column
+    return isNumberColumn(column);
+  }
+  return false;
+};
+var isColumnColorsView = function isColumnColorsView(columns) {
+  return columns.some(function (column) {
+    if (!isColumnHasColorRules(column)) return false;
+
+    // valid color rule: the column maybe changed type
+    if (!isColumnColorRulesValid(column)) return false;
+    return true;
+  });
+};
+var getValidRulesColumns = function getValidRulesColumns(columns) {
+  // judgement current table's columns has own color_rules columns or not
+  var ownRulesColumns = columns.filter(function (column) {
+    return isColumnHasColorRules(column);
+  });
+  if (ownRulesColumns.length === 0) return [];
+
+  // judgement current table's columns has valid color_rules columns ro not
+  var validRulesColumns = ownRulesColumns.filter(function (column) {
+    return isColumnColorRulesValid(column);
+  });
+  if (validRulesColumns.length === 0) return [];
+  return validRulesColumns;
+};
+var getSortedViewRows = function getSortedViewRows(column, view, table, value, _ref) {
+  var username = _ref.username,
+    userId = _ref.userId;
+  var filter = {
+    column_key: column.key,
+    filter_predicate: 'is_not_empty',
+    filter_term: '',
+    column: column
+  };
+  var formulaRows = view.formula_rows;
+  var filterRowIds = filterRows(FILTER_CONJUNCTION_TYPE.AND, [filter], table.rows, {
+    formulaRows: formulaRows,
+    username: username,
+    userId: userId
+  });
+  var sort = {
+    sort_type: 'up',
+    column_key: column.key
+  };
+  var rows = getRowsByIds(table, filterRowIds);
+  var sortedRowIds = sortTableRows([sort], rows, [column], {
+    formulaRows: formulaRows,
+    value: value
+  });
+  return getRowsByIds(table, sortedRowIds);
+};
+var getCellValue = function getCellValue(row, column, formulaRows) {
+  var key = column.key,
+    type = column.type;
+  var cellValue = row[key];
+  if (COMPUTED_COLUMN_TYPES.includes(type)) {
+    var formulaRow = formulaRows && formulaRows[row._id] || {};
+    if (CellType.LINK === type) {
+      var startCellValues = formulaRow[key] && Array.isArray(formulaRow[key]) ? formulaRow[key] : [];
+      var _ref2 = startCellValues.length > 0 ? startCellValues[0] : {},
+        _ref2$display_value = _ref2.display_value,
+        display_value = _ref2$display_value === void 0 ? null : _ref2$display_value;
+      cellValue = display_value;
+    } else {
+      var cellValues = formulaRow[key];
+      cellValue = Array.isArray(cellValues) ? cellValues[0] : cellValues;
+    }
+  }
+  return cellValue;
+};
+var getFormattedColumn = function getFormattedColumn(column, view, table, value, rows, _ref3) {
+  var username = _ref3.username,
+    userId = _ref3.userId;
+  var dupColumn = deepCopy(column);
+  var colorbys = dupColumn.colorbys;
+  var type = colorbys.type,
+    colorByRules = colorbys.color_by_rules,
+    rangeSettings = colorbys.range_settings,
+    repeatValueSettings = colorbys.repeat_value_settings,
+    duplicateColumnKey = colorbys.duplicate_column_key;
+  if (type === BY_RULES) {
+    // formatted color rules
+    var formattedColorRules = colorByRules.map(function (colorRule) {
+      var filters = colorRule.filters;
+      var validFilters = [];
+      try {
+        validFilters = deleteInvalidFilter(filters, [column]);
+      } catch (err) {
+        validFilters = [];
+      }
+      validFilters = getFormattedFilters(validFilters);
+
+      // return formatted colorRule
+      return _objectSpread(_objectSpread({}, colorRule), {}, {
+        filters: validFilters
+      });
+    });
+    dupColumn.colorbys = _objectSpread(_objectSpread({}, colorbys), {}, {
+      color_by_rules: formattedColorRules
+    });
+    return dupColumn;
+  }
+  if (type === BY_REPEAT_VALUE) {
+    var _ref4 = value || {},
+      _ref4$collaborators = _ref4.collaborators,
+      collaborators = _ref4$collaborators === void 0 ? [] : _ref4$collaborators;
+    var formattedColumn = RowColorUtils.getFormattedDuplicateColumns([dupColumn], [duplicateColumnKey], {
+      collaborators: collaborators
+    });
+    var duplicate_rows_ids_map = {};
+    var formulaRows = view.formula_rows;
+    for (var i = 0; i < rows.length; i++) {
+      var row = rows[i];
+      var rowId = row._id;
+      var formulaRow = formulaRows && formulaRows[rowId];
+      var rowValue = RowColorUtils.getDuplicateRowValue(row, formattedColumn, formulaRow);
+      if (!rowValue) continue;
+      var rowIds = duplicate_rows_ids_map[rowValue];
+      if (rowIds && rowIds.length > 0) {
+        rowIds.push(rowId);
+      } else {
+        duplicate_rows_ids_map[rowValue] = [rowId];
+      }
+    }
+    dupColumn.duplicate_rows_ids_map = duplicate_rows_ids_map;
+    dupColumn.colorbys = _objectSpread(_objectSpread({}, colorbys), {}, {
+      repeat_value_settings: repeatValueSettings
+    });
+    return dupColumn;
+  }
+  // type === BY_NUMERIC_RANGE
+  // column type has been changed
+  if (!isNumberColumn(column)) {
+    dupColumn.gradientColorUtils = null;
+    dupColumn.colorbys = _objectSpread(_objectSpread({}, colorbys), {}, {
+      range_settings: {}
+    });
+    return dupColumn;
+  }
+
+  // add gradient_colors computed properties for dumColumn
+  var colorType = rangeSettings.color_type,
+    isCustomStartValue = rangeSettings.is_custom_start_value,
+    isCustomEndValue = rangeSettings.is_custom_end_value,
+    startValue = rangeSettings.start_value,
+    endValue = rangeSettings.end_value;
+  var min = startValue;
+  var max = endValue;
+  if ((!isCustomStartValue || !isCustomEndValue) && table.rows.length > 0) {
+    // sort rows
+    var sortedRows = getSortedViewRows(column, view, table, value, {
+      username: username,
+      userId: userId
+    });
+    var _formulaRows = view.formula_rows;
+    // number rows length need great than zero
+    if (sortedRows.length > 0) {
+      var startRow = sortedRows[0];
+      var endRow = sortedRows[sortedRows.length - 1];
+      var startCellValue = getCellValue(startRow, column, _formulaRows);
+      var endCellValue = getCellValue(endRow, column, _formulaRows);
+      min = isCustomStartValue ? startValue : startCellValue;
+      max = isCustomEndValue ? endValue : endCellValue;
+    }
+  }
+  var gradientColorUtils = new GradientColorUtils({
+    colorType: colorType,
+    min: min,
+    max: max
+  });
+  dupColumn.gradientColorUtils = gradientColorUtils;
+  return dupColumn;
+};
+
+/**
+ * Calculate column color
+ * @param {array} rows
+ * @param {object} view
+ * @param {object} table e.g. { id_row_map, ... }
+ * @param {object} value e.g. { tables, collaborators, ... }
+ * @param {string} username
+ * @param {userId} username
+ * @returns column color, object
+ */
+var getColumnColors = function getColumnColors(rows, view, table, value) {
+  var _ref5 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    _ref5$username = _ref5.username,
+    username = _ref5$username === void 0 ? '' : _ref5$username,
+    _ref5$userId = _ref5.userId,
+    userId = _ref5$userId === void 0 ? '' : _ref5$userId;
+  var columns = table.columns;
+  var validRulesColumns = getValidRulesColumns(columns);
+  if (validRulesColumns.length === 0) return {};
+
+  // formatted column's color_rules
+  validRulesColumns = validRulesColumns.map(function (column) {
+    return getFormattedColumn(column, view, table, value, rows, {
+      username: username,
+      userId: userId
+    });
+  });
+
+  /**
+   * column_colors data struct
+   * {
+   *   row_id: {[column_key]: value, [column_key]: value},
+   *   row_id: {[column_key]: value, [column_key]: value},
+   * }
+   */
+  var column_colors = {};
+  var formulaRows = view.formula_rows;
+  var tableRows = isTableRows(rows) ? rows : getRowsByIds(table, rows);
+  var rowsLength = tableRows.length;
+
+  // forEach rows
+  var _loop = function _loop() {
+    var row = tableRows[i];
+
+    // forEach own color_rules columns
+    var column_color = {};
+    var rowId = row._id;
+    var formulaRow = formulaRows && formulaRows[rowId] || {};
+    for (var j = 0; j < validRulesColumns.length; j++) {
+      var column = validRulesColumns[j];
+      var columnKey = column.key,
+        colorbys = column.colorbys,
+        _column$duplicate_row = column.duplicate_rows_ids_map,
+        duplicate_rows_ids_map = _column$duplicate_row === void 0 ? {} : _column$duplicate_row;
+      var type = colorbys.type,
+        colorByRules = colorbys.color_by_rules,
+        rangeSettings = colorbys.range_settings,
+        repeatValueSettings = colorbys.repeat_value_settings,
+        duplicateColumnKey = colorbys.duplicate_column_key;
+      if (type === BY_RULES) {
+        // obtain the row data that meets the rules and record the color
+        for (var m = 0; m < colorByRules.length; m++) {
+          var colorRule = colorByRules[m];
+          var filter_conjunction = colorRule.filter_conjunction,
+            filters = colorRule.filters,
+            color = colorRule.color;
+          if (filterRow(row, filter_conjunction, filters, {
+            formulaRow: formulaRow,
+            username: username,
+            userId: userId
+          })) {
+            column_color[columnKey] = color;
+            break;
+          }
+        }
+      }
+      if (type === BY_REPEAT_VALUE) {
+        var _color = repeatValueSettings.color;
+        var _ref6 = value || {},
+          _ref6$collaborators = _ref6.collaborators,
+          collaborators = _ref6$collaborators === void 0 ? [] : _ref6$collaborators;
+        var formattedColumn = RowColorUtils.getFormattedDuplicateColumns([column], [duplicateColumnKey], {
+          collaborators: collaborators
+        });
+        var rowValue = RowColorUtils.getDuplicateRowValue(row, formattedColumn, formulaRow);
+        if (!rowValue) continue;
+        var rowIds = duplicate_rows_ids_map[rowValue];
+        if (rowIds && rowIds.length > 1) {
+          var hasRowId = rowIds.some(function (id) {
+            return id === rowId;
+          });
+          if (hasRowId) {
+            column_color[columnKey] = _color;
+            var firstDuplicateRowId = rowIds[0];
+            if (!column_colors[firstDuplicateRowId]) {
+              column_colors[firstDuplicateRowId] = column_color;
+            }
+          }
+        }
+      }
+      if (type === BY_NUMERIC_RANGE) {
+        if (Object.keys(rangeSettings).length === 0) break;
+        var cellValue = getCellValue(row, column, formulaRows);
+        if (cellValue || cellValue === 0) {
+          var gradientColorUtils = column.gradientColorUtils;
+          var cellColor = gradientColorUtils.getCellColor(cellValue);
+          if (cellColor) {
+            column_color[columnKey] = cellColor;
+          }
+        }
+      }
+    }
+    if (Object.keys(column_color).length > 0) {
+      column_colors[rowId] = column_color;
+    }
+  };
+  for (var i = 0; i < rowsLength; i++) {
+    _loop();
+  }
+  return column_colors;
+};
+
+/**
+ * Update column color by updated rows.
+ * @param {array} rows updated rows | rows ids
+ * @param {object} view
+ * @param {object} table e.g. { id_row_map, ... }
+ * @param {object} value e.g. { tables, collaborators, ... }
+ * @param {string} username
+ * @param {userId} username
+ * @returns column color, object
+ */
+var updateColumnColorsByUpdateRows = function updateColumnColorsByUpdateRows(rows, view, table, value) {
+  var _ref7 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    _ref7$username = _ref7.username,
+    username = _ref7$username === void 0 ? '' : _ref7$username,
+    _ref7$userId = _ref7.userId,
+    userId = _ref7$userId === void 0 ? '' : _ref7$userId;
+  var columns = table.columns;
+  var validRulesColumns = getValidRulesColumns(columns);
+  if (validRulesColumns.length === 0) return {};
+  var hasByGradientColorRule = validRulesColumns.some(function (column) {
+    var colorbys = column.colorbys;
+    return colorbys.type === BY_NUMERIC_RANGE;
+  });
+  var hasRepeatValueColorRule = validRulesColumns.some(function (column) {
+    var colorbys = column.colorbys;
+    return colorbys.type === BY_REPEAT_VALUE;
+  });
+
+  // if columns has one column which colorbys type is by_gradient_color,
+  // recalculate all the rows background color
+  if (hasByGradientColorRule || hasRepeatValueColorRule) {
+    view.column_colors = getColumnColors(table.rows, view, table, value, {
+      username: username,
+      userId: userId
+    });
+    return view.column_colors;
+  }
+
+  // recalculate the updated rows background color
+  var updatedRows = isTableRows(rows) ? rows : getRowsByIds(table, rows);
+  var columnColors = getColumnColors(updatedRows, view, table, value, {
+    username: username,
+    userId: userId
+  });
+  var column_colors = view.column_colors;
+  if (!column_colors) {
+    column_colors = {};
+    view.column_colors = column_colors;
+  }
+  updatedRows.forEach(function (row) {
+    var rowId = row._id;
+    var columnColor = columnColors[rowId];
+    column_colors[rowId] = columnColor;
+  });
+  return view.column_colors;
+};
+var ColumnColorUtils = {
+  isColumnHasColorRules: isColumnHasColorRules,
+  hasRelatedColumnColorRule: hasRelatedColumnColorRule,
+  isColumnColorRulesValid: isColumnColorRulesValid,
+  isColumnColorsView: isColumnColorsView,
+  getValidRulesColumns: getValidRulesColumns,
+  getSortedViewRows: getSortedViewRows,
+  getCellValue: getCellValue,
+  getFormattedColumn: getFormattedColumn,
+  getColumnColors: getColumnColors,
+  updateColumnColorsByUpdateRows: updateColumnColorsByUpdateRows
+};
+
+export { ColumnColorUtils as default };

package/es/color/gradient-color.js

@@ -0,0 +1,100 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import { COLOR_GRADATION_OPTIONS } from '../constants/color.js';
+
+var GradientColorUtils = /*#__PURE__*/function () {
+  function GradientColorUtils(_ref) {
+    var colorType = _ref.colorType,
+      max = _ref.max,
+      min = _ref.min;
+    _classCallCheck(this, GradientColorUtils);
+    var newColorType = colorType || 'color_gradation_1';
+    var colors = COLOR_GRADATION_OPTIONS[newColorType];
+    this.startColor = this.hexToRgb(colors[0]);
+    this.endColor = this.hexToRgb(colors[4]);
+    this.min = min;
+    this.max = max;
+    this.computeMap = {};
+  }
+  _createClass(GradientColorUtils, [{
+    key: "hexToRgb",
+    value: function hexToRgb(hexCode) {
+      var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
+      var nextHexCode = hexCode.toLowerCase();
+      if (nextHexCode && reg.test(nextHexCode)) {
+        if (nextHexCode.length === 4) {
+          var newHexCode = '#';
+          for (var i = 1; i < 4; i += 1) {
+            newHexCode += nextHexCode.slice(i, i + 1).concat(nextHexCode.slice(i, i + 1));
+          }
+          nextHexCode = newHexCode;
+        }
+        var hexCodeChange = [];
+        for (var _i = 1; _i < 7; _i += 2) {
+          hexCodeChange.push(parseInt("0x".concat(nextHexCode.slice(_i, _i + 2))));
+        }
+        return "RGB(".concat(hexCodeChange.join(','), ")");
+      }
+      return nextHexCode;
+    }
+  }, {
+    key: "getColorGradation",
+    value: function getColorGradation(color1, color2, value1, value2, value) {
+      var rgb1 = color1.split(',');
+      var r1 = parseInt(rgb1[0].split('(')[1]);
+      var g1 = parseInt(rgb1[1]);
+      var b1 = parseInt(rgb1[2].split(')')[0]);
+      var rgb2 = color2.split(',');
+      var r2 = parseInt(rgb2[0].split('(')[1]);
+      var g2 = parseInt(rgb2[1]);
+      var b2 = parseInt(rgb2[2].split(')')[0]);
+      var r = Math.round(r1 - (r1 - r2) / (value1 - value2) * (value1 - value));
+      var g = Math.round(g1 - (g1 - g2) / (value1 - value2) * (value1 - value));
+      var b = Math.round(b1 - (b1 - b2) / (value1 - value2) * (value1 - value));
+      return "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")");
+    }
+  }, {
+    key: "getCellColor",
+    value: function getCellColor(value) {
+      if (this.computeMap[value]) {
+        return this.computeMap[value];
+      }
+
+      // eslint-disable-next-line
+      if (value == this.min) {
+        if (this.computeMap[value]) {
+          this.computeMap[value] = this.startColor;
+        } else {
+          this.computeMap = _defineProperty({}, value, this.startColor);
+        }
+        return this.computeMap[value];
+      }
+
+      // eslint-disable-next-line
+      if (value == this.max) {
+        if (this.computeMap[value]) {
+          this.computeMap[value] = this.endColor;
+        } else {
+          this.computeMap = _defineProperty({}, value, this.endColor);
+        }
+        return this.computeMap[value];
+      }
+      if (value > this.min && value < this.max) {
+        var color1 = this.startColor,
+          color2 = this.endColor,
+          value1 = this.min,
+          value2 = this.max;
+        var color = this.getColorGradation(color1, color2, value1, value2, value);
+        this.computeMap[value] = color;
+        return this.computeMap[value];
+      }
+
+      // value < min || value > max
+      return null;
+    }
+  }]);
+  return GradientColorUtils;
+}();
+
+export { GradientColorUtils as default };