sea-chart 0.0.1

package/lib/utils/data-filter/filters-utils.js

@@ -0,0 +1,406 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _SIMPLE_TEXT_INPUT_CO, _DATE_LABEL_MAP, _ARRAY_PREDICATE, _STRING_PREDICATE, _DATE_EMPTY_LABEL_MAP;
+import { CellType, COLLABORATOR_COLUMN_TYPES, DATE_COLUMN_OPTIONS, FILTER_PREDICATE_TYPE, FILTER_COLUMN_OPTIONS, FILTER_TERM_MODIFIER_TYPE, FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE, filterTermModifierNotWithin, filterTermModifierIsWithin, isDateColumn, isNumericColumn } from 'dtable-utils';
+import { getColumnByKey } from '../column-utils';
+export var SPECIAL_TERM_TYPE = {
+  CREATOR: 'creator',
+  SINGLE_SELECT: 'single_select',
+  MULTIPLE_SELECT: 'multiple_select',
+  COLLABORATOR: 'collaborator',
+  RATE: 'rate'
+};
+export var SIMPLE_TEXT_INPUT_COLUMNS_MAP = (_SIMPLE_TEXT_INPUT_CO = {}, _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.TEXT, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.LONG_TEXT, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.GEOLOCATION, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.AUTO_NUMBER, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.EMAIL, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.URL, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.IMAGE, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, CellType.FILE, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, FORMULA_RESULT_TYPE.STRING, true), _defineProperty(_SIMPLE_TEXT_INPUT_CO, FORMULA_RESULT_TYPE.BOOL, true), _SIMPLE_TEXT_INPUT_CO);
+export var DATE_LABEL_MAP = (_DATE_LABEL_MAP = {}, _defineProperty(_DATE_LABEL_MAP, FILTER_TERM_MODIFIER_TYPE.EXACT_DATE, true), _defineProperty(_DATE_LABEL_MAP, FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_AGO, true), _defineProperty(_DATE_LABEL_MAP, FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_FROM_NOW, true), _defineProperty(_DATE_LABEL_MAP, FILTER_TERM_MODIFIER_TYPE.THE_NEXT_NUMBERS_OF_DAYS, true), _defineProperty(_DATE_LABEL_MAP, FILTER_TERM_MODIFIER_TYPE.THE_PAST_NUMBERS_OF_DAYS, true), _DATE_LABEL_MAP);
+var ARRAY_PREDICATE = (_ARRAY_PREDICATE = {}, _defineProperty(_ARRAY_PREDICATE, FILTER_PREDICATE_TYPE.IS_ANY_OF, true), _defineProperty(_ARRAY_PREDICATE, FILTER_PREDICATE_TYPE.IS_NONE_OF, true), _ARRAY_PREDICATE);
+var STRING_PREDICATE = (_STRING_PREDICATE = {}, _defineProperty(_STRING_PREDICATE, FILTER_PREDICATE_TYPE.IS, true), _defineProperty(_STRING_PREDICATE, FILTER_PREDICATE_TYPE.IS_NOT, true), _STRING_PREDICATE);
+export var DATE_EMPTY_LABEL_MAP = (_DATE_EMPTY_LABEL_MAP = {}, _defineProperty(_DATE_EMPTY_LABEL_MAP, FILTER_PREDICATE_TYPE.EMPTY, true), _defineProperty(_DATE_EMPTY_LABEL_MAP, FILTER_PREDICATE_TYPE.NOT_EMPTY, true), _DATE_EMPTY_LABEL_MAP);
+var MULTIPLE_SELECTOR_COLUMNS = [CellType.MULTIPLE_SELECT, CellType.COLLABORATOR, CellType.CREATOR, CellType.LAST_MODIFIER];
+var isArrayFilterTermByArrayType = function isArrayFilterTermByArrayType(array_type) {
+  return COLLABORATOR_COLUMN_TYPES.includes(array_type) || array_type === CellType.SINGLE_SELECT || array_type === CellType.MULTIPLE_SELECT;
+};
+export var isFilterTermArray = function isFilterTermArray(column, filterPredicate) {
+  var type = column.type,
+    data = column.data;
+  if (MULTIPLE_SELECTOR_COLUMNS.includes(type)) {
+    return true;
+  }
+  if (type === CellType.SINGLE_SELECT && [FILTER_PREDICATE_TYPE.IS_ANY_OF, FILTER_PREDICATE_TYPE.IS_NONE_OF].includes(filterPredicate)) {
+    return true;
+  }
+  if (FORMULA_COLUMN_TYPES_MAP[type]) {
+    var _ref = data || {},
+      result_type = _ref.result_type,
+      array_type = _ref.array_type;
+    if (result_type !== FORMULA_RESULT_TYPE.ARRAY) return false;
+    return isArrayFilterTermByArrayType(array_type);
+  }
+  if (type === CellType.LINK) {
+    var _ref2 = data || {},
+      _array_type = _ref2.array_type;
+    return isArrayFilterTermByArrayType(_array_type);
+  }
+  return false;
+};
+export var getUpdatedFilterByCreator = function getUpdatedFilterByCreator(filter, collaborator) {
+  var multipleSelectType = [FILTER_PREDICATE_TYPE.CONTAINS, FILTER_PREDICATE_TYPE.NOT_CONTAIN];
+  var filter_predicate = filter.filter_predicate,
+    filterTerm = filter.filter_term;
+  if (multipleSelectType.includes(filter_predicate)) {
+    filterTerm = filterTerm ? filter.filter_term.slice(0) : [];
+    var selectedEmail = collaborator.email;
+    var collaborator_index = filterTerm.indexOf(selectedEmail);
+    if (collaborator_index > -1) {
+      filterTerm.splice(collaborator_index, 1);
+    } else {
+      filterTerm.push(selectedEmail);
+    }
+  } else {
+    if (filterTerm[0] === collaborator.email) {
+      return;
+    }
+    filterTerm = [collaborator.email];
+  }
+  return Object.assign({}, filter, {
+    filter_term: filterTerm
+  });
+};
+export var getUpdatedFilterBySelectSingle = function getUpdatedFilterBySelectSingle(filter, columnOption) {
+  var new_filter_term;
+  // if predicate is any of / is none of, filter_term is array; else filter_term is string
+  if (filter.filter_predicate === FILTER_PREDICATE_TYPE.IS_ANY_OF || filter.filter_predicate === FILTER_PREDICATE_TYPE.IS_NONE_OF) {
+    new_filter_term = Array.isArray(filter.filter_term) ? _toConsumableArray(filter.filter_term) : [];
+    var index = new_filter_term.indexOf(columnOption.id);
+    if (index === -1) {
+      new_filter_term.push(columnOption.id);
+    } else {
+      new_filter_term.splice(index, 1);
+    }
+  } else {
+    new_filter_term = columnOption.id;
+  }
+  return Object.assign({}, filter, {
+    filter_term: new_filter_term
+  });
+};
+export var getUpdatedFilterBySelectMultiple = function getUpdatedFilterBySelectMultiple(filter, columnOption) {
+  var filterTerm = filter.filter_term ? filter.filter_term : [];
+  var index = filterTerm.indexOf(columnOption.id);
+  if (index > -1) {
+    filterTerm.splice(index, 1);
+  } else {
+    filterTerm.push(columnOption.id);
+  }
+  return Object.assign({}, filter, {
+    filter_term: filterTerm
+  });
+};
+export var getUpdatedFilterByCollaborator = function getUpdatedFilterByCollaborator(filter, collaborator) {
+  var filterTerm = filter.filter_term ? filter.filter_term.slice(0) : [];
+  var selectedEmail = collaborator.email;
+  var collaborator_index = filterTerm.indexOf(selectedEmail);
+  if (collaborator_index > -1) {
+    filterTerm.splice(collaborator_index, 1);
+  } else {
+    filterTerm.push(selectedEmail);
+  }
+  return Object.assign({}, filter, {
+    filter_term: filterTerm
+  });
+};
+export var getUpdatedFilterByRate = function getUpdatedFilterByRate(filter, value) {
+  if (filter.filter_term === value) {
+    return Object.assign({}, filter, {
+      filter_term: 0
+    });
+  }
+  return Object.assign({}, filter, {
+    filter_term: value
+  });
+};
+export var getColumnOptions = function getColumnOptions(column) {
+  var type = column.type,
+    data = column.data;
+  if (FORMULA_COLUMN_TYPES_MAP[type]) {
+    return getFormulaColumnFilterOptions(column);
+  }
+  if (type === CellType.LINK) {
+    var _ref3 = data || {},
+      array_type = _ref3.array_type;
+    if (array_type === FORMULA_RESULT_TYPE.BOOL) {
+      return FILTER_COLUMN_OPTIONS[CellType.CHECKBOX];
+    }
+    if (array_type === FORMULA_RESULT_TYPE.STRING) {
+      return FILTER_COLUMN_OPTIONS[CellType.TEXT];
+    }
+    return getFilterOptionsByArrayType(array_type);
+  }
+  return FILTER_COLUMN_OPTIONS[type] || {};
+};
+var getFormulaColumnFilterOptions = function getFormulaColumnFilterOptions(column) {
+  var data = column.data;
+  var _ref4 = data || {},
+    result_type = _ref4.result_type,
+    array_type = _ref4.array_type;
+  if (result_type === FORMULA_RESULT_TYPE.BOOL) {
+    return FILTER_COLUMN_OPTIONS[CellType.CHECKBOX];
+  }
+  if (result_type === FORMULA_RESULT_TYPE.STRING) {
+    return FILTER_COLUMN_OPTIONS[CellType.TEXT];
+  }
+  if ([FORMULA_RESULT_TYPE.NUMBER, FORMULA_RESULT_TYPE.DATE].includes(result_type)) {
+    return FILTER_COLUMN_OPTIONS[result_type];
+  }
+  if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+    return getFilterOptionsByArrayType(array_type);
+  }
+  return FILTER_COLUMN_OPTIONS[CellType.TEXT];
+};
+var getFilterOptionsByArrayType = function getFilterOptionsByArrayType(array_type) {
+  if (!array_type) {
+    return {};
+  }
+  var checkType = array_type;
+  if (COLLABORATOR_COLUMN_TYPES.includes(array_type)) {
+    checkType = CellType.COLLABORATOR;
+  } else if (array_type === CellType.SINGLE_SELECT) {
+    checkType = CellType.MULTIPLE_SELECT;
+  } else if (DATE_COLUMN_OPTIONS.includes(array_type)) {
+    checkType = CellType.DATE;
+  } else if (isNumericColumn({
+    type: array_type
+  })) {
+    checkType = CellType.NUMBER;
+  }
+
+  // only support: is
+  if (checkType === CellType.CHECKBOX || checkType === CellType.BOOL) {
+    return FILTER_COLUMN_OPTIONS[CellType.CHECKBOX];
+  }
+  var filterOptions = FILTER_COLUMN_OPTIONS[checkType] || FILTER_COLUMN_OPTIONS[CellType.TEXT];
+  var filterPredicateList = filterOptions.filterPredicateList;
+  if (filterPredicateList && !filterPredicateList.includes(FILTER_PREDICATE_TYPE.EMPTY)) {
+    filterPredicateList.push(FILTER_PREDICATE_TYPE.EMPTY);
+  }
+  if (filterPredicateList && !filterPredicateList.includes(FILTER_PREDICATE_TYPE.NOT_EMPTY)) {
+    filterPredicateList.push(FILTER_PREDICATE_TYPE.NOT_EMPTY);
+  }
+  return filterOptions;
+};
+export var getFilterByColumn = function getFilterByColumn(column) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var columnType = column.type,
+    columnData = column.data;
+  var _getColumnOptions = getColumnOptions(column),
+    filterPredicateList = _getColumnOptions.filterPredicateList;
+  if (!filterPredicateList) return;
+  var filterPredicate = filterPredicateList[0];
+  var updatedFilter = Object.assign({}, filter, {
+    column_key: column.key,
+    filter_predicate: filterPredicate
+  });
+
+  // text | number | long-text | url | email
+  // auto-number | geolocation | duration
+  updatedFilter.filter_term = '';
+
+  // checkbox
+  if (columnType === CellType.CHECKBOX) {
+    updatedFilter.filter_term = false;
+    return updatedFilter;
+  }
+  // rate
+  if (columnType === CellType.RATE) {
+    var rate_max_number = columnData.rate_max_number;
+    updatedFilter.filter_term = rate_max_number;
+    return updatedFilter;
+  }
+  // single-select | multiple-select | collaborators | creator | last-modifier
+  if (isFilterTermArray(column, filterPredicate)) {
+    updatedFilter.filter_term = [];
+    return updatedFilter;
+  }
+  // date | ctime | mtime
+  if (isDateColumn(column)) {
+    var filterTermModifier = filterPredicate === FILTER_PREDICATE_TYPE.IS_WITHIN ? filterTermModifierIsWithin[0] : filterTermModifierNotWithin[0];
+    updatedFilter.filter_term_modifier = filterTermModifier;
+    updatedFilter.filter_term = '';
+    return updatedFilter;
+  }
+  // formula | link-formula
+  if (FORMULA_COLUMN_TYPES_MAP[columnType]) {
+    var newUpdatedFilter = getFormulaColumnFilter(column, filter);
+    if (newUpdatedFilter) {
+      updatedFilter.filter_term = newUpdatedFilter.filter_term;
+    }
+    return updatedFilter;
+  }
+  // link
+  if (columnType === CellType.LINK) {
+    var _ref5 = columnData || {},
+      array_type = _ref5.array_type,
+      array_data = _ref5.array_data;
+    if (array_type) {
+      if (array_type === FORMULA_RESULT_TYPE.BOOL) {
+        array_type = CellType.CHECKBOX;
+      }
+      if (array_type === FORMULA_RESULT_TYPE.STRING) {
+        array_type = CellType.TEXT;
+      }
+      var linkedColumn = {
+        key: column.key,
+        type: array_type,
+        data: array_data
+      };
+      var _newUpdatedFilter = getFilterByColumn(linkedColumn, filter) || {};
+      if (_newUpdatedFilter) {
+        updatedFilter.filter_term = _newUpdatedFilter.filter_term;
+      }
+    }
+    return updatedFilter;
+  }
+  return updatedFilter;
+};
+export var getFormulaColumnFilter = function getFormulaColumnFilter(column, filter) {
+  var data = column.data;
+  var _ref6 = data || {},
+    result_type = _ref6.result_type,
+    array_type = _ref6.array_type,
+    array_data = _ref6.array_data;
+  if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+    var _linkedColumn = {
+      key: column.key,
+      type: array_type,
+      data: array_data
+    };
+    return getFilterByColumn(_linkedColumn, filter);
+  }
+  // result_type: string | number | bool | date
+  if (result_type === FORMULA_RESULT_TYPE.BOOL) {
+    array_type = CellType.CHECKBOX;
+  }
+  if (result_type === FORMULA_RESULT_TYPE.STRING) {
+    array_type = CellType.TEXT;
+  }
+  var linkedColumn = {
+    key: column.key,
+    type: array_type,
+    data: array_data
+  };
+  return getFilterByColumn(linkedColumn, filter);
+};
+
+// file, image : not support
+// text, long-text, number, single-select, date, ctime, mtime, formula, link, geolocation : string
+// checkbox : boolean
+// multiple-select, collaborator, creator, last modifier : array
+
+export var getUpdatedFilterByColumn = function getUpdatedFilterByColumn(filters, filterIndex, column) {
+  var filter = filters[filterIndex];
+  if (filter.column_key === column.key) {
+    return;
+  }
+  return getFilterByColumn(column, filter);
+};
+export var getUpdatedFilterByPredicate = function getUpdatedFilterByPredicate(filter, column, filterPredicate) {
+  var updatedFilter = Object.assign({}, filter, {
+    filter_predicate: filterPredicate
+  });
+  var columnType = column.type;
+  if (columnType === CellType.CHECKBOX) {
+    updatedFilter.filter_term = false;
+    return updatedFilter;
+  }
+  if ([CellType.SINGLE_SELECT, CellType.DEPARTMENT_SINGLE_SELECT].includes(columnType)) {
+    if (ARRAY_PREDICATE[filterPredicate]) {
+      if (ARRAY_PREDICATE[filter.filter_predicate] !== ARRAY_PREDICATE[filterPredicate]) {
+        updatedFilter.filter_term = [];
+      }
+    } else if (STRING_PREDICATE[filterPredicate]) {
+      if (STRING_PREDICATE[filter.filter_predicate] !== STRING_PREDICATE[filterPredicate]) {
+        updatedFilter.filter_term = '';
+      }
+    } else {
+      updatedFilter.filter_term = '';
+    }
+    return updatedFilter;
+  }
+  if ([CellType.CREATOR, CellType.LAST_MODIFIER].includes(columnType)) {
+    if (STRING_PREDICATE[filter.filter_predicate] !== STRING_PREDICATE[filterPredicate] || filterPredicate === FILTER_PREDICATE_TYPE.INCLUDE_ME) {
+      updatedFilter.filter_term = [];
+    }
+  }
+  if (isFilterTermArray(column, filterPredicate)) {
+    if (DATE_EMPTY_LABEL_MAP[filterPredicate] || filterPredicate === FILTER_PREDICATE_TYPE.INCLUDE_ME) {
+      updatedFilter.filter_term = [];
+    }
+    return updatedFilter;
+  }
+  if (isDateColumn(column)) {
+    var filterTermModifier = filterPredicate === FILTER_PREDICATE_TYPE.IS_WITHIN ? filterTermModifierIsWithin[0] : filterTermModifierNotWithin[0];
+    updatedFilter.filter_term_modifier = filterTermModifier;
+    return updatedFilter;
+  }
+  return updatedFilter;
+};
+export var getUpdatedFilterByTermModifier = function getUpdatedFilterByTermModifier(filter, filterTermModifier) {
+  if (filter.filter_term_modifier === filterTermModifier) {
+    return;
+  }
+  return Object.assign({}, filter, {
+    filter_term_modifier: filterTermModifier
+  });
+};
+export var getUpdatedFilterByNormalTerm = function getUpdatedFilterByNormalTerm(filter, column, filterIndex, event) {
+  var filterTerm;
+  if (column.type === CellType.CHECKBOX) {
+    filterTerm = event.target.checked;
+  } else {
+    filterTerm = event.target.value;
+  }
+  if (filter.filter_term === filterTerm) {
+    return filter;
+  }
+  return Object.assign({}, filter, {
+    filter_term: filterTerm
+  });
+};
+export var getUpdatedFilterBySpecialTerm = function getUpdatedFilterBySpecialTerm(filter, type, value) {
+  switch (type) {
+    case SPECIAL_TERM_TYPE.CREATOR:
+      {
+        return getUpdatedFilterByCreator(filter, value);
+      }
+    case SPECIAL_TERM_TYPE.SINGLE_SELECT:
+      {
+        return getUpdatedFilterBySelectSingle(filter, value);
+      }
+    case SPECIAL_TERM_TYPE.MULTIPLE_SELECT:
+      {
+        return getUpdatedFilterBySelectMultiple(filter, value);
+      }
+    case SPECIAL_TERM_TYPE.COLLABORATOR:
+      {
+        return getUpdatedFilterByCollaborator(filter, value);
+      }
+    case SPECIAL_TERM_TYPE.RATE:
+      {
+        return getUpdatedFilterByRate(filter, value);
+      }
+    default:
+      {
+        return filter;
+      }
+  }
+};
+export var getFormulaAndLinkFilters = function getFormulaAndLinkFilters(filters, columns) {
+  var formulaFilters = [];
+  filters.forEach(function (filter) {
+    var filterColumn = getColumnByKey(filter.column_key, columns);
+    var type = filterColumn.type;
+    if (FORMULA_COLUMN_TYPES_MAP[type] || type === CellType.LINK) {
+      formulaFilters.push(filter);
+    }
+  });
+  return formulaFilters;
+};

package/lib/utils/data-filter/index.js

@@ -0,0 +1,3 @@
+import FilterItemUtils from './filter-item-utils';
+export { SPECIAL_TERM_TYPE, SIMPLE_TEXT_INPUT_COLUMNS_MAP, DATE_LABEL_MAP, DATE_EMPTY_LABEL_MAP, isFilterTermArray, getUpdatedFilterByCreator, getUpdatedFilterBySelectSingle, getUpdatedFilterBySelectMultiple, getUpdatedFilterByCollaborator, getUpdatedFilterByRate, getColumnOptions, getFilterByColumn, getFormulaColumnFilter, getUpdatedFilterByColumn, getUpdatedFilterByPredicate, getUpdatedFilterByTermModifier, getUpdatedFilterByNormalTerm, getUpdatedFilterBySpecialTerm, getFormulaAndLinkFilters } from './filters-utils';
+export { FilterItemUtils };

package/lib/utils/date-translate.js

@@ -0,0 +1,66 @@
+import intl from '../intl';
+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 ruRU = require('@seafile/seafile-calendar/lib/locale/ru_RU');
+function translateCalendar(lang) {
+  var locale = lang ? lang : 'en';
+  var language;
+  switch (locale) {
+    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;
+    case 'ru':
+      language = ruRU;
+      break;
+    default:
+      language = enUS;
+  }
+  return language;
+}
+function getMobileDatePickerLocale() {
+  return {
+    DatePickerLocale: {
+      year: intl.get('Year'),
+      month: intl.get('Month'),
+      day: intl.get('Day'),
+      hour: intl.get('Hour'),
+      minute: intl.get('Minute')
+    },
+    okText: intl.get('Done'),
+    dismissText: intl.get('Cancel')
+  };
+}
+export { translateCalendar, getMobileDatePickerLocale };

package/lib/utils/index.js

@@ -0,0 +1,50 @@
+import ObjectUtils from './object-utils';
+import statisticColumn2SqlColumn, { summaryMethodColumn2SqlColumn } from './statistic-column-2-sql-column-utils';
+import StatisticsUtils from './statistic-utils';
+import { GENERIC_KEY_2_SIMILAR_KEYS } from '../constants';
+export { generatorCommonOptions } from './options-utils';
+export { getColumnOptions } from 'dtable-utils';
+export { getClientFormulaDisplayString, getClientLinkDisplayString } from './cell-format-utils';
+export { generateChartConfig } from './chart';
+export { getKnownCollaboratorByEmail, getKnownCollaboratorsByEmails, generateDefaultUser } from './collaborator-utils';
+export { getDateColumnFormat, isCheckboxColumn, getColumnByKey, getColumnByName, getColumnByType, getColumnByIndex, getColumnWidth, isNameColumn, isUrlColumn, getLinkColumns, calculateFormulaRows, handleCascadeColumn, isFrozen, findLastFrozenColumnIndex, isStatisticMapColumn, isStatisticWorldMapColumn, isStatisticMirrorColumn } from './column-utils';
+export { SPECIAL_TERM_TYPE, SIMPLE_TEXT_INPUT_COLUMNS_MAP, DATE_LABEL_MAP, DATE_EMPTY_LABEL_MAP, isFilterTermArray, getUpdatedFilterByCreator, getUpdatedFilterBySelectSingle, getUpdatedFilterBySelectMultiple, getUpdatedFilterByCollaborator, getUpdatedFilterByRate, getFilterByColumn, getFormulaColumnFilter, getUpdatedFilterByColumn, getUpdatedFilterByPredicate, getUpdatedFilterByTermModifier, getUpdatedFilterByNormalTerm, getUpdatedFilterBySpecialTerm, getFormulaAndLinkFilters, FilterItemUtils } from './data-filter';
+export { generatorKey } from './key-generator';
+export { translateCalendar } from './date-translate';
+export var isBoolean = function isBoolean(val) {
+  return typeof val === 'boolean';
+};
+export var getSimilarKeys = function getSimilarKeys(genericKey) {
+  var similarKeys = GENERIC_KEY_2_SIMILAR_KEYS[genericKey];
+  return similarKeys || [];
+};
+export var getChartConfigValueFromKeys = function getChartConfigValueFromKeys(keys, object) {
+  // eslint-disable-next-line
+  var existKey = keys.find(function (key) {
+    return ObjectUtils.hasOwnProperty(object, key);
+  });
+  return existKey ? object[existKey] : null;
+};
+export var getChartConfigValueByKey = function getChartConfigValueByKey(key, object) {
+  var similarKeys = getSimilarKeys(key);
+  if (!Array.isArray(similarKeys) || similarKeys.length === 0) {
+    // get value by the given 'genericKey' directly when has no similar keys.
+    // eslint-disable-next-line
+    return ObjectUtils.hasOwnProperty(object, key) ? object[key] : null;
+  }
+
+  // try to get value from the similar keys
+  return getChartConfigValueFromKeys(similarKeys, object);
+};
+export var eventStopPropagation = function eventStopPropagation(event) {
+  if (!event) return;
+  event.stopPropagation();
+  event.preventDefault && event.preventDefault();
+  event.nativeEvent && event.nativeEvent.stopImmediatePropagation && event.nativeEvent.stopImmediatePropagation();
+};
+export var getEventClassName = function getEventClassName(e) {
+  // svg mouseEvent event.target.className is an object
+  if (!e || !e.target) return '';
+  return e.target.getAttribute('class') || '';
+};
+export { ObjectUtils, statisticColumn2SqlColumn, summaryMethodColumn2SqlColumn, StatisticsUtils };

package/lib/utils/key-generator.js

@@ -0,0 +1,13 @@
+var generatorBase64Code = function generatorBase64Code() {
+  var keyLength = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 4;
+  var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz0123456789';
+  var key = '';
+  for (var i = 0; i < keyLength; i++) {
+    key += possible.charAt(Math.floor(Math.random() * possible.length));
+  }
+  return key;
+};
+export var generatorKey = function generatorKey() {
+  var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 4;
+  return generatorBase64Code(length);
+};

package/lib/utils/object-utils.js

@@ -0,0 +1,61 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+var ObjectUtils = /*#__PURE__*/function () {
+  function ObjectUtils() {
+    _classCallCheck(this, ObjectUtils);
+  }
+  _createClass(ObjectUtils, null, [{
+    key: "getDataType",
+    value: function getDataType(data) {
+      var type = typeof data;
+      if (type !== 'object') {
+        return type;
+      }
+      return Object.prototype.toString.call(data).replace(/^\[object (\S+)\]$/, '$1');
+    }
+  }, {
+    key: "iterable",
+    value: function iterable(data) {
+      return ['Object', 'Array'].includes(this.getDataType(data));
+    }
+  }, {
+    key: "isObjectChanged",
+    value: function isObjectChanged(source, comparison) {
+      var _this = this;
+      if (!this.iterable(source)) {
+        throw new Error("source should be a Object or Array , but got ".concat(this.getDataType(source)));
+      }
+      if (this.getDataType(source) !== this.getDataType(comparison)) {
+        return true;
+      }
+      var sourceKeys = Object.keys(source);
+      var comparisonKeys = Object.keys(_objectSpread(_objectSpread({}, source), comparison));
+      if (sourceKeys.length !== comparisonKeys.length) {
+        return true;
+      }
+      return comparisonKeys.some(function (key) {
+        if (_this.iterable(source[key])) {
+          return _this.isObjectChanged(source[key], comparison[key]);
+        } else {
+          return source[key] !== comparison[key];
+        }
+      });
+    }
+  }, {
+    key: "isSameObject",
+    value: function isSameObject(source, comparison) {
+      if (!source || !comparison) return false;
+      return !this.isObjectChanged(source, comparison);
+    }
+  }, {
+    key: "hasOwnProperty",
+    value: function hasOwnProperty(obj, propertyKey) {
+      if (!obj || !propertyKey) return false;
+      // eslint-disable-next-line
+      return Object.prototype.hasOwnProperty.call(obj, propertyKey);
+    }
+  }]);
+  return ObjectUtils;
+}();
+export default ObjectUtils;

package/lib/utils/options-utils.js

@@ -0,0 +1,61 @@
+import React from 'react';
+import classnames from 'classnames';
+var generatorCommonOption = function generatorCommonOption() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var selectValue = arguments.length > 2 ? arguments[2] : undefined;
+  var type = Object.prototype.toString.call(option);
+  var validOption = option,
+    isSelectOption;
+  if (type !== '[object Object]') {
+    isSelectOption = option === selectValue;
+    validOption = {
+      name: String(option),
+      value: option
+    };
+  } else {
+    isSelectOption = option.name === selectValue;
+  }
+  var _validOption = validOption,
+    name = _validOption.name,
+    displayName = _validOption.displayName,
+    disabled = _validOption.disabled,
+    optionType = _validOption.type,
+    isDuplicate = _validOption.isDuplicate;
+  if (optionType === 'divide') {
+    return {
+      value: validOption,
+      key: "divide-".concat(index),
+      type: optionType,
+      name: '',
+      isDuplicate: false,
+      label: /*#__PURE__*/React.createElement("div", {
+        className: "select-option-divide"
+      })
+    };
+  }
+  return {
+    value: validOption,
+    key: "".concat(name, "-").concat(index),
+    type: optionType,
+    name: name,
+    isDuplicate: isDuplicate,
+    label: /*#__PURE__*/React.createElement("div", {
+      className: classnames('common-select-option', {
+        'disabled': disabled
+      })
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "common-select-option-icon"
+    }, isSelectOption && /*#__PURE__*/React.createElement("i", {
+      className: "dtable-font dtable-icon-check-mark"
+    })), /*#__PURE__*/React.createElement("div", {
+      className: "common-select-option-name"
+    }, displayName || name))
+  };
+};
+export var generatorCommonOptions = function generatorCommonOptions(options, selectValue) {
+  if (!Array.isArray(options)) return [];
+  return options.map(function (option, index) {
+    return generatorCommonOption(option, index, selectValue);
+  });
+};