sea-chart 2.0.38 → 2.0.39

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

@@ -1,50 +1,57 @@
-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, COLLABORATOR_COLUMN_TYPES, getNumberDisplayString, getDateDisplayString, getCellValueStringResult, isNumber, 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 { CHART_TYPE } from '../constants/type';
-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 _type = require("../constants/type");
+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;
       }
@@ -54,7 +61,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 = [];
@@ -71,60 +79,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,
@@ -141,15 +151,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);
@@ -157,59 +167,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,
@@ -221,9 +231,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 {
@@ -237,24 +247,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", {
-            key: `${rowId}_${display_column_key}`,
+          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);
           });
@@ -266,81 +276,81 @@ 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-${index}`
+              key: "row-operation-multiple-select-".concat(index)
             });
           }));
         }
         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, {
@@ -350,10 +360,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'
@@ -362,10 +372,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,
@@ -376,10 +386,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,
@@ -388,7 +398,7 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.LONG_TEXT:
+    case _dtableUtils.CellType.LONG_TEXT:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -398,8 +408,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;
@@ -410,7 +420,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,
@@ -423,9 +433,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, {
@@ -434,7 +444,7 @@ export const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case CellType.DURATION:
+    case _dtableUtils.CellType.DURATION:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -444,10 +454,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
@@ -455,9 +465,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,
@@ -473,45 +483,46 @@ 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]: 'is',
-  [CellType.LINK]: 'is'
+  [_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]: 'is',
+  [_dtableUtils.CellType.LINK]: 'is'
 };
-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;
   }
@@ -523,14 +534,14 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
   } = column.data || {};
 
   // get the actual type for formula columns
-  if (type === CellType.FORMULA) {
-    if (result_type === FORMULA_RESULT_TYPE.ARRAY && array_type) {
+  if (type === _dtableUtils.CellType.FORMULA) {
+    if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY && array_type) {
       type = array_type;
     } else {
       type = result_type;
     }
   }
-  if (type === CellType.LINK_FORMULA) {
+  if (type === _dtableUtils.CellType.LINK_FORMULA) {
     type = array_type;
     // extract display_value from link formula column value
     if (Array.isArray(value) && value.length > 0) {
@@ -539,7 +550,7 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
   }
 
   // handle link column based on array_type
-  if (columnType === CellType.LINK) {
+  if (columnType === _dtableUtils.CellType.LINK) {
     var _column$data, _value$;
     const linkArrayType = (_column$data = column.data) === null || _column$data === void 0 ? void 0 : _column$data.array_type;
     if (linkArrayType) {
@@ -550,7 +561,7 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
       value = value[0].display_value;
     }
   }
-  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;
   }
@@ -559,9 +570,9 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
   }
 
   // handle collaborator type for formula/link_formula columns
-  const isFormulaCollaborator = (columnType === CellType.FORMULA || columnType === CellType.LINK_FORMULA) && result_type === FORMULA_RESULT_TYPE.ARRAY && COLLABORATOR_COLUMN_TYPES.includes(array_type);
+  const isFormulaCollaborator = (columnType === _dtableUtils.CellType.FORMULA || columnType === _dtableUtils.CellType.LINK_FORMULA) && result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY && _dtableUtils.COLLABORATOR_COLUMN_TYPES.includes(array_type);
   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);
@@ -573,8 +584,8 @@ const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
     filter['filter_term'] = value;
   }
   if (isFormulaCollaborator) {
-    filter['filter_predicate'] = filterPredicateMap[CellType.COLLABORATOR];
-  } else if ([CellType.LINK_FORMULA, CellType.LINK].includes(columnType)) {
+    filter['filter_predicate'] = filterPredicateMap[_dtableUtils.CellType.COLLABORATOR];
+  } else if ([_dtableUtils.CellType.LINK_FORMULA, _dtableUtils.CellType.LINK].includes(columnType)) {
     filter['filter_predicate'] = filterPredicateMap[columnType];
   } else {
     filter['filter_predicate'] = filterPredicateMap[type];
@@ -588,7 +599,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;
   }
@@ -605,14 +616,14 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   value = correctRow && correctRow[sqlColumnKey];
 
   // get the actual type for formula columns
-  if (type === CellType.FORMULA) {
-    if (result_type === FORMULA_RESULT_TYPE.ARRAY && array_type) {
+  if (type === _dtableUtils.CellType.FORMULA) {
+    if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY && array_type) {
       type = array_type;
     } else {
       type = result_type;
     }
   }
-  if (type === CellType.LINK_FORMULA) {
+  if (type === _dtableUtils.CellType.LINK_FORMULA) {
     type = array_type;
     // extract display_value from link formula column value
     if (Array.isArray(value) && value.length > 0) {
@@ -621,7 +632,7 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   }
 
   // handle link column based on array_type
-  if (columnType === CellType.LINK) {
+  if (columnType === _dtableUtils.CellType.LINK) {
     var _column$data2, _value$2;
     const linkArrayType = (_column$data2 = column.data) === null || _column$data2 === void 0 ? void 0 : _column$data2.array_type;
     if (linkArrayType) {
@@ -632,7 +643,7 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
       value = value[0].display_value;
     }
   }
-  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;
@@ -640,7 +651,7 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   }
 
   // handle collaborator type for formula/link_formula columns
-  const isFormulaCollaborator = (columnType === CellType.FORMULA || columnType === CellType.LINK_FORMULA) && result_type === FORMULA_RESULT_TYPE.ARRAY && COLLABORATOR_COLUMN_TYPES.includes(array_type);
+  const isFormulaCollaborator = (columnType === _dtableUtils.CellType.FORMULA || columnType === _dtableUtils.CellType.LINK_FORMULA) && result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY && _dtableUtils.COLLABORATOR_COLUMN_TYPES.includes(array_type);
 
   // value may contains spaces
   if (typeof value === 'string') {
@@ -652,15 +663,15 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
     filter['filter_term'] = value;
   }
   if (isFormulaCollaborator) {
-    filter['filter_predicate'] = filterPredicateMap[CellType.COLLABORATOR];
-  } else if ([CellType.LINK_FORMULA, CellType.LINK].includes(columnType)) {
+    filter['filter_predicate'] = filterPredicateMap[_dtableUtils.CellType.COLLABORATOR];
+  } else if ([_dtableUtils.CellType.LINK_FORMULA, _dtableUtils.CellType.LINK].includes(columnType)) {
     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 = '',
@@ -674,17 +685,17 @@ 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);
   let {
     sqlColumnGroupbyColumnKey,
     sqlGroupbyColumnKey,
     sqlXColumnKey,
     sqlYColumnKey
   } = chartSQLMap;
-  if (type === CHART_TYPE.COMPLETENESS_GROUP || type === CHART_TYPE.COMPLETENESS) {
+  if (type === _type.CHART_TYPE.COMPLETENESS_GROUP || type === _type.CHART_TYPE.COMPLETENESS) {
     const {
       sqlColumns
     } = chartSQLMap;
@@ -696,10 +707,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);
       }
     });
@@ -722,7 +733,7 @@ export const getFilterConditions = (statisticRecord, chart, table) => {
           value: name
         };
         filters.push(filter);
-      } else if (type === CHART_TYPE.SCATTER) {
+      } else if (type === _type.CHART_TYPE.SCATTER) {
         const filterX = getFilterByColumnType(config['x_axis_column_key'], columns, rows, sqlXColumnKey);
         const filterY = getFilterByColumnType(config['y_axis_column_key'], columns, rows, sqlYColumnKey);
         filters.push(filterX, filterY);
@@ -737,4 +748,5 @@ export const getFilterConditions = (statisticRecord, chart, table) => {
     }
   }
   return filters;
-};
+};
+exports.getFilterConditions = getFilterConditions;