sea-chart 1.1.64 → 2.0.0

package/dist/utils/row-record-utils.js

@@ -1,49 +1,56 @@
-import _ButtonFormatter from "dtable-ui-component/lib/ButtonFormatter";
-import _RateFormatter from "dtable-ui-component/lib/RateFormatter";
-import React from 'react';
-import { CellType, FORMULA_RESULT_TYPE, getNumberDisplayString, getDateDisplayString, getCellValueStringResult, isNumber, isDateColumn, isValidLink, getColumnOptions } from 'dtable-utils';
-import dayjs from 'dayjs';
-import { isEqual } from 'lodash-es';
-import cellFormatterFactory from '../components/cell-factory/cell-formatter-factory';
-import SimpleCellFormatter from '../components/cell-factory/SimpleCellFormatter';
-import SingleSelectOption from '../components/cell-factory/SingleSelectOption';
-import { isFunction, getFileIconUrl, getImageThumbnailUrl, isArchiveViewRowData } from '../utils/common-utils';
-import Highlighter from '../components/highlighter/highlighter';
-import DigitalSignUtils from '../utils/digital-sign-utils';
-import { getColumnByKey } from '../utils/column-utils';
-import context from '../context';
-import { xAxisMap, groupAxisMap } from '../constants';
-import { chartColumn2SqlColumn } from './sql';
-import { BaseUtils } from './chart-utils';
-export const UNSHOW_COLUMN_TYPE = [CellType.LINK, CellType.LONG_TEXT, CellType.FORMULA, CellType.LINK_FORMULA];
-export const getCellRecordWidth = column => {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isLookupImages = exports.getRowRecord = exports.getFormattedCell = exports.getFilterConditions = exports.getCellRecordWidth = exports.UNSHOW_COLUMN_TYPE = void 0;
+var _ButtonFormatter2 = _interopRequireDefault(require("dtable-ui-component/lib/ButtonFormatter"));
+var _RateFormatter2 = _interopRequireDefault(require("dtable-ui-component/lib/RateFormatter"));
+var _react = _interopRequireDefault(require("react"));
+var _dtableUtils = require("dtable-utils");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _lodashEs = require("lodash-es");
+var _cellFormatterFactory = _interopRequireDefault(require("../components/cell-factory/cell-formatter-factory"));
+var _SimpleCellFormatter = _interopRequireDefault(require("../components/cell-factory/SimpleCellFormatter"));
+var _SingleSelectOption = _interopRequireDefault(require("../components/cell-factory/SingleSelectOption"));
+var _commonUtils = require("../utils/common-utils");
+var _highlighter = _interopRequireDefault(require("../components/highlighter/highlighter"));
+var _digitalSignUtils = _interopRequireDefault(require("../utils/digital-sign-utils"));
+var _columnUtils = require("../utils/column-utils");
+var _context = _interopRequireDefault(require("../context"));
+var _constants = require("../constants");
+var _sql = require("./sql");
+var _chartUtils = require("./chart-utils");
+const UNSHOW_COLUMN_TYPE = exports.UNSHOW_COLUMN_TYPE = [_dtableUtils.CellType.LINK, _dtableUtils.CellType.LONG_TEXT, _dtableUtils.CellType.FORMULA, _dtableUtils.CellType.LINK_FORMULA];
+const getCellRecordWidth = column => {
   let {
     type,
     data
   } = column;
   switch (type) {
-    case CellType.DATE:
+    case _dtableUtils.CellType.DATE:
       {
         let isShowHourAndMinute = data && data.format && data.format.indexOf('HH:mm') > -1;
         return isShowHourAndMinute ? 160 : 100;
       }
-    case CellType.CTIME:
-    case CellType.MTIME:
-    case CellType.LINK:
-    case CellType.GEOLOCATION:
+    case _dtableUtils.CellType.CTIME:
+    case _dtableUtils.CellType.MTIME:
+    case _dtableUtils.CellType.LINK:
+    case _dtableUtils.CellType.GEOLOCATION:
       {
         return 160;
       }
-    case CellType.COLLABORATOR:
+    case _dtableUtils.CellType.COLLABORATOR:
       {
         return 100;
       }
-    case CellType.CHECKBOX:
+    case _dtableUtils.CellType.CHECKBOX:
       {
         return 40;
       }
-    case CellType.NUMBER:
-    case CellType.AUTO_NUMBER:
+    case _dtableUtils.CellType.NUMBER:
+    case _dtableUtils.CellType.AUTO_NUMBER:
       {
         return 120;
       }
@@ -53,7 +60,8 @@ export const getCellRecordWidth = column => {
       }
   }
 };
-export const getRowRecord = function (currentTableId, row, columns, unShowColumnKeyList) {
+exports.getCellRecordWidth = getCellRecordWidth;
+const getRowRecord = function (currentTableId, row, columns, unShowColumnKeyList) {
   let matchedResult = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
   if (!Array.isArray(unShowColumnKeyList)) {
     unShowColumnKeyList = [];
@@ -70,60 +78,62 @@ export const getRowRecord = function (currentTableId, row, columns, unShowColumn
     }, column.width);
   });
 };
-export const isLookupImages = column => {
+exports.getRowRecord = getRowRecord;
+const isLookupImages = column => {
   const {
     type,
     data
   } = column;
-  if (type !== CellType.LINK_FORMULA) return false;
+  if (type !== _dtableUtils.CellType.LINK_FORMULA) return false;
   const {
     result_type,
     array_type
   } = data || {};
-  if (result_type !== FORMULA_RESULT_TYPE.ARRAY) return false;
-  return array_type === CellType.IMAGE || array_type === CellType.DIGITAL_SIGN;
+  if (result_type !== _dtableUtils.FORMULA_RESULT_TYPE.ARRAY) return false;
+  return array_type === _dtableUtils.CellType.IMAGE || array_type === _dtableUtils.CellType.DIGITAL_SIGN;
 };
+exports.isLookupImages = isLookupImages;
 function _getCellRecord(displayValue, rowId, column, columnWidth) {
   let {
     key
   } = column;
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/_react.default.createElement("div", {
     className: "row-cell-value text-truncate",
     key: rowId + '_' + key,
     style: {
       width: columnWidth
     }
-  }, displayValue ? displayValue : /*#__PURE__*/React.createElement("span", {
+  }, displayValue ? displayValue : /*#__PURE__*/_react.default.createElement("span", {
     className: "row-cell-value-empty"
   }));
 }
 function _renderSearch(value, searchValue) {
-  return /*#__PURE__*/React.createElement("span", {
+  return /*#__PURE__*/_react.default.createElement("span", {
     className: "cell-value-ellipsis text-truncate",
     title: value
-  }, /*#__PURE__*/React.createElement(Highlighter, {
+  }, /*#__PURE__*/_react.default.createElement(_highlighter.default, {
     highlight: searchValue
   }, value));
 }
 function getLookupImagesDOMs(value, arrayType) {
   if (!value) return null;
   let images = Array.isArray(value) ? value : [value];
-  if (arrayType === CellType.DIGITAL_SIGN) {
-    images = value.map(sign => DigitalSignUtils.getSignImageUrl(sign)).filter(Boolean);
+  if (arrayType === _dtableUtils.CellType.DIGITAL_SIGN) {
+    images = value.map(sign => _digitalSignUtils.default.getSignImageUrl(sign)).filter(Boolean);
   }
   const amount = images.length;
   if (amount === 0) return null;
-  const imgSrc = getImageThumbnailUrl(images[0]);
-  return /*#__PURE__*/React.createElement("div", {
+  const imgSrc = (0, _commonUtils.getImageThumbnailUrl)(images[0]);
+  return /*#__PURE__*/_react.default.createElement("div", {
     className: "image-cell-value"
-  }, /*#__PURE__*/React.createElement("img", {
+  }, /*#__PURE__*/_react.default.createElement("img", {
     alt: "",
     src: imgSrc
-  }), amount > 1 && /*#__PURE__*/React.createElement("span", {
+  }), amount > 1 && /*#__PURE__*/_react.default.createElement("span", {
     className: "cell-value-size"
   }, '+' + amount));
 }
-export const getFormattedCell = function (column, row) {
+const getFormattedCell = function (column, row) {
   let {
     formulaRow = {},
     searchValue = null,
@@ -140,15 +150,15 @@ export const getFormattedCell = function (column, row) {
   let value = row[key];
   let displayValue;
   let isNonEmptyArray = Array.isArray(value) && value.length > 0;
-  const departments = context.getDepartments();
+  const departments = _context.default.getDepartments();
   switch (type) {
-    case CellType.TEXT:
+    case _dtableUtils.CellType.TEXT:
       {
         if (value && typeof value === 'string') {
           if (searchValue) {
             displayValue = _renderSearch(value, searchValue);
           } else {
-            displayValue = /*#__PURE__*/React.createElement("span", {
+            displayValue = /*#__PURE__*/_react.default.createElement("span", {
               className: "cell-value-ellipsis text-truncate",
               title: value
             }, value);
@@ -156,59 +166,59 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.DATE:
+    case _dtableUtils.CellType.DATE:
       {
         if (value && typeof value === 'string') {
           const format = column.data && column.data.format ? column.data.format : 'YYYY-MM-DD';
-          const formatValue = getDateDisplayString(value, format);
+          const formatValue = (0, _dtableUtils.getDateDisplayString)(value, format);
           displayValue = searchValue ? _renderSearch(formatValue, searchValue) : formatValue;
         }
         break;
       }
-    case CellType.CTIME:
-    case CellType.MTIME:
+    case _dtableUtils.CellType.CTIME:
+    case _dtableUtils.CellType.MTIME:
       {
         if (value && typeof value === 'string') {
           if (searchValue) {
-            displayValue = /*#__PURE__*/React.createElement(Highlighter, {
+            displayValue = /*#__PURE__*/_react.default.createElement(_highlighter.default, {
               highlight: searchValue
-            }, dayjs(value).format('YYYY-MM-DD HH:mm:ss'));
+            }, (0, _dayjs.default)(value).format('YYYY-MM-DD HH:mm:ss'));
           } else {
-            displayValue = dayjs(value).format('YYYY-MM-DD HH:mm:ss');
+            displayValue = (0, _dayjs.default)(value).format('YYYY-MM-DD HH:mm:ss');
           }
         }
         break;
       }
-    case CellType.NUMBER:
+    case _dtableUtils.CellType.NUMBER:
       {
-        if (isNumber(value)) {
+        if ((0, _dtableUtils.isNumber)(value)) {
           const {
             data = {}
           } = column;
-          const formatedValue = getNumberDisplayString(value, data);
+          const formatedValue = (0, _dtableUtils.getNumberDisplayString)(value, data);
           if (searchValue) {
             displayValue = _renderSearch(formatedValue, searchValue);
           } else {
-            displayValue = /*#__PURE__*/React.createElement("div", {
+            displayValue = /*#__PURE__*/_react.default.createElement("div", {
               className: "number-formatter"
             }, formatedValue);
           }
         }
         break;
       }
-    case CellType.LINK:
+    case _dtableUtils.CellType.LINK:
       {
         displayValue = null;
         const {
           data
         } = column;
-        if (!isValidLink(data)) break;
+        if (!(0, _dtableUtils.isValidLink)(data)) break;
 
         // is default view: row data can get from formula row
         // is archive view: row data can get form rowdata
-        value = isArchiveViewRowData(row, column) ? value : formulaRow[key];
+        value = (0, _commonUtils.isArchiveViewRowData)(row, column) ? value : formulaRow[key];
         if (!value || !Array.isArray(value) || value.length === 0) break;
-        const collaborators = context.getCollaboratorsFromCache();
+        const collaborators = _context.default.getCollaboratorsFromCache();
         const {
           display_column_key,
           array_type,
@@ -220,9 +230,9 @@ export const getFormattedCell = function (column, row) {
           type: array_type,
           data: array_data
         };
-        displayValue = /*#__PURE__*/React.createElement("div", {
+        displayValue = /*#__PURE__*/_react.default.createElement("div", {
           className: "links-formatter"
-        }, /*#__PURE__*/React.createElement("div", {
+        }, /*#__PURE__*/_react.default.createElement("div", {
           className: "formatter-show"
         }, value.map(item => {
           const {
@@ -236,24 +246,24 @@ export const getFormattedCell = function (column, row) {
           const formulaRows = {
             [rowId]: linkedRow
           };
-          const displayResult = getCellValueStringResult(linkedRow, linkedColumn, {
+          const displayResult = (0, _dtableUtils.getCellValueStringResult)(linkedRow, linkedColumn, {
             formulaRows,
             collaborators,
             departments
           });
-          return /*#__PURE__*/React.createElement("div", {
+          return /*#__PURE__*/_react.default.createElement("div", {
             key: "".concat(rowId, "_").concat(display_column_key),
             className: "link"
-          }, /*#__PURE__*/React.createElement("span", {
+          }, /*#__PURE__*/_react.default.createElement("span", {
             className: "link-name"
           }, displayResult));
         })));
         break;
       }
-    case CellType.COLLABORATOR:
+    case _dtableUtils.CellType.COLLABORATOR:
       {
         if (value && isNonEmptyArray) {
-          const allCollaborators = context.getCollaboratorsFromCache();
+          const allCollaborators = _context.default.getCollaboratorsFromCache();
           let validValue = value.filter(item => {
             return allCollaborators.find(collaborator => collaborator.email === item);
           });
@@ -265,23 +275,23 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.SINGLE_SELECT:
+    case _dtableUtils.CellType.SINGLE_SELECT:
       {
         if (value && typeof value === 'string') {
-          displayValue = /*#__PURE__*/React.createElement(SingleSelectOption, {
+          displayValue = /*#__PURE__*/_react.default.createElement(_SingleSelectOption.default, {
             column: column,
             value: value
           });
         }
         break;
       }
-    case CellType.MULTIPLE_SELECT:
+    case _dtableUtils.CellType.MULTIPLE_SELECT:
       {
         if (value && isNonEmptyArray) {
-          displayValue = /*#__PURE__*/React.createElement("span", {
+          displayValue = /*#__PURE__*/_react.default.createElement("span", {
             className: "multiple-select-formatter"
           }, value.map((item, index) => {
-            return /*#__PURE__*/React.createElement(SingleSelectOption, {
+            return /*#__PURE__*/_react.default.createElement(_SingleSelectOption.default, {
               column: column,
               value: item,
               key: "row-operation-multiple-select-".concat(index)
@@ -290,56 +300,56 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.FILE:
+    case _dtableUtils.CellType.FILE:
       {
         if (value && isNonEmptyArray) {
           let {
             name,
             type
           } = value[0];
-          let fileIconUrl = getFileIconUrl(name, type);
+          let fileIconUrl = (0, _commonUtils.getFileIconUrl)(name, type);
           let amount = value.length;
-          displayValue = /*#__PURE__*/React.createElement("div", {
+          displayValue = /*#__PURE__*/_react.default.createElement("div", {
             className: "image-cell-value"
-          }, /*#__PURE__*/React.createElement("img", {
+          }, /*#__PURE__*/_react.default.createElement("img", {
             alt: "",
             src: fileIconUrl
-          }), amount > 1 && /*#__PURE__*/React.createElement("span", {
+          }), amount > 1 && /*#__PURE__*/_react.default.createElement("span", {
             className: "cell-value-size"
           }, '+' + amount));
         }
         break;
       }
-    case CellType.IMAGE:
+    case _dtableUtils.CellType.IMAGE:
       {
         if (value && isNonEmptyArray) {
-          const imgSrc = getImageThumbnailUrl(value[0]);
+          const imgSrc = (0, _commonUtils.getImageThumbnailUrl)(value[0]);
           const amount = value.length;
-          displayValue = /*#__PURE__*/React.createElement("div", {
+          displayValue = /*#__PURE__*/_react.default.createElement("div", {
             className: "image-cell-value"
-          }, /*#__PURE__*/React.createElement("img", {
+          }, /*#__PURE__*/_react.default.createElement("img", {
             alt: "",
             src: imgSrc
-          }), amount > 1 && /*#__PURE__*/React.createElement("span", {
+          }), amount > 1 && /*#__PURE__*/_react.default.createElement("span", {
             className: "cell-value-size"
           }, '+' + amount));
         }
         break;
       }
-    case CellType.DIGITAL_SIGN:
+    case _dtableUtils.CellType.DIGITAL_SIGN:
       {
-        const signImageUrl = getImageThumbnailUrl(DigitalSignUtils.getSignImageUrl(value));
+        const signImageUrl = (0, _commonUtils.getImageThumbnailUrl)(_digitalSignUtils.default.getSignImageUrl(value));
         if (signImageUrl) {
-          displayValue = /*#__PURE__*/React.createElement("div", {
+          displayValue = /*#__PURE__*/_react.default.createElement("div", {
             className: "image-cell-value"
-          }, /*#__PURE__*/React.createElement("img", {
+          }, /*#__PURE__*/_react.default.createElement("img", {
             src: signImageUrl,
             alt: ""
           }));
         }
         break;
       }
-    case CellType.DEPARTMENT_SINGLE_SELECT:
+    case _dtableUtils.CellType.DEPARTMENT_SINGLE_SELECT:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -349,10 +359,10 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.CHECKBOX:
+    case _dtableUtils.CellType.CHECKBOX:
       {
         if (value) {
-          displayValue = /*#__PURE__*/React.createElement("span", {
+          displayValue = /*#__PURE__*/_react.default.createElement("span", {
             className: "dtable-font dtable-icon-check-mark",
             style: {
               color: '#20c933'
@@ -361,10 +371,10 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.GEOLOCATION:
+    case _dtableUtils.CellType.GEOLOCATION:
       {
         if (value && typeof value === 'object') {
-          displayValue = /*#__PURE__*/React.createElement("div", {
+          displayValue = /*#__PURE__*/_react.default.createElement("div", {
             className: "geolocation-formatter"
           }, createColumnFormatter(type, {
             value,
@@ -375,10 +385,10 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.CREATOR:
-    case CellType.LAST_MODIFIER:
+    case _dtableUtils.CellType.CREATOR:
+    case _dtableUtils.CellType.LAST_MODIFIER:
       {
-        const collaborators = context.getCollaboratorsFromCache();
+        const collaborators = _context.default.getCollaboratorsFromCache();
         if (value) {
           displayValue = createColumnFormatter(type, {
             value,
@@ -387,7 +397,7 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.LONG_TEXT:
+    case _dtableUtils.CellType.LONG_TEXT:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -397,8 +407,8 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.FORMULA:
-    case CellType.LINK_FORMULA:
+    case _dtableUtils.CellType.FORMULA:
+    case _dtableUtils.CellType.LINK_FORMULA:
       {
         if (!formulaRow) {
           break;
@@ -409,7 +419,7 @@ export const getFormattedCell = function (column, row) {
           displayValue = getLookupImagesDOMs(newValue, column.data.array_type);
           break;
         }
-        const collaborators = context.getCollaboratorsFromCache();
+        const collaborators = _context.default.getCollaboratorsFromCache();
         let formatterProps = {
           value: newValue,
           column,
@@ -422,9 +432,9 @@ export const getFormattedCell = function (column, row) {
         break;
       }
     // email, url, audo_number are same
-    case CellType.EMAIL:
-    case CellType.URL:
-    case CellType.AUTO_NUMBER:
+    case _dtableUtils.CellType.EMAIL:
+    case _dtableUtils.CellType.URL:
+    case _dtableUtils.CellType.AUTO_NUMBER:
       {
         if (value) {
           displayValue = searchValue ? _renderSearch(value, searchValue) : createColumnFormatter(type, {
@@ -433,7 +443,7 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.DURATION:
+    case _dtableUtils.CellType.DURATION:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -443,10 +453,10 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.RATE:
+    case _dtableUtils.CellType.RATE:
       {
         if (value) {
-          displayValue = /*#__PURE__*/React.createElement(_RateFormatter, {
+          displayValue = /*#__PURE__*/_react.default.createElement(_RateFormatter2.default, {
             value: value,
             column: column,
             editable: false
@@ -454,9 +464,9 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.BUTTON:
+    case _dtableUtils.CellType.BUTTON:
       {
-        displayValue = /*#__PURE__*/React.createElement(_ButtonFormatter, {
+        displayValue = /*#__PURE__*/_react.default.createElement(_ButtonFormatter2.default, {
           row: row,
           column: column,
           preventClickEvent: true,
@@ -472,56 +482,57 @@ export const getFormattedCell = function (column, row) {
   }
   return _getCellRecord(displayValue, rowId, column, columnWidth);
 };
+exports.getFormattedCell = getFormattedCell;
 const createColumnFormatter = (columnType, formatterProps) => {
-  const Formatter = cellFormatterFactory.createFormatter(columnType);
-  if (React.isValidElement(Formatter)) {
-    return React.cloneElement(Formatter, {
+  const Formatter = _cellFormatterFactory.default.createFormatter(columnType);
+  if (/*#__PURE__*/_react.default.isValidElement(Formatter)) {
+    return /*#__PURE__*/_react.default.cloneElement(Formatter, {
       ...formatterProps
     });
-  } else if (isFunction(Formatter)) {
-    return /*#__PURE__*/React.createElement(Formatter, formatterProps);
+  } else if ((0, _commonUtils.isFunction)(Formatter)) {
+    return /*#__PURE__*/_react.default.createElement(Formatter, formatterProps);
   }
-  return /*#__PURE__*/React.createElement(SimpleCellFormatter, formatterProps);
+  return /*#__PURE__*/_react.default.createElement(_SimpleCellFormatter.default, formatterProps);
 };
 const filterPredicateMap = {
-  [CellType.TEXT]: 'is',
-  [CellType.NUMBER]: 'equal',
-  [CellType.CHECKBOX]: 'is',
-  [CellType.DATE]: 'is',
-  [CellType.CTIME]: 'is',
-  [CellType.MTIME]: 'is',
-  [CellType.SINGLE_SELECT]: 'is',
-  [CellType.MULTIPLE_SELECT]: 'has_all_of',
-  [CellType.DEPARTMENT_SINGLE_SELECT]: 'is',
-  [CellType.COLLABORATOR]: 'has_all_of',
-  [CellType.CREATOR]: 'is',
-  [CellType.LAST_MODIFIER]: 'is',
-  [CellType.AUTO_NUMBER]: 'is',
-  [CellType.EMAIL]: 'is',
-  [CellType.URL]: 'is',
-  [CellType.STRING]: 'is',
-  [CellType.BOOL]: 'is',
-  [CellType.LINK_FORMULA]: 'has_any_of'
+  [_dtableUtils.CellType.TEXT]: 'is',
+  [_dtableUtils.CellType.NUMBER]: 'equal',
+  [_dtableUtils.CellType.CHECKBOX]: 'is',
+  [_dtableUtils.CellType.DATE]: 'is',
+  [_dtableUtils.CellType.CTIME]: 'is',
+  [_dtableUtils.CellType.MTIME]: 'is',
+  [_dtableUtils.CellType.SINGLE_SELECT]: 'is',
+  [_dtableUtils.CellType.MULTIPLE_SELECT]: 'has_all_of',
+  [_dtableUtils.CellType.DEPARTMENT_SINGLE_SELECT]: 'is',
+  [_dtableUtils.CellType.COLLABORATOR]: 'has_all_of',
+  [_dtableUtils.CellType.CREATOR]: 'is',
+  [_dtableUtils.CellType.LAST_MODIFIER]: 'is',
+  [_dtableUtils.CellType.AUTO_NUMBER]: 'is',
+  [_dtableUtils.CellType.EMAIL]: 'is',
+  [_dtableUtils.CellType.URL]: 'is',
+  [_dtableUtils.CellType.STRING]: 'is',
+  [_dtableUtils.CellType.BOOL]: 'is',
+  [_dtableUtils.CellType.LINK_FORMULA]: 'has_any_of'
 };
-const USE_OPTION_ID_CELL_TYPES = [CellType.SINGLE_SELECT, CellType.MULTIPLE_SELECT];
+const USE_OPTION_ID_CELL_TYPES = [_dtableUtils.CellType.SINGLE_SELECT, _dtableUtils.CellType.MULTIPLE_SELECT];
 const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
   if (!rows) rows = [];
   const filter = {
     column_key: columnKey || ''
   };
-  const column = getColumnByKey(columnKey, columns);
+  const column = (0, _columnUtils.getColumnByKey)(columnKey, columns);
   if (!column) {
     return filter;
   }
   let type = column.type;
   const columnType = column.type;
-  if (type === CellType.FORMULA) {
+  if (type === _dtableUtils.CellType.FORMULA) {
     type = column.data.result_type;
   }
-  if (type === CellType.LINK_FORMULA) {
+  if (type === _dtableUtils.CellType.LINK_FORMULA) {
     type = column.data.array_type;
   }
-  if (column && [CellType.GEOLOCATION, CellType.DATE, CellType.MTIME, CellType.CTIME].includes(type)) {
+  if (column && [_dtableUtils.CellType.GEOLOCATION, _dtableUtils.CellType.DATE, _dtableUtils.CellType.MTIME, _dtableUtils.CellType.CTIME].includes(type)) {
     filter['value'] = value;
     return filter;
   }
@@ -529,7 +540,7 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
     value = value.trim();
   }
   if (USE_OPTION_ID_CELL_TYPES.includes(column.type)) {
-    const options = getColumnOptions(column);
+    const options = (0, _dtableUtils.getColumnOptions)(column);
     // name may contains spaces
     // value maybe id or name, find option by name or id
     const selectedOption = options.find(o => o.name.trim() === value || o.id === value);
@@ -540,7 +551,7 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
   }
 
   // link_formula use has_any_of
-  if (columnType === CellType.LINK_FORMULA) {
+  if (columnType === _dtableUtils.CellType.LINK_FORMULA) {
     filter['filter_predicate'] = filterPredicateMap[columnType];
   } else {
     filter['filter_predicate'] = filterPredicateMap[type];
@@ -554,7 +565,7 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   };
 
   // need column to get type
-  const column = getColumnByKey(columnKey, columns);
+  const column = (0, _columnUtils.getColumnByKey)(columnKey, columns);
   if (!column) {
     return filter;
   }
@@ -565,13 +576,13 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   let columnType = column.type;
   const correctRow = rows.find(r => sqlColumnKey in r);
   value = correctRow && correctRow[sqlColumnKey];
-  if (type === CellType.FORMULA) {
+  if (type === _dtableUtils.CellType.FORMULA) {
     type = column.data.result_type;
   }
-  if (type === CellType.LINK_FORMULA) {
+  if (type === _dtableUtils.CellType.LINK_FORMULA) {
     type = column.data.array_type;
   }
-  if (column && [CellType.GEOLOCATION, CellType.DATE, CellType.MTIME, CellType.CTIME].includes(type)) {
+  if (column && [_dtableUtils.CellType.GEOLOCATION, _dtableUtils.CellType.DATE, _dtableUtils.CellType.MTIME, _dtableUtils.CellType.CTIME].includes(type)) {
     // link_formula result is an array, but can't pass the value directly as an array here
     if (Array.isArray(value)) value = value[0];
     filter['value'] = value;
@@ -585,14 +596,14 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   filter['filter_term'] = value;
 
   // link_formula use has_any_of
-  if (columnType === CellType.LINK_FORMULA) {
+  if (columnType === _dtableUtils.CellType.LINK_FORMULA) {
     filter['filter_predicate'] = filterPredicateMap[columnType];
   } else {
     filter['filter_predicate'] = filterPredicateMap[type];
   }
   return filter;
 };
-export const getFilterConditions = (statisticRecord, chart, table) => {
+const getFilterConditions = (statisticRecord, chart, table) => {
   const columns = table.columns || [];
   const {
     name = '',
@@ -606,10 +617,10 @@ export const getFilterConditions = (statisticRecord, chart, table) => {
     type
   } = config;
   const filters = [];
-  const columnKey = xAxisMap[type];
-  const groupColumnKey = groupAxisMap[type];
-  chart.config = BaseUtils.convertConfig(config);
-  const chartSQLMap = chartColumn2SqlColumn(chart, table);
+  const columnKey = _constants.xAxisMap[type];
+  const groupColumnKey = _constants.groupAxisMap[type];
+  chart.config = _chartUtils.BaseUtils.convertConfig(config);
+  const chartSQLMap = (0, _sql.chartColumn2SqlColumn)(chart, table);
   const {
     sqlColumnGroupbyColumnKey,
     sqlGroupbyColumnKey
@@ -620,10 +631,10 @@ export const getFilterConditions = (statisticRecord, chart, table) => {
     rows.forEach(r => {
       const xValue = r[sqlGroupbyColumnKey];
       const yValue = r[sqlColumnGroupbyColumnKey];
-      if (!xValueList.some(v => isEqual(v, xValue))) {
+      if (!xValueList.some(v => (0, _lodashEs.isEqual)(v, xValue))) {
         xValueList.push(xValue);
       }
-      if (!yValueList.some(v => isEqual(v, yValue))) {
+      if (!yValueList.some(v => (0, _lodashEs.isEqual)(v, yValue))) {
         yValueList.push(yValue);
       }
     });
@@ -657,4 +668,5 @@ export const getFilterConditions = (statisticRecord, chart, table) => {
     }
   }
   return filters;
-};
+};
+exports.getFilterConditions = getFilterConditions;